@colin4k1024/tsp 2.5.1 → 2.5.3

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,
+};

package/scripts/lib/heartbeat-scheduler.js

@@ -0,0 +1,265 @@
+'use strict';
+
+/**
+ * heartbeat-scheduler.js
+ *
+ * Heartbeat engine for Loop Engineering.
+ * Runs configured discovery scans on a schedule, classifies results,
+ * and routes findings to goals or triage inbox.
+ *
+ * This module provides the logic; scheduling is handled by CronCreate/CronDelete
+ * or ScheduleWakeup in the Claude Code runtime.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const yaml = require ? undefined : undefined; // yaml parsing fallback below
+
+const { createGoal, saveGoal } = require('./completion-oracle');
+
+const DEFAULT_CONFIG = {
+  interval: '30m',
+  scans: [],
+  budget: {
+    maxDollarsPerHour: 2.0,
+    pauseOnExhaust: true,
+  },
+};
+
+const SCAN_ACTIONS = {
+  autoGoal: 'auto-goal',
+  triage: 'triage',
+  notify: 'notify',
+  ignore: 'ignore',
+};
+
+// Simple YAML parser for heartbeat config (avoids external dependency)
+function parseSimpleYaml(content) {
+  try {
+    // Try JSON first (YAML superset)
+    return JSON.parse(content);
+  } catch {
+    // Minimal YAML parsing for heartbeat.yaml structure
+    const lines = content.split('\n');
+    const result = { heartbeat: { scans: [], budget: {} } };
+    let currentScan = null;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const indentLevel = line.search(/\S/);
+
+      if (trimmed.startsWith('interval:')) {
+        result.heartbeat.interval = trimmed.split(':')[1].trim().replace(/['"]/g, '');
+      } else if (trimmed.startsWith('maxDollarsPerHour:')) {
+        result.heartbeat.budget.maxDollarsPerHour = parseFloat(trimmed.split(':')[1].trim());
+      } else if (trimmed.startsWith('pauseOnExhaust:')) {
+        result.heartbeat.budget.pauseOnExhaust = trimmed.split(':')[1].trim() === 'true';
+      } else if (trimmed.startsWith('- name:')) {
+        if (currentScan) result.heartbeat.scans.push(currentScan);
+        currentScan = { name: trimmed.replace('- name:', '').trim().replace(/['"]/g, '') };
+      } else if (currentScan && indentLevel >= 6) {
+        const [key, ...valueParts] = trimmed.split(':');
+        const value = valueParts.join(':').trim().replace(/['"]/g, '');
+        if (key === 'command') currentScan.command = value;
+        else if (key === 'onFailure') currentScan.onFailure = value;
+        else if (key === 'threshold') currentScan.threshold = parseFloat(value);
+        else if (key === 'description') currentScan.description = value;
+      }
+    }
+    if (currentScan) result.heartbeat.scans.push(currentScan);
+    return result;
+  }
+}
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot || process.cwd(), '.claude', 'heartbeat.yaml');
+  if (!fs.existsSync(configPath)) return DEFAULT_CONFIG;
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed = parseSimpleYaml(content);
+    return { ...DEFAULT_CONFIG, ...parsed.heartbeat };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+function runScan(scan) {
+  const startTime = Date.now();
+  try {
+    const output = execSync(scan.command, {
+      encoding: 'utf-8',
+      timeout: 60000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    let passed = true;
+
+    if (scan.threshold !== undefined) {
+      const numeric = parseInt(output.match(/\d+/)?.[0] || '0', 10);
+      passed = numeric <= scan.threshold;
+    } else {
+      const exitMatch = output.match(/EXIT:(\d+)$/);
+      passed = exitMatch ? exitMatch[1] === '0' : true;
+    }
+
+    return {
+      name: scan.name,
+      passed,
+      output: output.slice(0, 500),
+      durationMs: Date.now() - startTime,
+      timestamp: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      name: scan.name,
+      passed: false,
+      output: (error.stderr || error.message || 'Unknown error').slice(0, 500),
+      durationMs: Date.now() - startTime,
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+function classifyResult(scan, result) {
+  if (result.passed) return { action: 'pass', scan, result };
+  return {
+    action: scan.onFailure || SCAN_ACTIONS.triage,
+    scan,
+    result,
+  };
+}
+
+function createTriageItem(scan, result) {
+  return {
+    id: `triage-${Date.now().toString(36)}`,
+    source: `heartbeat:${scan.name}`,
+    severity: scan.onFailure === SCAN_ACTIONS.autoGoal ? 'high' : 'medium',
+    summary: `${scan.description || scan.name}: ${result.output.slice(0, 100)}`,
+    detail: result.output,
+    suggestedActions: ['Create goal to fix', 'Ignore for now', 'Defer to next session'],
+    createdAt: new Date().toISOString(),
+    status: 'pending',
+  };
+}
+
+function appendToTriageInbox(item) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const inboxDir = path.join(home, '.claude', 'triage');
+  if (!fs.existsSync(inboxDir)) {
+    fs.mkdirSync(inboxDir, { recursive: true });
+  }
+  const inboxPath = path.join(inboxDir, 'inbox.jsonl');
+  fs.appendFileSync(inboxPath, JSON.stringify(item) + '\n', 'utf-8');
+  return inboxPath;
+}
+
+function createGoalFromScanFailure(scan, result) {
+  const objective = `Fix ${scan.description || scan.name}: ${result.output.slice(0, 80)}`;
+
+  const stoppingConditions = [{
+    type: 'custom_command',
+    command: scan.command,
+    description: scan.description || scan.name,
+  }];
+
+  if (scan.threshold !== undefined) {
+    stoppingConditions[0].threshold = scan.threshold;
+  }
+
+  const goal = createGoal(objective, { stoppingConditions });
+  saveGoal(goal);
+  return goal;
+}
+
+function runHeartbeat(projectRoot) {
+  const config = loadConfig(projectRoot);
+
+  if (config.scans.length === 0) {
+    return {
+      status: 'no_scans',
+      message: 'No scans configured in .claude/heartbeat.yaml',
+      results: [],
+    };
+  }
+
+  const results = config.scans.map(scan => {
+    const result = runScan(scan);
+    const classified = classifyResult(scan, result);
+
+    if (classified.action === SCAN_ACTIONS.autoGoal) {
+      const goal = createGoalFromScanFailure(scan, result);
+      classified.goalId = goal.goalId;
+    } else if (classified.action === SCAN_ACTIONS.triage) {
+      const item = createTriageItem(scan, result);
+      appendToTriageInbox(item);
+      classified.triageId = item.id;
+    }
+
+    return classified;
+  });
+
+  const passed = results.filter(r => r.action === 'pass').length;
+  const failed = results.length - passed;
+
+  return {
+    status: failed > 0 ? 'issues_found' : 'all_clear',
+    timestamp: new Date().toISOString(),
+    summary: `${passed}/${results.length} scans passed`,
+    results,
+  };
+}
+
+function getHeartbeatStatus(projectRoot) {
+  const config = loadConfig(projectRoot);
+
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const lastRunPath = path.join(home, '.claude', 'heartbeat-last-run.json');
+  let lastRun = null;
+  if (fs.existsSync(lastRunPath)) {
+    try {
+      lastRun = JSON.parse(fs.readFileSync(lastRunPath, 'utf-8'));
+    } catch { /* ignore */ }
+  }
+
+  return {
+    configured: config.scans.length > 0,
+    interval: config.interval,
+    scanCount: config.scans.length,
+    scans: config.scans.map(s => ({ name: s.name, onFailure: s.onFailure, description: s.description })),
+    budget: config.budget,
+    lastRun,
+  };
+}
+
+function saveLastRun(result) {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const lastRunPath = path.join(home, '.claude', 'heartbeat-last-run.json');
+  const dir = path.dirname(lastRunPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(lastRunPath, JSON.stringify(result, null, 2), 'utf-8');
+}
+
+function parseInterval(interval) {
+  const match = (interval || '30m').match(/^(\d+)(m|h)$/);
+  if (!match) return 30 * 60;
+  const value = parseInt(match[1], 10);
+  return match[2] === 'h' ? value * 60 * 60 : value * 60;
+}
+
+module.exports = {
+  SCAN_ACTIONS,
+  loadConfig,
+  runScan,
+  classifyResult,
+  createTriageItem,
+  appendToTriageInbox,
+  createGoalFromScanFailure,
+  runHeartbeat,
+  getHeartbeatStatus,
+  saveLastRun,
+  parseInterval,
+};

package/scripts/lib/install/request.js

@@ -3,7 +3,7 @@
 const { validateInstallModuleIds } = require('../install-manifests');
 const { normalizeInstallTarget } = require('../install-targets/registry');
 
-const LEGACY_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'opencode'];
+const LEGACY_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'opencode', 'cangming'];
 
 function dedupeStrings(values) {
   return [...new Set((Array.isArray(values) ? values : []).map(value => String(value).trim()).filter(Boolean))];

package/scripts/lib/install-manifests.js

@@ -8,7 +8,7 @@ const {
 } = require('./install-targets/registry');
 
 const DEFAULT_REPO_ROOT = path.join(__dirname, '../..');
-const SUPPORTED_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'gemini', 'opencode', 'codebuddy', 'copilot', 'windsurf', 'augment'];
+const SUPPORTED_INSTALL_TARGETS = ['claude', 'cursor', 'antigravity', 'codex', 'gemini', 'opencode', 'cangming', 'codewhale', 'codebuddy', 'copilot', 'windsurf', 'augment'];
 const COMPONENT_FAMILY_PREFIXES = {
   baseline: 'baseline:',
   language: 'lang:',
@@ -54,6 +54,14 @@ const LEGACY_COMPAT_BASE_MODULE_IDS_BY_TARGET = Object.freeze({
     'platform-configs',
     'workflow-quality',
   ],
+  codewhale: [
+    'rules-core',
+    'agents-core',
+    'commands-core',
+    'hooks-runtime',
+    'platform-configs',
+    'workflow-quality',
+  ],
 });
 const LEGACY_LANGUAGE_ALIAS_TO_CANONICAL = Object.freeze({
   cpp: 'cpp',