claude-flow-novice 2.18.28 → 2.18.30

package/.claude/commands/cfn-fix-errors.md

@@ -0,0 +1,300 @@
+---
+description: "Coordinate agents to fix compilation errors using post-edit validation and Cerebras gates"
+argument-hint: "<language> [--max-parallel=5] [--max-cycles=10]"
+allowed-tools: ["Task", "TaskOutput", "TodoWrite", "Read", "Bash"]
+---
+
+# CFN Fix Errors - Agent Coordination Mode
+
+**Version:** 1.1.0  |  **Date:** 2025-12-21  |  **Status:** Production Ready
+
+## Quick Overview
+
+Main chat coordinates up to 5 background agents to fix compilation errors in parallel. Each agent works on one file using Cerebras acceleration and post-edit validation.
+
+### Key Features
+- **Max 5 parallel agents** with continuous spawning
+- **Single-file focus** - each agent fixes one file only
+- **2-attempt retry** logic per file before deferring to Phase 2
+- **Post-edit validation** confirms fixes are correct
+- **Cerebras gates** prevent semantic changes (12 structural validations)
+- **Automatic Phase 2** transition at <40 errors
+
+### When to Use
+- 20+ compilation errors
+- Errors are mostly mechanical (imports, types, syntax)
+- Want visibility into agent progress
+- Need fast bulk error reduction
+
+---
+
+## Execution Instructions (Follow These Steps)
+
+### Step 1: Parse Arguments and Initialize
+
+**YOU SHOULD:** Parse the command arguments and set up session tracking.
+
+```bash
+# Extract language from arguments (first word before any flags)
+LANGUAGE="typescript"  # or "rust" from user's command
+
+# Parse optional flags (use defaults if not provided)
+MAX_PARALLEL=5
+MAX_CYCLES=10
+
+# Generate unique session ID
+SESSION_ID="cfn-fix-$(date +%s | tail -c 6)-${RANDOM}"
+echo "Session ID: $SESSION_ID | Language: $LANGUAGE | Max Parallel: $MAX_PARALLEL"
+```
+
+**VALIDATE:** Language must be "rust", "typescript", or "ts"
+
+---
+
+### Step 2: Get Error Files
+
+**YOU SHOULD:** Run the appropriate type checker and get files with errors.
+
+**For Rust:**
+```bash
+cd [PROJECT_ROOT]
+SQLX_OFFLINE=true cargo check 2>&1 | grep "^error\[" | awk -F':' '{print $1}' | sort | uniq -c | sort -rn
+```
+
+**For TypeScript:**
+```bash
+cd [PROJECT_ROOT]
+# Try common script names: typecheck, type-check, or tsc
+npm run typecheck 2>&1 | grep "error TS" | awk -F'(' '{print $1}' | sort | uniq -c | sort -rn
+```
+
+**OUTPUT FORMAT:**
+```
+  45 src/api/handler.ts
+  32 src/db/models.ts
+  18 src/utils/helpers.ts
+```
+
+**YOU SHOULD:** Store this list and track state for each file:
+- `attempts`: 0-2 (retry counter)
+- `status`: "queued" | "in_progress" | "success" | "defer"
+- `agentId`: null | "agent-session-file"
+
+---
+
+### Step 3: Spawn Agents (Continuous Loop)
+
+**YOU SHOULD:** Spawn agents continuously, maintaining exactly 5 active agents at any time.
+
+**Agent Spawn Pattern:**
+
+```typescript
+// While there are files to process OR active agents running:
+while (fileQueue.length > 0 || activeAgents.length > 0) {
+
+  // Spawn up to 5 agents
+  while (activeAgents.length < MAX_PARALLEL && fileQueue.length > 0) {
+    const file = fileQueue.shift();
+    const agentId = `${LANGUAGE}-fixer-${SESSION_ID}-${sanitize(file)}`;
+
+    // Use Task tool with background=true
+    const taskId = Task("rust-developer" OR "typescript-specialist",
+      `[SEE AGENT PROMPT BELOW]`,
+      {run_in_background: true}
+    );
+
+    // Track this agent
+    activeAgents.push({file, agentId, taskId, attempts: 1});
+  }
+
+  // Monitor agents (non-blocking check)
+  for each activeAgent {
+    const result = TaskOutput(agent.taskId, {block: false, timeout: 0});
+
+    if (result.status === 'completed') {
+      // Parse result: SUCCESS | RETRY | DEFER
+      if (result.output.includes('SUCCESS')) {
+        // File fixed! Remove from queue
+      } else if (agent.attempts < 2) {
+        // Retry: add back to queue, increment attempts
+        fileQueue.push(file);
+        fileState[file].attempts++;
+      } else {
+        // 2 attempts failed: defer to Phase 2
+        phase2Queue.push(file);
+      }
+
+      // Remove from active agents (frees slot for next file)
+      activeAgents.remove(agent);
+    }
+  }
+
+  // Small delay to prevent tight loop
+  sleep(1 second);
+}
+```
+
+**AGENT PROMPT TEMPLATE:**
+
+Use this exact prompt structure for spawned agents:
+
+```
+AGENT_ID="${agentId}"
+FILE_PATH="${file}"
+SESSION_ID="${SESSION_ID}"
+ATTEMPT=${attempts}/2
+
+TASK: Fix compilation errors in a single file using Cerebras acceleration.
+
+WORKFLOW:
+1. Read file: ${file}
+
+2. Call Cerebras single-file fixer:
+   [FOR RUST]
+   npx tsx /path/to/cerebras-gated-fixer-v2.ts --file="${file}" --agent-id="${agentId}"
+
+   [FOR TYPESCRIPT]
+   npx tsx /path/to/typescript-gated-fixer-v2.ts --file="${file}" --agent-id="${agentId}"
+
+3. Validate with post-edit pipeline:
+   ./.claude/hooks/cfn-invoke-post-edit.sh "${file}" --agent-id "${agentId}"
+
+4. Return status:
+   - If post-edit validation PASSES (exit 0): Return "SUCCESS"
+   - If post-edit validation FAILS (exit 1): Return "RETRY" (attempt 1) or "DEFER" (attempt 2)
+
+CEREBRAS GATES:
+- Phase 1a: Cerebras generates fix
+- Phase 1b: 12 gates validate (LineCount, FnSignature, ImportDup, BraceBalance, SemanticDiff, OrphanedCode, ImportPath, PatternDup, ImplLocation, TypeCast, MatchArm, Regression)
+- Up to 3 retries per gate rejection
+
+CRITICAL RESTRICTIONS:
+- DO NOT run eslint, cargo clippy, cargo check, or npm run typecheck on ENTIRE codebase
+- Work ONLY on file: ${file}
+- Use Cerebras for speed
+- Post-edit validation runs on this file only
+
+SUCCESS CRITERIA:
+Post-edit pipeline returns exit code 0
+
+RETURN: Print "SUCCESS" or "DEFER" clearly in your final output.
+```
+
+---
+
+### Step 4: Cycle Completion and Phase Transition
+
+**YOU SHOULD:** After all agents complete (activeAgents.length === 0), check if Phase 2 is needed.
+
+**Recheck Error Count:**
+
+```bash
+# Rust
+SQLX_OFFLINE=true cargo check 2>&1 | grep -c "^error\["
+
+# TypeScript
+npm run typecheck 2>&1 | grep -c "error TS"
+```
+
+**Phase 2 Triggers:**
+- Error count < 40
+- No progress made (same error count as before)
+- Max cycles reached
+- All files processed (queue empty, no deferrals)
+
+**IF Phase 2 needed:**
+
+```typescript
+// Spawn dedicated cleanup agent (NOT background - visible)
+Task("rust-developer" OR "typescript-specialist", `
+AGENT_ID="${LANGUAGE}-phase2-${SESSION_ID}"
+
+TASK: Fix remaining compilation errors after Phase 1 bulk processing.
+
+CONTEXT:
+- Phase 1 processed files with Cerebras acceleration
+- ${ERROR_COUNT} errors remaining
+- Errors require context-aware fixes
+
+WORKING DIRECTORY: [PROJECT_ROOT]
+
+STEP 1: Get error locations
+[RUST] SQLX_OFFLINE=true cargo check 2>&1 | grep -E "^error\\[E" | sort | uniq -c
+[TYPESCRIPT] npm run typecheck 2>&1 | grep -E "error TS" | sort | uniq -c
+
+STEP 2: Fix each file
+1. Read FULL file for context
+2. Identify root cause (not symptom)
+3. Apply minimal fix
+4. Run post-edit validation:
+   ./.claude/hooks/cfn-invoke-post-edit.sh "$FILE" --agent-id "${AGENT_ID}"
+5. Verify with compiler after EACH file
+
+RULES:
+- Read FULL file before editing
+- Preserve ALL existing imports
+- Fix root causes first
+- Verify after EACH file
+- Run post-edit pipeline after EACH edit
+
+RESTRICTIONS:
+- DO NOT run linters on entire codebase
+- Work on one file at a time
+
+Report final error count when done.
+`)
+```
+
+---
+
+## Important Notes
+
+### State Tracking
+
+**YOU SHOULD** maintain these data structures in memory:
+
+```typescript
+// File state
+fileState = {
+  "src/api.ts": {attempts: 1, status: "in_progress", agentId: "ts-fixer-123-api"},
+  "src/db.ts": {attempts: 2, status: "defer", agentId: null}
+}
+
+// Active agents
+activeAgents = [
+  {file: "src/api.ts", agentId: "ts-fixer-123-api", taskId: "abc123", attempts: 1}
+]
+
+// Phase 2 queue
+phase2Queue = ["src/db.ts", "src/models.ts"]
+```
+
+### Error Handling
+
+- If agent fails to spawn: Log error, skip file, continue
+- If TaskOutput times out: Treat as DEFER, add to Phase 2
+- If post-edit hook missing: Warn user, continue without validation
+
+### Progress Reporting
+
+**YOU SHOULD** periodically report progress to user:
+- "Spawned agent 3/5 for src/api.ts (attempt 1/2)"
+- "Agent completed: src/utils.ts - SUCCESS"
+- "Agent completed: src/db.ts - DEFER (2 attempts failed)"
+- "Cycle 1 complete: 45 → 23 errors (-22)"
+
+---
+
+## Related Documentation
+
+- **Cerebras Rust Fixer**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts`
+- **Cerebras TypeScript Fixer**: `.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts`
+- **Post-Edit Pipeline**: `.claude/hooks/cfn-invoke-post-edit.sh`
+- **Task Mode Reference**: `.claude/commands/cfn-loop-task.md`
+
+---
+
+## Version History
+
+- v1.1.0 (2025-12-21) - Clarified instructions, removed pseudocode confusion
+- v1.0.0 (2025-12-21) - Initial coordination mode implementation

package/.claude/skills/cfn-compilation-error-fixer/lib/fixer/cerebras-gated-fixer-v2.ts

@@ -19,6 +19,10 @@ import { execSync } from 'child_process';
 
 // ============== CONFIGURATION ==============
 
+// Parse --file and --agent-id parameters
+const fileArg = process.argv.find(arg => arg.startsWith('--file='));
+const agentIdArg = process.argv.find(arg => arg.startsWith('--agent-id='));
+
 const CONFIG = {
   maxGlobalIterations: 5,
   maxFileRetries: 2,
@@ -32,6 +36,8 @@ const CONFIG = {
   dryRun: process.argv.includes('--dry-run'),
   patchDir: '/tmp/rust-fix-patches',
   verbose: process.argv.includes('--verbose'),
+  singleFile: fileArg ? fileArg.split('=')[1] : null,  // Single-file mode
+  agentId: agentIdArg ? agentIdArg.split('=')[1] : null,  // Agent ID for coordination mode
 };
 
 // ============== TYPE DEFINITIONS ==============
@@ -1342,6 +1348,12 @@ async function main() {
   console.log(`Layer 3 LLM Review: ${CONFIG.enableLayer3 ? 'ON' : 'OFF'}`);
   console.log(`Clippy: ${CONFIG.enableClippy ? 'ON' : 'OFF'}`);
   console.log(`Dry-Run: ${CONFIG.dryRun ? 'ON' : 'OFF'}`);
+  if (CONFIG.singleFile) {
+    console.log(`Single-File Mode: ${CONFIG.singleFile}`);
+    if (CONFIG.agentId) {
+      console.log(`Agent ID: ${CONFIG.agentId}`);
+    }
+  }
   console.log();
 
   const apiKey = loadCerebrasKey();
@@ -1380,7 +1392,17 @@ async function main() {
     const fileFeedback = new Map<string, Map<number, string>>();
 
     let totalApplied = 0;
-    const files = [...allErrors.entries()];
+    let files = [...allErrors.entries()];
+
+    // Single-file mode: filter to only the specified file
+    if (CONFIG.singleFile) {
+      files = files.filter(([filePath]) => filePath === CONFIG.singleFile);
+      if (files.length === 0) {
+        console.log(`\nSingle-file mode: No errors found in ${CONFIG.singleFile}`);
+        console.log('File may have already been fixed or has no compilation errors.');
+        break;
+      }
+    }
 
     for (const [filePath, errors] of files) {
       const fullPath = path.join(CONFIG.projectPath, filePath);

package/.claude/skills/cfn-compilation-error-fixer/lib/fixer/typescript-gated-fixer-v2.ts

@@ -33,6 +33,10 @@ import {
 
 // ============== CONFIGURATION ==============
 
+// Parse --file and --agent-id parameters
+const fileArg = process.argv.find(arg => arg.startsWith('--file='));
+const agentIdArg = process.argv.find(arg => arg.startsWith('--agent-id='));
+
 const CONFIG = {
   maxGlobalIterations: 5,
   maxFileRetries: 2,
@@ -47,6 +51,8 @@ const CONFIG = {
   verbose: process.argv.includes('--verbose'),
   includeTypes: process.argv.includes('--types') ? ['ts', 'tsx'] : ['ts', 'tsx'],
   excludePattern: process.env.TS_EXCLUDE_PATTERN || 'node_modules|dist|build|\\.git',
+  singleFile: fileArg ? fileArg.split('=')[1] : null,  // Single-file mode
+  agentId: agentIdArg ? agentIdArg.split('=')[1] : null,  // Agent ID for coordination mode
   // Security limits
   maxFileSize: 1024 * 1024, // 1MB
   maxLineLength: 1000,
@@ -867,6 +873,13 @@ async function main() {
   console.log(`   Model: ${CONFIG.model}`);
   console.log(`   Dry run: ${CONFIG.dryRun}`);
 
+  if (CONFIG.singleFile) {
+    console.log(`   Single-File Mode: ${CONFIG.singleFile}`);
+    if (CONFIG.agentId) {
+      console.log(`   Agent ID: ${CONFIG.agentId}`);
+    }
+  }
+
   if (CONFIG.dryRun) {
     console.log(`   Patch dir: ${CONFIG.patchDir}`);
   }
@@ -900,6 +913,30 @@ async function main() {
     errorsByFile.get(error.file)!.push(error);
   }
 
+  // Single-file mode: filter to only the specified file
+  if (CONFIG.singleFile) {
+    const normalizedPath = path.normalize(CONFIG.singleFile);
+    const matchingFiles = Array.from(errorsByFile.keys()).filter(f =>
+      f === normalizedPath || f.endsWith(normalizedPath) || normalizedPath.endsWith(f)
+    );
+
+    if (matchingFiles.length === 0) {
+      console.log(`\n✅ Single-file mode: No errors found in ${CONFIG.singleFile}`);
+      console.log('   File may have already been fixed or has no compilation errors.');
+      return;
+    }
+
+    // Keep only the matching file
+    const singleFileErrors = new Map<string, TypeScriptError[]>();
+    for (const file of matchingFiles) {
+      singleFileErrors.set(file, errorsByFile.get(file)!);
+    }
+    errorsByFile.clear();
+    for (const [k, v] of singleFileErrors) {
+      errorsByFile.set(k, v);
+    }
+  }
+
   console.log(`   Across ${errorsByFile.size} files\n`);
 
   // Process errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.18.28",
+  "version": "2.18.30",
   "description": "Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture\n\nIncludes Local RuVector Accelerator and all CFN skills for complete functionality.",
   "main": "index.js",
   "type": "module",