claude-code-kit 0.31.0__tar.gz → 0.33.0__tar.gz

{claude_code_kit-0.31.0 → claude_code_kit-0.33.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.31.0",
+      "version": "0.33.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.31.0",
+  "version": "0.33.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.31.0 → claude_code_kit-0.33.0}/CHANGELOG.md

@@ -4,6 +4,35 @@ 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.33.0] — 2026-06-25
+
+**Pre-code Reuse & YAGNI gate** (pattern adopted from the [ponytail](https://github.com/DietrichGebert/ponytail)
+plugin, MIT; re-derived in claude-kit's idiom, no vendored code). The kit's complexity controls were all
+*reactive* (the `over-engineering-review` skill scans bloat out after code exists). This adds the proactive
+twin:
+
+- **`rules/mandatory-workflow.md` §2a.5 — Reuse & YAGNI Gate** — a new Phase-2 stage between "read code"
+  (2a) and "write code" (2b). Before adding any new file/function/abstraction, the developer walks a
+  stop-at-first-rung ladder — *needs to exist? → already in the codebase? → stdlib? → native platform
+  feature? → existing dependency? → minimum that works?* — applying the same delete/stdlib/native/yagni/
+  shrink lenses as `over-engineering-review`, but *before* the code is written. Wired into the Quick
+  Reference flow and the pipeline-gating table.
+- **`skills/over-engineering-review/SKILL.md`** — cross-links the gate as its proactive twin.
+
+No catalog/hook/agent/count changes; existing commands unaffected.
+
+## [0.32.0] — 2026-06-25
+
+**Two patterns adopted from Agent-Reach (MIT); no behavior change to existing commands.**
+
+- **`claude-kit init --dry-run`** — preview the resolved plan (stack / profile / scope / MCP / gates)
+  and the exact list of files a fresh install would write, **without touching the target project**.
+  Implemented by running the real installer into a throwaway sandbox and discarding it, so the preview
+  can never drift from a real install. Great for CI, onboarding, and evaluation.
+- **Root `llms.txt`** — a concise, machine-readable project guide (the llmstxt.org convention) so agents
+  and tools discovering the repo get install + key-command + concept pointers fast. Repo artifact only;
+  not shipped in the wheel/sdist or scaffolded into projects.
+
 ## [0.31.0] — 2026-06-24
 
 **Sharper skill auto-triggering.** Added explicit `Do NOT use when … → use [sibling]` boundary clauses to

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.31.0
+Version: 0.33.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

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.31.0"
+version = "0.33.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.31.0 → claude_code_kit-0.33.0}/rules/mandatory-workflow.md

@@ -202,6 +202,30 @@ app entry points, shared barrels) require telling the user what and why, the imp
 getting approval first. NEVER add/remove/upgrade dependencies without confirmation.
 **Gate:** you understand every file/function you'll touch; the file list is task-scoped only.
 
+## 2a.5 — Reuse & YAGNI Gate `[Developer]`
+The cheapest code is the code you never write. Before adding a single new file, function, type, or
+abstraction, walk this ladder and **stop at the first rung that satisfies the need** — only what
+survives every rung gets written:
+
+1. **Does it need to exist at all?** If the task is satisfiable without this code, don't write it.
+2. **Already in the codebase?** Search first; reuse the existing utility, component, or pattern
+   rather than adding a parallel one.
+3. **Standard library?** Prefer the language's stdlib over a hand-rolled equivalent.
+4. **Native platform feature?** A built-in input type, a CSS feature, a DB constraint, a framework
+   primitive — use it before adding a dependency or custom code.
+5. **An existing dependency?** Reuse something already installed before pulling in a new one (and
+   adding a dependency needs user approval — see 2a).
+6. **The minimum that works?** No abstraction with a single caller, no config nobody sets, no layer
+   that only delegates, no flexibility no requirement asks for.
+
+Record any deliberate shortcut where you take it — `# shortcut: <ceiling> — <upgrade path>` (see
+`.claude/skills/simplification-debt/SKILL.md`) — so it is traceable, not silent debt.
+
+This is the **proactive twin** of the reactive `over-engineering-review` skill: the same
+delete/stdlib/native/yagni/shrink lenses, applied *before* the code exists rather than scanned out
+after. **Gate:** every new unit of code traces to a rung you could not satisfy more cheaply, and the
+implementation adds no abstraction the spec does not require.
+
 ## 2b — Write Implementation Code `[Developer]`
 Follow the approved spec + dev docs and your stack's rules.
 - Put files in the correct module/package; don't put module-specific code in shared dirs.
@@ -309,7 +333,7 @@ B1 understand → B2 failing test → B3 root cause → B4 fix → B5 quality ga
 Phase 1: 1a Understand [Orchestrator] → 1b Clarify → 1c Spec [Spec Writer]
   → 1d Dev docs [Dev Doc Writer] → 1e EM review [EM Reviewer, max 3]
   → 1e.5 Plan critique [Devil's Advocate, standard+] → 1f Story breakdown + coverage gate [Story Planner]
-Phase 2: 2a Read code [Developer] → 2b Implement → 2c Code review [Code Reviewer, max 5] → 2d Impact check
+Phase 2: 2a Read code [Developer] → 2a.5 Reuse/YAGNI gate → 2b Implement → 2c Code review [Code Reviewer, max 5] → 2d Impact check
 Phase 3: 3a Unit tests ─┐ 3b E2E tests ─┘ (parallel)
   → 3b.5 Test-coverage gate (blind review + Devil's Advocate)
   → 3b.6 Security (Security Clear) → 3b.7 DevOps + Observability (if applicable)
@@ -324,6 +348,7 @@ Phase 3: 3a Unit tests ─┐ 3b E2E tests ─┘ (parallel)
 | EM `APPROVED` (1e) | Plan critique (standard+) / Story Planner starts |
 | Plan critique CONFIRMED (1e.5, standard+) | Story breakdown is final |
 | Story coverage complete — every criterion mapped, no scope creep (1f) | Developer starts coding |
+| Reuse & YAGNI gate cleared (2a.5) | Writing implementation code (2b) |
 | Code Reviewer `APPROVED` (2c) | Testing starts |
 | Both testers pass (3a+3b) | Test-coverage gate |
 | Test-coverage PASS/CONFIRMED (3b.5) | Security review |

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/skills/over-engineering-review/SKILL.md

@@ -18,6 +18,10 @@ description: Scans code for over-engineering ONLY and returns a terse delete-lis
   when you want the complexity axis alone, in a scannable form, with no other noise.
 - **Not `code-simplification`:** that skill *applies* the refactor and preserves behavior step by step.
   This skill produces the list; hand the list to `code-simplification` (or a developer) to execute.
+- **Proactive twin — `mandatory-workflow.md` §2a.5:** this skill scans complexity *out* after code
+  exists; the **Reuse & YAGNI Gate** (`.claude/rules/mandatory-workflow.md`, stage 2a.5) applies the
+  same five lenses *before* code is written. Run the gate to avoid the bloat; run this skill to catch
+  what slipped through.
 
 ## When to use
 

{claude_code_kit-0.31.0 → claude_code_kit-0.33.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.31.0"
+__version__ = "0.33.0"

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/src/claude_kit/cli.py

@@ -23,6 +23,7 @@ from claude_kit import (
     upgrader,
     validator,
 )
+from claude_kit.models import ResolvedPlan
 
 BANNER = r"""
   ___ _      _   _ ___  ___   _  _____ _____
@@ -79,6 +80,51 @@ def _print_report(ok: bool, messages: list[str]) -> None:
         raise typer.Exit(1)
 
 
+def _resolve_plan(src: Path, *, config: Optional[str], defaults: bool) -> ResolvedPlan:
+    """Resolve the user's selection (``--config`` / ``--defaults`` / interactive) into a plan."""
+    try:
+        if config is not None:
+            selection = prompts.from_config(config, src)
+        elif defaults:
+            selection = catalog.defaults(src)
+        else:
+            selection = prompts.interactive(src)
+        return catalog.resolve(src, selection)
+    except (ValueError, FileNotFoundError) as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(2) from exc
+
+
+def _print_dry_run(src: Path, target: Path, plan: ResolvedPlan) -> None:
+    """Print the resolved plan + the exact files a fresh install would write. Touches nothing."""
+    sel = plan.selection
+    stack_str = (
+        f"{sel.frontend_framework}/{sel.frontend_language} + "
+        f"{sel.backend_language}/{sel.backend_framework} + {sel.database}"
+    )
+    _, paths = scaffold.preview_install(src, target, plan)
+    typer.echo(f"\nDRY RUN — previewing install into {target} (no files written)\n")
+    typer.echo(f"  profile : {sel.profile}    scope: {sel.scope}")
+    typer.echo(f"  stack   : {stack_str}")
+    typer.echo(f"  MCP     : {', '.join(sorted(plan.mcp_servers)) or 'none'}")
+    typer.echo(
+        f"  resolves to: {len(plan.agents)} agents · {len(plan.skills)} skills · "
+        f"{len(plan.overlay_rules)} overlay rules · {len(plan.hooks)} hooks · "
+        f"{len(plan.gates)} gates"
+    )
+    if plan.gates:
+        typer.echo(f"  gates   : {', '.join(plan.gates)}")
+    typer.echo(f"\nWould write {len(paths)} file(s):")
+    for p in paths:
+        typer.echo(f"  + {p}")
+    if (target / ".claude").exists():
+        typer.echo(
+            "\nNote: this project already has .claude/ — a real run would MERGE (preserving your "
+            "files) or need --force. Use `claude-kit diff` to preview an upgrade."
+        )
+    typer.echo("\nDRY RUN — nothing was written.")
+
+
 @app.command()
 def init(
     path: Optional[str] = typer.Argument(
@@ -95,6 +141,11 @@ def init(
         "--force",
         help="overwrite existing CLAUDE.md / settings.json / .mcp.json",
     ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="preview the resolved plan and the files that would be written; write nothing",
+    ),
 ) -> None:
     """Scaffold a Claude Code SDLC configuration into a project."""
     non_interactive = defaults or config is not None
@@ -107,6 +158,14 @@ def init(
         else:
             raw = path
         target = Path(raw).expanduser().resolve()
+
+        # --dry-run: resolve + preview only. Never create the target or write anything; skip the
+        # existing-.claude handling and the install spine entirely.
+        if dry_run:
+            plan = _resolve_plan(src, config=config, defaults=defaults)
+            _print_dry_run(src, target, plan)
+            return
+
         if not target.exists():
             if not non_interactive and not typer.confirm(
                 f"Create {target}?", default=True
@@ -145,17 +204,7 @@ def init(
                 typer.echo(f"  • backed up existing .claude/ -> .claude.bak-{n}")
 
         # 3) Resolve the selection.
-        try:
-            if config is not None:
-                selection = prompts.from_config(config, src)
-            elif defaults:
-                selection = catalog.defaults(src)
-            else:
-                selection = prompts.interactive(src)
-            plan = catalog.resolve(src, selection)
-        except (ValueError, FileNotFoundError) as exc:
-            typer.echo(f"error: {exc}", err=True)
-            raise typer.Exit(2) from exc
+        plan = _resolve_plan(src, config=config, defaults=defaults)
 
         # 4) Install. Merge mode reconciles non-destructively (preserving the user's own files);
         # fresh / overwrite / backup all go through the destructive install spine.

{claude_code_kit-0.31.0 → claude_code_kit-0.33.0}/src/claude_kit/scaffold.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import hashlib
 import json
 import shutil
+import tempfile
 from contextlib import ExitStack
 from importlib.resources import as_file, files
 from pathlib import Path
@@ -566,3 +567,36 @@ def install_sdlc(
     _update_gitignore(target, log)
     _write_config(src, target, plan, log)
     return log
+
+
+def preview_install(
+    src: Path, target: Path, plan: ResolvedPlan
+) -> tuple[list[str], list[str]]:
+    """Compute what :func:`install_sdlc` would write, without touching ``target``.
+
+    Runs the real installer into a throwaway temporary directory (``force=True`` so it always writes
+    the full fresh-install set), captures its per-component log, and walks the temp tree to list the
+    files that would be created. The temp dir is discarded before returning, so the caller's project
+    is never modified. Reusing the real installer keeps the preview from ever drifting from actual
+    install behavior — there is no second code path to keep in sync.
+
+    Args:
+        src: Payload root (same as :func:`install_sdlc`).
+        target: The project that *would* be installed into — used only to label the render context
+            (project name); it is never read or written.
+        plan: The resolved install plan.
+
+    Returns:
+        ``(log_lines, would_write_paths)`` — the installer's per-component log, and the sorted list of
+        file paths (relative to the project root) that a fresh install would create.
+    """
+    # Pin the project name to the real target so the previewed context matches a real install
+    # (install_sdlc uses setdefault, so this wins over the sandbox dir name).
+    plan.context.setdefault("project_name", target.name)
+    with tempfile.TemporaryDirectory(prefix="claude-kit-dryrun-") as tmp:
+        sandbox = Path(tmp)
+        log = install_sdlc(src, sandbox, plan, force=True)
+        paths = sorted(
+            str(p.relative_to(sandbox)) for p in sandbox.rglob("*") if p.is_file()
+        )
+    return log, paths