ctx-cc 3.4.4 → 4.0.0

package/src/worktree.js

@@ -0,0 +1,244 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { readState, writeState } from './state.js';
+import { buildContext } from './context.js';
+import { runAgent } from './runner.js';
+
+const WORKTREES_DIR = '.ctx/worktrees';
+
+/**
+ * Parse a dependency graph from the parallelizer agent output.
+ * Input format: array of { taskId, title, dependsOn: [taskId] }
+ * Returns waves: [ [task, task], [task], ... ]
+ */
+export function buildWaves(tasks) {
+  if (!tasks || tasks.length === 0) return [];
+
+  const completed = new Set();
+  const waves = [];
+  const remaining = [...tasks];
+  let safetyCounter = 0;
+
+  while (remaining.length > 0 && safetyCounter < 100) {
+    safetyCounter++;
+    const wave = [];
+
+    for (let i = remaining.length - 1; i >= 0; i--) {
+      const task = remaining[i];
+      const deps = task.dependsOn || [];
+      const allDepsComplete = deps.every(d => completed.has(d));
+
+      if (allDepsComplete) {
+        wave.push(task);
+        remaining.splice(i, 1);
+      }
+    }
+
+    if (wave.length === 0) {
+      // Circular dependency — force remaining into a single wave
+      waves.push(remaining.splice(0));
+      break;
+    }
+
+    waves.push(wave);
+    for (const t of wave) completed.add(t.taskId);
+  }
+
+  return waves;
+}
+
+/**
+ * Create a git worktree for a task.
+ * Returns the worktree path.
+ */
+export function createWorktree(projectDir, taskId) {
+  const worktreeBase = path.join(projectDir, WORKTREES_DIR);
+  if (!fs.existsSync(worktreeBase)) fs.mkdirSync(worktreeBase, { recursive: true });
+
+  const worktreePath = path.join(worktreeBase, taskId);
+  const branchName = `ctx-task-${taskId}`;
+
+  try {
+    // Create branch and worktree
+    execSync(`git worktree add "${worktreePath}" -b "${branchName}" HEAD`, {
+      cwd: projectDir, encoding: 'utf-8', timeout: 10000,
+    });
+    return worktreePath;
+  } catch (err) {
+    throw new Error(`Failed to create worktree for ${taskId}: ${err.message}`);
+  }
+}
+
+/**
+ * Merge a worktree branch back to the current branch.
+ * Returns { merged: boolean, conflicts: boolean, error: string|null }
+ */
+export function mergeWorktree(projectDir, taskId) {
+  const branchName = `ctx-task-${taskId}`;
+
+  try {
+    const result = execSync(`git merge --no-ff "${branchName}" -m "ctx(merge): task ${taskId}"`, {
+      cwd: projectDir, encoding: 'utf-8', timeout: 10000,
+    });
+    return { merged: true, conflicts: false, error: null };
+  } catch (err) {
+    if (err.message.includes('CONFLICT') || err.message.includes('Merge conflict')) {
+      // Abort the merge
+      try { execSync('git merge --abort', { cwd: projectDir, timeout: 5000 }); } catch {}
+      return { merged: false, conflicts: true, error: `Merge conflicts in task ${taskId}` };
+    }
+    return { merged: false, conflicts: false, error: err.message };
+  }
+}
+
+/**
+ * Clean up a worktree and its branch.
+ */
+export function cleanupWorktree(projectDir, taskId) {
+  const worktreePath = path.join(projectDir, WORKTREES_DIR, taskId);
+  const branchName = `ctx-task-${taskId}`;
+
+  try {
+    execSync(`git worktree remove "${worktreePath}" --force`, {
+      cwd: projectDir, timeout: 10000,
+    });
+  } catch {
+    // Manual cleanup
+    if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true });
+    try { execSync('git worktree prune', { cwd: projectDir, timeout: 5000 }); } catch {}
+  }
+
+  // Delete branch
+  try {
+    execSync(`git branch -D "${branchName}"`, { cwd: projectDir, timeout: 5000 });
+  } catch {}
+}
+
+/**
+ * Execute a wave of tasks in parallel using git worktrees.
+ * Each task runs in its own worktree with a separate claude process.
+ *
+ * Returns { results: [{ taskId, success, error }], conflicts: [taskId] }
+ */
+export async function executeWave({ wave, agentsDir, agentFile, projectDir, ctxDir, streaming = false, timeout = 300000 }) {
+  const agentPath = path.join(agentsDir, agentFile);
+
+  // Create worktrees for all tasks
+  const worktrees = [];
+  for (const task of wave) {
+    try {
+      const wtPath = createWorktree(projectDir, task.taskId);
+      worktrees.push({ task, worktreePath: wtPath });
+    } catch (err) {
+      worktrees.push({ task, worktreePath: null, error: err.message });
+    }
+  }
+
+  // Run agents in parallel (non-streaming for parallel execution)
+  const promises = worktrees.map(async ({ task, worktreePath, error }) => {
+    if (error) return { taskId: task.taskId, success: false, error };
+
+    try {
+      const { context } = buildContext('execute', worktreePath, ctxDir);
+      await runAgent({
+        agentPath,
+        message: `Execute task: ${task.title}\n\n${task.description || ''}`,
+        streaming: false, // Must be non-streaming for parallel
+        timeout,
+        context,
+      });
+      return { taskId: task.taskId, success: true, error: null };
+    } catch (err) {
+      return { taskId: task.taskId, success: false, error: err.message };
+    }
+  });
+
+  const results = await Promise.all(promises);
+
+  // Merge successful worktrees back
+  const conflicts = [];
+  for (const result of results) {
+    if (result.success) {
+      const merge = mergeWorktree(projectDir, result.taskId);
+      if (merge.conflicts) {
+        conflicts.push(result.taskId);
+        result.success = false;
+        result.error = merge.error;
+      }
+    }
+    // Cleanup worktree
+    cleanupWorktree(projectDir, result.taskId);
+  }
+
+  return { results, conflicts };
+}
+
+/**
+ * Execute all waves sequentially (wave N+1 waits for wave N).
+ *
+ * Options:
+ *   waves, agentsDir, agentFile, projectDir, ctxDir, streaming, timeout, onWave
+ *
+ * Returns { waveResults: [...], conflicts: [...] }
+ */
+export async function executeAllWaves({ waves, agentsDir, agentFile, projectDir, ctxDir, streaming = false, timeout = 300000, onWave = null }) {
+  const allResults = [];
+  const allConflicts = [];
+
+  for (let i = 0; i < waves.length; i++) {
+    const wave = waves[i];
+    if (onWave) onWave({ waveIndex: i, total: waves.length, taskCount: wave.length, status: 'starting' });
+
+    const { results, conflicts } = await executeWave({
+      wave, agentsDir, agentFile, projectDir, ctxDir, streaming, timeout,
+    });
+
+    allResults.push({ waveIndex: i, results });
+    allConflicts.push(...conflicts);
+
+    if (onWave) onWave({ waveIndex: i, total: waves.length, taskCount: wave.length, status: 'completed', results });
+
+    // Update state with wave progress
+    const state = readState(ctxDir);
+    if (state) {
+      state.waveProgress = state.waveProgress || [];
+      state.waveProgress.push({
+        waveIndex: i,
+        completedAt: new Date().toISOString(),
+        taskResults: results.map(r => ({ taskId: r.taskId, success: r.success })),
+      });
+      writeState(ctxDir, state);
+    }
+  }
+
+  // Re-queue conflicting tasks as sequential
+  if (allConflicts.length > 0) {
+    const state = readState(ctxDir);
+    if (state) {
+      state.conflictTasks = allConflicts;
+      writeState(ctxDir, state);
+    }
+  }
+
+  return { waveResults: allResults, conflicts: allConflicts };
+}
+
+/**
+ * Format wave execution results for display.
+ */
+export function formatWaveResults(waveResults, conflicts) {
+  const lines = [];
+  for (const wave of waveResults) {
+    lines.push(`  Wave ${wave.waveIndex + 1}:`);
+    for (const r of wave.results) {
+      const icon = r.success ? '✓' : '✗';
+      lines.push(`    ${icon} ${r.taskId}${r.error ? ` — ${r.error}` : ''}`);
+    }
+  }
+  if (conflicts.length > 0) {
+    lines.push('');
+    lines.push(`  ⚠ Merge conflicts (re-queued as sequential): ${conflicts.join(', ')}`);
+  }
+  return lines.join('\n');
+}

