codeforge-dev 1.4.0

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/hooks/hooks.json

@@ -0,0 +1,33 @@
+{
+  "description": "Enhance plan generation and task management with custom post-processing",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "EnterPlanMode",
+        "hooks": [{
+          "type": "command",
+          "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/enhance-planning.py",
+          "timeout": 5
+        }]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write",
+        "hooks": [{
+          "type": "command",
+          "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/post-enhance-plan.py",
+          "timeout": 30
+        }]
+      },
+      {
+        "matcher": "TaskCreate|TaskUpdate",
+        "hooks": [{
+          "type": "command",
+          "command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/post-enhance-task.py",
+          "timeout": 30
+        }]
+      }
+    ]
+  }
+}

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/scripts/enhance-planning.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Plan Enhancer PreToolUse Hook Script
+
+Injects custom planning instructions when Claude enters plan mode.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+
+def get_plugin_root() -> Path:
+    """Get the plugin root directory."""
+    # Script is at ${CLAUDE_PLUGIN_ROOT}/scripts/enhance-planning.py
+    return Path(__file__).parent.parent
+
+
+def load_planning_instructions() -> str:
+    """Load custom planning instructions from config file."""
+    config_path = get_plugin_root() / "config" / "planning-instructions.md"
+
+    if not config_path.exists():
+        return ""
+
+    try:
+        return config_path.read_text().strip()
+    except Exception as e:
+        print(f"Warning: Could not read planning instructions: {e}", file=sys.stderr)
+        return ""
+
+
+def handle_enter_plan_mode(tool_input: dict) -> dict:
+    """Handle EnterPlanMode tool - inject custom instructions."""
+    instructions = load_planning_instructions()
+
+    if not instructions:
+        # No instructions configured, allow without modification
+        return {"decision": "allow"}
+
+    return {
+        "decision": "allow",
+        "additionalContext": f"\n\n--- Custom Planning Instructions ---\n{instructions}\n--- End Custom Instructions ---\n",
+    }
+
+
+def main():
+    """Main entry point."""
+    try:
+        # Read hook input from stdin
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Route to appropriate handler
+    if tool_name == "EnterPlanMode":
+        result = handle_enter_plan_mode(tool_input)
+    else:
+        # Unknown tool, allow by default
+        result = {"decision": "allow"}
+
+    # Output result as JSON
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/scripts/enhancers/enhance-plan.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+# =============================================================================
+# Plan Enhancement Script
+# =============================================================================
+#
+# This script is called after Claude writes a plan file.
+# Customize it to enhance plans with your own logic.
+#
+# Usage: enhance-plan.sh <plan-file-path>
+#
+# The plan file content is already written. You can:
+#   - Read it, modify it, write it back in-place
+#   - Call external APIs (LLM critique, linters, validators)
+#   - Add sections, headers, or metadata
+#   - Validate structure and add missing elements
+#
+# Exit codes:
+#   0 - Success (stdout is shown to Claude as enhancement output)
+#   Non-zero - Failure (stderr is shown as a warning)
+#
+# =============================================================================
+
+PLAN_FILE="$1"
+
+if [[ -z "$PLAN_FILE" ]]; then
+    echo "Error: No plan file path provided" >&2
+    exit 1
+fi
+
+if [[ ! -f "$PLAN_FILE" ]]; then
+    echo "Error: Plan file not found: $PLAN_FILE" >&2
+    exit 1
+fi
+
+# -----------------------------------------------------------------------------
+# Example Enhancements (uncomment to enable)
+# -----------------------------------------------------------------------------
+
+# Example 1: Add timestamp header
+# sed -i "1i<!-- Enhanced: $(date -Iseconds) -->" "$PLAN_FILE"
+
+# Example 2: Add enhancement marker at end
+# echo -e "\n---\n_Plan reviewed by enhancement script at $(date)_" >> "$PLAN_FILE"
+
+# Example 3: Run through another LLM for critique
+# CRITIQUE=$(cat "$PLAN_FILE" | llm "Briefly critique this plan in 2-3 bullet points")
+# echo -e "\n## AI Critique\n$CRITIQUE" >> "$PLAN_FILE"
+
+# Example 4: Validate required sections exist
+# required_sections=("## Summary" "## Files to Modify" "## Testing Strategy")
+# for section in "${required_sections[@]}"; do
+#     if ! grep -q "$section" "$PLAN_FILE"; then
+#         echo "Warning: Missing section: $section" >&2
+#     fi
+# done
+
+# Example 5: Add word/line count metadata
+# LINES=$(wc -l < "$PLAN_FILE")
+# WORDS=$(wc -w < "$PLAN_FILE")
+# sed -i "1i<!-- Lines: $LINES | Words: $WORDS -->" "$PLAN_FILE"
+
+# -----------------------------------------------------------------------------
+# Your custom enhancement logic goes here
+# -----------------------------------------------------------------------------
+
+# Default: No enhancement, just pass through
+echo "No custom enhancements configured"
+exit 0

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/scripts/enhancers/enhance-task.sh

