codeforge-dev 1.5.8 → 1.8.0

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

@@ -46,13 +46,23 @@ SKILLS = {
             "headless mode",
             "claude -p",
             "stream-json",
-            "agent sdk",
             "claude code headless",
             "run claude in ci",
             "claude in pipeline",
         ],
         "terms": [],
     },
+    "claude-agent-sdk": {
+        "phrases": [
+            "agent sdk",
+            "claude agent sdk",
+            "build an agent",
+            "create an agent",
+            "canusetool",
+            "sdk permissions",
+        ],
+        "terms": ["claude-agent-sdk", "claude_agent_sdk"],
+    },
     "pydantic-ai": {
         "phrases": [
             "pydantic ai",
@@ -115,6 +125,7 @@ SKILLS = {
             "dockerfile",
             "docker compose",
             "docker-compose",
+            "compose file",
             "multi-stage build",
             "health check",
             "healthcheck",
@@ -122,7 +133,7 @@ SKILLS = {
             "docker volume",
             "docker image",
         ],
-        "terms": ["dockerfile"],
+        "terms": ["dockerfile", "compose"],
     },
     "skill-building": {
         "phrases": [
@@ -152,6 +163,139 @@ SKILLS = {
         ],
         "terms": ["diagnose", "troubleshoot"],
     },
+    "refactoring-patterns": {
+        "phrases": [
+            "refactor this",
+            "clean up code",
+            "improve code structure",
+            "reduce complexity",
+        ],
+        "terms": [
+            "refactor",
+            "refactoring",
+            "code smell",
+            "extract function",
+            "dead code",
+        ],
+    },
+    "security-checklist": {
+        "phrases": [
+            "security review",
+            "check for vulnerabilities",
+            "audit security",
+            "find security issues",
+        ],
+        "terms": [
+            "security",
+            "vulnerability",
+            "owasp",
+            "injection",
+            "xss",
+            "secrets",
+            "cve",
+        ],
+    },
+    "git-forensics": {
+        "phrases": [
+            "git history",
+            "who changed this",
+            "when did this break",
+            "git blame",
+        ],
+        "terms": ["bisect", "blame", "archaeology", "git log", "pickaxe", "reflog"],
+    },
+    "specification-writing": {
+        "phrases": [
+            "write a spec",
+            "define requirements",
+            "acceptance criteria",
+            "user stories",
+        ],
+        "terms": [
+            "specification",
+            "requirements",
+            "ears",
+            "gherkin",
+            "given when then",
+        ],
+    },
+    "performance-profiling": {
+        "phrases": [
+            "profile performance",
+            "find bottleneck",
+            "benchmark this",
+            "why is this slow",
+        ],
+        "terms": [
+            "profiling",
+            "benchmark",
+            "flamegraph",
+            "bottleneck",
+            "latency",
+            "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/syntax-validator.py

@@ -19,11 +19,16 @@ EXTENSIONS = {".json", ".jsonc", ".yaml", ".yml", ".toml"}
 
 
 def strip_jsonc_comments(text: str) -> str:
-    """Remove // and /* */ comments from JSONC text."""
-    # Remove single-line comments (not inside strings)
-    text = re.sub(r"(?<!:)//.*$", "", text, flags=re.MULTILINE)
-    # Remove multi-line comments
+    """Remove // and /* */ comments from JSONC text.
+
+    Handles URLs (https://...) by only stripping // comments that are
+    preceded by whitespace or appear at line start, not those inside strings.
+    """
+    # Remove multi-line comments first
     text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+    # Remove single-line comments: // preceded by start-of-line or whitespace
+    # This avoids stripping :// in URLs
+    text = re.sub(r"(^|[\s,\[\{])//.*$", r"\1", text, flags=re.MULTILINE)
     return text
 
 

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

package/.devcontainer/plugins/devs-marketplace/plugins/code-directive/scripts/verify-no-regression.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Verify no regression - PostToolUse hook for refactorer agent.
+
+After each Edit operation, runs the project test suite to ensure
+the refactoring didn't break anything. Includes debounce to avoid
+running tests too frequently during rapid edits.
+
+Reads hook input from stdin (JSON). Returns JSON on stdout.
+Non-blocking on detection failures: always exits 0 if no framework found.
+
+Exit 0: Tests pass, no framework found, debounced, or timeout
+Exit 2: Tests fail (forces agent to fix regression before continuing)
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+
+DEBOUNCE_SECONDS = 10
+
+
+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 should_debounce(session_id: str) -> bool:
+    """Check if we should skip this run due to recent execution.
+
+    Uses a timestamp file in /tmp to throttle test runs during rapid edits.
+    Returns True if the last run was less than DEBOUNCE_SECONDS ago.
+    """
+    stamp_path = f"/tmp/claude-regression-{session_id}"
+    now = time.time()
+
+    try:
+        with open(stamp_path, "r") as f:
+            last_run = float(f.read().strip())
+        if now - last_run < DEBOUNCE_SECONDS:
+            return True
+    except (OSError, ValueError):
+        pass
+
+    try:
+        with open(stamp_path, "w") as f:
+            f.write(str(now))
+    except OSError:
+        pass
+
+    return False
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    tool_input = input_data.get("tool_input", {})
+    file_path = tool_input.get("file_path", "")
+
+    if not file_path:
+        sys.exit(0)
+
+    # Debounce: skip if tests ran recently in this session
+    session_id = input_data.get("session_id", "default")
+    if should_debounce(session_id):
+        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:
+        # Timeout is non-critical for PostToolUse — don't block the agent
+        json.dump(
+            {
+                "additionalContext": f"[Tests] {framework} timed out after 60s — skipping regression check."
+            },
+            sys.stdout,
+        )
+        sys.exit(0)
+    except FileNotFoundError:
+        sys.exit(0)
+    except OSError:
+        sys.exit(0)
+
+    output = (result.stdout + "\n" + result.stderr).strip()
+    if not output:
+        output = "(no test output)"
+
+    # Truncate to last 50 lines
+    lines = output.splitlines()
+    if len(lines) > 50:
+        output = "...(truncated)\n" + "\n".join(lines[-50:])
+
+    if result.returncode != 0:
+        edited = os.path.basename(file_path)
+        json.dump(
+            {
+                "error": (
+                    f"Regression detected after editing {edited} "
+                    f"({framework}). Fix the failing tests before continuing:\n{output}"
+                )
+            },
+            sys.stdout,
+        )
+        sys.exit(2)
+
+    json.dump(
+        {"additionalContext": f"[Tests] No regression ({framework}): all tests passed"},
+        sys.stdout,
+    )
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()