codeforge-dev 1.13.0 → 1.14.2

package/.devcontainer/plugins/devs-marketplace/plugins/protected-files-guard/README.md

@@ -66,6 +66,34 @@ The Bash guard parses commands for write-indicating patterns and extracts the ta
 
 Both hooks have a 5-second timeout.
 
+## 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": {
+       "protected-files-guard@<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/protected-files-guard/scripts/guard-protected-bash.py

@@ -104,7 +104,7 @@ def main():
         for target in targets:
             is_protected, message = check_path(target)
             if is_protected:
-                print(json.dumps({"error": f"{message} (via bash command)"}))
+                print(f"{message} (via bash command)", file=sys.stderr)
                 sys.exit(2)
 
         sys.exit(0)

package/.devcontainer/plugins/devs-marketplace/plugins/protected-files-guard/scripts/guard-protected.py

@@ -89,8 +89,8 @@ def main():
         is_protected, message = check_path(file_path)
 
         if is_protected:
-            # 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 edit to proceed

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
 	"name": "session-context",
 	"description": "Session lifecycle hooks: git state injection, TODO harvesting, and commit reminders",
-	"version": "1.0.0",
 	"author": {
 		"name": "AnExiledDev"
 	}

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/README.md

@@ -0,0 +1,140 @@
+# session-context
+
+Claude Code plugin that injects contextual information at session boundaries. Provides git state awareness at session start, surfaces TODO/FIXME markers, and reminds about uncommitted changes when Claude finishes responding.
+
+## What It Does
+
+Three hooks that run automatically at session lifecycle boundaries:
+
+| Phase | Script | What It Injects |
+|-------|--------|-----------------|
+| Session start | `git-state-injector.py` | Current branch, status, recent commits, uncommitted changes |
+| Session start | `todo-harvester.py` | Count and top 10 TODO/FIXME/HACK/XXX markers in the codebase |
+| Stop | `commit-reminder.py` | Advisory about staged/unstaged changes that should be committed |
+
+All hooks are non-blocking and cap their output to prevent context bloat.
+
+### Git State Injection
+
+Runs at session start and injects:
+- Current branch name
+- Working tree status (up to 20 lines)
+- Recent commit log
+- Diff stat of uncommitted changes (up to 15 lines)
+- Total output capped at 2000 characters
+
+### TODO Harvesting
+
+Scans source files for tech debt markers and injects a summary:
+- Searches for `TODO`, `FIXME`, `HACK`, `XXX` comments
+- File types: `.py`, `.ts`, `.tsx`, `.js`, `.jsx`, `.go`, `.rs`, `.sh`, `.svelte`, `.vue`, `.rb`, `.java`, `.kt`
+- Shows total count plus top 10 items
+- Output capped at 800 characters
+
+### Commit Reminder
+
+Fires when Claude stops responding and checks for uncommitted work:
+- Detects staged and unstaged changes
+- Injects an advisory so Claude can naturally ask if the user wants to commit
+- Uses a guard flag to prevent infinite loops (the reminder itself is a Stop event)
+
+## How It Works
+
+### Hook Lifecycle
+
+```
+Session starts
+  |
+  +-> SessionStart fires
+  |     |
+  |     +-> git-state-injector.py
+  |     |     |
+  |     |     +-> Runs git branch, status, log, diff --stat
+  |     |     +-> Caps output, injects as additionalContext
+  |     |
+  |     +-> todo-harvester.py
+  |           |
+  |           +-> Greps codebase for TODO/FIXME/HACK/XXX
+  |           +-> Injects count + top 10 as additionalContext
+  |
+  |  ... Claude works ...
+  |
+Claude stops responding
+  |
+  +-> Stop fires
+        |
+        +-> commit-reminder.py
+              |
+              +-> Checks git status for changes
+              +-> Has changes? -> Inject commit advisory
+              +-> No changes? -> Silent (no output)
+```
+
+### Exit Code Behavior
+
+All three scripts exit 0 (advisory only). They never block operations.
+
+### Error Handling
+
+| Scenario | Behavior |
+|----------|----------|
+| Not a git repository | Silent exit (no output) |
+| Git command failure | Silent exit (no output) |
+| JSON parse failure | Silent exit |
+
+### Timeouts
+
+| Hook | Timeout |
+|------|---------|
+| Git state injection | 10s |
+| TODO harvesting | 8s |
+| Commit reminder | 8s |
+
+## 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": {
+       "session-context@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
+## Plugin Structure
+
+```
+session-context/
++-- .claude-plugin/
+|   +-- plugin.json            # Plugin metadata
++-- hooks/
+|   +-- hooks.json             # Hook registrations (SessionStart + Stop)
++-- scripts/
+|   +-- git-state-injector.py  # Git state context (SessionStart)
+|   +-- todo-harvester.py      # Tech debt markers (SessionStart)
+|   +-- commit-reminder.py     # Uncommitted changes advisory (Stop)
++-- README.md                  # This file
+```
+
+## Requirements
+
+- Python 3.11+
+- Git (for git state injection and commit reminders)
+- Claude Code with plugin hook support

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/hooks/hooks.json

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

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/scripts/commit-reminder.py

