closed-loop-cli 1.0.0

package/src/orchestrator/dgm-archive.ts

@@ -0,0 +1,257 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Darwin Gödel Machine (DGM) — Archive Entry
+ * แต่ละ entry คือ snapshot ของ agent ณ จุดหนึ่งใน evolutionary lineage
+ */
+export interface ArchiveEntry {
+  /** Unique identifier สำหรับ snapshot นี้ */
+  id: string;
+  /** Git commit hash ที่ snapshot นี้ถูก commit ไว้ */
+  commitHash: string;
+  /** ID ของ parent entry ที่สร้าง snapshot นี้ขึ้นมา (null = origin) */
+  parentId: string | null;
+  /** Empirical fitness score (0–1) วัดจาก test pass rate */
+  fitness: number;
+  /** Mutation strategy ที่ถูกใช้เพื่อสร้าง snapshot นี้ */
+  mutationStrategy: string;
+  /** Task description ที่ mutation นี้ถูก apply สำหรับ */
+  task: string;
+  /** Timestamp ของการสร้าง snapshot */
+  timestamp: string;
+  /** Metadata เพิ่มเติม (test counts, metrics, etc.) */
+  metadata: {
+    passCount?: number;
+    failCount?: number;
+    totalTests?: number;
+    passRate?: number;
+    goalDriftIndex?: number;
+    constraintPreservationScore?: number;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Summary statistics ของ Archive ปัจจุบัน
+ */
+export interface ArchiveStats {
+  totalEntries: number;
+  bestFitness: number;
+  averageFitness: number;
+  bestEntryId: string | null;
+  latestEntryId: string | null;
+  generationDepth: number;
+}
+
+const ARCHIVE_FILENAME = 'dgm-archive.json';
+const DEFAULT_MAX_SIZE = 20;
+
+/**
+ * DGM Archive Manager
+ *
+ * เก็บ population ของ agent snapshots และจัดการ selection สำหรับ
+ * Darwin Gödel Machine evolution loop ตาม paper:
+ * "Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents"
+ */
+export class DGMArchive {
+  private archivePath: string;
+  private entries: ArchiveEntry[];
+
+  constructor(workspaceRoot?: string) {
+    const root = workspaceRoot || process.cwd();
+    this.archivePath = path.join(root, ARCHIVE_FILENAME);
+    this.entries = this.load();
+  }
+
+  // ─────────────────────────────────────────
+  // Persistence
+  // ─────────────────────────────────────────
+
+  private load(): ArchiveEntry[] {
+    if (!fs.existsSync(this.archivePath)) {
+      return [];
+    }
+    try {
+      const raw = fs.readFileSync(this.archivePath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed.entries) ? parsed.entries : [];
+    } catch {
+      return [];
+    }
+  }
+
+  private save(): void {
+    const data = {
+      version: '1.0.0',
+      lastUpdated: new Date().toISOString(),
+      entries: this.entries
+    };
+    try {
+      fs.writeFileSync(this.archivePath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('[DGMArchive] Failed to save archive:', err);
+    }
+  }
+
+  // ─────────────────────────────────────────
+  // Core Operations
+  // ─────────────────────────────────────────
+
+  /**
+   * เพิ่ม snapshot ใหม่เข้า archive
+   * @returns entry ที่เพิ่งเพิ่มเข้าไป
+   */
+  addEntry(entry: Omit<ArchiveEntry, 'id' | 'timestamp'>): ArchiveEntry {
+    const newEntry: ArchiveEntry = {
+      ...entry,
+      id: this.generateId(),
+      timestamp: new Date().toISOString()
+    };
+    this.entries.push(newEntry);
+    this.save();
+    return newEntry;
+  }
+
+  /**
+   * เลือก parent entry สำหรับ mutation รอบต่อไป
+   * ใช้ fitness-weighted sampling (DGM parent selection strategy)
+   *
+   * @param strategy 'fitness_weighted' | 'best' | 'random'
+   */
+  getBestParent(strategy: 'fitness_weighted' | 'best' | 'random' = 'fitness_weighted'): ArchiveEntry | null {
+    if (this.entries.length === 0) return null;
+
+    if (strategy === 'best') {
+      return [...this.entries].sort((a, b) => b.fitness - a.fitness)[0];
+    }
+
+    if (strategy === 'random') {
+      return this.entries[Math.floor(Math.random() * this.entries.length)];
+    }
+
+    // fitness_weighted: สุ่มโดยน้ำหนักตาม fitness score (DGM default)
+    return this.fitnessWeightedSample();
+  }
+
+  /**
+   * Trace lineage จาก entry ไปถึง origin
+   * @returns ordered array ตั้งแต่ origin จนถึง entry นี้
+   */
+  getLineage(entryId: string): ArchiveEntry[] {
+    const lineage: ArchiveEntry[] = [];
+    let current = this.findById(entryId);
+
+    while (current) {
+      lineage.unshift(current);
+      if (!current.parentId) break;
+      current = this.findById(current.parentId);
+    }
+
+    return lineage;
+  }
+
+  /**
+   * ตัด entries เก่าเพื่อป้องกัน archive ใหญ่เกินไป
+   * จะเก็บ entries ที่มี fitness สูงสุดไว้ก่อน
+   */
+  pruneOldEntries(maxSize: number = DEFAULT_MAX_SIZE): number {
+    if (this.entries.length <= maxSize) return 0;
+
+    // เรียง fitness สูงสุดก่อน แล้วตัดส่วนที่เกิน
+    const sorted = [...this.entries].sort((a, b) => b.fitness - a.fitness);
+    const pruned = this.entries.length - maxSize;
+    this.entries = sorted.slice(0, maxSize);
+    this.save();
+    return pruned;
+  }
+
+  // ─────────────────────────────────────────
+  // Query / Stats
+  // ─────────────────────────────────────────
+
+  getAll(): ArchiveEntry[] {
+    return [...this.entries];
+  }
+
+  findById(id: string): ArchiveEntry | undefined {
+    return this.entries.find(e => e.id === id);
+  }
+
+  getBestEntry(): ArchiveEntry | null {
+    if (this.entries.length === 0) return null;
+    return [...this.entries].sort((a, b) => b.fitness - a.fitness)[0];
+  }
+
+  getStats(): ArchiveStats {
+    if (this.entries.length === 0) {
+      return {
+        totalEntries: 0,
+        bestFitness: 0,
+        averageFitness: 0,
+        bestEntryId: null,
+        latestEntryId: null,
+        generationDepth: 0
+      };
+    }
+
+    const sorted = [...this.entries].sort((a, b) => b.fitness - a.fitness);
+    const best = sorted[0];
+    const latest = [...this.entries].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    )[0];
+
+    const avgFitness =
+      this.entries.reduce((sum, e) => sum + e.fitness, 0) / this.entries.length;
+
+    const depth = latest ? this.getLineage(latest.id).length : 0;
+
+    return {
+      totalEntries: this.entries.length,
+      bestFitness: best.fitness,
+      averageFitness: Math.round(avgFitness * 1000) / 1000,
+      bestEntryId: best.id,
+      latestEntryId: latest?.id ?? null,
+      generationDepth: depth
+    };
+  }
+
+  /**
+   * ดึง history ล่าสุด N entries (เรียงตามเวลา)
+   */
+  getRecentHistory(n: number = 10): ArchiveEntry[] {
+    return [...this.entries]
+      .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+      .slice(0, n);
+  }
+
+  // ─────────────────────────────────────────
+  // Private Helpers
+  // ─────────────────────────────────────────
+
+  /**
+   * Fitness-weighted random sampling (Roulette Wheel Selection)
+   * สูตรจาก DGM paper: เลือก parent ตาม probability ∝ fitness
+   */
+  private fitnessWeightedSample(): ArchiveEntry {
+    const totalFitness = this.entries.reduce((sum, e) => sum + Math.max(e.fitness, 0.01), 0);
+    let r = Math.random() * totalFitness;
+
+    for (const entry of this.entries) {
+      r -= Math.max(entry.fitness, 0.01);
+      if (r <= 0) return entry;
+    }
+
+    // fallback: คืน entry สุดท้าย
+    return this.entries[this.entries.length - 1];
+  }
+
+  /**
+   * สร้าง unique ID แบบ timestamp + random
+   */
+  private generateId(): string {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).substring(2, 6);
+    return `dgm_${ts}_${rand}`;
+  }
+}

package/src/orchestrator/event-stream.ts

@@ -0,0 +1,90 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface EventStreamMessage {
+  id: string;
+  timestamp: string;
+  source: 'user' | 'agent' | 'environment' | 'system';
+  type: 'message' | 'action' | 'observation' | 'log';
+  name: string;
+  content: string;
+  metadata?: any;
+}
+
+export class EventStream {
+  private static instance: EventStream;
+  private filePath: string;
+  private events: EventStreamMessage[] = [];
+
+  private constructor() {
+    const workspaceRoot = process.cwd();
+    this.filePath = path.join(workspaceRoot, 'event-stream-history.json');
+    this.loadEvents();
+  }
+
+  public static getInstance(): EventStream {
+    if (!EventStream.instance) {
+      EventStream.instance = new EventStream();
+    }
+    return EventStream.instance;
+  }
+
+  private loadEvents() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const data = fs.readFileSync(this.filePath, 'utf-8');
+        this.events = JSON.parse(data);
+      } else {
+        this.events = [];
+      }
+    } catch (e) {
+      console.error('[EventStream] Failed to load event stream history:', e);
+      this.events = [];
+    }
+  }
+
+  private saveEvents() {
+    try {
+      fs.writeFileSync(this.filePath, JSON.stringify(this.events, null, 2), 'utf-8');
+    } catch (e) {
+      console.error('[EventStream] Failed to save event stream history:', e);
+    }
+  }
+
+  public publish(
+    source: 'user' | 'agent' | 'environment' | 'system',
+    type: 'message' | 'action' | 'observation' | 'log',
+    name: string,
+    content: string,
+    metadata?: any
+  ): EventStreamMessage {
+    const event: EventStreamMessage = {
+      id: Math.random().toString(36).substring(2, 11),
+      timestamp: new Date().toISOString(),
+      source,
+      type,
+      name,
+      content,
+      metadata
+    };
+    this.events.push(event);
+    
+    // Cap at 1000 events to prevent massive file sizes
+    if (this.events.length > 1000) {
+      this.events.shift();
+    }
+    
+    this.saveEvents();
+    
+    return event;
+  }
+
+  public getEvents(): EventStreamMessage[] {
+    return this.events;
+  }
+
+  public clear() {
+    this.events = [];
+    this.saveEvents();
+  }
+}

