ccsetup 1.1.1 → 1.2.1

package/template/hooks/workflow-selector/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Environment variable toggle — exit early if not enabled
+// Enable with: export CCSETUP_WORKFLOW=1
+const enabled = process.env.CCSETUP_WORKFLOW;
+if (!enabled || (enabled !== '1' && enabled.toLowerCase() !== 'true')) {
+  console.log('{}');
+  process.exit(0);
+}
+
+// Simple workflow selector that reads from agent-orchestration.md
+class WorkflowSelector {
+  constructor() {
+    this.workflows = this.loadWorkflows();
+    this.availableAgents = this.getAvailableAgents();
+  }
+
+  loadWorkflows() {
+    const orchestrationPath = path.join(process.cwd(), 'docs', 'agent-orchestration.md');
+    
+    if (!fs.existsSync(orchestrationPath)) {
+      return this.getDefaultWorkflows();
+    }
+
+    try {
+      // First try to use Claude to extract workflows intelligently
+      const workflows = this.loadWorkflowsWithClaude(orchestrationPath);
+      if (workflows && Object.keys(workflows).length > 0) {
+        return workflows;
+      }
+    } catch (error) {
+      // Claude extraction failed, continue with regex
+    }
+
+    // Fallback to regex-based extraction
+    return this.loadWorkflowsWithRegex(orchestrationPath);
+  }
+
+  loadWorkflowsWithClaude(orchestrationPath) {
+    const { execSync } = require('child_process');
+    
+    try {
+      const content = fs.readFileSync(orchestrationPath, 'utf8');
+      
+      const extractPrompt = `
+Extract all workflows from this agent orchestration document.
+
+For each workflow, identify:
+1. The workflow name
+2. The sequence of agents used
+3. The purpose/description
+
+Return ONLY a JSON object with this structure:
+{
+  "workflow_key": {
+    "name": "Workflow Name",
+    "agents": ["agent1", "agent2", "agent3"],
+    "purpose": "Brief description"
+  }
+}
+
+Document content:
+${content}
+
+Extract all workflows and return valid JSON only.
+`;
+
+      const claudeResult = execSync(
+        `claude --print "${extractPrompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 * 10 }
+      );
+
+      // Parse the JSON result
+      const parsed = JSON.parse(claudeResult);
+      
+      // Validate and normalize the workflows
+      const workflows = {};
+      for (const [key, workflow] of Object.entries(parsed)) {
+        if (workflow.name && Array.isArray(workflow.agents) && workflow.agents.length > 0) {
+          // Normalize agent names (remove "agent" suffix, lowercase)
+          const normalizedAgents = workflow.agents.map(agent => 
+            agent.toLowerCase().replace(/\s*agent\s*$/, '').trim()
+          );
+          
+          workflows[key] = {
+            name: workflow.name,
+            agents: normalizedAgents,
+            purpose: workflow.purpose || ''
+          };
+        }
+      }
+      
+      return workflows;
+    } catch (error) {
+      // Claude extraction failed
+      return null;
+    }
+  }
+
+  loadWorkflowsWithRegex(orchestrationPath) {
+    try {
+      const content = fs.readFileSync(orchestrationPath, 'utf8');
+      const workflows = {};
+      
+      // Enhanced regex patterns for better extraction
+      const workflowSections = this.extractWorkflowSections(content);
+      
+      for (const section of workflowSections) {
+        const workflow = this.parseWorkflowSection(section);
+        if (workflow) {
+          const key = workflow.name.toLowerCase().replace(/\s+/g, '_');
+          workflows[key] = workflow;
+        }
+      }
+      
+      // If no workflows found, return defaults
+      return Object.keys(workflows).length > 0 ? workflows : this.getDefaultWorkflows();
+    } catch (error) {
+      return this.getDefaultWorkflows();
+    }
+  }
+
+  extractWorkflowSections(content) {
+    const sections = [];
+    
+    // Split by workflow headers
+    const workflowRegex = /### \d+\.\s+(.+?)\s+Workflow([\s\S]*?)(?=### \d+\.|## |$)/g;
+    let match;
+    
+    while ((match = workflowRegex.exec(content)) !== null) {
+      sections.push({
+        name: match[1].trim(),
+        content: match[2].trim()
+      });
+    }
+    
+    return sections;
+  }
+
+  parseWorkflowSection(section) {
+    const workflow = {
+      name: section.name,
+      agents: []
+    };
+    
+    // Look for the Flow section
+    const flowMatch = section.content.match(/\*\*Flow\*\*:?\s*([\s\S]*?)(?=\*\*|###|$)/);
+    if (!flowMatch) return null;
+    
+    const flowContent = flowMatch[1];
+    
+    // Extract agents from various formats
+    const agents = this.extractAgentsFromFlow(flowContent);
+    
+    if (agents.length > 0) {
+      workflow.agents = agents;
+      return workflow;
+    }
+    
+    return null;
+  }
+
+  extractAgentsFromFlow(flowContent) {
+    const agents = [];
+    const lines = flowContent.split('\n');
+    
+    for (const line of lines) {
+      // Pattern 1: "1. **Agent Name** → Description"
+      let match = line.match(/^\d+\.\s*\*\*([^*→]+?)(?:\s+Agent)?\*\*/);
+      
+      // Pattern 2: "- Agent Name: Description"
+      if (!match) {
+        match = line.match(/^[-•]\s*\*\*([^*:]+?)(?:\s+Agent)?\*\*/);
+      }
+      
+      // Pattern 3: "Agent Name →"
+      if (!match) {
+        match = line.match(/^\s*([A-Za-z\s]+?)\s*(?:Agent\s*)?→/);
+      }
+      
+      if (match) {
+        const agent = match[1].toLowerCase()
+          .replace(/\s*agent\s*$/, '')
+          .trim();
+        
+        if (agent && !agents.includes(agent) && agent.length > 0) {
+          agents.push(agent);
+        }
+      }
+    }
+    
+    return agents;
+  }
+
+  getDefaultWorkflows() {
+    return {
+      feature_development: {
+        name: 'Feature Development',
+        agents: ['researcher', 'planner', 'coder', 'checker']
+      },
+      bug_fix: {
+        name: 'Bug Fix',
+        agents: ['researcher', 'coder', 'checker']
+      },
+      refactoring: {
+        name: 'Refactoring',
+        agents: ['researcher', 'planner', 'coder', 'checker']
+      },
+      api_development: {
+        name: 'API Development',
+        agents: ['planner', 'backend', 'frontend', 'checker']
+      },
+      ui_component: {
+        name: 'UI Component',
+        agents: ['frontend', 'shadcn', 'checker']
+      },
+      blockchain: {
+        name: 'Blockchain Development',
+        agents: ['planner', 'blockchain', 'checker']
+      },
+      qa: {
+        name: 'QA',
+        agents: ['researcher', 'checker', 'coder', 'checker']
+      }
+    };
+  }
+
+  getAvailableAgents() {
+    const agentsDir = path.join(process.cwd(), '.claude', 'agents');
+    
+    if (!fs.existsSync(agentsDir)) {
+      return [];
+    }
+    
+    try {
+      return fs.readdirSync(agentsDir)
+        .filter(file => file.endsWith('.md'))
+        .map(file => file.replace('.md', '').toLowerCase());
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async selectWorkflow(prompt) {
+    const { execSync } = require('child_process');
+    
+    try {
+      // First, let's use Claude to analyze the prompt and understand the task type
+      const analyzePrompt = `
+Analyze this user prompt and determine the most appropriate workflow type.
+User prompt: "${prompt}"
+
+Available workflows:
+${Object.entries(this.workflows).map(([key, workflow]) => 
+  `- ${workflow.name}: uses agents [${workflow.agents.join(', ')}]`
+).join('\n')}
+
+Consider:
+1. What type of task is this? (feature, bug fix, refactoring, API work, UI work, testing, etc.)
+2. What agents would be most helpful?
+3. Match to the most appropriate workflow
+
+Respond with ONLY the workflow key (e.g., 'feature_development', 'bug_fix', etc.)
+`;
+
+      // Use Claude to analyze the prompt
+      const claudeAnalysis = execSync(
+        `claude --print "${analyzePrompt.replace(/"/g, '\\"')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+      ).trim().toLowerCase().replace(/['"]/g, '');
+
+      // Validate the response is a valid workflow key
+      if (this.workflows[claudeAnalysis]) {
+        return this.workflows[claudeAnalysis];
+      }
+
+      // If Claude's response isn't valid, fall back to enhanced keyword matching
+      return this.enhancedKeywordMatching(prompt);
+      
+    } catch (error) {
+      // If Claude command fails, fall back to enhanced keyword matching
+      console.error('Claude analysis failed, using keyword matching:', error.message);
+      return this.enhancedKeywordMatching(prompt);
+    }
+  }
+
+  enhancedKeywordMatching(prompt) {
+    const promptLower = prompt.toLowerCase();
+    
+    // Score each workflow based on keyword matches
+    const scores = {};
+    
+    // Define keyword weights for each workflow
+    const workflowKeywords = {
+      bug_fix: {
+        keywords: ['fix', 'bug', 'error', 'issue', 'broken', 'crash', 'fail', 'debug', 'problem', 'wrong'],
+        weight: 2
+      },
+      refactoring: {
+        keywords: ['refactor', 'improve', 'optimize', 'clean', 'restructure', 'reorganize', 'simplify', 'enhance'],
+        weight: 2
+      },
+      api_development: {
+        keywords: ['api', 'endpoint', 'rest', 'graphql', 'backend', 'server', 'route', 'request', 'response'],
+        weight: 2
+      },
+      ui_component: {
+        keywords: ['ui', 'component', 'frontend', 'react', 'vue', 'interface', 'button', 'form', 'page', 'view'],
+        weight: 2
+      },
+      qa: {
+        keywords: ['test', 'qa', 'quality', 'testing', 'unit', 'integration', 'e2e', 'coverage', 'assert'],
+        weight: 2
+      },
+      feature_development: {
+        keywords: ['add', 'create', 'implement', 'build', 'develop', 'feature', 'new', 'functionality'],
+        weight: 1
+      },
+      blockchain: {
+        keywords: ['blockchain', 'smart contract', 'web3', 'ethereum', 'solidity', 'defi', 'crypto', 'wallet'],
+        weight: 3
+      }
+    };
+    
+    // Calculate scores for each workflow
+    Object.entries(workflowKeywords).forEach(([workflow, config]) => {
+      scores[workflow] = 0;
+      config.keywords.forEach(keyword => {
+        if (promptLower.includes(keyword)) {
+          scores[workflow] += config.weight;
+        }
+      });
+    });
+    
+    // Find the workflow with the highest score
+    let bestWorkflow = 'feature_development';
+    let highestScore = 0;
+    
+    Object.entries(scores).forEach(([workflow, score]) => {
+      if (score > highestScore && this.workflows[workflow]) {
+        highestScore = score;
+        bestWorkflow = workflow;
+      }
+    });
+    
+    return this.workflows[bestWorkflow] || this.workflows.feature_development || Object.values(this.workflows)[0];
+  }
+
+  filterAgentsByAvailability(agents) {
+    if (this.availableAgents.length === 0) {
+      return agents; // Return all if we can't check
+    }
+    
+    return agents.filter(agent => this.availableAgents.includes(agent));
+  }
+}
+
+// Main execution - reads from stdin as Claude Code provides
+if (require.main === module) {
+  let inputData = '';
+  
+  process.stdin.on('data', (chunk) => {
+    inputData += chunk;
+  });
+  
+  process.stdin.on('end', async () => {
+    try {
+      const input = JSON.parse(inputData);
+      const prompt = input.prompt || '';
+      
+      if (!prompt) {
+        console.log('{}');
+        return;
+      }
+      
+      const selector = new WorkflowSelector();
+      const workflow = await selector.selectWorkflow(prompt);
+      const agents = selector.filterAgentsByAvailability(workflow.agents);
+      
+      // Output suggestion — Claude should ask the user before applying
+      const output = {
+        workflow: workflow.name,
+        agents: agents,
+        message: `[Workflow Suggestion] Based on this prompt, the "${workflow.name}" workflow may be a good fit: ${agents.join(' → ')}. Ask the user if they'd like to follow this workflow or just proceed normally with Claude Code's default behavior.`
+      };
+
+      console.log(JSON.stringify(output));
+    } catch (error) {
+      // Silent fail - just return empty
+      console.log('{}');
+    }
+  });
+}
+
+module.exports = WorkflowSelector;

package/template/scripts/codex-review/codex-review.sh

@@ -0,0 +1,266 @@
+#!/bin/bash
+# codex-review.sh — Review plans, implementations, or code changes via Codex CLI
+# Usage: codex-review.sh [plan-file-or--] [--model <model>]
+#   No arguments: reviews git changes (code review)
+#   With plan file: reviews plan, or plan+implementation if git changes exist
+#
+# Exit codes:
+#   0 = success
+#   1 = codex CLI not installed / nothing to review
+#   2 = auth/API error
+#   3 = timeout
+
+set -euo pipefail
+
+PLAN_FILE=""
+PLAN_CONTENT=""
+DIFF_CONTENT=""
+MODEL="${CODEX_REVIEW_MODEL:-}"
+TIMEOUT=120
+MAX_DIFF_CHARS=50000
+
+if command -v timeout &>/dev/null; then
+  TIMEOUT_CMD="timeout"
+elif command -v gtimeout &>/dev/null; then
+  TIMEOUT_CMD="gtimeout"
+else
+  TIMEOUT_CMD=""
+fi
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --model)
+      MODEL="$2"
+      shift 2
+      ;;
+    --model=*)
+      MODEL="${1#*=}"
+      shift
+      ;;
+    -)
+      PLAN_FILE="-"
+      shift
+      ;;
+    *)
+      if [[ -z "$PLAN_FILE" ]]; then
+        PLAN_FILE="$1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+# Check prerequisites
+if ! command -v codex &>/dev/null; then
+  echo "Error: codex CLI is not installed. Install it with: npm install -g @openai/codex" >&2
+  exit 1
+fi
+
+# Read plan content (optional — only when a plan file is provided)
+if [[ "$PLAN_FILE" == "-" ]]; then
+  PLAN_CONTENT=$(cat)
+elif [[ -n "$PLAN_FILE" && -f "$PLAN_FILE" ]]; then
+  PLAN_CONTENT=$(cat "$PLAN_FILE")
+elif [[ -n "$PLAN_FILE" ]]; then
+  echo "Error: Plan file not found: $PLAN_FILE" >&2
+  exit 1
+fi
+
+# Gather git diff (silently skips if git unavailable or not in a repo)
+gather_git_diff() {
+  if ! command -v git &>/dev/null; then return; fi
+  if ! git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then return; fi
+
+  DIFF_CONTENT=$(git diff HEAD 2>/dev/null || true)
+
+  if [[ -z "$DIFF_CONTENT" ]]; then
+    DIFF_CONTENT=$(git diff HEAD~1..HEAD 2>/dev/null || true)
+  fi
+
+  # Fallback for initial commit (no HEAD yet) or staged-only changes
+  if [[ -z "$DIFF_CONTENT" ]]; then
+    DIFF_CONTENT=$(git diff --cached 2>/dev/null || true)
+  fi
+
+  if [[ -n "$DIFF_CONTENT" && ${#DIFF_CONTENT} -gt $MAX_DIFF_CHARS ]]; then
+    DIFF_CONTENT="${DIFF_CONTENT:0:$MAX_DIFF_CHARS}
+
+[... diff truncated at ${MAX_DIFF_CHARS} characters ...]"
+  fi
+}
+
+gather_git_diff
+
+# Must have at least a plan or git changes to review
+if [[ -z "$PLAN_CONTENT" && -z "$DIFF_CONTENT" ]]; then
+  echo "Error: No plan file or git changes found. Nothing to review." >&2
+  echo "Usage: codex-review.sh [plan-file-or--] [--model <model>]" >&2
+  exit 1
+fi
+
+CMD_ARGS=()
+if [[ -n "$MODEL" ]]; then
+  CMD_ARGS+=(--model "$MODEL")
+fi
+
+# Build prompt based on available inputs
+if [[ -n "$PLAN_CONTENT" && -n "$DIFF_CONTENT" ]]; then
+  # Implementation review: validate code changes against the plan
+  REVIEW_PROMPT="You are a senior architect reviewing an implementation against its plan. Validate that the code changes correctly fulfill the plan requirements.
+
+## Plan
+
+$PLAN_CONTENT
+
+---
+
+## Implementation (git diff)
+
+$DIFF_CONTENT
+
+---
+
+Provide a structured review covering:
+
+## Plan Compliance
+- Which plan requirements are correctly implemented?
+- Which plan requirements are missing or incomplete?
+- Any divergence from the planned approach?
+
+## Acceptance Criteria
+- For each acceptance criterion in the plan, is it met by the implementation?
+- List any unmet criteria explicitly
+
+## Code Quality
+- Are there bugs or logic errors in the implementation?
+- Security concerns in the changed code?
+- Performance issues?
+
+## Suggestions
+- Specific issues to fix before merging
+- Missing tests or validation
+- Improvements to better match the plan
+
+Be direct and specific. Reference exact file paths and line ranges from the diff."
+
+elif [[ -n "$PLAN_CONTENT" ]]; then
+  # Plan review: architectural review of the plan itself
+  REVIEW_PROMPT="You are a senior architect reviewing this plan. Provide a structured review covering:
+
+## Architecture Review
+- Are the technical choices sound?
+- Are there simpler alternatives?
+- Any missing dependencies or integration concerns?
+
+## Risk Assessment
+- What could go wrong?
+- What edge cases are unhandled?
+- Any security or performance concerns?
+
+## Suggestions
+- Specific improvements with rationale
+- Missing acceptance criteria
+- Implementation order concerns
+
+Be direct and specific. Reference exact sections of the plan.
+
+---
+
+Plan to review:
+
+$PLAN_CONTENT"
+
+else
+  # Code review: standalone review of git changes
+  REVIEW_PROMPT="You are a senior engineer performing a code review. Review the following code changes for quality, correctness, and best practices.
+
+## Code Changes (git diff)
+
+$DIFF_CONTENT
+
+---
+
+Provide a structured review covering:
+
+## Bugs and Correctness
+- Logic errors or incorrect behavior
+- Missing null/error handling
+- Off-by-one errors or boundary conditions
+
+## Security
+- Injection vulnerabilities
+- Exposed secrets or credentials
+- Missing input validation
+
+## Performance
+- Unnecessary computations or allocations
+- Inefficient patterns
+- Missing caching opportunities
+
+## Code Quality
+- Naming and readability
+- Adherence to existing code conventions
+- Dead code or unnecessary complexity
+
+## Suggestions
+- Specific improvements with rationale
+- Missing tests
+- Documentation gaps
+
+Be direct and specific. Reference exact file paths and line ranges from the diff."
+fi
+
+# Run codex exec with timeout (if available)
+# Temporarily disable exit-on-error to capture the actual exit code before
+# checking it. Using "if ! OUTPUT=$(cmd)" sets $? to 0 inside the then-block
+# (the negated result), making timeout detection (exit 124) impossible.
+set +e
+if [[ -n "$TIMEOUT_CMD" ]]; then
+  OUTPUT=$($TIMEOUT_CMD "${TIMEOUT}s" codex exec ${CMD_ARGS[@]+"${CMD_ARGS[@]}"} "$REVIEW_PROMPT" 2>&1)
+else
+  OUTPUT=$(codex exec ${CMD_ARGS[@]+"${CMD_ARGS[@]}"} "$REVIEW_PROMPT" 2>&1)
+fi
+EXIT_CODE=$?
+set -e
+
+if [[ $EXIT_CODE -ne 0 ]]; then
+  if [[ $EXIT_CODE -eq 124 ]]; then
+    echo "Error: Codex review timed out after ${TIMEOUT}s. Try a shorter plan or increase TIMEOUT." >&2
+    exit 3
+  fi
+
+  if echo "$OUTPUT" | grep -qi "login\|log in\|sign in\|authenticate first"; then
+    echo "Error: Codex CLI requires login. Run 'codex login' first." >&2
+    exit 2
+  fi
+
+  if echo "$OUTPUT" | grep -qi "auth\|unauthorized\|api.key\|invalid.*key\|forbidden\|permission denied"; then
+    echo "Error: Codex authentication failed. Check your OpenAI API key." >&2
+    echo "$OUTPUT" >&2
+    exit 2
+  fi
+
+  if echo "$OUTPUT" | grep -qi "rate.limit\|too many requests\|429\|quota\|exceeded.*limit"; then
+    echo "Error: Rate limited by OpenAI API. Wait a moment and try again." >&2
+    echo "$OUTPUT" >&2
+    exit 2
+  fi
+
+  if echo "$OUTPUT" | grep -qi "network\|connect\|ECONNREFUSED\|ENOTFOUND\|DNS\|resolve\|unreachable\|timed out"; then
+    echo "Error: Network error. Check your internet connection." >&2
+    echo "$OUTPUT" >&2
+    exit 2
+  fi
+
+  if echo "$OUTPUT" | grep -qi "model.*not found\|does not exist\|invalid.*model\|unknown model"; then
+    echo "Error: Invalid model '${MODEL:-default}'. Check available models with 'codex --help'." >&2
+    echo "$OUTPUT" >&2
+    exit 2
+  fi
+
+  echo "Error: Codex review failed (exit code $EXIT_CODE)" >&2
+  echo "$OUTPUT" >&2
+  exit 2
+fi
+
+echo "$OUTPUT"