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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.31.0",
+  "version": "0.32.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.32.0}/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.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.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.31.0
+Version: 0.32.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.32.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.31.0"
+version = "0.32.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.32.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.32.0"

{claude_code_kit-0.31.0 → claude_code_kit-0.32.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.32.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