@colin4k1024/tsp 2.5.0 → 2.5.2

package/scripts/lib/blame-attribution.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * blame-attribution.js
+ *
+ * Maps goal iteration failures to specific code changes using git blame/diff.
+ * Produces targeted rework briefs that constrain the next iteration's scope.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const MAX_REWORK_ATTEMPTS = 3;
+
+function parseFailureLocations(failOutput) {
+  const locations = [];
+  const lines = failOutput.split('\n');
+
+  for (const line of lines) {
+    // Match common test failure patterns:
+    // "FAIL src/auth/refresh.test.ts"
+    // "● Auth > should refresh tokens"
+    // "at Object.<anonymous> (src/auth/refresh.ts:23:5)"
+    // "src/auth/refresh.ts(23,5): error TS2345"
+    const fileLineMatch = line.match(/([a-zA-Z0-9_\-./]+\.[a-z]{1,4})[:(](\d+)/);
+    if (fileLineMatch) {
+      const filePath = fileLineMatch[1];
+      const lineNumber = parseInt(fileLineMatch[2], 10);
+      if (!filePath.includes('node_modules') && !filePath.includes('.git')) {
+        locations.push({ file: filePath, line: lineNumber, context: line.trim() });
+      }
+    }
+
+    // Match "FAIL" prefixed paths
+    const failMatch = line.match(/FAIL\s+(.+\.[a-z]{1,4})/);
+    if (failMatch) {
+      locations.push({ file: failMatch[1].trim(), line: null, context: line.trim() });
+    }
+  }
+
+  // Deduplicate by file
+  const seen = new Set();
+  return locations.filter(loc => {
+    const key = `${loc.file}:${loc.line || 0}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync('git diff --name-only HEAD 2>/dev/null || git diff --name-only', {
+      encoding: 'utf-8',
+      cwd,
+      timeout: 10000,
+    }).trim();
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function getFileDiff(filePath, cwd) {
+  try {
+    return execSync(`git diff HEAD -- "${filePath}" 2>/dev/null || git diff -- "${filePath}"`, {
+      encoding: 'utf-8',
+      cwd,
+      timeout: 10000,
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function intersectFailuresWithChanges(failureLocations, changedFiles) {
+  return failureLocations.filter(loc => {
+    const normalizedFail = loc.file.replace(/^\.\//, '');
+    return changedFiles.some(changed => {
+      const normalizedChanged = changed.replace(/^\.\//, '');
+      return normalizedFail === normalizedChanged ||
+             normalizedFail.endsWith(normalizedChanged) ||
+             normalizedChanged.endsWith(normalizedFail);
+    });
+  });
+}
+
+function buildReworkBrief(goal, oracleResult, blameResult) {
+  const iteration = goal.currentIteration;
+  const failingFiles = blameResult.blamedLocations.map(l => l.file);
+  const uniqueFiles = [...new Set(failingFiles)];
+
+  const brief = [
+    '## REWORK BRIEF',
+    '',
+    `**Goal:** ${goal.objective}`,
+    `**Iteration:** ${iteration} (rework attempt ${blameResult.attemptCount} for this scope)`,
+    '',
+    '**Failing evidence:**',
+    ...blameResult.blamedLocations.map(l =>
+      `- ${l.file}${l.line ? ':' + l.line : ''} — ${l.context.slice(0, 100)}`
+    ),
+    '',
+    '**Root cause (blame):**',
+    ...blameResult.changedFiles.slice(0, 5).map(f => `- Changed: ${f}`),
+    '',
+    '**Constraint:**',
+    ...uniqueFiles.map(f => `- ONLY modify: ${f}`),
+    '- DO NOT touch test files unless they are the source of the bug',
+    '- DO NOT expand scope beyond the blamed files',
+    '',
+  ];
+
+  if (oracleResult.nextHint) {
+    brief.push('**Oracle hint:**', oracleResult.nextHint, '');
+  }
+
+  return brief.join('\n');
+}
+
+function analyzeBlame(goal, oracleResult, cwd) {
+  const failOutput = (oracleResult.reasons || []).join('\n') +
+    '\n' + (oracleResult.conditionResults || [])
+      .filter(r => !r.passed)
+      .map(r => r.output)
+      .join('\n');
+
+  const failureLocations = parseFailureLocations(failOutput);
+  const changedFiles = getChangedFiles(cwd);
+  const blamedLocations = intersectFailuresWithChanges(failureLocations, changedFiles);
+
+  // Determine if escalation is needed
+  const shouldEscalate = blamedLocations.length === 0 && failureLocations.length > 0;
+
+  return {
+    failureLocations,
+    changedFiles,
+    blamedLocations: blamedLocations.length > 0 ? blamedLocations : failureLocations.slice(0, 5),
+    intersection: blamedLocations.length > 0,
+    shouldEscalate,
+    escalationReason: shouldEscalate ? 'no_blame_intersection' : null,
+    attemptCount: 1, // caller should update from tracking store
+  };
+}
+
+// Rework tracking
+
+function getReworkTrackingPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return path.join(home, '.claude', 'rework-tracking.json');
+}
+
+function loadReworkTracking() {
+  const trackPath = getReworkTrackingPath();
+  if (!fs.existsSync(trackPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(trackPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveReworkTracking(tracking) {
+  const trackPath = getReworkTrackingPath();
+  const dir = path.dirname(trackPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(trackPath, JSON.stringify(tracking, null, 2), 'utf-8');
+}
+
+function recordReworkAttempt(filePath, outcome) {
+  const tracking = loadReworkTracking();
+  if (!tracking[filePath]) {
+    tracking[filePath] = { attempts: 0, outcomes: [], lastAttempt: null, totalCost: 0 };
+  }
+  tracking[filePath].attempts += 1;
+  tracking[filePath].outcomes.push(outcome);
+  tracking[filePath].lastAttempt = new Date().toISOString();
+  saveReworkTracking(tracking);
+  return tracking[filePath];
+}
+
+function shouldEscalateFile(filePath) {
+  const tracking = loadReworkTracking();
+  const record = tracking[filePath];
+  if (!record) return false;
+  return record.attempts >= MAX_REWORK_ATTEMPTS;
+}
+
+function getPersistentTroubleSpots() {
+  const tracking = loadReworkTracking();
+  return Object.entries(tracking)
+    .filter(([, record]) => record.attempts >= MAX_REWORK_ATTEMPTS)
+    .map(([file, record]) => ({ file, ...record }));
+}
+
+module.exports = {
+  MAX_REWORK_ATTEMPTS,
+  parseFailureLocations,
+  getChangedFiles,
+  getFileDiff,
+  intersectFailuresWithChanges,
+  buildReworkBrief,
+  analyzeBlame,
+  loadReworkTracking,
+  saveReworkTracking,
+  recordReworkAttempt,
+  shouldEscalateFile,
+  getPersistentTroubleSpots,
+};

package/scripts/lib/completion-oracle.js

@@ -0,0 +1,351 @@
+'use strict';
+
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const GOAL_STATES = {
+  active: 'active',
+  paused: 'paused',
+  converged: 'converged',
+  escalated: 'escalated',
+  failed: 'failed',
+};
+
+const ESCALATION_REASONS = {
+  budgetExhausted: 'budget_exhausted',
+  repeatedFailure: 'repeated_failure',
+  oracleUncertain: 'oracle_uncertain',
+  manual: 'manual',
+};
+
+function generateGoalId() {
+  return `goal-${crypto.randomBytes(4).toString('hex')}`;
+}
+
+function createGoal(objective, options = {}) {
+  const now = new Date().toISOString();
+  return {
+    goalId: generateGoalId(),
+    objective,
+    stoppingConditions: options.stoppingConditions || inferStoppingConditions(objective),
+    budget: {
+      maxIterations: options.maxIterations || 15,
+      maxDuration: options.maxDuration || '2h',
+      maxDollars: options.maxDollars || 10,
+    },
+    oracle: {
+      model: options.checkerModel || 'haiku',
+      allowedTools: ['Read', 'Bash'],
+      prompt: options.oraclePrompt || null,
+    },
+    state: GOAL_STATES.active,
+    currentIteration: 0,
+    createdAt: now,
+    updatedAt: now,
+    history: [],
+    escalation: null,
+  };
+}
+
+function inferStoppingConditions(objective) {
+  const lower = objective.toLowerCase();
+  const conditions = [];
+
+  if (lower.includes('test') && (lower.includes('pass') || lower.includes('fix'))) {
+    conditions.push({
+      type: 'test_pass',
+      command: 'npm test 2>&1; echo "EXIT:$?"',
+      description: 'All tests pass',
+    });
+  }
+
+  if (lower.includes('lint') || lower.includes('eslint')) {
+    conditions.push({
+      type: 'lint_clean',
+      command: 'npm run lint -- --quiet 2>&1; echo "EXIT:$?"',
+      description: 'Linter reports no errors',
+    });
+  }
+
+  if (lower.includes('coverage')) {
+    const match = lower.match(/(\d+)\s*%/);
+    const threshold = match ? parseInt(match[1], 10) : 80;
+    conditions.push({
+      type: 'coverage_threshold',
+      command: 'npm test -- --coverage --coverageReporters=text-summary 2>&1',
+      threshold,
+      description: `Test coverage >= ${threshold}%`,
+    });
+  }
+
+  if (lower.includes('build') && (lower.includes('pass') || lower.includes('fix'))) {
+    conditions.push({
+      type: 'build_pass',
+      command: 'npm run build 2>&1; echo "EXIT:$?"',
+      description: 'Build succeeds',
+    });
+  }
+
+  if (conditions.length === 0) {
+    conditions.push({
+      type: 'custom_command',
+      command: 'echo "Manual verification required"; exit 1',
+      description: 'Requires explicit stopping condition — use --condition flag',
+    });
+  }
+
+  return conditions;
+}
+
+function evaluateCondition(condition) {
+  try {
+    const output = execSync(condition.command, {
+      encoding: 'utf-8',
+      timeout: 60000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    let passed = true;
+
+    if (condition.type === 'coverage_threshold' && condition.threshold) {
+      const coverageMatch = output.match(/(?:All files|Statements)\s*[:|]\s*([\d.]+)%/);
+      if (coverageMatch) {
+        passed = parseFloat(coverageMatch[1]) >= condition.threshold;
+      } else {
+        passed = false;
+      }
+    } else {
+      const exitMatch = output.match(/EXIT:(\d+)$/);
+      if (exitMatch) {
+        passed = exitMatch[1] === '0';
+      }
+    }
+
+    return { type: condition.type, passed, output: output.slice(0, 500) };
+  } catch (error) {
+    return {
+      type: condition.type,
+      passed: false,
+      output: (error.stderr || error.message || '').slice(0, 500),
+    };
+  }
+}
+
+function buildOraclePrompt(goal, conditionResults, iterationSummary) {
+  const recentHistory = goal.history.slice(-3);
+
+  return `You are a completion oracle. Your job is to evaluate whether a goal has been achieved.
+You CANNOT modify code — you can only read and evaluate.
+
+## Goal
+Objective: ${goal.objective}
+
+## Stopping Conditions Results
+${conditionResults.map(r => `- [${r.passed ? 'PASS' : 'FAIL'}] ${r.type}: ${r.output.slice(0, 200)}`).join('\n')}
+
+## Maker's Iteration Summary
+${iterationSummary || '(no summary provided)'}
+
+## Recent History
+${recentHistory.map(h => `Iteration ${h.iteration}: ${h.oracleVerdict} — ${(h.failReasons || []).join(', ')}`).join('\n') || '(first iteration)'}
+
+## Your Task
+Evaluate whether ALL stopping conditions are met. Respond with EXACTLY this JSON:
+{
+  "converged": <true if ALL conditions pass, false otherwise>,
+  "conditionResults": [{"type": "...", "passed": true/false, "output": "brief"}],
+  "reasons": ["why not converged, if applicable"],
+  "nextHint": "specific guidance for the maker's next iteration (if not converged)",
+  "confidence": <0.0 to 1.0>
+}`;
+}
+
+function checkBudget(goal) {
+  if (goal.currentIteration >= goal.budget.maxIterations) {
+    return { exhausted: true, reason: ESCALATION_REASONS.budgetExhausted, detail: 'Max iterations reached' };
+  }
+
+  const durationMs = parseDuration(goal.budget.maxDuration);
+  const elapsed = Date.now() - new Date(goal.createdAt).getTime();
+  if (elapsed >= durationMs) {
+    return { exhausted: true, reason: ESCALATION_REASONS.budgetExhausted, detail: 'Max duration reached' };
+  }
+
+  const totalCost = goal.history.reduce((sum, h) => sum + (h.costDollars || 0), 0);
+  if (totalCost >= goal.budget.maxDollars) {
+    return { exhausted: true, reason: ESCALATION_REASONS.budgetExhausted, detail: 'Max cost reached' };
+  }
+
+  const recentFails = goal.history.slice(-5).filter(h => h.oracleVerdict === 'fail');
+  if (recentFails.length >= 5) {
+    return { exhausted: true, reason: ESCALATION_REASONS.repeatedFailure, detail: '5 consecutive failures' };
+  }
+
+  return { exhausted: false };
+}
+
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(m|h)$/);
+  if (!match) return 2 * 60 * 60 * 1000;
+  const value = parseInt(match[1], 10);
+  return match[2] === 'h' ? value * 60 * 60 * 1000 : value * 60 * 1000;
+}
+
+function recordIteration(goal, verdict, costDollars = 0) {
+  const entry = {
+    iteration: goal.currentIteration,
+    makerSummary: verdict.makerSummary || null,
+    oracleVerdict: verdict.converged ? 'pass' : 'fail',
+    failReasons: verdict.reasons || [],
+    nextHint: verdict.nextHint || null,
+    timestamp: new Date().toISOString(),
+    costDollars,
+  };
+  goal.history.push(entry);
+  goal.currentIteration += 1;
+  goal.updatedAt = new Date().toISOString();
+
+  if (verdict.converged) {
+    goal.state = GOAL_STATES.converged;
+  }
+
+  return entry;
+}
+
+function escalateGoal(goal, reason, detail) {
+  goal.state = GOAL_STATES.escalated;
+  goal.escalation = {
+    reason,
+    details: detail,
+    escalatedAt: new Date().toISOString(),
+  };
+  goal.updatedAt = new Date().toISOString();
+}
+
+function pauseGoal(goal) {
+  goal.state = GOAL_STATES.paused;
+  goal.updatedAt = new Date().toISOString();
+}
+
+function resumeGoal(goal) {
+  if (goal.state === GOAL_STATES.paused || goal.state === GOAL_STATES.escalated) {
+    goal.state = GOAL_STATES.active;
+    goal.updatedAt = new Date().toISOString();
+  }
+}
+
+// Goal persistence
+
+function getGoalsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  const dir = path.join(home, '.claude', 'goals');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function saveGoal(goal) {
+  const filePath = path.join(getGoalsDir(), `${goal.goalId}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(goal, null, 2), 'utf-8');
+  return filePath;
+}
+
+function loadGoal(goalId) {
+  const filePath = path.join(getGoalsDir(), `${goalId}.json`);
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function listGoals(filter) {
+  const dir = getGoalsDir();
+  if (!fs.existsSync(dir)) return [];
+
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8')))
+    .filter(g => !filter || g.state === filter)
+    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+}
+
+function getActiveGoals() {
+  return listGoals(GOAL_STATES.active);
+}
+
+// Oracle execution (integration point for claude -p or sub-agent)
+
+function runOracleEvaluation(goal, iterationSummary) {
+  const conditionResults = goal.stoppingConditions.map(evaluateCondition);
+  const allPassed = conditionResults.every(r => r.passed);
+
+  if (allPassed) {
+    return {
+      converged: true,
+      conditionResults,
+      reasons: [],
+      nextHint: null,
+      confidence: 1.0,
+    };
+  }
+
+  const failedConditions = conditionResults.filter(r => !r.passed);
+  return {
+    converged: false,
+    conditionResults,
+    reasons: failedConditions.map(r => `${r.type}: ${r.output.slice(0, 100)}`),
+    nextHint: `Focus on: ${failedConditions.map(r => r.type).join(', ')}. ${failedConditions[0].output.slice(0, 200)}`,
+    confidence: 0.7,
+    oraclePrompt: buildOraclePrompt(goal, conditionResults, iterationSummary),
+  };
+}
+
+// Main loop driver (called by the goal command handler)
+
+async function runGoalIteration(goal, makerFn) {
+  const budgetCheck = checkBudget(goal);
+  if (budgetCheck.exhausted) {
+    escalateGoal(goal, budgetCheck.reason, budgetCheck.detail);
+    saveGoal(goal);
+    return { action: 'escalated', goal };
+  }
+
+  const makerResult = await makerFn(goal);
+
+  const oracleResult = runOracleEvaluation(goal, makerResult.summary);
+
+  const entry = recordIteration(goal, {
+    ...oracleResult,
+    makerSummary: makerResult.summary,
+  }, makerResult.costDollars || 0);
+
+  saveGoal(goal);
+
+  if (oracleResult.converged) {
+    return { action: 'converged', goal, entry };
+  }
+
+  return { action: 'continue', goal, entry, nextHint: oracleResult.nextHint };
+}
+
+module.exports = {
+  GOAL_STATES,
+  ESCALATION_REASONS,
+  generateGoalId,
+  createGoal,
+  inferStoppingConditions,
+  evaluateCondition,
+  buildOraclePrompt,
+  checkBudget,
+  recordIteration,
+  escalateGoal,
+  pauseGoal,
+  resumeGoal,
+  saveGoal,
+  loadGoal,
+  listGoals,
+  getActiveGoals,
+  runOracleEvaluation,
+  runGoalIteration,
+};