npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

cadet-agent

v0.21.0

Published

Cross-IDE agent framework for Unity/C# game-development — one-command install

Vulnerabilities

Powered byPowered by Snyk
  • 0High
  • 0Medium
  • 0Low

Links

Git

Maintainers

covynecovyne

Keywords

cadetcadet-agentunitygame-developmentai-agentcopilotcursorclaude-code

Readme

Cadet-Agent

Cadet-Agent is an opinionated cross-IDE agent framework for game-development workflows. It is built on foundational software engineering practices and real-world game-development experience, with the goal of guiding you through the entire development process — from requirements and technical design through TDD, implementation, and review.

Cadet-Agent is not a one-shot code generator. It won't spit out a finished game from a single prompt. Instead, it walks you through each phase methodically: calibrating the learner model, scoping work into epics and stories, planning architecture, writing tests first, and iterating on feedback. The shared framework core integrates with GitHub Copilot, Cursor, Continue, and Claude Code.

Repository Layout

  • .cadet/agent/core/ contains the shared Cadet-Agent framework documents.
    • cadet-agent.md is the thin global directive: identity, non-negotiable rules, workflow routing, hard-gate protocol, and skill dispatch.
    • skills/ contains scoped workflow-phase skills (Requirements, Architecture, Spike, StoryBreakdown, TDD, Debugging, CodeReview).
    • templates/ contains runtime templates for planning artifacts.
  • .cadet/agent/docs/ contains setup guides for each supported IDE.
  • .github/agents/ contains the Copilot custom agent definitions (Cadet Agent + Cadet Agent Reviewer).
  • .github/prompts/ contains Copilot slash-command skill prompts (/cadet-review, /cadet-tdd, etc.).
  • .cursor/ contains Cursor-specific authored files.
  • .continue/ contains Continue-specific authored files.
  • .claude/ contains Claude Code-specific authored files.
  • These IDE folders hold thin integration shims; the core framework logic still lives in .cadet/agent/core/.
  • package-agent.ps1 builds the distributable cadet-agent.zip package.
  • publish-npm.ps1 publishes the CLI to npm using a token from ~/.npm_token.

Cross-IDE Support

Cadet-Agent provides full workflow parity across four IDEs. The same 7 skills + resume + reviewer are available in each:

| Feature | GitHub Copilot | Cursor | Continue | Claude Code | |---|---|---|---|---| | Auto-load rules | Agent definition | alwaysApply rule | Project rule | Project skill | | Skill dispatch | /cadet-<skill> prompts | Natural language | /cadet-<skill> commands | /cadet-<skill> skills | | Requirements | ✅ | ✅ | ✅ | ✅ | | Architecture | ✅ | ✅ | ✅ | ✅ | | Spike | ✅ | ✅ | ✅ | ✅ | | Story Breakdown | ✅ | ✅ | ✅ | ✅ | | TDD | ✅ | ✅ | ✅ | ✅ | | Debugging | ✅ | ✅ | ✅ | ✅ | | Code Review | ✅ | ✅ | ✅ | ✅ | | Resume | ✅ | ✅ | ✅ | ✅ | | Reviewer mode | Agent picker | Rule toggle | /cadet-agent-reviewer | /cadet-agent-reviewer | | Git guard | PreToolUse hook | Manual | Manual | Manual |

All adapters delegate to the canonical files under .cadet/agent/core/ — no duplicated rules or skills. See ADAPTERS.md for the full inventory.

Quick Install

npx cadet-agent@latest init

This downloads the latest framework release and extracts it into your current directory. For a specific target directory:

npx cadet-agent@latest init --target ./my-unity-project

Keeping the Framework Updated

npx cadet-agent@latest sync

When a new release is available, sync downloads the updated framework and replaces managed files (.cadet/agent/core/, IDE integration shims, agent definitions). Your local policies (.cadet/agent/policies/) and project plans (.cadet/agent/project-plans/) are automatically preserved. After syncing, start a fresh chat for the changes to take effect.

To sync a specific directory:

npx cadet-agent@latest sync --target ./my-unity-project

Manual Install (fallback)

If you prefer to install from a packaged release artifact, download cadet-agent.zip from GitHub Releases and extract it into your Unity project root:

Expand-Archive .\cadet-agent.zip -DestinationPath . -Force

Getting Started

  • For framework navigation after install, see .cadet/agent/core/README.md.
  • IDE setup guides and full documentation are at the canonical repository (GitHub Pages).

Workflow

Cadet-Agent follows a structured SDLC with hard gates between phases. The workflow path adapts to change size: large changes go through the full pipeline, small changes skip planning artifacts, and no_test_required changes (docs, config) skip TDD.

