claude-code-kit 0.55.0__tar.gz → 0.56.0__tar.gz

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "claude-kit",
       "source": "./",
       "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker): install CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json, then run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.",
-      "version": "0.55.0",
+      "version": "0.56.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker). `claude-kit init` asks ordered questions and installs CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates with working memory and a self-improving learnings loop.",
   "author": {
     "name": "Arjunsingh Yadav",

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to claude-kit are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project uses
 [semantic versioning](https://semver.org/).
 
+## [0.56.0] — 2026-07-01
+
+**`export` command — carry the config to Cursor / VS Code / GitHub Copilot.** A teammate who works in
+an editor that isn't Claude Code can't consume `.claude/` or run the gated `/sdlc` pipeline. `claude-kit
+export` projects the **same resolved plan** into the formats those single-agent editors read natively,
+so claude-kit's standards travel even where the pipeline can't. No change to the core promise —
+configuration-only SDLC scaffolding for Claude Code, no application code, no Docker, stack-agnostic
+core, catalog-driven. **0 new agents/skills**; `catalog.resolve()` untouched (a pure projection of the
+existing plan).
+
+### Added
+
+- **`claude-kit export [path] -t cursor|agents|copilot`.** Re-targets the resolved `ResolvedPlan` to:
+  - **`cursor`** — `.cursor/rules/*.mdc` (one per rule, with YAML frontmatter derived generically from
+    each rule: `description` = H1 + lead sentence; `alwaysApply: false` for the on-demand rule set;
+    overlay rules get `globs` keyed on the plan's *language/database* values — `typescript` →
+    `**/*.ts,**/*.tsx`, `python` → `**/*.py`, `postgres` → `**/*.sql`, …), an always-applied
+    `000-project.mdc` charter, and `.cursor/mcp.json` (the `type` discriminator stripped for Cursor).
+  - **`agents`** — a root `AGENTS.md` (charter + single-agent SDLC checklist + rule index + fidelity
+    note); read by both Cursor and Copilot.
+  - **`copilot`** — `.github/copilot-instructions.md` (the same synthesized document as `agents`).
+- **Honest fidelity, everywhere.** Rules, the project charter, and MCP port cleanly; the **enforced**
+  quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only and are
+  exported as a single-agent **self-check checklist**. Every exported document states this explicitly
+  (a "What ports from Claude Code — and what doesn't" note + the workflow guide's opening).
+- **Flags mirror `init`:** `--dry-run` (report, write nothing), `--force` (refresh in place; otherwise
+  a hand-edited file is preserved and the new version lands beside it as a `.claude-kit` sidecar),
+  `--config`/`--defaults` (resolve a fresh selection instead of the project's installed one), `--json`.
+- **New payload template** `templates/export/sdlc-workflow-guide.md.tmpl` (stack-agnostic; renders with
+  the project's real test/lint/build commands), plus `tests/test_export.py` and
+  [`docs/cursor-export.md`](docs/cursor-export.md) (usage + the full fidelity matrix).
+
 ## [0.55.0] — 2026-07-01
 
 **React overlay rules split under Claude Code's 40k memory limit.** Two React design-system overlay

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.55.0
+Version: 0.56.0
 Summary: Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.
 Project-URL: Homepage, https://github.com/ajyadav013/claude-kit
 Project-URL: Repository, https://github.com/ajyadav013/claude-kit
@@ -236,6 +236,36 @@ README.claude-sdlc.md
 
 ---
 
+## Use in Cursor / VS Code / Copilot (export)
+
+A teammate who works in **Cursor**, **VS Code**, or **GitHub Copilot** can't consume `.claude/` or run
+the gated multi-agent `/sdlc` pipeline — those editors drive their own single agent. `claude-kit
+export` projects the **same resolved plan** into the formats those agents read natively, so the
+standards travel even when the pipeline can't:
+
+```bash
+claude-kit export .                              # → .cursor/ (default target)
+claude-kit export . -t cursor -t agents -t copilot   # all three at once
+claude-kit export . --dry-run                    # preview; writes nothing
+```
+
+| Target | Emits | What lands |
+|---|---|---|
+| `cursor` | `.cursor/rules/*.mdc` + `.cursor/mcp.json` | The full rule set (one on-demand `.mdc` each, overlays auto-attach by file glob), an always-applied `000-project.mdc` charter, and your MCP servers |
+| `agents` | `AGENTS.md` (repo root) | Project charter + single-agent SDLC checklist + rule index (read by Cursor **and** Copilot) |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents` |
+
+**Fidelity is honest.** Rules, the project charter, and MCP servers port cleanly. The **enforced**
+quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only — the
+export carries the SDLC workflow as a **single-agent self-check checklist**, not enforced gates. Every
+exported document says so. Exports are regenerable projections: `--force` refreshes them in place, and
+without it a hand-edited file is preserved (the new version drops beside it as a `.claude-kit` sidecar).
+
+See **[docs/cursor-export.md](docs/cursor-export.md)** for the full fidelity matrix and the `.mdc`
+frontmatter mapping.
+
+---
+
 ## Feature details
 
 Each area from the [Features](#features) table, expanded — the README stays short; open only what you
@@ -724,6 +754,7 @@ everything available.
 | `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
 | `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
+| `export [path] -t cursor\|agents\|copilot [--force] [--dry-run] [--json]` | Project the config into Cursor (`.cursor/`), a root `AGENTS.md`, or GitHub Copilot (`.github/copilot-instructions.md`) for editors that aren't Claude Code |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
 | `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/README.md

@@ -203,6 +203,36 @@ README.claude-sdlc.md
 
 ---
 
+## Use in Cursor / VS Code / Copilot (export)
+
+A teammate who works in **Cursor**, **VS Code**, or **GitHub Copilot** can't consume `.claude/` or run
+the gated multi-agent `/sdlc` pipeline — those editors drive their own single agent. `claude-kit
+export` projects the **same resolved plan** into the formats those agents read natively, so the
+standards travel even when the pipeline can't:
+
+```bash
+claude-kit export .                              # → .cursor/ (default target)
+claude-kit export . -t cursor -t agents -t copilot   # all three at once
+claude-kit export . --dry-run                    # preview; writes nothing
+```
+
+| Target | Emits | What lands |
+|---|---|---|
+| `cursor` | `.cursor/rules/*.mdc` + `.cursor/mcp.json` | The full rule set (one on-demand `.mdc` each, overlays auto-attach by file glob), an always-applied `000-project.mdc` charter, and your MCP servers |
+| `agents` | `AGENTS.md` (repo root) | Project charter + single-agent SDLC checklist + rule index (read by Cursor **and** Copilot) |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents` |
+
+**Fidelity is honest.** Rules, the project charter, and MCP servers port cleanly. The **enforced**
+quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only — the
+export carries the SDLC workflow as a **single-agent self-check checklist**, not enforced gates. Every
+exported document says so. Exports are regenerable projections: `--force` refreshes them in place, and
+without it a hand-edited file is preserved (the new version drops beside it as a `.claude-kit` sidecar).
+
+See **[docs/cursor-export.md](docs/cursor-export.md)** for the full fidelity matrix and the `.mdc`
+frontmatter mapping.
+
+---
+
 ## Feature details
 
 Each area from the [Features](#features) table, expanded — the README stays short; open only what you
@@ -691,6 +721,7 @@ everything available.
 | `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
 | `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
+| `export [path] -t cursor\|agents\|copilot [--force] [--dry-run] [--json]` | Project the config into Cursor (`.cursor/`), a root `AGENTS.md`, or GitHub Copilot (`.github/copilot-instructions.md`) for editors that aren't Claude Code |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
 | `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/docs/architecture.md

@@ -75,6 +75,17 @@ flowchart TB
 Adding a framework/database/profile/MCP server is a **catalog edit + a `templates/stacks/` folder** —
 never a change to `resolve()`.
 
+### Same plan, second target: `export` (for non-Claude-Code editors)
+
+The `ResolvedPlan` is the reuse seam. `claude-kit export` (`src/claude_kit/export.py`) takes the **same**
+plan and, instead of `scaffold.install_sdlc()` writing `.claude/`, projects it into the formats a
+single-agent editor reads natively — `.cursor/rules/*.mdc` + `.cursor/mcp.json` (Cursor), a root
+`AGENTS.md`, or `.github/copilot-instructions.md` (Copilot). It is a pure projection: it adds no stack
+knowledge, and `catalog.resolve()` gains no branches (golden rules #1 and #6). Fidelity is asymmetric
+and stated in every exported file — rules, the charter, and MCP port cleanly, while the *enforced*
+gates and reviewer subagents become single-agent guidance. See
+[cursor-export.md](cursor-export.md) for the full mapping.
+
 ---
 
 ## 3. The SDLC pipeline (run)

claude_code_kit-0.56.0/docs/cursor-export.md

@@ -0,0 +1,94 @@
+# Exporting to Cursor / VS Code / GitHub Copilot
+
+claude-kit's home is **Claude Code**, where it installs a `.claude/` configuration and runs a gated,
+multi-agent `/sdlc` pipeline. A teammate working in **Cursor**, **VS Code**, or **GitHub Copilot**
+uses that editor's *own* single agent — which can't read `.claude/` or run the pipeline. `claude-kit
+export` bridges the gap by projecting the **same resolved plan** into the formats those agents read
+natively.
+
+It is a **projection**, not a second source of truth: the exporter re-targets the exact `ResolvedPlan`
+that `init` installs (`catalog.resolve()` is untouched, no new stack knowledge). Re-run it any time to
+regenerate; it writes **configuration only** — no application code, no Docker.
+
+## Usage
+
+```bash
+claude-kit export .                                   # default target: cursor
+claude-kit export . -t cursor -t agents -t copilot    # all three
+claude-kit export . --dry-run                         # preview; write nothing
+claude-kit export . --force                            # refresh existing files in place
+claude-kit export . -t agents --json                  # machine-readable file list
+```
+
+By default `export` resolves from the project's **installed selection**
+(`.claude/config/init-options.json`), so the export matches what was scaffolded. Pass `--config FILE`
+or `--defaults` to resolve a fresh selection instead — useful for a standalone export into a project
+that never ran `init`.
+
+**Conflict-safe writes.** Exports are regenerable, so `--force` refreshes them in place. Without
+`--force`, an existing (possibly hand-edited) file is preserved and the new version is written beside it
+as a `<name>.claude-kit` sidecar — the same non-destructive convention the installer uses.
+
+## What each target emits
+
+| Target | Files | Contents |
+|---|---|---|
+| `cursor` | `.cursor/rules/000-project.mdc` | The project **charter** + single-agent SDLC workflow + fidelity note. `alwaysApply: true` — always in context. |
+| | `.cursor/rules/<rule>.mdc` (one per rule) | Every core rule and every stack overlay, `alwaysApply: false` (agent pulls on demand by `description`); overlays also carry `globs` to auto-attach on matching files. |
+| | `.cursor/mcp.json` | Your selected MCP servers (omitted when none are selected). |
+| `agents` | `AGENTS.md` (repo root) | Charter + workflow + a **rule index** (one line per rule) + the fidelity note. Read by both Cursor and Copilot. |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents`. |
+
+## `.mdc` frontmatter derivation
+
+Each Cursor rule file gets YAML frontmatter derived generically from the rule's own content — no
+per-stack branching:
+
+- **`description`** — the rule's H1 heading plus its first lead sentence (falling back to a humanized
+  filename), trimmed to ~200 characters. Cursor uses this to decide when to pull an on-demand rule.
+- **`alwaysApply`** — `false` for the whole rule set (mirroring Claude Code's on-demand rule loading);
+  `true` only for the synthesized `000-project.mdc` charter.
+- **`globs`** — attached to **overlay** rules only, chosen from the overlay's lane and the plan's
+  *language/database* values (not framework names):
+
+  | Lane | Source value | Example glob |
+  |---|---|---|
+  | frontend | `frontend_language` | `typescript` → `**/*.ts,**/*.tsx` |
+  | backend | `backend_language` | `python` → `**/*.py`, `go` → `**/*.go` |
+  | database | `database` | `postgres` → `**/*.sql` |
+
+  A store with no reliable file signal (e.g. a document database) gets **no** glob and loads by
+  `description` instead. Core rules never get globs.
+
+Values are JSON-quoted so the frontmatter is always valid YAML — an unquoted glob such as
+`**/*.{ts,tsx}` would be misparsed as a YAML flow mapping.
+
+## MCP projection
+
+Cursor's `.cursor/mcp.json` uses a top-level `mcpServers` map and infers transport from the keys
+present — stdio servers use `command`/`args`/`env`, remote servers use `url`/`headers`. claude-kit's
+internal `type` discriminator is **dropped**; every other key passes through verbatim.
+
+## Fidelity: what ports, and what doesn't
+
+| Capability | Claude Code | Exported (Cursor / AGENTS.md / Copilot) |
+|---|---|---|
+| Engineering rules + stack/design-system overlays | ✅ enforced/on-demand | ✅ full text (`.mdc`) or index (AGENTS.md) |
+| Project charter (stack, commands, lanes) | ✅ | ✅ |
+| MCP servers | ✅ (`.mcp.json`) | ✅ Cursor (`.cursor/mcp.json`); not applicable to AGENTS.md/Copilot |
+| SDLC phases | ✅ **enforced quality gates** | ⚠️ single-agent **self-check checklist** (guidance) |
+| Independent reviewer subagents | ✅ separate agents | ❌ one agent plays every role |
+| Security scan (parallel sub-scanners) | ✅ | ⚠️ a security self-check step in the checklist |
+| Automated defect loop (blocks on unproven verdict) | ✅ | ⚠️ described as discipline; nothing blocks |
+
+The enforced gates, reviewer subagents, and automated defect loop depend on Claude Code's multi-agent
+runtime and **cannot** be reproduced under a single-agent editor. The export is honest about this: the
+charter carries a "What ports from Claude Code — and what doesn't" note, and the workflow guide opens
+by stating it is a self-check checklist, not enforced gates.
+
+## Out of scope (for now)
+
+- **Cursor hooks** (`.cursor/hooks.json`) and **commands/skills** export — a different event/format
+  model; noted as future work.
+- **Drift tracking** of exported files in the `init-options.json` ownership manifest — exports are
+  regenerable projections (`export --force` refreshes), so they are intentionally not tracked.

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.55.0"
+version = "0.56.0"
 description = "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop."
 readme = "README.md"
 requires-python = ">=3.9"

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/src/claude_kit/__init__.py

@@ -7,4 +7,4 @@ Docker): ``claude-kit init`` asks ordered questions and lays down ``CLAUDE.md``
 as a plugin. Extensibility is data-driven via the ``catalog/`` (stacks, profiles, MCP).
 """
 
-__version__ = "0.55.0"
+__version__ = "0.56.0"

{claude_code_kit-0.55.0 → claude_code_kit-0.56.0}/src/claude_kit/cli.py

@@ -27,7 +27,8 @@ from claude_kit import (
     upgrader,
     validator,
 )
-from claude_kit.models import ResolvedPlan
+from claude_kit import export as exporter
+from claude_kit.models import ResolvedPlan, Selection
 
 # Planned-but-unimplemented commands are hidden from `--help` by default so they
 # can't be mistaken for working features. Set CLAUDE_KIT_EXPERIMENTAL=1 to surface
@@ -316,6 +317,110 @@ def init(
         )
 
 
+def _plan_for_export(
+    src: Path, target_dir: Path, *, config: Optional[str], defaults: bool
+) -> ResolvedPlan:
+    """Resolve the plan to export: prefer the project's installed selection, else config/defaults/prompt.
+
+    ``export .`` in an installed project reads ``.claude/config/init-options.json`` so the export
+    matches what was scaffolded. ``--config`` / ``--defaults`` force a fresh resolution (useful for a
+    standalone export into a project that never ran ``init``); with neither and no install present, it
+    falls back to the interactive prompt via :func:`_resolve_plan`.
+    """
+    opts = target_dir / ".claude" / "config" / "init-options.json"
+    if config is None and not defaults and opts.is_file():
+        try:
+            data = json.loads(opts.read_text(encoding="utf-8"))
+            selection = Selection.from_dict(data.get("selection", {}))
+            return catalog.resolve(src, selection)
+        except (ValueError, KeyError, json.JSONDecodeError) as exc:
+            typer.echo(f"error: could not read installed selection: {exc}", err=True)
+            raise typer.Exit(2) from exc
+    return _resolve_plan(src, config=config, defaults=defaults)
+
+
+# Module-level singleton: a repeatable-list option can't be defined inline (ruff B008 flags a call in
+# a mutable-typed argument default), so the Option lives here and the command reads it as its default.
+_EXPORT_TARGET_OPTION = typer.Option(
+    None,
+    "--target",
+    "-t",
+    help="export target(s), repeatable: cursor | agents | copilot (default: cursor)",
+)
+
+
+@app.command()
+def export(
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+    target: Optional[list[str]] = _EXPORT_TARGET_OPTION,
+    config: Optional[str] = typer.Option(
+        None,
+        "--config",
+        help="resolve the selection from a YAML file instead of the installed one",
+    ),
+    defaults: bool = typer.Option(
+        False,
+        "--defaults",
+        help="resolve from catalog defaults instead of the installed selection",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="overwrite existing exported files instead of writing .claude-kit sidecars",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="report the files that would be written; write nothing"
+    ),
+    json_out: bool = typer.Option(
+        False, "--json", help="emit the written-file list as JSON instead of text"
+    ),
+) -> None:
+    """Export the config for Cursor / AGENTS.md / GitHub Copilot (editors that aren't Claude Code).
+
+    Projects the same resolved plan claude-kit installs under .claude/ into the formats a single-agent
+    editor reads natively — the full rule set + a project charter + the SDLC workflow as guidance, plus
+    MCP servers for Cursor. The enforced gates and reviewer subagents are Claude Code-only.
+    """
+    targets = list(dict.fromkeys(target or ["cursor"]))
+    unknown = [t for t in targets if t not in exporter.VALID_TARGETS]
+    if unknown:
+        typer.echo(
+            f"error: unknown export target(s): {', '.join(unknown)} "
+            f"(choices: {', '.join(exporter.VALID_TARGETS)})",
+            err=True,
+        )
+        raise typer.Exit(2)
+    with ExitStack() as stack:
+        src = scaffold.payload_dir(stack)
+        target_dir = Path(path).expanduser().resolve()
+        plan = _plan_for_export(src, target_dir, config=config, defaults=defaults)
+        written = exporter.export_targets(
+            src, target_dir, plan, targets, force=force, dry_run=dry_run
+        )
+
+    if json_out:
+        typer.echo(
+            json.dumps(
+                {
+                    "target": str(target_dir),
+                    "targets": targets,
+                    "dry_run": dry_run,
+                    "written": written,
+                },
+                indent=2,
+            )
+        )
+        return
+
+    typer.echo(f"\nclaude-kit export → {', '.join(targets)}  ({target_dir})\n")
+    for w in written:
+        typer.echo(f"  {'+' if dry_run else '•'} {w}")
+    tail = "  (dry run — nothing written)" if dry_run else ""
+    typer.echo(
+        f"\n{'Would write' if dry_run else 'Wrote'} {len(written)} file(s).{tail}"
+    )
+
+
 @app.command()
 def validate(
     path: str = typer.Argument(".", help="target project dir (default: .)"),