codeforge-dev 1.7.0 → 1.8.0

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/hooks/hooks.json

@@ -21,6 +21,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/skill-suggester.py",
             "timeout": 3
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/ticket-linker.py",
+            "timeout": 12
           }
         ]
       }
@@ -37,6 +42,40 @@
         ]
       }
     ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/advisory-test-runner.py",
+            "timeout": 65
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/commit-reminder.py",
+            "timeout": 8
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/git-state-injector.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/todo-harvester.py",
+            "timeout": 8
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "Edit|Write",

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()

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

@@ -235,6 +235,67 @@ SKILLS = {
             "throughput",
         ],
     },
+    "api-design": {
+        "phrases": [
+            "api design",
+            "rest api design",
+            "design an api",
+            "design a rest",
+            "api convention",
+            "endpoint design",
+            "api versioning",
+            "pagination pattern",
+            "error response format",
+        ],
+        "terms": ["openapi", "swagger", "rfc7807"],
+    },
+    "ast-grep-patterns": {
+        "phrases": [
+            "ast-grep",
+            "ast grep",
+            "structural search",
+            "structural code search",
+            "syntax-aware search",
+            "tree-sitter",
+        ],
+        "terms": ["sg run", "ast-grep", "tree-sitter"],
+    },
+    "dependency-management": {
+        "phrases": [
+            "check dependencies",
+            "audit dependencies",
+            "outdated packages",
+            "dependency health",
+            "license check",
+            "unused dependencies",
+            "vulnerability scan",
+        ],
+        "terms": ["pip-audit", "npm audit", "cargo audit", "govulncheck"],
+    },
+    "documentation-patterns": {
+        "phrases": [
+            "write a readme",
+            "write documentation",
+            "add docstrings",
+            "add jsdoc",
+            "document the api",
+            "documentation template",
+            "update the docs",
+        ],
+        "terms": ["docstring", "jsdoc", "tsdoc", "godoc", "rustdoc"],
+    },
+    "migration-patterns": {
+        "phrases": [
+            "migrate from",
+            "upgrade to",
+            "version upgrade",
+            "framework migration",
+            "bump python",
+            "upgrade pydantic",
+            "migrate express",
+        ],
+        "terms": ["migrate", "migration", "upgrade"],
+    },
 }
 
 # Pre-compile term patterns for whole-word matching

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/ticket-linker.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Ticket linker — UserPromptSubmit hook that auto-fetches GitHub issues/PRs.
+
+When the user's prompt contains #123 or a full GitHub issue/PR URL,
+fetches the ticket body via `gh` and injects it as additionalContext
+so Claude has the full ticket context without the user copy-pasting.
+
+Reads hook input from stdin (JSON). Returns JSON on stdout.
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import re
+import subprocess
+import sys
+
+GH_CMD_TIMEOUT = 5
+MAX_REFS = 3
+BODY_CHAR_CAP = 1500
+TOTAL_OUTPUT_CAP = 3000
+
+# Short refs: #123 (but not inside URLs or hex colors)
+SHORT_REF_RE = re.compile(r"(?<![/\w])#(\d+)\b")
+
+# Full GitHub URLs: github.com/owner/repo/issues/123 or .../pull/123
+URL_REF_RE = re.compile(r"github\.com/[^/\s]+/[^/\s]+/(?:issues|pull)/(\d+)")
+
+
+def extract_refs(prompt: str) -> list[int]:
+    """Extract deduplicated issue/PR numbers from the prompt."""
+    seen: set[int] = set()
+    refs: list[int] = []
+
+    for match in SHORT_REF_RE.finditer(prompt):
+        num = int(match.group(1))
+        if num not in seen and num > 0:
+            seen.add(num)
+            refs.append(num)
+
+    for match in URL_REF_RE.finditer(prompt):
+        num = int(match.group(1))
+        if num not in seen and num > 0:
+            seen.add(num)
+            refs.append(num)
+
+    return refs[:MAX_REFS]
+
+
+def fetch_ticket(number: int) -> str | None:
+    """Fetch a GitHub issue/PR via gh CLI. Returns formatted string or None."""
+    try:
+        result = subprocess.run(
+            [
+                "gh",
+                "issue",
+                "view",
+                str(number),
+                "--json",
+                "number,title,body,state,labels",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=GH_CMD_TIMEOUT,
+        )
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return None
+
+    if result.returncode != 0:
+        return None
+
+    try:
+        data = json.loads(result.stdout)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+    title = data.get("title", "(no title)")
+    state = data.get("state", "UNKNOWN")
+    body = data.get("body", "") or ""
+    labels = data.get("labels", [])
+
+    label_names = [lb.get("name", "") for lb in labels if lb.get("name")]
+    label_str = ", ".join(label_names) if label_names else "none"
+
+    # Truncate body
+    if len(body) > BODY_CHAR_CAP:
+        body = body[:BODY_CHAR_CAP] + "\n...(truncated)"
+
+    parts = [
+        f"[Ticket #{number}] {title}",
+        f"State: {state} | Labels: {label_str}",
+    ]
+    if body.strip():
+        parts.append(body.strip())
+
+    return "\n".join(parts)
+
+
+def main():
+    raw = sys.stdin.read().strip()
+    if not raw:
+        sys.exit(0)
+
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    prompt = data.get("prompt", "")
+    if not prompt:
+        sys.exit(0)
+
+    refs = extract_refs(prompt)
+    if not refs:
+        sys.exit(0)
+
+    tickets: list[str] = []
+    for number in refs:
+        ticket = fetch_ticket(number)
+        if ticket:
+            tickets.append(ticket)
+
+    if not tickets:
+        sys.exit(0)
+
+    output = "\n\n---\n\n".join(tickets)
+
+    # Cap total output
+    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()