codeforge-dev 1.13.0 → 1.14.2

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-	"description": "Agent redirection and subagent configuration hooks",
+	"description": "Agent redirection, subagent configuration, and team quality gate hooks",
 	"hooks": {
 		"PreToolUse": [
 			{
@@ -24,6 +24,28 @@
 					}
 				]
 			}
+		],
+		"TeammateIdle": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/teammate-idle-check.py",
+						"timeout": 10
+					}
+				]
+			}
+		],
+		"TaskCompleted": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/task-completed-check.py",
+						"timeout": 60
+					}
+				]
+			}
 		]
 	}
 }

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/guard-readonly-bash.py

@@ -12,7 +12,7 @@ command substitution ($(), backticks), backgrounding (&), redirections
 (>, >>), eval/exec, inline scripting (python -c, node -e), and
 path/backslash prefix bypasses (/usr/bin/rm, \\rm).
 
-Reads tool input from stdin (JSON). Returns JSON on stdout.
+Reads tool input from stdin (JSON). Outputs block reason to stderr.
 Exit 0: Command is safe (allowed)
 Exit 2: Command would modify state (blocked)
 """
@@ -601,7 +601,7 @@ def main():
         error = check_general_readonly(command)
 
     if error:
-        json.dump({"error": error}, sys.stdout)
+        print(error, file=sys.stderr)
         sys.exit(2)
 
     sys.exit(0)

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/inject-cwd.py

@@ -23,10 +23,13 @@ def main():
 
     json.dump(
         {
-            "additionalContext": (
-                f"Working Directory: {cwd} — restrict all file operations to "
-                f"this directory unless explicitly instructed otherwise."
-            )
+            "hookSpecificOutput": {
+                "hookEventName": "SubagentStart",
+                "additionalContext": (
+                    f"Working Directory: {cwd} — restrict all file operations to "
+                    f"this directory unless explicitly instructed otherwise."
+                ),
+            }
         },
         sys.stdout,
     )

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/task-completed-check.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+TaskCompleted quality gate — runs project test suite before allowing completion.
+
+Detects the project's test framework and runs it. If tests fail, the task
+stays open and the teammate receives feedback to fix the failures.
+
+Exit 0: Tests pass (or no test framework / runner not installed)
+Exit 2: Tests fail (task stays open, feedback sent via stderr)
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+TIMEOUT_SECONDS = 60
+
+
+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 any(
+                    marker in content
+                    for marker in ("[tool.pytest", "[pytest]", "[tool:pytest]")
+                ):
+                    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:
+        json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        pass
+
+    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=TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired:
+        # Timeout is not a definitive failure — allow completion but warn
+        print(
+            f"Tests timed out ({framework}, {TIMEOUT_SECONDS}s). "
+            f"Task completion allowed — verify tests manually.",
+            file=sys.stderr,
+        )
+        sys.exit(0)
+    except FileNotFoundError:
+        sys.exit(0)
+    except OSError:
+        sys.exit(0)
+
+    if result.returncode == 0:
+        sys.exit(0)
+
+    output = (result.stdout + "\n" + result.stderr).strip()
+    if not output:
+        output = "(no test output)"
+
+    lines = output.splitlines()
+    if len(lines) > 50:
+        output = "...(truncated)\n" + "\n".join(lines[-50:])
+
+    print(
+        f"Tests failed ({framework}). Fix failures before marking task complete:\n{output}",
+        file=sys.stderr,
+    )
+    sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/teammate-idle-check.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+TeammateIdle quality gate — checks if teammate has incomplete tasks.
+
+Runs when a teammate is about to go idle. Queries the shared task list
+directory for tasks assigned to this teammate that aren't yet completed.
+
+Exit 0: Allow idle (no incomplete tasks or unable to determine)
+Exit 2: Send feedback via stderr (incomplete tasks found)
+"""
+
+import json
+import os
+import sys
+
+
+def find_incomplete_tasks(teammate_name: str) -> list[str]:
+    """Scan task directories for incomplete tasks owned by this teammate."""
+    config_dir = os.environ.get("CLAUDE_CONFIG_DIR", os.path.expanduser("~/.claude"))
+    tasks_base = os.path.join(config_dir, "tasks")
+
+    if not os.path.isdir(tasks_base):
+        return []
+
+    incomplete = []
+    for entry in os.listdir(tasks_base):
+        team_dir = os.path.join(tasks_base, entry)
+        if not os.path.isdir(team_dir):
+            continue
+
+        for filename in sorted(os.listdir(team_dir)):
+            if not filename.endswith(".json"):
+                continue
+
+            task_path = os.path.join(team_dir, filename)
+            try:
+                with open(task_path, "r", encoding="utf-8") as f:
+                    task = json.load(f)
+
+                owner = task.get("owner", "")
+                status = task.get("status", "")
+                subject = task.get("subject", filename)
+
+                if owner == teammate_name and status in ("pending", "in_progress"):
+                    incomplete.append(subject)
+            except (OSError, json.JSONDecodeError, ValueError):
+                continue
+
+    return incomplete
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    teammate_name = (
+        input_data.get("teammate_name")
+        or input_data.get("agent_name")
+        or ""
+    )
+    if not teammate_name:
+        sys.exit(0)
+
+    incomplete = find_incomplete_tasks(teammate_name)
+    if not incomplete:
+        sys.exit(0)
+
+    task_list = "; ".join(incomplete[:5])
+    suffix = f" (and {len(incomplete) - 5} more)" if len(incomplete) > 5 else ""
+    print(
+        f"You have {len(incomplete)} incomplete task(s): {task_list}{suffix}. "
+        f"Check TaskList and continue working before going idle.",
+        file=sys.stderr,
+    )
+    sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/verify-no-regression.py