@@ -0,0 +1,120 @@
+#!/bin/bash
+# =============================================================================
+# Task Enhancement Script
+# =============================================================================
+#
+# This script is called after Claude creates or updates a task.
+# Customize it to enhance tasks with your own logic.
+#
+# Usage: enhance-task.sh <task-json-file> <task-subject> [plan-path]
+#
+# Arguments:
+#   $1 - Path to the task JSON file
+#   $2 - Subject of the task being created/updated
+#   $3 - (Optional) Path to the session's plan file (if one exists)
+#
+# Environment variables:
+#   TASK_TOOL - Either "TaskCreate" or "TaskUpdate"
+#   PLAN_PATH - Path to the session's plan file (same as $3, for convenience)
+#
+# The task JSON file contains all tasks for this session as a JSON array.
+# Each task object has: subject, description, status, activeForm, etc.
+#
+# Plan-Task Correlation:
+#   When a plan exists for this session, you can use $PLAN_PATH to read
+#   the enhanced plan content and use it to inform task enhancement.
+#   This allows tasks to reference or validate against the approved plan.
+#
+# You can:
+#   - Read/modify the JSON file in-place
+#   - Call external APIs (LLM critique, validators)
+#   - Add metadata or annotations to tasks
+#   - Validate task structure
+#   - Cross-reference tasks with the plan file
+#
+# Exit codes:
+#   0 - Success (stdout is shown to Claude as enhancement output)
+#   Non-zero - Failure (stderr is shown as a warning)
+#
+# =============================================================================
+
+TASK_FILE="$1"
+TASK_SUBJECT="$2"
+PLAN_PATH="${3:-${PLAN_PATH:-}}"  # Use arg $3 or env var PLAN_PATH
+TOOL="${TASK_TOOL:-unknown}"
+
+if [[ -z "$TASK_FILE" ]]; then
+    echo "Error: No task file path provided" >&2
+    exit 1
+fi
+
+if [[ ! -f "$TASK_FILE" ]]; then
+    echo "Error: Task file not found: $TASK_FILE" >&2
+    exit 1
+fi
+
+# -----------------------------------------------------------------------------
+# Example Enhancements (uncomment to enable)
+# -----------------------------------------------------------------------------
+
+# Example 1: Add timestamp to the most recent task's description
+# if command -v jq &> /dev/null; then
+#     TIMESTAMP=$(date -Iseconds)
+#     jq --arg ts "$TIMESTAMP" --arg subj "$TASK_SUBJECT" \
+#        '(.[] | select(.subject == $subj) | .description) += " [Enhanced: \($ts)]"' \
+#        "$TASK_FILE" > "${TASK_FILE}.tmp" && mv "${TASK_FILE}.tmp" "$TASK_FILE"
+# fi
+
+# Example 2: Log task creation/updates
+# echo "[$(date -Iseconds)] $TOOL: $TASK_SUBJECT" >> /tmp/task-log.txt
+
+# Example 3: Validate task has description
+# if command -v jq &> /dev/null; then
+#     EMPTY_DESC=$(jq -r '.[] | select(.description == "" or .description == null) | .subject' "$TASK_FILE")
+#     if [[ -n "$EMPTY_DESC" ]]; then
+#         echo "Warning: Tasks with empty descriptions found" >&2
+#     fi
+# fi
+
+# Example 4: Add priority field based on keywords
+# if command -v jq &> /dev/null; then
+#     jq '
+#       .[] |= (
+#         if (.subject | test("urgent|critical|ASAP"; "i")) then
+#           .priority = "high"
+#         elif (.subject | test("minor|low"; "i")) then
+#           .priority = "low"
+#         else
+#           .priority = "normal"
+#         end
+#       )
+#     ' "$TASK_FILE" > "${TASK_FILE}.tmp" && mv "${TASK_FILE}.tmp" "$TASK_FILE"
+# fi
+
+# Example 5: Export tasks to external system
+# curl -X POST -H "Content-Type: application/json" \
+#      -d @"$TASK_FILE" \
+#      "https://your-api.example.com/tasks"
+
+# Example 6: Use plan context for task enhancement (Plan-Task Correlation)
+# If a plan file exists for this session, use it to enhance tasks
+# if [[ -n "$PLAN_PATH" && -f "$PLAN_PATH" ]]; then
+#     # Extract plan title from the file
+#     PLAN_TITLE=$(head -1 "$PLAN_PATH" | sed 's/^# //')
+#     echo "Task created under plan: $PLAN_TITLE"
+#
+#     # Example: Add plan reference to task metadata
+#     # if command -v jq &> /dev/null; then
+#     #     jq --arg plan "$PLAN_PATH" --arg subj "$TASK_SUBJECT" \
+#     #        '(.[] | select(.subject == $subj) | .metadata.planFile) = $plan' \
+#     #        "$TASK_FILE" > "${TASK_FILE}.tmp" && mv "${TASK_FILE}.tmp" "$TASK_FILE"
+#     # fi
+# fi
+
+# -----------------------------------------------------------------------------
+# Your custom enhancement logic goes here
+# -----------------------------------------------------------------------------
+
+# Default: No enhancement, just pass through
+echo "No custom task enhancements configured"
+exit 0

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/scripts/post-enhance-plan.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Plan Enhancer PostToolUse Hook Script
+
+Captures plan files after they're written, runs a user-customizable
+enhancement script, and notifies Claude of the enhancement.
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_plugin_root() -> Path:
+    """Get the plugin root directory."""
+    # Script is at ${CLAUDE_PLUGIN_ROOT}/scripts/post-enhance-plan.py
+    return Path(__file__).parent.parent
+
+
+def is_plan_file(file_path: str) -> bool:
+    """Check if a file is a plan file based on path patterns."""
+    return "/plans/" in file_path or file_path.endswith(".plan.md")
+
+
+def get_enhancement_script() -> Path | None:
+    """Get the user's enhancement script if it exists and is executable."""
+    script_path = get_plugin_root() / "scripts" / "enhancers" / "enhance-plan.sh"
+
+    if script_path.exists() and script_path.is_file():
+        return script_path
+
+    return None
+
+
+def run_enhancement_script(script_path: Path, plan_file_path: str) -> tuple[bool, str]:
+    """
+    Run the enhancement script on the plan file.
+
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    try:
+        result = subprocess.run(
+            [str(script_path), plan_file_path],
+            capture_output=True,
+            text=True,
+            timeout=25,  # Leave buffer for hook timeout
+            cwd=get_plugin_root(),
+        )
+
+        if result.returncode == 0:
+            output = result.stdout.strip()
+            return True, output if output else "Enhancement completed successfully"
+        else:
+            stderr = result.stderr.strip()
+            return (
+                False,
+                f"Enhancement script failed (exit {result.returncode}): {stderr}",
+            )
+
+    except subprocess.TimeoutExpired:
+        return False, "Enhancement script timed out"
+    except Exception as e:
+        return False, f"Error running enhancement script: {e}"
+
+
+def handle_write(tool_input: dict, tool_response: dict) -> dict:
+    """Handle Write tool PostToolUse - enhance plan files."""
+    file_path = tool_input.get("file_path", "")
+
+    # Only process plan files
+    if not is_plan_file(file_path):
+        return {}  # Silent pass-through for non-plan files
+
+    # Check if enhancement script exists
+    script_path = get_enhancement_script()
+    if script_path is None:
+        return {}  # No enhancement script configured
+
+    # Verify the file was written successfully
+    if not Path(file_path).exists():
+        return {}  # File doesn't exist, skip enhancement
+
+    # Run the enhancement script
+    success, message = run_enhancement_script(script_path, file_path)
+
+    if success:
+        return {
+            "additionalContext": (
+                f"\n--- Plan Enhancement Applied ---\n"
+                f"The plan file at `{file_path}` was enhanced by a custom script.\n"
+                f"Output: {message}\n"
+                f"The file content has been modified. Re-read if you need the updated content.\n"
+                f"--- End Enhancement Notice ---\n"
+            )
+        }
+    else:
+        return {
+            "additionalContext": (
+                f"\n--- Plan Enhancement Warning ---\n"
+                f"Enhancement script ran but reported an issue:\n{message}\n"
+                f"--- End Enhancement Notice ---\n"
+            )
+        }
+
+
+def main():
+    """Main entry point."""
+    try:
+        # Read hook input from stdin
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+    tool_response = input_data.get("tool_response", {})
+
+    # Route to appropriate handler
+    if tool_name == "Write":
+        result = handle_write(tool_input, tool_response)
+    else:
+        # Unknown tool, pass through silently
+        result = {}
+
+    # Output result as JSON
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/workflow-enhancer/scripts/post-enhance-task.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+Task Enhancer PostToolUse Hook Script
+
+Captures tasks after they're created/updated, runs a user-customizable
+enhancement script, and notifies Claude of the enhancement.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_plugin_root() -> Path:
+    """Get the plugin root directory."""
+    # Script is at ${CLAUDE_PLUGIN_ROOT}/scripts/post-enhance-task.py
+    return Path(__file__).parent.parent
+
+
+def find_session_plan(transcript_path: str, cwd: str) -> Path | None:
+    """
+    Find the most recent plan file created in this session.
+
+    Uses two methods:
+    1. Read transcript for Write calls to /plans/ directory
+    2. Fallback: scan plans directory for most recently modified file
+    """
+    # Method 1: Read transcript for Write calls to /plans/
+    if transcript_path:
+        transcript = Path(transcript_path)
+        if transcript.exists():
+            try:
+                with open(transcript) as f:
+                    for line in f:
+                        try:
+                            entry = json.loads(line)
+                            # Look for tool_use entries with Write tool
+                            if (
+                                entry.get("type") == "tool_use"
+                                and entry.get("name") == "Write"
+                            ):
+                                file_path = entry.get("input", {}).get("file_path", "")
+                                if "/plans/" in file_path and Path(file_path).exists():
+                                    return Path(file_path)
+                        except json.JSONDecodeError:
+                            continue
+            except (OSError, IOError):
+                pass  # Fall through to Method 2
+
+    # Method 2: Fallback - scan plans directory for most recent
+    plans_dir = Path(cwd) / ".claude" / "plans"
+    if plans_dir.exists():
+        plan_files = sorted(
+            plans_dir.glob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True
+        )
+        if plan_files:
+            return plan_files[0]
+
+    return None
+
+
+def find_task_file(session_id: str) -> Path | None:
+    """
+    Find the task JSON file for the given session.
+
+    Task files are stored at:
+    - /workspaces/.claude/todos/{session_id}-agent-{session_id}.json
+    - ~/.claude/todos/{session_id}-agent-{session_id}.json
+    """
+    if not session_id:
+        return None
+
+    # Build the expected filename pattern
+    filename = f"{session_id}-agent-{session_id}.json"
+
+    # Check possible locations
+    locations = [
+        Path("/workspaces/.claude/todos") / filename,
+        Path.home() / ".claude" / "todos" / filename,
+    ]
+
+    for path in locations:
+        if path.exists():
+            return path
+
+    # Also try scanning the todos directories for any matching session
+    todos_dirs = [
+        Path("/workspaces/.claude/todos"),
+        Path.home() / ".claude" / "todos",
+    ]
+
+    for todos_dir in todos_dirs:
+        if todos_dir.exists():
+            # Look for files starting with the session_id
+            for f in todos_dir.glob(f"{session_id}*.json"):
+                return f
+
+    return None
+
+
+def get_enhancement_script() -> Path | None:
+    """Get the user's enhancement script if it exists."""
+    script_path = get_plugin_root() / "scripts" / "enhancers" / "enhance-task.sh"
+
+    if script_path.exists() and script_path.is_file():
+        return script_path
+
+    return None
+
+
+def run_enhancement_script(
+    script_path: Path,
+    task_file_path: str,
+    task_subject: str,
+    tool_name: str,
+    plan_path: str | None = None,
+) -> tuple[bool, str]:
+    """
+    Run the enhancement script on the task file.
+
+    Args:
+        script_path: Path to the enhancement script
+        task_file_path: Path to the task JSON file
+        task_subject: Subject of the task being created/updated
+        tool_name: Either "TaskCreate" or "TaskUpdate"
+        plan_path: Optional path to the session's plan file
+
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    try:
+        env = os.environ.copy()
+        env["TASK_TOOL"] = tool_name
+        if plan_path:
+            env["PLAN_PATH"] = plan_path
+
+        # Build arguments: script, task_file, subject, [plan_path]
+        args = [str(script_path), task_file_path, task_subject]
+        if plan_path:
+            args.append(plan_path)
+
+        result = subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            timeout=25,  # Leave buffer for hook timeout
+            cwd=get_plugin_root(),
+            env=env,
+        )
+
+        if result.returncode == 0:
+            output = result.stdout.strip()
+            return True, output if output else "Enhancement completed successfully"
+        else:
+            stderr = result.stderr.strip()
+            return (
+                False,
+                f"Enhancement script failed (exit {result.returncode}): {stderr}",
+            )
+
+    except subprocess.TimeoutExpired:
+        return False, "Enhancement script timed out"
+    except Exception as e:
+        return False, f"Error running enhancement script: {e}"
+
+
+def handle_task_tool(
+    tool_name: str,
+    tool_input: dict,
+    tool_response: dict,
+    session_id: str,
+    transcript_path: str = "",
+    cwd: str = "",
+) -> dict:
+    """Handle TaskCreate/TaskUpdate PostToolUse - enhance tasks."""
+    task_subject = tool_input.get("subject", "")
+
+    # For TaskUpdate, we might not have a subject in the input
+    if not task_subject and tool_name == "TaskUpdate":
+        task_subject = tool_input.get("taskId", "unknown")
+
+    # Check if enhancement script exists
+    script_path = get_enhancement_script()
+    if script_path is None:
+        return {}  # No enhancement script configured
+
+    # Find the task file
+    task_file = find_task_file(session_id)
+    if task_file is None:
+        return {}  # Task file not found, skip silently
+
+    # Find the session's plan file (if any)
+    plan_file = find_session_plan(transcript_path, cwd)
+    plan_path = str(plan_file) if plan_file else None
+
+    # Run the enhancement script
+    success, message = run_enhancement_script(
+        script_path, str(task_file), task_subject, tool_name, plan_path
+    )
+
+    if success:
+        return {
+            "additionalContext": (
+                f"\n--- Task Enhancement Applied ---\n"
+                f"The task file at `{task_file}` was enhanced by a custom script.\n"
+                f"Tool: {tool_name} | Subject: {task_subject}\n"
+                f"Output: {message}\n"
+                f"--- End Enhancement Notice ---\n"
+            )
+        }
+    else:
+        return {
+            "additionalContext": (
+                f"\n--- Task Enhancement Warning ---\n"
+                f"Enhancement script ran but reported an issue:\n{message}\n"
+                f"--- End Enhancement Notice ---\n"
+            )
+        }
+
+
+def main():
+    """Main entry point."""
+    try:
+        # Read hook input from stdin
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+    tool_response = input_data.get("tool_response", {})
+    session_id = input_data.get("session_id", "")
+    transcript_path = input_data.get("transcript_path", "")
+    cwd = input_data.get("cwd", "")
+
+    # Route to handler for task tools
+    if tool_name in ("TaskCreate", "TaskUpdate"):
+        result = handle_task_tool(
+            tool_name, tool_input, tool_response, session_id, transcript_path, cwd
+        )
+    else:
+        # Unknown tool, pass through silently
+        result = {}
+
+    # Output result as JSON
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()