package/templates/PRD.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://ctx.dev/schemas/prd.json",
-  "version": "2.1",
+  "version": "3.5",
   "project": {
     "name": "{{project_name}}",
     "description": "{{project_description}}",

package/templates/config.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://ctx.dev/schemas/config.json",
-  "version": "3.3",
+  "version": "3.5",
 
   "models": {
     "architect": {
@@ -109,38 +109,6 @@
     "forceCheckpointThreshold": 0.7
   },
 
-  "parallelization": {
-    "enabled": true,
-    "maxParallelTasks": 3,
-    "requireDependencyAnalysis": true,
-    "fileLocking": true
-  },
-
-  "review": {
-    "enabled": true,
-    "beforeCommit": true,
-    "blockOnCritical": true,
-    "blockOnHigh": true,
-    "warnOnMedium": true,
-    "autoFix": false,
-    "checks": {
-      "typeErrors": true,
-      "importResolution": true,
-      "circularDeps": true,
-      "security": true,
-      "bestPractices": true,
-      "consoleLogs": true,
-      "emptyBlocks": true
-    }
-  },
-
-  "criteria": {
-    "autoSuggest": true,
-    "minCriteria": 5,
-    "maxCriteria": 15,
-    "categories": ["happy_path", "validation", "error_states", "security", "performance"]
-  },
-
   "debug": {
     "maxAttempts": 10,
     "persistSessions": true,
@@ -148,214 +116,10 @@
     "autoResume": true
   },
 
-  "integrations": {
-    "linear": {
-      "enabled": false,
-      "apiKey": "env:LINEAR_API_KEY",
-      "teamId": null,
-      "projectId": null,
-      "syncOnCreate": true,
-      "syncOnVerify": true,
-      "closeOnComplete": true,
-      "statusMapping": {
-        "pending": "Todo",
-        "executing": "In Progress",
-        "verifying": "In Review",
-        "complete": "Done"
-      }
-    },
-    "jira": {
-      "enabled": false,
-      "baseUrl": null,
-      "email": "env:JIRA_EMAIL",
-      "apiToken": "env:JIRA_API_TOKEN",
-      "projectKey": null,
-      "issueType": "Story",
-      "syncOnCreate": true,
-      "syncOnVerify": true,
-      "transitionMapping": {
-        "executing": "In Progress",
-        "verifying": "In Review",
-        "complete": "Done"
-      }
-    },
-    "github": {
-      "enabled": false,
-      "repository": null,
-      "token": "env:GITHUB_TOKEN",
-      "syncIssues": true,
-      "closeOnComplete": true,
-      "createPROnComplete": false,
-      "labels": {
-        "feature": "enhancement",
-        "bug": "bug",
-        "design": "design"
-      }
-    },
-    "slack": {
-      "enabled": false,
-      "webhookUrl": "env:SLACK_WEBHOOK_URL",
-      "notifyOnPhaseComplete": false,
-      "notifyOnVerifyFail": true,
-      "notifyOnHandoff": false
-    }
-  },
-
   "ui": {
     "showTokenUsage": true,
     "showModelInfo": true,
     "showWaveProgress": true,
     "verboseOutput": false
-  },
-
-  "team": {
-    "enabled": false,
-    "members": [],
-    "fileLocking": {
-      "enabled": true,
-      "expiryMinutes": 60,
-      "autoRelease": true
-    },
-    "notifications": {
-      "onPhaseStart": false,
-      "onPhaseComplete": true,
-      "onVerifyFail": true,
-      "onConflict": true,
-      "onMilestoneComplete": true
-    },
-    "branching": {
-      "strategy": "feature",
-      "prefix": "ctx"
-    }
-  },
-
-  "audit": {
-    "enabled": true,
-    "retention": {
-      "daily": "90d",
-      "weekly": "1y",
-      "monthly": "3y"
-    },
-    "logging": {
-      "tokens": true,
-      "costs": true,
-      "decisions": true,
-      "fileAccess": true,
-      "externalCalls": true
-    },
-    "compliance": {
-      "soc2": false,
-      "hipaa": false,
-      "gdpr": false
-    },
-    "reports": {
-      "dailySummary": true,
-      "weeklySummary": true,
-      "exportFormat": "json"
-    }
-  },
-
-  "metrics": {
-    "enabled": true,
-    "collection": {
-      "tokens": true,
-      "costs": true,
-      "timing": true,
-      "quality": true
-    },
-    "aggregation": {
-      "daily": true,
-      "weekly": true,
-      "monthly": true
-    },
-    "costRates": {
-      "opus": {"input": 0.015, "output": 0.075},
-      "sonnet": {"input": 0.003, "output": 0.015},
-      "haiku": {"input": 0.00025, "output": 0.00125}
-    },
-    "roi": {
-      "developerHourlyRate": 150,
-      "hoursPerStoryManual": 4
-    },
-    "alerts": {
-      "dailyCostThreshold": 10,
-      "weeklyStoriesTarget": 10
-    }
-  },
-
-  "milestone": {
-    "autoTag": true,
-    "tagFormat": "v{version}",
-    "archiveOnComplete": true,
-    "requireAudit": true,
-    "gapPhasesEnabled": true
-  },
-
-  "learning": {
-    "enabled": true,
-    "observePatterns": true,
-    "observeDecisions": true,
-    "observeFailures": true,
-    "minConfidence": 0.7,
-    "applyPatterns": true,
-    "enforceConventions": true,
-    "memoryPath": ".ctx/memory/"
-  },
-
-  "predict": {
-    "enabled": true,
-    "autoSuggest": {
-      "onMilestoneComplete": true,
-      "onAllStoriesPass": true,
-      "weeklyDigest": false
-    },
-    "categories": ["revenue", "engagement", "retention", "operations", "performance", "security"],
-    "maxSuggestions": 10,
-    "minROI": 5,
-    "includeQuickWins": true,
-    "researchDepth": "balanced"
-  },
-
-  "monitor": {
-    "enabled": false,
-    "pollInterval": "5m",
-    "autoFix": {
-      "enabled": false,
-      "safePatterns": ["null-check", "import-missing", "type-mismatch"],
-      "requireReview": true,
-      "createPR": true
-    },
-    "sentry": {
-      "enabled": false,
-      "token": "env:SENTRY_AUTH_TOKEN",
-      "organization": null,
-      "project": null,
-      "environment": "production"
-    },
-    "logrocket": {
-      "enabled": false,
-      "appId": null,
-      "apiKey": "env:LOGROCKET_API_KEY"
-    },
-    "alerts": {
-      "errorSpike": {
-        "threshold": 50,
-        "window": "5m"
-      },
-      "slack": true,
-      "pagerduty": false
-    }
-  },
-
-  "voice": {
-    "enabled": false,
-    "engine": "auto",
-    "language": "en-US",
-    "wakeWord": "Hey CTX",
-    "confirmCommands": true,
-    "dictationEndPhrase": "done",
-    "dictationPauseSeconds": 3,
-    "noiseReduction": true,
-    "minConfidence": 0.7
   }
 }