closed-loop-cli 1.0.0

package/dist/orchestrator/dgm-archive.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DGMArchive = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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"
+ */
+class DGMArchive {
+    archivePath;
+    entries;
+    constructor(workspaceRoot) {
+        const root = workspaceRoot || process.cwd();
+        this.archivePath = path.join(root, ARCHIVE_FILENAME);
+        this.entries = this.load();
+    }
+    // ─────────────────────────────────────────
+    // Persistence
+    // ─────────────────────────────────────────
+    load() {
+        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 [];
+        }
+    }
+    save() {
+        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) {
+        const newEntry = {
+            ...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') {
+        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) {
+        const lineage = [];
+        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 = DEFAULT_MAX_SIZE) {
+        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() {
+        return [...this.entries];
+    }
+    findById(id) {
+        return this.entries.find(e => e.id === id);
+    }
+    getBestEntry() {
+        if (this.entries.length === 0)
+            return null;
+        return [...this.entries].sort((a, b) => b.fitness - a.fitness)[0];
+    }
+    getStats() {
+        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 = 10) {
+        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
+     */
+    fitnessWeightedSample() {
+        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
+     */
+    generateId() {
+        const ts = Date.now().toString(36);
+        const rand = Math.random().toString(36).substring(2, 6);
+        return `dgm_${ts}_${rand}`;
+    }
+}
+exports.DGMArchive = DGMArchive;

package/dist/orchestrator/event-stream.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStream = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class EventStream {
+    static instance;
+    filePath;
+    events = [];
+    constructor() {
+        const workspaceRoot = process.cwd();
+        this.filePath = path.join(workspaceRoot, 'event-stream-history.json');
+        this.loadEvents();
+    }
+    static getInstance() {
+        if (!EventStream.instance) {
+            EventStream.instance = new EventStream();
+        }
+        return EventStream.instance;
+    }
+    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 = [];
+        }
+    }
+    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);
+        }
+    }
+    publish(source, type, name, content, metadata) {
+        const event = {
+            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;
+    }
+    getEvents() {
+        return this.events;
+    }
+    clear() {
+        this.events = [];
+        this.saveEvents();
+    }
+}
+exports.EventStream = EventStream;

package/dist/orchestrator/fitness-evaluator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateFitness = evaluateFitness;
+exports.compareToBaseline = compareToBaseline;
+exports.parseTestOutput = parseTestOutput;
+const shell_tools_1 = require("../tools/shell-tools");
+/**
+ * วัด empirical fitness จาก test suite ปัจจุบัน
+ *
+ * DGM approach: fitness วัดจากผล unit test จริง ไม่ใช่ heuristic เพียงอย่างเดียว
+ * "Each new agent version is evaluated empirically using coding benchmarks"
+ */
+async function evaluateFitness() {
+    // Step 1: ตรวจ compile
+    const compileRes = await (0, shell_tools_1.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 (0, shell_tools_1.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
+ */
+function compareToBaseline(candidate, baseline) {
+    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 ปัจจุบันในโปรเจกต์
+ */
+function parseTestOutput(output) {
+    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 };
+}