codeforge-dev 1.5.8 → 1.8.0

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

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+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 hook input from stdin (JSON). Returns JSON on stdout.
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+
+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.
+    """
+    try:
+        entries = set(os.listdir(cwd))
+    except OSError:
+        return ("", [])
+
+    # --- Python: pytest ---
+    if "pytest.ini" in entries or "conftest.py" in entries:
+        return ("pytest", ["python3", "-m", "pytest", "--tb=short", "-q"])
+
+    for cfg_name in ("pyproject.toml", "setup.cfg", "tox.ini"):
+        cfg_path = os.path.join(cwd, cfg_name)
+        if os.path.isfile(cfg_path):
+            try:
+                with open(cfg_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                if (
+                    "[tool.pytest" in content
+                    or "[pytest]" in content
+                    or "[tool:pytest]" in content
+                ):
+                    return ("pytest", ["python3", "-m", "pytest", "--tb=short", "-q"])
+            except OSError:
+                pass
+
+    if "tests" in entries and os.path.isdir(os.path.join(cwd, "tests")):
+        return ("pytest", ["python3", "-m", "pytest", "--tb=short", "-q"])
+
+    for entry in entries:
+        if entry.startswith("test_") and entry.endswith(".py"):
+            return ("pytest", ["python3", "-m", "pytest", "--tb=short", "-q"])
+
+    # --- JavaScript: vitest ---
+    for name in entries:
+        if name.startswith("vitest.config"):
+            return ("vitest", ["npx", "vitest", "run", "--reporter=verbose"])
+
+    for vite_cfg in ("vite.config.ts", "vite.config.js"):
+        cfg_path = os.path.join(cwd, vite_cfg)
+        if os.path.isfile(cfg_path):
+            try:
+                with open(cfg_path, "r", encoding="utf-8") as f:
+                    if "test" in f.read():
+                        return (
+                            "vitest",
+                            ["npx", "vitest", "run", "--reporter=verbose"],
+                        )
+            except OSError:
+                pass
+
+    # --- JavaScript: jest ---
+    for name in entries:
+        if name.startswith("jest.config"):
+            return ("jest", ["npx", "jest", "--verbose"])
+
+    pkg_json = os.path.join(cwd, "package.json")
+    if os.path.isfile(pkg_json):
+        try:
+            with open(pkg_json, "r", encoding="utf-8") as f:
+                pkg = json.loads(f.read())
+
+            if "jest" in pkg:
+                return ("jest", ["npx", "jest", "--verbose"])
+
+            dev_deps = pkg.get("devDependencies", {})
+            deps = pkg.get("dependencies", {})
+
+            if "mocha" in dev_deps or "mocha" in deps:
+                return ("mocha", ["npx", "mocha", "--reporter", "spec"])
+
+            test_script = pkg.get("scripts", {}).get("test", "")
+            if test_script and "no test specified" not in test_script:
+                return ("npm-test", ["npm", "test"])
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    # --- Go ---
+    if "go.mod" in entries:
+        return ("go", ["go", "test", "./...", "-count=1"])
+
+    # --- Rust ---
+    if "Cargo.toml" in entries:
+        return ("cargo", ["cargo", "test"])
+
+    return ("", [])
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    # Skip if another Stop hook is already blocking
+    if input_data.get("stop_hook_active"):
+        sys.exit(0)
+
+    cwd = os.getcwd()
+    framework, cmd = detect_test_framework(cwd)
+
+    if not framework:
+        sys.exit(0)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+    except subprocess.TimeoutExpired:
+        json.dump(
+            {"additionalContext": f"[Tests] {framework} timed out after 60s"},
+            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,
+        )
+        sys.exit(0)
+
+    # Tests failed — truncate to last 30 lines
+    if not output:
+        output = "(no test output)"
+
+    lines = output.splitlines()
+    if len(lines) > 30:
+        output = "...(truncated)\n" + "\n".join(lines[-30:])
+
+    json.dump(
+        {"additionalContext": (f"[Tests] Some tests FAILED ({framework}):\n{output}")},
+        sys.stdout,
+    )
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/collect-edited-files.py

@@ -30,12 +30,14 @@ def main():
     if not os.path.isfile(file_path):
         sys.exit(0)
 
-    tmp_path = f"/tmp/claude-edited-files-{session_id}"
-    try:
-        with open(tmp_path, "a") as f:
-            f.write(file_path + "\n")
-    except OSError:
-        pass  # non-critical, don't block Claude
+    # Write to both formatter and linter temp files (independent pipelines)
+    for prefix in ("claude-edited-files", "claude-lint-files"):
+        tmp_path = f"/tmp/{prefix}-{session_id}"
+        try:
+            with open(tmp_path, "a") as f:
+                f.write(file_path + "\n")
+        except OSError:
+            pass  # non-critical, don't block Claude
 
     sys.exit(0)
 

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

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Commit reminder — Stop hook that advises about uncommitted changes.
+
+On Stop, checks for uncommitted changes (staged + unstaged) and injects
+an advisory reminder as additionalContext. Claude sees it and can
+naturally ask the user if they want to commit.
+
+Reads hook input from stdin (JSON). Returns JSON on stdout.
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import subprocess
+import sys
+
+GIT_CMD_TIMEOUT = 5
+
+
+def _run_git(args: list[str]) -> str | None:
+    """Run a git command and return stdout, or None on any failure."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True,
+            text=True,
+            timeout=GIT_CMD_TIMEOUT,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        pass
+    return None
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    # Skip if another Stop hook is already blocking
+    if input_data.get("stop_hook_active"):
+        sys.exit(0)
+
+    # Check if there are any changes at all
+    porcelain = _run_git(["status", "--porcelain"])
+    if porcelain is None:
+        # Not a git repo or git not available
+        sys.exit(0)
+    if not porcelain.strip():
+        # Working tree clean
+        sys.exit(0)
+
+    lines = porcelain.strip().splitlines()
+    total = len(lines)
+
+    # Count staged vs unstaged
+    staged = 0
+    unstaged = 0
+    for line in lines:
+        index_status = line[0:1] if len(line) > 0 else " "
+        worktree_status = line[1:2] if len(line) > 1 else " "
+
+        if index_status not in (" ", "?"):
+            staged += 1
+        if worktree_status not in (" ", "?"):
+            unstaged += 1
+        if line[0:2] == "??":
+            unstaged += 1
+
+    parts = []
+    if staged:
+        parts.append(f"{staged} staged")
+    if unstaged:
+        parts.append(f"{unstaged} unstaged")
+
+    summary = ", ".join(parts) if parts else f"{total} changed"
+
+    message = (
+        f"[Uncommitted Changes] {total} files with changes ({summary}).\n"
+        "Consider asking the user if they'd like to commit before finishing."
+    )
+
+    json.dump({"additionalContext": message}, sys.stdout)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Git state injector — SessionStart hook that injects repo state as context.
+
+Runs git commands to gather branch, status, recent commits, and uncommitted
+changes. Injects the results as additionalContext so Claude starts every
+session knowing the current git state.
+
+Reads hook input from stdin (JSON). Returns JSON on stdout.
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+GIT_CMD_TIMEOUT = 5
+STATUS_LINE_CAP = 20
+DIFF_STAT_LINE_CAP = 15
+TOTAL_OUTPUT_CAP = 2000
+
+
+def _run_git(args: list[str], cwd: str) -> str | None:
+    """Run a git command and return stdout, or None on any failure."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=GIT_CMD_TIMEOUT,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        pass
+    return None
+
+
+def _cap_lines(text: str, limit: int) -> str:
+    """Truncate text to a maximum number of lines."""
+    lines = text.splitlines()
+    if len(lines) <= limit:
+        return text
+    return "\n".join(lines[:limit]) + f"\n...({len(lines) - limit} more lines)"
+
+
+def main():
+    try:
+        json.load(sys.stdin)
+    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
+        sys.exit(0)
+
+    sections = []
+    sections.append(f"Branch: {branch or '(detached HEAD)'}")
+
+    # Git status
+    status = _run_git(["status", "--short"], cwd)
+    if status:
+        status_lines = status.splitlines()
+        modified = sum(1 for l in status_lines if l.strip() and l[0:1] == "M")
+        added = sum(1 for l in status_lines if l[0:1] == "A")
+        deleted = sum(1 for l in status_lines if l[0:1] == "D")
+        untracked = sum(1 for l in status_lines if l[0:2] == "??")
+
+        counts = []
+        if modified:
+            counts.append(f"{modified} modified")
+        if added:
+            counts.append(f"{added} added")
+        if deleted:
+            counts.append(f"{deleted} deleted")
+        if untracked:
+            counts.append(f"{untracked} untracked")
+
+        summary = ", ".join(counts) if counts else f"{len(status_lines)} changed"
+        sections.append(f"Status: {summary}")
+        sections.append(_cap_lines(status, STATUS_LINE_CAP))
+    else:
+        sections.append("Status: clean")
+
+    # Recent commits
+    log = _run_git(["log", "--oneline", "-5"], cwd)
+    if log:
+        sections.append(f"Recent commits:\n{log}")
+
+    # Uncommitted diff stats
+    diff_stat = _run_git(["diff", "--stat"], cwd)
+    if diff_stat:
+        sections.append(
+            f"Uncommitted changes:\n{_cap_lines(diff_stat, DIFF_STAT_LINE_CAP)}"
+        )
+
+    output = "[Git State]\n" + "\n".join(sections)
+
+    # Cap total output to avoid context bloat
+    if len(output) > TOTAL_OUTPUT_CAP:
+        output = output[:TOTAL_OUTPUT_CAP] + "\n...(truncated)"
+
+    json.dump({"additionalContext": output}, sys.stdout)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()