@@ -178,7 +178,10 @@ def main():
         # Timeout is non-critical for PostToolUse — don't block the agent
         json.dump(
             {
-                "additionalContext": f"[Tests] {framework} timed out after 60s — skipping regression check."
+                "hookSpecificOutput": {
+                    "hookEventName": "PostToolUse",
+                    "additionalContext": f"[Tests] {framework} timed out after 60s — skipping regression check.",
+                }
             },
             sys.stdout,
         )
@@ -199,19 +202,20 @@ def main():
 
     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,
+        print(
+            f"Regression detected after editing {edited} "
+            f"({framework}). Fix the failing tests before continuing:\n{output}",
+            file=sys.stderr,
         )
         sys.exit(2)
 
     json.dump(
-        {"additionalContext": f"[Tests] No regression ({framework}): all tests passed"},
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "PostToolUse",
+                "additionalContext": f"[Tests] No regression ({framework}): all tests passed",
+            }
+        },
         sys.stdout,
     )
     sys.exit(0)

package/.devcontainer/plugins/devs-marketplace/plugins/agent-system/scripts/verify-tests-pass.py

@@ -136,12 +136,7 @@ def main():
             timeout=60,
         )
     except subprocess.TimeoutExpired:
-        json.dump(
-            {
-                "additionalContext": f"[Tests] {framework} timed out after 60s. Consider running tests manually."
-            },
-            sys.stdout,
-        )
+        print(f"Tests timed out ({framework})", file=sys.stderr)
         sys.exit(2)
     except FileNotFoundError:
         # Test runner not installed — non-critical
@@ -159,16 +154,9 @@ def main():
         output = "...(truncated)\n" + "\n".join(lines[-50:])
 
     if result.returncode != 0:
-        json.dump(
-            {"error": f"Tests failed ({framework}):\n{output}"},
-            sys.stdout,
-        )
+        print(f"Tests failed ({framework}):\n{output}", file=sys.stderr)
         sys.exit(2)
 
-    json.dump(
-        {"additionalContext": f"[Tests] All tests passed ({framework})"},
-        sys.stdout,
-    )
     sys.exit(0)
 
 

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/README.md

@@ -50,45 +50,31 @@ Biome is resolved in this order:
 
 ## Installation
 
-### 1. Place the plugin
+### CodeForge DevContainer
 
-Copy the `auto-code-quality/` directory into your Claude Code plugin marketplace:
+Pre-installed and activated automatically — no setup needed.
 
-```
-your-marketplace/
-├── .claude-plugin/
-│   └── marketplace.json
-└── plugins/
-    └── auto-code-quality/    ← this directory
-```
+### From GitHub
 
-### 2. Register in marketplace.json
+Use this plugin in any Claude Code setup:
 
-Add this entry to your `marketplace.json` `plugins` array:
-
-```json
-{
-  "name": "auto-code-quality",
-  "description": "Self-contained code quality: auto-format + auto-lint edited files",
-  "version": "1.0.0",
-  "source": "./plugins/auto-code-quality",
-  "category": "development"
-}
-```
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
 
-### 3. Enable in settings.json
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
 
-Add to your Claude Code `settings.json` under `enabledPlugins`:
+2. Enable the plugin in your `.claude/settings.json`:
 