@@ -7,7 +7,8 @@ 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).
+Blocks with decision/reason so Claude addresses uncommitted changes
+before finishing. The stop_hook_active guard prevents infinite loops.
 """
 
 import json
@@ -82,7 +83,7 @@ def main():
         "Consider asking the user if they'd like to commit before finishing."
     )
 
-    json.dump({"additionalContext": message}, sys.stdout)
+    json.dump({"decision": "block", "reason": message}, sys.stdout)
     sys.exit(0)
 
 

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/scripts/git-state-injector.py

@@ -64,7 +64,15 @@ def main():
             f"Working Directory: {cwd} — restrict all file operations to this "
             f"directory unless explicitly instructed otherwise."
         )
-        json.dump({"additionalContext": output}, sys.stdout)
+        json.dump(
+            {
+                "hookSpecificOutput": {
+                    "hookEventName": "SessionStart",
+                    "additionalContext": output,
+                }
+            },
+            sys.stdout,
+        )
         sys.exit(0)
 
     sections = []
@@ -117,7 +125,15 @@ def main():
     if len(output) > TOTAL_OUTPUT_CAP:
         output = output[:TOTAL_OUTPUT_CAP] + "\n...(truncated)"
 
-    json.dump({"additionalContext": output}, sys.stdout)
+    json.dump(
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "SessionStart",
+                "additionalContext": output,
+            }
+        },
+        sys.stdout,
+    )
     sys.exit(0)
 
 

package/.devcontainer/plugins/devs-marketplace/plugins/session-context/scripts/todo-harvester.py

@@ -122,7 +122,15 @@ def main():
     if len(body) > TOTAL_OUTPUT_CAP:
         body = body[:TOTAL_OUTPUT_CAP] + "\n...(truncated)"
 
-    json.dump({"additionalContext": body}, sys.stdout)
+    json.dump(
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "SessionStart",
+                "additionalContext": body,
+            }
+        },
+        sys.stdout,
+    )
     sys.exit(0)
 
 

package/.devcontainer/plugins/devs-marketplace/plugins/skill-engine/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
 	"name": "skill-engine",
 	"description": "21 coding knowledge packs with auto-suggestion for frameworks, tools, and patterns",
-	"version": "1.0.0",
 	"author": {
 		"name": "AnExiledDev"
 	}

package/.devcontainer/plugins/devs-marketplace/plugins/skill-engine/README.md

@@ -0,0 +1,158 @@
+# skill-engine
+
+Claude Code plugin that provides 21 coding knowledge packs (skills) with automatic suggestion based on user prompts. Each skill contains domain-specific instructions and reference material that Claude loads on demand via the `/skill` command.
+
+## What It Does
+
+Two capabilities:
+
+1. **Skill library** — 21 skills covering frameworks, tools, and development patterns. Each skill is a structured knowledge pack with a `SKILL.md` entrypoint and `references/` subdirectory containing detailed reference docs.
+
+2. **Auto-suggestion** — A `UserPromptSubmit` hook watches user prompts for keyword matches and suggests relevant skills as context, so Claude can proactively load the right knowledge.
+
+### Skill Catalog
+
+| Skill | Domain |
+|-------|--------|
+| api-design | REST conventions, error handling, API patterns |
+| ast-grep-patterns | Semantic code search patterns by language |
+| claude-agent-sdk | Building custom agents with the Agent SDK (TypeScript) |
+| claude-code-headless | CLI flags, output parsing, SDK and MCP integration |
+| debugging | Error patterns, log locations, diagnosis procedures |
+| dependency-management | Package managers, ecosystem commands, license compliance |
+| docker | Dockerfile patterns, docker-compose services |
+| docker-py | Docker SDK for Python, container lifecycle |
+| documentation-patterns | API doc templates, docstring formats |
+| fastapi | Routing, Pydantic v2, SSE streaming, middleware, dependencies |
+| git-forensics | Advanced git commands, blame history, investigation playbooks |
+| migration-patterns | Framework/version migrations for JavaScript and Python |
+| performance-profiling | Profiling tools, interpreting results, optimization |
+| pydantic-ai | Building AI agents with Pydantic, tools, models, streaming |
+| refactoring-patterns | Safe transformations, code smell catalog |
+| security-checklist | OWASP patterns, secrets management, vulnerability detection |
+| skill-building | How to author skills, patterns and anti-patterns |
+| sqlite | Schema, pragmas, advanced queries, FTS5, JS/Python patterns |
+| svelte5 | Runes, reactivity, components, SPA routing, LayerCake |
+| team | Agent team orchestration, parallel workstreams, task coordination |
+| testing | Testing frameworks, FastAPI testing, Svelte testing |
+
+### Auto-Suggestion
+
+The `skill-suggester.py` hook matches user prompts against keyword maps defined in each skill. When a match is found, it injects a suggestion via `additionalContext` so Claude knows a relevant skill is available.
+
+Keywords are defined per skill as:
+- **Phrases** — Multi-word patterns (e.g., "docker compose", "REST API")
+- **Terms** — Single keywords (e.g., "FastAPI", "pytest")
+
+## How It Works
+
+### Hook Lifecycle
+
+```
+User submits a prompt
+  |
+  +-> UserPromptSubmit fires
+        |
+        +-> skill-suggester.py
+              |
+              +-> Scan prompt against all skill keyword maps
+              +-> Match found? -> Inject skill suggestion as additionalContext
+              +-> No match? -> Silent (no output)
+```
+
+### Skill Structure
+
+Each skill follows a standard layout:
+
+```
+skills/
++-- skill-name/
+    +-- SKILL.md             # Entrypoint: instructions, patterns, key concepts
+    +-- references/          # Detailed reference material
+        +-- topic-a.md
+        +-- topic-b.md
+```
+
+Skills are loaded via Claude Code's `/skill` slash command (e.g., `/skill fastapi`). The `SKILL.md` file is the primary document Claude reads; references are loaded as needed for deeper detail.
+
+### Exit Code Behavior
+
+| Exit Code | Meaning |
+|-----------|---------|
+| 0 | Suggestion injected (or no match — silent) |
+
+The hook never blocks operations.
+
+### Timeouts
+
+| Hook | Timeout |
+|------|---------|
+| Skill suggestion (UserPromptSubmit) | 3s |
+
+## 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": {
+       "skill-engine@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
+## Plugin Structure
+
+```
+skill-engine/
++-- .claude-plugin/
+|   +-- plugin.json                  # Plugin metadata
++-- hooks/
+|   +-- hooks.json                   # UserPromptSubmit hook registration
++-- scripts/
+|   +-- skill-suggester.py           # Keyword-based skill auto-suggestion
++-- skills/
+|   +-- api-design/                  # 21 skill directories
+|   +-- ast-grep-patterns/
+|   +-- claude-agent-sdk/
+|   +-- claude-code-headless/
+|   +-- debugging/
+|   +-- dependency-management/
+|   +-- docker/
+|   +-- docker-py/
+|   +-- documentation-patterns/
+|   +-- fastapi/
+|   +-- git-forensics/
+|   +-- migration-patterns/
+|   +-- performance-profiling/
+|   +-- pydantic-ai/
+|   +-- refactoring-patterns/
+|   +-- security-checklist/
+|   +-- skill-building/
+|   +-- sqlite/
+|   +-- svelte5/
+|   +-- team/
+|   +-- testing/
++-- README.md                        # This file
+```
+
+## Requirements
+
+- Python 3.11+
+- Claude Code with plugin hook support (skills)

package/.devcontainer/plugins/devs-marketplace/plugins/skill-engine/hooks/hooks.json

@@ -1,21 +1,8 @@
 {
-	"description": "Skill auto-suggestion on user prompts and Plan agent starts",
+	"description": "Skill auto-suggestion on user prompts",
 	"hooks": {
 		"UserPromptSubmit": [
 			{
-				"matcher": "*",
-				"hooks": [
-					{
-						"type": "command",
-						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/skill-suggester.py",
-						"timeout": 3
-					}
-				]
-			}
-		],
-		"SubagentStart": [
-			{
-				"matcher": "Plan",
 				"hooks": [
 					{
 						"type": "command",