Robotics Skill

A modular robotics library covering six domains: state estimation (Kalman, EKF, UKF, particle filter), kinematics (DH forward kinematics, Jacobian IK, CCD, FABRIK), control (PID with auto-tuning, LQR, MPC, pure pursuit, Stanley), path planning (A*/Dijkstra, RRT, RRT*, PRM, D* Lite), drivetrain models (differential, mecanum, swerve, Ackermann), and SLAM (pose graph optimization).

When to use this skill

When you need robotics algorithms without adding a robotics framework dependency. Covers core algorithms from Robotics Toolbox (Corke), FilterPy, python-control, PythonRobotics, and OMPL, implemented from scratch with clear provenance.

Arguments

$ARGUMENTS has the format: <nodes> [--lang <language>]

• •nodes: Space-separated list of node names to translate, or all for every node. Dependencies are resolved automatically — specify only the nodes you want.
• •--lang: Target language (e.g. python, rust, go, cpp, csharp, swift, kotlin, typescript). Defaults to typescript if omitted.

Examples:

• •kalman-filter --lang python — translate just the Kalman filter subset to Python
• •jacobian-ik --lang cpp — translate the full Jacobian IK pipeline to C++
• •differential-drive pure-pursuit --lang rust — translate a mobile robot subset to Rust
• •all --lang go — translate the full library to Go

Node Graph

                              ┌── result-types ──────────────────────────────────────┐
                              │        │                                             │
                              │        ├──→ pid                                      │
                              │        ├──→ fopdt-model                              │
                              │        ├──→ pid-tuning-rules                         │
                              │        ├──→ relay-analysis                            │
                              │        ├──→ fabrik                                    │
                              │        ├──→ particle-filter                           │
                              │        ├──→ graph-search                              │
                              │        ├──→ rrt ──────────→ rrt-star                  │
                              │        │    └──────────────→ prm                      │
                              │        ├──→ d-star                                    │
                              │        │                                             │
drivetrain-types ─────────────┤        │    ┌── plan-path ←── any-of(graph-search,   │
    ├──→ differential-drive   │        │    │                  rrt, rrt-star, prm,    │
    ├──→ mecanum-drive        │        │    │                  d-star)                │
    ├──→ swerve-drive         │        │    │                                        │
    ├──→ ackermann            │        │    └── solve-ik ←── any-of(jacobian-ik,     │
    │                         │        │                      ccd, fabrik)            │
    ├──→ pure-pursuit ←───────┘        │                                             │
    └──→ stanley-controller ←──────────┘                                             │
                                                                                     │
mat-ops ──────────────────────────────────────────────────────────────────────────────┘
    │                                                                     │
    ├──→ rotation-ops ──→ transform-ops                                   │
    │         │                │                                          │
    │         │                ├── (+ dh-parameters) ──→ forward-kinematics
    │         │                │                              │           │
    │         │                │                           jacobian       │
    │         │                │                              │           │
    │         │                ├── (+ forward-kin) ──→ jacobian-ik ←──────┘
    │         │                └── (+ forward-kin) ──→ ccd ←─────────────┘
    │         │
    ├──→ dh-parameters                     ┌── test-chains ←── dh-parameters
    │                                      │
    ├──→ state-types                       └── test-scenarios ←── result-types
    │       ├──→ kalman-filter
    │       ├──→ ekf
    │       ├──→ ukf
    │       └──→ estimate-state ←── any-of(kalman-filter, ekf, ukf)
    │
    ├──→ lqr
    ├──→ mpc ←── state-types, result-types, optimization:bfgs
    └──→ pose-graph-optimization

Nodes

Subset Extraction

• •Just Kalman Filter: mat-ops + state-types + kalman-filter (3 nodes)
• •Just EKF: mat-ops + state-types + ekf (3 nodes)
• •Just PID: result-types + pid (2 nodes)
• •PID Tuning: result-types + pid + fopdt-model + pid-tuning-rules (4 nodes)
• •Just FABRIK: result-types + fabrik (2 nodes)
• •Jacobian IK: mat-ops + rotation-ops + transform-ops + dh-parameters + forward-kinematics + jacobian + jacobian-ik + result-types (8 nodes)
• •Just LQR: mat-ops + lqr (2 nodes)
• •Just RRT: result-types + rrt (2 nodes)
• •Diff-drive + pursuit: result-types + drivetrain-types + differential-drive + pure-pursuit (4 nodes)
• •MPC: mat-ops + state-types + result-types + mpc + optimization:bfgs (4 nodes + cross-skill)
• •Full library: all 37 non-test nodes
• •Test nodes are optional — only needed for validation

Handling help

When $ARGUMENTS is help, read HELP.md and use it to guide the user through node and language selection. The help guide contains a decision tree covering robot type, task domain, common profiles (FRC, FTC, MATE, undergrad, hobbyist), and language idioms. Walk through it interactively, asking the user about their requirements, then recommend specific nodes and a target language.

Translation Workflow

For each node in dependency order:

1. •If $ARGUMENTS is help, read HELP.md and guide the user interactively
2. •Read the node spec at nodes/<name>/spec.md for behavior, API, and test vectors
3. •Read language-specific hints at nodes/<name>/to-<lang>.md if available
4. •Generate the implementation and tests in the target language
5. •If the spec is ambiguous, consult the TypeScript reference at reference/src/<name>.ts

The reference code is TypeScript with 100% line and function coverage. Every node has a corresponding test file at reference/src/<name>.test.ts that serves as the behavioral contract.

Cross-Skill Dependencies

The mpc node depends on optimization:bfgs — the BFGS optimizer from the optimization skill. When translating mpc:

1. •Check if the optimization skill is installed
2. •If not, prompt: "The mpc node depends on bfgs from the optimization skill. Install it?"
3. •Resolve the transitive closure of bfgs within the optimization skill
4. •Generate both skills' nodes into a single output

Key Design Decisions (Off-Policy)

These defaults differ across robotics libraries. Our choices with provenance:

Error Handling

• •IK solvers: return IKResult with converged=false if max iterations exceeded
• •Filters: no exceptions; invalid covariance matrices are caller's responsibility
• •Planners: return PlanResult with success=false if no path found
• •PID: output clamping prevents unbounded output; integral clamping prevents windup
• •LQR: throws if DARE does not converge (system not stabilizable)
• •MPC: returns result with converged=false if optimizer fails
• •Drivetrains: pure kinematic transforms — no error states
• •Pose graph: returns with iteration count if max iterations exceeded

Cross-Validation Targets