-```json
-{
-  "enabledPlugins": {
-    "auto-code-quality@your-marketplace": true
-  }
-}
-```
+   ```json
+   {
+     "enabledPlugins": {
+       "auto-code-quality@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
 
-Replace `your-marketplace` with the name of your marketplace.
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
 
 ## How It Works
 

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/hooks/hooks.json

@@ -20,7 +20,6 @@
 		],
 		"Stop": [
 			{
-				"matcher": "",
 				"hooks": [
 					{
 						"type": "command",
@@ -31,6 +30,11 @@
 						"type": "command",
 						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/lint-file.py",
 						"timeout": 60
+					},
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/advisory-test-runner.py",
+						"timeout": 20
 					}
 				]
 			}

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

@@ -4,11 +4,11 @@ Advisory test runner — Stop hook that injects test results as context.
 
 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.
+if no files were edited. Results are returned as systemMessage (pass/timeout) or decision/reason
+block (failure) so Claude acts on test failures before finishing.
 
 Reads hook input from stdin (JSON). Returns JSON on stdout.
-Always exits 0 (advisory, never blocking).
+Always exits 0. Failures use decision: "block" to prevent stopping.
 """
 
 import json
@@ -310,9 +310,7 @@ def main():
         )
     except subprocess.TimeoutExpired:
         json.dump(
-            {
-                "additionalContext": f"[Tests] {framework} timed out after {TIMEOUT_SECONDS}s"
-            },
+            {"systemMessage": f"[Tests] {framework} timed out after {TIMEOUT_SECONDS}s"},
             sys.stdout,
         )
         sys.exit(0)
@@ -323,7 +321,7 @@ def main():
 
     if result.returncode == 0:
         json.dump(
-            {"additionalContext": f"[Tests] All tests passed ({framework})"},
+            {"systemMessage": f"[Tests] All tests passed ({framework})"},
             sys.stdout,
         )
         sys.exit(0)
@@ -337,7 +335,10 @@ def main():
         output = "...(truncated)\n" + "\n".join(lines[-30:])
 
     json.dump(
-        {"additionalContext": (f"[Tests] Some tests FAILED ({framework}):\n{output}")},
+        {
+            "decision": "block",
+            "reason": f"[Tests] Some tests FAILED ({framework}):\n{output}",
+        },
         sys.stdout,
     )
     sys.exit(0)

package/.devcontainer/plugins/devs-marketplace/plugins/codeforge-lsp/README.md

@@ -20,6 +20,34 @@ The plugin uses the `lspServers` field in `plugin.json` to declare server config
 
 Each server maps file extensions to language identifiers. When Claude Code opens a file matching a registered extension, it routes it to the corresponding LSP server for diagnostics, completions, and other language features.
 
+## Installation
+
+### CodeForge DevContainer
+
+Pre-installed and activated automatically — no setup needed.
+
+### From GitHub
+
+Use this plugin in any Claude Code setup:
+
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
+
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
+
+2. Enable the plugin in your `.claude/settings.json`:
+
+   ```json
+   {
+     "enabledPlugins": {
+       "codeforge-lsp@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
 ## Plugin Structure
 
 ```

package/.devcontainer/plugins/devs-marketplace/plugins/dangerous-command-blocker/README.md

@@ -53,6 +53,34 @@ Claude calls the Bash tool
 
 The hook has a 5-second timeout. If the script takes longer, Claude Code proceeds with the command.
 
+## Installation
+
+### CodeForge DevContainer
+
+Pre-installed and activated automatically — no setup needed.
+
+### From GitHub
+
+Use this plugin in any Claude Code setup:
+
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
+
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
+
+2. Enable the plugin in your `.claude/settings.json`:
+
+   ```json
+   {
+     "enabledPlugins": {
+       "dangerous-command-blocker@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
 ## Plugin Structure
 
 ```

package/.devcontainer/plugins/devs-marketplace/plugins/dangerous-command-blocker/scripts/block-dangerous.py

@@ -116,8 +116,8 @@ def main():
         is_dangerous, message = check_command(command)
 
         if is_dangerous:
-            # Output error message and exit 2 to block
-            print(json.dumps({"error": message}))
+            # Output error to stderr (exit 2 ignores stdout)
+            print(message, file=sys.stderr)
             sys.exit(2)
 
         # Allow command to proceed

package/.devcontainer/plugins/devs-marketplace/plugins/notify-hook/README.md

@@ -25,6 +25,34 @@ Claude stops responding (Stop event)
 
 The hook has a 5-second timeout. The plugin contains no scripts of its own — it delegates entirely to the `claude-notify` binary.
 
+## Installation
+
+### CodeForge DevContainer
+
+Pre-installed and activated automatically — no setup needed.
+
+### From GitHub
+
+Use this plugin in any Claude Code setup:
+
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
+
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
+
+2. Enable the plugin in your `.claude/settings.json`:
+
+   ```json
+   {
+     "enabledPlugins": {
+       "notify-hook@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
 ## Plugin Structure
 
 ```

package/.devcontainer/plugins/devs-marketplace/plugins/notify-hook/hooks/hooks.json

@@ -3,7 +3,6 @@
   "hooks": {
     "Stop": [
       {
-        "matcher": "",
         "hooks": [
           {
             "type": "command",