flowchart TD
    START(["🚀 User starts session"])
    RESUME{"state.json<br/>exists?"}
    INIT["Initialize state.json<br/>phase: context-resolution"]
    REPORT["Report current phase,<br/>epics, stories & gates"]
    CR["🔍 Context Resolution<br/>classify change size,<br/>calibrate learner,<br/>detect policy"]
    REQ["📋 Requirements<br/>Given/When/Then criteria<br/>assumption audit"]
    ARCH["🏗️ Architecture<br/>technical design,<br/>ADR decisions"]
    SPIKE["🧪 Spikes<br/>resolve unverified<br/>assumptions"]
    BREAKDOWN["📐 Story Breakdown<br/>epics → testable stories"]
    IMPL["🔨 Implementation<br/>TDD per story,<br/>red → green → refactor"]
    REVIEW["✅ Review<br/>hard gate: 17-step<br/>code review, security"]
    VALIDATE["✔️ Validation<br/>acceptance criteria,<br/>design artifact sync"]
    CLOSED(["🎉 Closed"])
    NEXT_STORY{"More stories<br/>in epic?"}

    START --> RESUME
    RESUME -->|"no"| INIT --> CR
    RESUME -->|"yes"| REPORT --> CR

    CR -->|"large change"| REQ
    CR -->|"small / no_test_required"| IMPL

    REQ --> ARCH
    ARCH -->|"unverified assumptions"| SPIKE
    ARCH -->|"all assumptions resolved"| BREAKDOWN
    SPIKE -->|"spike complete"| ARCH

    BREAKDOWN --> IMPL

    IMPL -->|"story complete"| REVIEW
    REVIEW -->|"gate: codeReviewCompleted ✅<br/>gate: securityReviewPassed ✅"| VALIDATE
    VALIDATE -->|"gate: designArtifactSyncConfirmed ✅"| NEXT_STORY
    NEXT_STORY -->|"yes"| IMPL
    NEXT_STORY -->|"no"| CLOSED

    style START fill:#4a9,stroke:#333,color:#fff
    style CLOSED fill:#4a9,stroke:#333,color:#fff
    style RESUME fill:#e8a840,stroke:#333,color:#000
    style REVIEW fill:#e87440,stroke:#333,color:#fff
    style VALIDATE fill:#e87440,stroke:#333,color:#fff

Resuming a Session

Use the /cadet-resume slash command to pick up where you left off. It reads .cadet/state.json and reports the current phase, epic/story progress, and outstanding gates — then dispatches the right skill for the next step. If no state file exists, it initializes a fresh session from context-resolution.

Phase Gating

Hard gates are enforced at every phase transition. The agent reads .cadet/state.json → gates before advancing and blocks the transition if any required gate is false. Gates cannot be skipped without an explicit user-directed exception recorded in changeHistory.

| Transition | Required Gates | |---|---| | implementation → review | testsPassed, compileCheckConfirmed, unityAnalyzerClean, storyTrackingUpdated | | review → validation | codeReviewCompleted, securityReviewPassed, acceptanceCriteriaValidated | | validation → closed | designArtifactSyncConfirmed |

Examples

GitHub Copilot

Run npx cadet-agent@latest init in your Unity project root, then open the repo in VS Code.

Agent mode: Select the Cadet Agent agent from the agent picker in Copilot Chat. The agent definition at .github/agents/cadet.agent.md loads the thin directive in .cadet/agent/core/cadet-agent.md and dispatches scoped skills.

[Describe your game dev task...]

Cadet Agent will classify the change, check .cadet/state.json for blocking gates, and invoke the appropriate skill.

Skill mode: For a specific workflow phase, use the matching slash command so the skill becomes the primary instruction context:

/cadet-requirements
create a requirements doc for a kart handling prototype
/cadet-review
review the PR at https://github.com/... or review story-1 in epic-1-player-movement

Review mode: After the Cadet Agent completes a task, select the Cadet Agent Reviewer from the agent picker. Provide the task, story, or PR to review:

Review the PR at https://github.com/... or Review story-1 in epic-1-player-movement

The reviewer will read .cadet/agent/core/cadet-agent.md as the rulebook, audit .cadet/state.json for gate compliance, and check the code and artifacts against every non-negotiable rule. It produces a structured report with a gate audit, process deviations, and recommendations — it does not edit code.

Cursor feature request

After opening the repository in Cursor, the always-apply rule in .cursor/rules/cadet-agent.md should load automatically. A typical request looks like this:

Design a small vertical slice for a kart handling prototype in Unity. Start with requirements, then a technical design, then the first TDD task.

Cursor will use the Cadet rule to pull workflow, standards, and guidance from .cadet/agent/core before responding.

Continue planning request

With Continue installed in VS Code, open the repository and ask for a scoped planning artifact:

Create a requirements outline for a single-player time-trial mode with ghost replay support and Given/When/Then acceptance criteria.

The Continue rule in .continue/rules/cadet-agent.md should steer the response back through the shared Cadet framework.

Repository policy example

If a specific game repository needs local conventions, add a policy file under .cadet/agent/policies using .cadet/agent/core/Templates/PolicyTemplate.md. For example, a repository policy could define:

  • where project plans should live
  • where shared gameplay code should be extracted
  • which Unity packages or UI stack are the project default

Package Output

Running ./package-agent.ps1 produces cadet-agent.zip with this layout:

  • .cadet/agent/core/
  • .cadet/agent/core/skills/
  • .cadet/agent/core/templates/
  • .github/agents/cadet.agent.md
  • .github/agents/cadet-agent-reviewer.agent.md
  • .github/prompts/cadet-*.prompt.md
  • .github/hooks/
  • .cursor/rules/cadet-agent.md
  • .continue/rules/cadet-agent.md
  • .claude/skills/cadet-agent.md

Notes

  • .cadet/agent/core/FrameworkManifest.json defines the managed and preserved paths for packaged installs.
  • Workflow progress is tracked in .cadet/state.json with two modes: markdown (epic/story files) or GitHub (Projects/Issues).
  • Repository-specific policy overlays belong in .cadet/agent/policies.
  • Planning artifacts belong in .cadet/agent/project-plans unless an active policy says otherwise.