codeforge-dev 1.9.0 → 1.11.0

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/advisory-test-runner.py

@@ -2,9 +2,10 @@
 """
 Advisory test runner — Stop hook that injects test results as context.
 
-Detects the project's test framework and runs the test suite. Results are
-returned as additionalContext so Claude sees pass/fail info without being
-blocked. If tests fail, Claude's next response will naturally address them.
+Reads the list of files edited this session (written by collect-edited-files.py),
+maps them to affected test files, and runs only those tests. Skips entirely
+if no files were edited. Results are returned as additionalContext so Claude
+sees pass/fail info without being blocked.
 
 Reads hook input from stdin (JSON). Returns JSON on stdout.
 Always exits 0 (advisory, never blocking).
@@ -15,15 +16,37 @@ import os
 import subprocess
 import sys
 
+TIMEOUT_SECONDS = 15
+
+
+def get_edited_files(session_id: str) -> list[str]:
+    """Read the list of files edited this session.
+
+    Relies on collect-edited-files.py writing paths to a temp file.
+    Returns deduplicated list of paths that still exist on disk.
+    """
+    tmp_path = f"/tmp/claude-edited-files-{session_id}"
+    try:
+        with open(tmp_path, "r") as f:
+            raw = f.read()
+    except OSError:
+        return []
+
+    seen: set[str] = set()
+    result: list[str] = []
+    for line in raw.strip().splitlines():
+        path = line.strip()
+        if path and path not in seen and os.path.isfile(path):
+            seen.add(path)
+            result.append(path)
+    return result
+
 
 def detect_test_framework(cwd: str) -> tuple[str, list[str]]:
     """Detect which test framework is available in the project.
 
-    Checks for: pytest, vitest, jest, mocha, go test, cargo test.
-    Falls back to npm test if a test script is defined.
-
     Returns:
-        Tuple of (framework_name, command_list) or ("", []) if none found.
+        Tuple of (framework_name, base_command) or ("", []) if none found.
     """
     try:
         entries = set(os.listdir(cwd))
@@ -102,7 +125,7 @@ def detect_test_framework(cwd: str) -> tuple[str, list[str]]:
 
     # --- Go ---
     if "go.mod" in entries:
-        return ("go", ["go", "test", "./...", "-count=1"])
+        return ("go", ["go", "test", "-count=1"])
 
     # --- Rust ---
     if "Cargo.toml" in entries:
@@ -111,6 +134,139 @@ def detect_test_framework(cwd: str) -> tuple[str, list[str]]:
     return ("", [])
 
 
+def resolve_pytest_tests(edited_files: list[str], cwd: str) -> tuple[list[str], bool]:
+    """Map edited Python files to their corresponding pytest test files.
+
+    Returns:
+        (test_files, run_all) — if run_all is True, run the whole suite
+        (e.g. conftest.py was edited).
+    """
+    test_files: list[str] = []
+
+    for path in edited_files:
+        if not path.endswith(".py"):
+            continue
+
+        basename = os.path.basename(path)
+
+        # conftest changes can affect anything — run full suite
+        if basename == "conftest.py":
+            return ([], True)
+
+        # Already a test file — include directly
+        if basename.startswith("test_") or "/tests/" in path:
+            if os.path.isfile(path):
+                test_files.append(path)
+            continue
+
+        # Map source → test via directory mirroring
+        # e.g. src/engine/db/sessions.py → tests/engine/db/test_sessions.py
+        # e.g. src/engine/api/routes/github.py → tests/engine/api/test_routes_github.py
+        rel = os.path.relpath(path, cwd)
+        parts = rel.split(os.sep)
+
+        # Strip leading "src/" if present
+        if parts and parts[0] == "src":
+            parts = parts[1:]
+
+        if not parts:
+            continue
+
+        module = parts[-1]  # e.g. "sessions.py"
+        module_name = module.removesuffix(".py")
+        parent_parts = parts[:-1]  # e.g. ["engine", "db"]
+
+        # Standard mapping: tests/<parent>/test_<module>.py
+        test_path = os.path.join(cwd, "tests", *parent_parts, f"test_{module_name}.py")
+        if os.path.isfile(test_path):
+            test_files.append(test_path)
+            continue
+
+        # Routes mapping: src/engine/api/routes/github.py
+        # → tests/engine/api/test_routes_github.py
+        if len(parent_parts) >= 2 and parent_parts[-1] == "routes":
+            route_test = os.path.join(
+                cwd,
+                "tests",
+                *parent_parts[:-1],
+                f"test_routes_{module_name}.py",
+            )
+            if os.path.isfile(route_test):
+                test_files.append(route_test)
+
+    # Deduplicate while preserving order
+    seen: set[str] = set()
+    unique: list[str] = []
+    for t in test_files:
+        if t not in seen:
+            seen.add(t)
+            unique.append(t)
+
+    return (unique, False)
+
+
+def resolve_affected_tests(
+    edited_files: list[str], cwd: str, framework: str
+) -> tuple[list[str], bool]:
+    """Resolve edited files to framework-specific test arguments.
+
+    Returns:
+        (extra_args, run_all) — extra_args to append to the base command.
+        If run_all is True, run the whole suite (no extra args needed).
+        If extra_args is empty and run_all is False, skip testing entirely.
+    """
+    if framework == "pytest":
+        test_files, run_all = resolve_pytest_tests(edited_files, cwd)
+        return (test_files, run_all)
+
+    if framework == "vitest":
+        # vitest --related does dep-graph analysis natively
+        source_files = [
+            f
+            for f in edited_files
+            if not f.endswith(
+                (".md", ".json", ".yaml", ".yml", ".toml", ".txt", ".css")
+            )
+        ]
+        if not source_files:
+            return ([], False)
+        return (["--related"] + source_files, False)
+
+    if framework == "jest":
+        source_files = [
+            f
+            for f in edited_files
+            if not f.endswith(
+                (".md", ".json", ".yaml", ".yml", ".toml", ".txt", ".css")
+            )
+        ]
+        if not source_files:
+            return ([], False)
+        return (["--findRelatedTests"] + source_files, False)
+
+    if framework == "go":
+        # Map edited .go files to their package directories
+        pkgs: set[str] = set()
+        for path in edited_files:
+            if path.endswith(".go"):
+                pkg_dir = os.path.dirname(path)
+                rel = os.path.relpath(pkg_dir, cwd)
+                pkgs.add(f"./{rel}")
+        if not pkgs:
+            return ([], False)
+        return (sorted(pkgs), False)
+
+    # cargo, mocha, npm-test — no granular selection, run full suite
+    code_files = [
+        f
+        for f in edited_files
+        if not f.endswith((".md", ".json", ".yaml", ".yml", ".toml", ".txt"))
+    ]
+    if not code_files:
+        return ([], False)
+    return ([], True)
+
+
 def main():
     try:
         input_data = json.load(sys.stdin)
@@ -121,34 +277,51 @@ def main():
     if input_data.get("stop_hook_active"):
         sys.exit(0)
 
+    session_id = input_data.get("session_id", "")
+    if not session_id:
+        sys.exit(0)
+
+    # No files edited this session — nothing to test
+    edited_files = get_edited_files(session_id)
+    if not edited_files:
+        sys.exit(0)
+
     cwd = os.getcwd()
-    framework, cmd = detect_test_framework(cwd)
+    framework, base_cmd = detect_test_framework(cwd)
 
     if not framework:
         sys.exit(0)
 
+    extra_args, run_all = resolve_affected_tests(edited_files, cwd, framework)
+
+    # No affected tests and not a run-all situation — skip
+    if not extra_args and not run_all:
+        sys.exit(0)
+
+    cmd = base_cmd + extra_args
+
     try:
         result = subprocess.run(
             cmd,
             cwd=cwd,
             capture_output=True,
             text=True,
-            timeout=60,
+            timeout=TIMEOUT_SECONDS,
         )
     except subprocess.TimeoutExpired:
         json.dump(
-            {"additionalContext": f"[Tests] {framework} timed out after 60s"},
+            {
+                "additionalContext": f"[Tests] {framework} timed out after {TIMEOUT_SECONDS}s"
+            },
             sys.stdout,
         )
         sys.exit(0)
     except (FileNotFoundError, OSError):
-        # Test runner not installed or not accessible
         sys.exit(0)
 
     output = (result.stdout + "\n" + result.stderr).strip()
 
     if result.returncode == 0:
-        # Extract test count from output if possible
         json.dump(
             {"additionalContext": f"[Tests] All tests passed ({framework})"},
             sys.stdout,

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/git-state-injector.py

@@ -47,20 +47,31 @@ def _cap_lines(text: str, limit: int) -> str:
 
 
 def main():
+    # Parse hook input to get cwd from Claude Code (falls back to os.getcwd())
+    cwd = os.getcwd()
     try:
-        json.load(sys.stdin)
+        input_data = json.load(sys.stdin)
+        cwd = input_data.get("cwd", cwd)
     except (json.JSONDecodeError, ValueError):
         pass
 
-    cwd = os.getcwd()
-
     # Check if we're in a git repo at all
     branch = _run_git(["branch", "--show-current"], cwd)
     if branch is None:
-        # Not a git repo or git not available
+        # Not a git repo or git not available — still inject working directory
+        output = (
+            f"[Git State]\n"
+            f"Working Directory: {cwd} — restrict all file operations to this "
+            f"directory unless explicitly instructed otherwise."
+        )
+        json.dump({"additionalContext": output}, sys.stdout)
         sys.exit(0)
 
     sections = []
+    sections.append(
+        f"Working Directory: {cwd} — restrict all file operations to this "
+        f"directory unless explicitly instructed otherwise."
+    )
     sections.append(f"Branch: {branch or '(detached HEAD)'}")
 
     # Git status

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/inject-cwd.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""
+CWD injector — SubagentStart hook that tells subagents the working directory.
+
+Reads hook input from stdin (JSON), extracts cwd, and returns it as
+additionalContext so every subagent knows where to scope its work.
+
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import os
+import sys
+
+
+def main():
+    cwd = os.getcwd()
+    try:
+        input_data = json.load(sys.stdin)
+        cwd = input_data.get("cwd", cwd)
+    except (json.JSONDecodeError, ValueError):
+        pass
+
+    json.dump(
+        {
+            "additionalContext": (
+                f"Working Directory: {cwd} — restrict all file operations to "
+                f"this directory unless explicitly instructed otherwise."
+            )
+        },
+        sys.stdout,
+    )
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/skill-suggester.py

@@ -296,6 +296,30 @@ SKILLS = {
         ],
         "terms": ["migrate", "migration", "upgrade"],
     },
+    "spec-build": {
+        "phrases": [
+            "implement the spec",
+            "build from spec",
+            "start building",
+            "spec-build",
+            "implement this feature from the spec",
+            "build what the spec describes",
+            "implement from the spec",
+            "build the feature",
+        ],
+        "terms": ["spec-build"],
+    },
+    "spec-review": {
+        "phrases": [
+            "review the spec",
+            "check spec adherence",
+            "verify implementation",
+            "spec-review",
+            "does code match spec",
+            "audit implementation",
+        ],
+        "terms": ["spec-review"],
+    },
 }
 
 # Pre-compile term patterns for whole-word matching

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/spec-reminder.py

@@ -109,8 +109,10 @@ def main():
     message = (
         f"[Spec Reminder] Code was modified in {dirs_str} "
         "but no specs were updated. "
-        "Use /spec-update to update the relevant spec, "
-        "or /spec-new if no spec exists for this feature."
+        "Use /spec-review to verify implementation against the spec, "
+        "then /spec-update to close the loop. "
+        "Use /spec-new if no spec exists for this feature, "
+        "or /spec-refine if the spec is still in draft status."
     )
 
     json.dump({"additionalContext": message}, sys.stdout)

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/skills/documentation-patterns/SKILL.md

@@ -65,7 +65,7 @@ Development setup, how to run tests, how to submit changes. Link to CONTRIBUTING
 
 ## Sizing Rules
 
-Documentation files consumed by AI tools (CLAUDE.md, specs, architecture docs) should be **≤200 lines** each. Split large documents by concern. Each file should be independently useful.
+Documentation files consumed by AI tools (CLAUDE.md, specs, architecture docs) should aim for **~200 lines** each. Split large documents by concern when practical. Each file should be independently useful.
 
 For human-facing docs (README, API reference), there is no hard limit, but prefer shorter docs that link to detailed sub-pages over monolithic documents.