codeforge-dev 1.7.0 → 1.9.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/spec-reminder.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+Spec reminder — Stop hook that advises about spec updates after code changes.
+
+On Stop, checks if source code was modified but no .specs/ files were updated.
+Injects an advisory reminder as additionalContext pointing the user to
+/spec-update.
+
+Only fires when a .specs/ directory exists (project uses the spec system).
+
+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
+
+# Directories whose changes should trigger the spec reminder
+CODE_DIRS = (
+    "src/",
+    "lib/",
+    "app/",
+    "pkg/",
+    "internal/",
+    "cmd/",
+    "tests/",
+    "api/",
+    "frontend/",
+    "backend/",
+    "packages/",
+    "services/",
+    "components/",
+    "pages/",
+    "routes/",
+)
+
+
+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)
+
+    cwd = os.getcwd()
+
+    # Only fire if this project uses the spec system
+    if not os.path.isdir(os.path.join(cwd, ".specs")):
+        sys.exit(0)
+
+    # Get all changed files (staged + unstaged)
+    diff_output = _run_git(["diff", "--name-only", "HEAD"])
+    staged_output = _run_git(["diff", "--name-only", "--cached"])
+
+    # Also include untracked files in source dirs
+    untracked = _run_git(["ls-files", "--others", "--exclude-standard"])
+
+    all_files: set[str] = set()
+    for output in (diff_output, staged_output, untracked):
+        if output:
+            all_files.update(output.splitlines())
+
+    if not all_files:
+        sys.exit(0)
+
+    # Check if any code directories have changes
+    has_code_changes = any(f.startswith(d) for f in all_files for d in CODE_DIRS)
+
+    if not has_code_changes:
+        sys.exit(0)
+
+    # Check if any spec files were also changed
+    has_spec_changes = any(f.startswith(".specs/") for f in all_files)
+
+    if has_spec_changes:
+        # Specs were updated alongside code — no reminder needed
+        sys.exit(0)
+
+    # Code changed but specs didn't — inject reminder
+    code_dirs_touched = sorted(
+        {f.split("/")[0] + "/" for f in all_files if "/" in f}
+        & {d.rstrip("/") + "/" for d in CODE_DIRS}
+    )
+    dirs_str = ", ".join(code_dirs_touched[:3])
+
+    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."
+    )
+
+    json.dump({"additionalContext": message}, sys.stdout)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/todo-harvester.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+TODO/FIXME harvester — SessionStart hook that surfaces tech debt markers.
+
+Greps the codebase for TODO/FIXME/HACK/XXX comments and injects a count
+plus the top items as additionalContext so Claude can proactively mention
+tech debt when relevant.
+
+Reads hook input from stdin (JSON). Returns JSON on stdout.
+Always exits 0 (advisory, never blocking).
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+GREP_TIMEOUT = 5
+MAX_ITEMS = 10
+TOTAL_OUTPUT_CAP = 800
+
+SOURCE_INCLUDES = [
+    "--include=*.py",
+    "--include=*.ts",
+    "--include=*.tsx",
+    "--include=*.js",
+    "--include=*.jsx",
+    "--include=*.go",
+    "--include=*.rs",
+    "--include=*.sh",
+    "--include=*.svelte",
+    "--include=*.vue",
+    "--include=*.rb",
+    "--include=*.java",
+    "--include=*.kt",
+]
+
+EXCLUDE_DIRS = [
+    "--exclude-dir=node_modules",
+    "--exclude-dir=.git",
+    "--exclude-dir=__pycache__",
+    "--exclude-dir=.venv",
+    "--exclude-dir=venv",
+    "--exclude-dir=dist",
+    "--exclude-dir=build",
+    "--exclude-dir=vendor",
+    "--exclude-dir=.next",
+    "--exclude-dir=.nuxt",
+    "--exclude-dir=target",
+    "--exclude-dir=.mypy_cache",
+    "--exclude-dir=.pytest_cache",
+]
+
+
+def main():
+    try:
+        json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        pass
+
+    cwd = os.getcwd()
+
+    cmd = (
+        ["grep", "-rn", "-E", r"\b(TODO|FIXME|HACK|XXX)\b"]
+        + SOURCE_INCLUDES
+        + EXCLUDE_DIRS
+        + [cwd]
+    )
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=GREP_TIMEOUT,
+        )
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        sys.exit(0)
+
+    # grep returns 1 for no matches — that's fine
+    output = result.stdout.strip()
+    if not output:
+        sys.exit(0)
+
+    lines = output.splitlines()
+    total_count = len(lines)
+
+    # Count unique files
+    files_seen: set[str] = set()
+    items: list[str] = []
+
+    for line in lines:
+        # Format: filepath:linenum:content
+        parts = line.split(":", 2)
+        if len(parts) >= 3:
+            filepath = parts[0]
+            files_seen.add(filepath)
+
+            if len(items) < MAX_ITEMS:
+                # Make path relative to cwd for readability
+                rel_path = os.path.relpath(filepath, cwd)
+                line_num = parts[1]
+                content = parts[2].strip()
+
+                # Trim long lines
+                if len(content) > 80:
+                    content = content[:77] + "..."
+
+                items.append(f"  {rel_path}:{line_num}: {content}")
+
+    file_count = len(files_seen)
+    header = (
+        f"[Tech Debt] {total_count} TODO/FIXME items found across {file_count} files"
+    )
+
+    if items:
+        body = header + "\nTop items:\n" + "\n".join(items)
+    else:
+        body = header
+
+    # Cap total output
+    if len(body) > TOTAL_OUTPUT_CAP:
+        body = body[:TOTAL_OUTPUT_CAP] + "\n...(truncated)"
+
+    json.dump({"additionalContext": body}, sys.stdout)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()