package/src/orchestrator/fitness-evaluator.ts

@@ -0,0 +1,154 @@
+import { runCommand } from '../tools/shell-tools';
+
+/**
+ * Fitness Report จากการ evaluate โดย unit tests
+ * Fitness = empirical test pass rate (0–1) ตาม DGM paper concept
+ */
+export interface FitnessReport {
+  /** Pass rate (0–1) = passCount / totalTests */
+  passRate: number;
+  /** จำนวน tests ที่ผ่าน */
+  passCount: number;
+  /** จำนวน tests ที่ fail */
+  failCount: number;
+  /** จำนวน tests ทั้งหมด */
+  totalTests: number;
+  /** Composite fitness score (0–1) รวม compile status */
+  score: number;
+  /** Compilation ผ่านหรือไม่ */
+  compileSuccess: boolean;
+  /** สรุปผล */
+  summary: string;
+  /** Raw output จาก test runner */
+  rawOutput?: string;
+}
+
+/**
+ * ผลเปรียบเทียบ fitness ระหว่าง baseline กับ candidate
+ */
+export interface FitnessComparison {
+  improved: boolean;
+  delta: number;
+  baseline: FitnessReport;
+  candidate: FitnessReport;
+  message: string;
+}
+
+/**
+ * วัด empirical fitness จาก test suite ปัจจุบัน
+ *
+ * DGM approach: fitness วัดจากผล unit test จริง ไม่ใช่ heuristic เพียงอย่างเดียว
+ * "Each new agent version is evaluated empirically using coding benchmarks"
+ */
+export async function evaluateFitness(): Promise<FitnessReport> {
+  // Step 1: ตรวจ compile
+  const compileRes = await runCommand('npm run build');
+  const compileSuccess = compileRes.exitCode === 0;
+
+  if (!compileSuccess) {
+    return {
+      passRate: 0,
+      passCount: 0,
+      failCount: 0,
+      totalTests: 0,
+      score: 0,
+      compileSuccess: false,
+      summary: `Compilation failed — fitness = 0`,
+      rawOutput: compileRes.stdout + compileRes.stderr
+    };
+  }
+
+  // Step 2: run tests
+  const testRes = await runCommand('npm test');
+  const rawOutput = (testRes.stdout || '') + (testRes.stderr || '');
+
+  // Step 3: parse test output
+  const parsed = parseTestOutput(rawOutput);
+
+  // Step 4: คำนวณ composite score
+  // score = pass_rate ถ้า compile ผ่าน, 0 ถ้า compile fail
+  const score = compileSuccess ? parsed.passRate : 0;
+
+  const summary =
+    `Compile: ${compileSuccess ? 'PASS' : 'FAIL'} | ` +
+    `Tests: ${parsed.passCount}/${parsed.totalTests} passed ` +
+    `(${(parsed.passRate * 100).toFixed(1)}%) | Score: ${score.toFixed(3)}`;
+
+  return {
+    ...parsed,
+    score,
+    compileSuccess,
+    summary,
+    rawOutput
+  };
+}
+
+/**
+ * เปรียบเทียบ fitness ระหว่าง baseline snapshot กับ candidate snapshot
+ */
+export function compareToBaseline(
+  candidate: FitnessReport,
+  baseline: FitnessReport
+): FitnessComparison {
+  const delta = candidate.score - baseline.score;
+  const improved = delta > 0;
+
+  const message = improved
+    ? `✔ Fitness improved: ${baseline.score.toFixed(3)} → ${candidate.score.toFixed(3)} (+${delta.toFixed(3)})`
+    : delta === 0
+    ? `= Fitness unchanged: ${candidate.score.toFixed(3)}`
+    : `✘ Fitness regressed: ${baseline.score.toFixed(3)} → ${candidate.score.toFixed(3)} (${delta.toFixed(3)})`;
+
+  return { improved, delta, baseline, candidate, message };
+}
+
+/**
+ * Parse test runner output เพื่อนับ pass/fail counts
+ * รองรับ format ของ test runner ปัจจุบันในโปรเจกต์
+ */
+export function parseTestOutput(output: string): Pick<
+  FitnessReport,
+  'passRate' | 'passCount' | 'failCount' | 'totalTests'
+> {
+  let passCount = 0;
+  let failCount = 0;
+
+  // Pattern 1: "[Pass] <test name>" ซึ่งเป็น format ของ run-tests.ts ปัจจุบัน
+  const passMatches = output.match(/\[Pass\]/g);
+  const failMatches = output.match(/\[Fail\]/g);
+
+  if (passMatches || failMatches) {
+    passCount = passMatches ? passMatches.length : 0;
+    failCount = failMatches ? failMatches.length : 0;
+  }
+
+  // Pattern 2: Mocha format — "X passing" / "X failing"
+  const mochaPassing = output.match(/(\d+)\s+passing/i);
+  const mochaFailing = output.match(/(\d+)\s+failing/i);
+
+  if (mochaPassing || mochaFailing) {
+    passCount = mochaPassing ? parseInt(mochaPassing[1], 10) : passCount;
+    failCount = mochaFailing ? parseInt(mochaFailing[1], 10) : failCount;
+  }
+
+  // Pattern 3: Jest format — "Tests: X passed, Y failed"
+  const jestLine = output.match(/Tests:\s+(\d+)\s+passed(?:,\s+(\d+)\s+failed)?/i);
+  if (jestLine) {
+    passCount = parseInt(jestLine[1], 10) || passCount;
+    failCount = jestLine[2] ? parseInt(jestLine[2], 10) : failCount;
+  }
+
+  // Pattern 4: "ALL BINARY ASSERTION TESTS PASSED" — หมายถึง 100% ผ่าน
+  if (output.includes('ALL BINARY ASSERTION TESTS PASSED')) {
+    // ถ้าตรวจจับ pass ไม่ได้ชัดเจนให้ fallback = ผ่านทั้งหมด
+    if (passCount === 0 && failCount === 0) {
+      passCount = 11; // จำนวน tests ใน run-tests.ts (Test 1–11)
+      failCount = 0;
+    }
+  }
+
+  const totalTests = passCount + failCount;
+  const passRate = totalTests > 0 ? passCount / totalTests : (failCount === 0 ? 1 : 0);
+
+  return { passRate, passCount, failCount, totalTests };
+}