closed-loop-cli 1.0.0

package/src/orchestrator/sahoo-gateway.ts

@@ -0,0 +1,300 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface SahooMetrics {
+  semanticDrift: number;
+  lexicalDrift: number;
+  structuralDrift: number;
+  distributionalDrift: number;
+  goalDriftIndex: number;
+  constraintPreservationScore: number;
+  regressionRisk: number;
+}
+
+/**
+ * Helper: Computes character trigrams and returns a map of frequencies.
+ */
+function getTrigramFreq(str: string): Map<string, number> {
+  const map = new Map<string, number>();
+  if (str.length < 3) return map;
+  for (let i = 0; i <= str.length - 3; i++) {
+    const trigram = str.substring(i, i + 3);
+    map.set(trigram, (map.get(trigram) || 0) + 1);
+  }
+  return map;
+}
+
+/**
+ * Calculates Semantic Drift using Trigram Cosine Similarity.
+ * Cosine distance = 1 - Cosine Similarity.
+ */
+export function calculateSemanticDrift(before: string, after: string): number {
+  const tBefore = getTrigramFreq(before);
+  const tAfter = getTrigramFreq(after);
+
+  if (tBefore.size === 0 && tAfter.size === 0) return 0;
+
+  // Calculate dot product and magnitudes
+  let dotProduct = 0;
+  tBefore.forEach((val, key) => {
+    if (tAfter.has(key)) {
+      dotProduct += val * (tAfter.get(key) || 0);
+    }
+  });
+
+  let magBefore = 0;
+  tBefore.forEach(val => magBefore += val * val);
+  magBefore = Math.sqrt(magBefore);
+
+  let magAfter = 0;
+  tAfter.forEach(val => magAfter += val * val);
+  magAfter = Math.sqrt(magAfter);
+
+  if (magBefore === 0 || magAfter === 0) return 1.0;
+
+  const similarity = Math.min(Math.max(dotProduct / (magBefore * magAfter), -1.0), 1.0);
+  const distance = 1.0 - similarity;
+  return Math.abs(distance) < 1e-12 ? 0 : distance; // Cosine distance
+}
+
+/**
+ * Calculates Lexical Drift using normalized Levenshtein edit distance.
+ */
+export function calculateLexicalDrift(before: string, after: string): number {
+  if (before === after) return 0;
+  if (before.length === 0) return 1.0;
+  if (after.length === 0) return 1.0;
+
+  const matrix: number[][] = [];
+  const bLen = before.length;
+  const aLen = after.length;
+
+  // For memory optimization under large strings, cap calculation length
+  const maxLen = 1000;
+  const sBefore = before.substring(0, maxLen);
+  const sAfter = after.substring(0, maxLen);
+  const n = sBefore.length;
+  const m = sAfter.length;
+
+  for (let i = 0; i <= n; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= m; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (sBefore[i - 1] === sAfter[j - 1]) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1,     // insertion
+          matrix[i - 1][j] + 1      // deletion
+        );
+      }
+    }
+  }
+
+  return matrix[n][m] / Math.max(n, m);
+}
+
+/**
+ * Calculates Structural Drift: normalized line and size differences.
+ */
+export function calculateStructuralDrift(before: string, after: string): number {
+  const linesBefore = before.split('\n').length;
+  const linesAfter = after.split('\n').length;
+  const sizeBefore = before.length;
+  const sizeAfter = after.length;
+
+  const lineDiff = Math.abs(linesAfter - linesBefore) / (Math.max(linesBefore, 1));
+  const sizeDiff = Math.abs(sizeAfter - sizeBefore) / (Math.max(sizeBefore, 1));
+
+  return Math.min((lineDiff + sizeDiff) / 2, 1.0);
+}
+
+/**
+ * Calculates Distributional Drift by evaluating changes in JavaScript/TypeScript keyword frequencies.
+ */
+export function calculateDistributionalDrift(before: string, after: string): number {
+  const keywords = ['const', 'let', 'var', 'if', 'else', 'for', 'while', 'function', 'class', 'import', 'export', 'return', 'await', 'async'];
+  
+  function getKeywordFreq(str: string): Map<string, number> {
+    const map = new Map<string, number>();
+    const tokens = str.split(/\W+/);
+    tokens.forEach(tok => {
+      if (keywords.includes(tok)) {
+        map.set(tok, (map.get(tok) || 0) + 1);
+      }
+    });
+    return map;
+  }
+
+  const freqBefore = getKeywordFreq(before);
+  const freqAfter = getKeywordFreq(after);
+
+  let totalDiff = 0;
+  let totalKeys = 0;
+
+  keywords.forEach(kw => {
+    const countBefore = freqBefore.get(kw) || 0;
+    const countAfter = freqAfter.get(kw) || 0;
+    totalDiff += Math.abs(countAfter - countBefore);
+    totalKeys += countBefore + countAfter;
+  });
+
+  if (totalKeys === 0) return 0;
+  return Math.min(totalDiff / totalKeys, 1.0);
+}
+
+/**
+ * Safety Constraints Check for CPS (Constraint Preservation Score).
+ */
+export function checkSafetyConstraints(filePath: string, content: string, compileSuccess: boolean, testsSuccess: boolean): { score: number, failedList: string[] } {
+  const failedList: string[] = [];
+  let satisfied = 0;
+  const K = 5; // Number of total constraints
+
+  // Constraint 1: Compiles successfully
+  if (compileSuccess) {
+    satisfied++;
+  } else {
+    failedList.push('CompilationFailure');
+  }
+
+  // Constraint 2: Tests pass
+  if (testsSuccess) {
+    satisfied++;
+  } else {
+    failedList.push('TestExecutionFailure');
+  }
+
+  // Constraint 3: No dynamic eval / Function execution in code
+  const hasEval = /\beval\s*\(/i.test(content) || /\bnew\s+Function\s*\(/i.test(content);
+  if (!hasEval) {
+    satisfied++;
+  } else {
+    failedList.push('DynamicCodeExecutionViolation');
+  }
+
+  // Constraint 4: No hardcoded secrets
+  const secretPatterns = [
+    /tp-[a-zA-Z0-9]{32,}/,             // MiMo Token pattern
+    /sk-[a-zA-Z0-9]{20,}/              // standard key patterns
+  ];
+  const hasSecrets = secretPatterns.some(pat => pat.test(content));
+  if (!hasSecrets) {
+    satisfied++;
+  } else {
+    failedList.push('SecretLeakViolation');
+  }
+
+  // Constraint 5: Path safety (inside workspace)
+  const normalizedPath = filePath.replace(/\\/g, '/');
+  const isSafePath = !normalizedPath.includes('../') && !normalizedPath.includes('..\\');
+  if (isSafePath) {
+    satisfied++;
+  } else {
+    failedList.push('PathSafetyViolation');
+  }
+
+  return {
+    score: satisfied / K,
+    failedList
+  };
+}
+
+/**
+ * Evaluates a codebase mutation against the SAHOO Safeguarding Policy.
+ */
+export function evaluateSahoo(
+  filePath: string,
+  beforeContent: string,
+  afterContent: string,
+  compileSuccess: boolean,
+  testsSuccess: boolean,
+  historicalScores: number[] = [1.0] // Default history to prevent division by zero
+): { passed: boolean; metrics: SahooMetrics; reason?: string } {
+  
+  // 1. Calculate individual drifts
+  const semantic = calculateSemanticDrift(beforeContent, afterContent);
+  const lexical = calculateLexicalDrift(beforeContent, afterContent);
+  const structural = calculateStructuralDrift(beforeContent, afterContent);
+  const distributional = calculateDistributionalDrift(beforeContent, afterContent);
+
+  // 2. Compute Goal Drift Index (GDI)
+  // GDI = 0.38*semantic + 0.12*lexical + 0.21*structural + 0.29*distributional
+  const gdi = (0.38 * semantic) + (0.12 * lexical) + (0.21 * structural) + (0.29 * distributional);
+
+  // 3. Compute Constraint Preservation Score (CPS)
+  const { score: cps, failedList } = checkSafetyConstraints(filePath, afterContent, compileSuccess, testsSuccess);
+
+  // 4. Compute Regression Risk (R_c)
+  // Pr(Q_c < Q_max - delta)
+  // We model Q_c as the current CPS score. Q_max is the highest historical score (typically 1.0).
+  // If historical performance is low, we quantify risk mathematically.
+  const qMax = Math.max(...historicalScores, 1.0);
+  const currentQ = cps;
+  
+  // Calculate variance of historical scores
+  const mean = historicalScores.reduce((a, b) => a + b, 0) / historicalScores.length;
+  const variance = historicalScores.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / historicalScores.length;
+  const stdDev = Math.max(Math.sqrt(variance), 0.05); // Min standard dev of 5%
+
+  // Regression Risk estimate using Gaussian Cumulative Distribution proxy:
+  // Z = (currentQ - qMax) / stdDev
+  // R_c = P(Z < 0)
+  const z = (currentQ - qMax) / stdDev;
+  let regressionRisk = 0.5; // default if z == 0
+  if (z < 0) {
+    // Standard approximation of normal CDF
+    regressionRisk = 1.0 - (1.0 / (1.0 + Math.exp(-1.6 * z)));
+  } else {
+    regressionRisk = 1.0 / (1.0 + Math.exp(1.6 * z));
+  }
+
+  const metrics: SahooMetrics = {
+    semanticDrift: semantic,
+    lexicalDrift: lexical,
+    structuralDrift: structural,
+    distributionalDrift: distributional,
+    goalDriftIndex: gdi,
+    constraintPreservationScore: cps,
+    regressionRisk: regressionRisk
+  };
+
+  // Halting policies:
+  // 1. GDI Threshold: Halts execution if GDI > 0.440
+  if (gdi > 0.440) {
+    return {
+      passed: false,
+      metrics,
+      reason: `Blocked by SAHOO: Goal Drift Index exceeded threshold (${gdi.toFixed(3)} > 0.440)`
+    };
+  }
+
+  // 2. CPS Threshold: Halts execution if CPS < 1.0 (Zero-tolerance for safety violations)
+  if (cps < 1.0) {
+    return {
+      passed: false,
+      metrics,
+      reason: `Blocked by SAHOO: Constraint Preservation Score fell below 1.0 (Violations: ${failedList.join(', ')})`
+    };
+  }
+
+  // 3. Regression Risk threshold: Halt if risk > 0.8
+  if (regressionRisk > 0.80) {
+    return {
+      passed: false,
+      metrics,
+      reason: `Blocked by SAHOO: Regression Risk too high (${(regressionRisk * 100).toFixed(1)}% > 80%)`
+    };
+  }
+
+  return {
+    passed: true,
+    metrics
+  };
+}

package/src/orchestrator/state-manager.ts

@@ -0,0 +1,161 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SahooMetrics } from './sahoo-gateway';
+export type { SahooMetrics };
+
+export interface EvolutionState {
+  status: 'idle' | 'reflecting' | 'scanning' | 'refactoring' | 'evaluating' | 'committing' | 'rolling_back' | 'optimizing_prompt' | 'cooldown' | 'error';
+  currentCycle: number;
+  maxCycles: number;
+  tokenBudget: number;
+  tokensUsed: {
+    input: number;
+    output: number;
+    total: number;
+  };
+  lastUpdated: string;
+  currentTask: string | null;
+  lastRefactorProposal: {
+    targetFile: string;
+    refactorGoal: string;
+    time: string;
+  } | null;
+  lastRefactorResult: {
+    success: boolean;
+    targetFile: string;
+    message: string;
+    time: string;
+    metrics?: SahooMetrics;
+    reason?: string;
+  } | null;
+  lastPromptOptimization: {
+    success: boolean;
+    baselineScore: number;
+    candidateScore: number;
+    approved: boolean;
+    time: string;
+  } | null;
+  history: Array<{
+    cycle: number;
+    time: string;
+    type: 'refactor' | 'prompt_opt' | 'dgm_evolution';
+    description: string;
+    success: boolean;
+    details?: string;
+  }>;
+  archive: Array<{
+    commitHash: string;
+    task: string;
+    cycle: number;
+    timestamp: string;
+    metrics?: SahooMetrics;
+  }>;
+  /** DGM-specific: fitness score ปัจจุบัน (test pass rate 0–1) */
+  currentFitness: number;
+  /** DGM-specific: fitness score สูงสุดที่เคยได้ */
+  bestFitness: number;
+  /** DGM-specific: จำนวน entries ใน dgm-archive.json ปัจจุบัน */
+  dgmPopulationSize: number;
+  /** DGM-specific: ID ของ best archive entry ที่ fitness สูงสุด */
+  dgmBestEntryId: string | null;
+}
+
+const statePath = path.join(process.cwd(), 'evolution-state.json');
+
+const defaultState: EvolutionState = {
+  status: 'idle',
+  currentCycle: 0,
+  maxCycles: 0,
+  tokenBudget: 500000,
+  tokensUsed: { input: 0, output: 0, total: 0 },
+  lastUpdated: new Date().toISOString(),
+  currentTask: null,
+  lastRefactorProposal: null,
+  lastRefactorResult: null,
+  lastPromptOptimization: null,
+  history: [],
+  archive: [],
+  currentFitness: 0,
+  bestFitness: 0,
+  dgmPopulationSize: 0,
+  dgmBestEntryId: null
+};
+
+export function getEvolutionState(): EvolutionState {
+  if (!fs.existsSync(statePath)) {
+    return defaultState;
+  }
+  try {
+    const raw = fs.readFileSync(statePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (e) {
+    return defaultState;
+  }
+}
+
+import { EventStream } from './event-stream';
+
+export function updateEvolutionState(update: Partial<EvolutionState>): EvolutionState {
+  const currentState = getEvolutionState();
+  
+  const tokensUsed = update.tokensUsed 
+    ? { ...currentState.tokensUsed, ...update.tokensUsed }
+    : currentState.tokensUsed;
+    
+  const merged: EvolutionState = {
+    ...currentState,
+    ...update,
+    tokensUsed,
+    lastUpdated: new Date().toISOString()
+  };
+
+  merged.tokensUsed.total = merged.tokensUsed.input + merged.tokensUsed.output;
+
+  // Log status transitions to EventStream
+  if (update.status && update.status !== currentState.status) {
+    EventStream.getInstance().publish(
+      'system',
+      'log',
+      'StateTransition',
+      `System status changed from '${currentState.status}' to '${update.status}'`
+    );
+  }
+
+  try {
+    fs.writeFileSync(statePath, JSON.stringify(merged, null, 2), 'utf-8');
+  } catch (err) {
+    console.error('Failed to write evolution state file:', err);
+  }
+
+  return merged;
+}
+
+export function appendHistory(item: Omit<EvolutionState['history'][0], 'time'>) {
+  const state = getEvolutionState();
+  const historyItem = {
+    ...item,
+    time: new Date().toISOString()
+  };
+  const updatedHistory = [...state.history, historyItem];
+  
+  if (updatedHistory.length > 50) {
+    updatedHistory.shift();
+  }
+
+  updateEvolutionState({ history: updatedHistory });
+}
+
+export function appendArchive(item: Omit<EvolutionState['archive'][0], 'timestamp'>) {
+  const state = getEvolutionState();
+  const archiveItem = {
+    ...item,
+    timestamp: new Date().toISOString()
+  };
+  const updatedArchive = [...(state.archive || []), archiveItem];
+  
+  if (updatedArchive.length > 10) {
+    updatedArchive.shift();
+  }
+
+  updateEvolutionState({ archive: updatedArchive });
+}

package/src/orchestrator/system-prompt.txt

@@ -0,0 +1 @@
+You are an autonomous coding agent in a codebase. Fulfill tasks accurately using file read/write/edit tools and terminal access. Always use editFile for partial edits to existing files; use writeFile only for new files. After running commands, verify compilation and tests; if tests fail, fix issues (self-healing). Be concise: plan before changes to minimize token waste and thinking overhead.