closed-loop-cli 1.0.0

package/dist/dashboard/server.js

@@ -0,0 +1,237 @@
+"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.startDashboardServer = startDashboardServer;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PORT = 3000;
+const PUBLIC_DIR = path.join(process.cwd(), 'src', 'dashboard', 'public');
+function startDashboardServer() {
+    const server = http.createServer((req, res) => {
+        const url = req.url || '/';
+        // Enable CORS
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        // API endpoints
+        if (url === '/api/state') {
+            const statePath = path.join(process.cwd(), 'evolution-state.json');
+            if (fs.existsSync(statePath)) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                fs.createReadStream(statePath).pipe(res);
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    status: 'idle',
+                    currentCycle: 0,
+                    tokensUsed: { input: 0, output: 0, total: 0 },
+                    history: [],
+                    message: 'Daemon state not yet initialized.'
+                }));
+            }
+            return;
+        }
+        if (url === '/api/learnings') {
+            const learningsPath = path.join(process.cwd(), 'Learnings.md');
+            if (fs.existsSync(learningsPath)) {
+                res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+                fs.createReadStream(learningsPath).pipe(res);
+            }
+            else {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Learnings.md not found.');
+            }
+            return;
+        }
+        if (url === '/api/logs') {
+            const logPath = path.join(process.cwd(), 'evolution.log');
+            if (fs.existsSync(logPath)) {
+                res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+                // Return last 200 lines
+                fs.readFile(logPath, 'utf-8', (err, data) => {
+                    if (err) {
+                        res.writeHead(500);
+                        res.end('Error reading logs.');
+                        return;
+                    }
+                    const lines = data.split('\n');
+                    const lastLines = lines.slice(-200).join('\n');
+                    res.end(lastLines);
+                });
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('No evolution logs found. Start the evolution daemon to begin logging.');
+            }
+            return;
+        }
+        if (url === '/api/research') {
+            const researchPath = path.join(process.cwd(), 'research-log.json');
+            if (fs.existsSync(researchPath)) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                fs.createReadStream(researchPath).pipe(res);
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify([]));
+            }
+            return;
+        }
+        // DGM Archive endpoint — returns population of evolution snapshots
+        if (url === '/api/dgm-archive') {
+            const archivePath = path.join(process.cwd(), 'dgm-archive.json');
+            if (fs.existsSync(archivePath)) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                fs.createReadStream(archivePath).pipe(res);
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    version: '1.0.0',
+                    entries: [],
+                    message: 'DGM archive not yet initialized. Run --dgm to start.'
+                }));
+            }
+            return;
+        }
+        // DGM Fitness endpoint — returns current fitness metrics from state
+        if (url === '/api/fitness') {
+            const statePath = path.join(process.cwd(), 'evolution-state.json');
+            if (fs.existsSync(statePath)) {
+                try {
+                    const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        currentFitness: state.currentFitness ?? 0,
+                        bestFitness: state.bestFitness ?? 0,
+                        dgmPopulationSize: state.dgmPopulationSize ?? 0,
+                        dgmBestEntryId: state.dgmBestEntryId ?? null,
+                        lastUpdated: state.lastUpdated
+                    }));
+                }
+                catch {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Failed to read state' }));
+                }
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ currentFitness: 0, bestFitness: 0, dgmPopulationSize: 0, dgmBestEntryId: null }));
+            }
+            return;
+        }
+        // Event stream API endpoint
+        if (url === '/api/event-stream') {
+            const streamPath = path.join(process.cwd(), 'event-stream-history.json');
+            if (fs.existsSync(streamPath)) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                fs.createReadStream(streamPath).pipe(res);
+            }
+            else {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify([]));
+            }
+            return;
+        }
+        // Microagents list endpoint
+        if (url === '/api/microagents') {
+            try {
+                const { MicroagentRegistry } = require('../orchestrator/microagent-registry');
+                const registry = MicroagentRegistry.getInstance();
+                registry.loadMicroagents();
+                const agents = registry.getMicroagents();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(agents));
+            }
+            catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Failed to read microagents' }));
+            }
+            return;
+        }
+        // Static file serving
+        let filePath = path.join(PUBLIC_DIR, url === '/' ? 'index.html' : url);
+        // Safety check: ensure file path stays within PUBLIC_DIR
+        const resolvedPath = path.resolve(filePath);
+        if (!resolvedPath.startsWith(path.resolve(PUBLIC_DIR))) {
+            res.writeHead(403, { 'Content-Type': 'text/plain' });
+            res.end('Forbidden');
+            return;
+        }
+        const extname = path.extname(filePath);
+        let contentType = 'text/html';
+        switch (extname) {
+            case '.js':
+                contentType = 'text/javascript';
+                break;
+            case '.css':
+                contentType = 'text/css';
+                break;
+            case '.json':
+                contentType = 'application/json';
+                break;
+            case '.png':
+                contentType = 'image/png';
+                break;
+            case '.jpg':
+                contentType = 'image/jpg';
+                break;
+        }
+        fs.exists(filePath, (exists) => {
+            if (exists) {
+                res.writeHead(200, { 'Content-Type': contentType });
+                fs.createReadStream(filePath).pipe(res);
+            }
+            else {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('404 Not Found');
+            }
+        });
+    });
+    server.listen(PORT, () => {
+        console.log(`\n\x1b[36m[Dashboard Server] Web interface running at http://localhost:${PORT}\x1b[0m\n`);
+    });
+}
+// Support executing directly if run from CLI
+if (require.main === module) {
+    startDashboardServer();
+}

package/dist/index.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const dotenv = __importStar(require("dotenv"));
+const autogenesis_1 = require("./orchestrator/autogenesis");
+const server_1 = require("./dashboard/server");
+const telegram_bot_1 = require("./orchestrator/telegram-bot");
+const task_agent_1 = require("./orchestrator/task-agent");
+// Phase 3 is initialized
+// Load environment variables
+dotenv.config();
+function printHeader() {
+    console.log('\x1b[35m%s\x1b[0m', '==================================================');
+    console.log('\x1b[36m%s\x1b[0m', '      Closed-Loop Self-Developing Coding CLI       ');
+    console.log('\x1b[35m%s\x1b[0m', '==================================================');
+    console.log('Using endpoint: ' + (process.env.ANTHROPIC_BASE_URL || 'default anthropic'));
+    console.log('Main Model: ' + (process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]'));
+    console.log('Subagent Model: ' + (process.env.CLAUDE_CODE_SUBAGENT_MODEL || 'mimo-v2.5-pro'));
+    console.log('Type a task to begin, or type "exit" to quit.\n');
+}
+async function startInteractiveCLI(effort = 'standard', codeactMode = false) {
+    printHeader();
+    console.log('\x1b[33m%s\x1b[0m', '--- CLAUDE CODE INTERACTIVE MODE (Conversational CLI) ---');
+    console.log('Conversation history is maintained. Type "exit" or "quit" to leave.\n');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: '\x1b[35mClaudeCode > \x1b[0m'
+    });
+    const history = [];
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log('Goodbye!');
+            process.exit(0);
+        }
+        rl.pause(); // Pause standard input while agent runs
+        try {
+            const response = await (0, task_agent_1.runTaskAgent)(input, {
+                role: 'coder_codeact', // Coder with command execution tools
+                effort,
+                history: history
+            });
+            // Update history
+            history.push({ role: 'user', content: input });
+            history.push({ role: 'assistant', content: response.result });
+            console.log(`\n\x1b[32m[Claude Code Response]:\x1b[0m\n${response.result}\n`);
+        }
+        catch (err) {
+            console.error('\n\x1b[31m[Agent Error]:\x1b[0m', err.message);
+        }
+        rl.resume();
+        rl.prompt();
+    }).on('close', () => {
+        console.log('\nGoodbye!');
+        process.exit(0);
+    });
+}
+function setupLogRedirection() {
+    const logFile = fs.createWriteStream(path.join(process.cwd(), 'evolution.log'), { flags: 'a' });
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = function (...args) {
+        originalLog.apply(console, args);
+        logFile.write(args.join(' ') + '\n');
+    };
+    console.error = function (...args) {
+        originalError.apply(console, args);
+        logFile.write('ERROR: ' + args.join(' ') + '\n');
+    };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Parse codeact option
+    let codeactMode = false;
+    const codeactIdx = args.findIndex(arg => arg === '--codeact' || arg === '--openhands');
+    if (codeactIdx !== -1) {
+        codeactMode = true;
+        args.splice(codeactIdx, 1);
+    }
+    // Parse effort option
+    let effort = 'standard';
+    const effortIdx = args.findIndex(arg => arg === '--effort' || arg === '-e');
+    if (effortIdx !== -1 && effortIdx + 1 < args.length) {
+        const val = args[effortIdx + 1].toLowerCase();
+        if (val === 'ultracode' || val === 'max') {
+            effort = 'ultracode';
+        }
+        // Remove --effort and its value from args
+        args.splice(effortIdx, 2);
+    }
+    else {
+        const envEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL || 'standard';
+        if (envEffort === 'max' || envEffort === 'ultracode') {
+            effort = 'ultracode';
+        }
+    }
+    if (args.length > 0) {
+        if (args[0] === '--telegram') {
+            try {
+                console.log(`\n\x1b[33m[Running Standalone Telegram ChatOps Mode]\x1b[0m`);
+                (0, telegram_bot_1.startTelegramBot)();
+                return;
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[Telegram ChatOps Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        if (args[0] === '--dashboard') {
+            try {
+                console.log(`\n\x1b[33m[Running Standalone Dashboard Monitor Mode]\x1b[0m`);
+                (0, server_1.startDashboardServer)();
+                return;
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[Dashboard Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        const isContinuous = args.includes('--continuous') || args.includes('-c');
+        if (isContinuous) {
+            try {
+                let cycles = 0; // infinite
+                const cyclesIdx = args.indexOf('--cycles');
+                if (cyclesIdx !== -1 && cyclesIdx + 1 < args.length) {
+                    cycles = parseInt(args[cyclesIdx + 1], 10) || 0;
+                }
+                let tokenBudget = 500000; // default 500k tokens
+                const budgetIdx = args.indexOf('--budget-tokens');
+                if (budgetIdx !== -1 && budgetIdx + 1 < args.length) {
+                    tokenBudget = parseInt(args[budgetIdx + 1], 10) || 500000;
+                }
+                console.log(`\n\x1b[33m[Running Continuous Self-Evolution Daemon Mode]\x1b[0m`);
+                console.log(`- Cycle Limit:  ${cycles === 0 ? 'Infinite' : cycles}`);
+                console.log(`- Token Budget: ${tokenBudget} tokens\n`);
+                setupLogRedirection();
+                (0, server_1.startDashboardServer)();
+                (0, telegram_bot_1.startTelegramBot)();
+                const engine = new autogenesis_1.AutogenesisEngine();
+                engine.setEffort(effort);
+                engine.codeactMode = codeactMode;
+                await engine.runContinuousEvolution(cycles, tokenBudget);
+                console.log('\n\x1b[32m[Continuous Self-Evolution Daemon Stopped Cleanly]\x1b[0m');
+                process.exit(0);
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[Continuous Self-Evolution Daemon Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        if (args[0] === '--refactor') {
+            try {
+                console.log(`\n\x1b[33m[Running Autonomous Refactoring Mode]\x1b[0m`);
+                const engine = new autogenesis_1.AutogenesisEngine();
+                engine.setEffort(effort);
+                engine.codeactMode = codeactMode;
+                await engine.runAutonomousRefactor();
+                console.log('\n\x1b[32m[Autonomous Refactoring Completed]\x1b[0m');
+                process.exit(0);
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[Autonomous Refactoring Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        if (args[0] === '--optimize-prompt') {
+            try {
+                console.log(`\n\x1b[33m[Running Prompt Optimization Benchmarking Mode]\x1b[0m`);
+                const engine = new autogenesis_1.AutogenesisEngine();
+                engine.setEffort(effort);
+                engine.codeactMode = codeactMode;
+                await engine.runPromptOptimization();
+                console.log('\n\x1b[32m[Prompt Optimization Completed]\x1b[0m');
+                process.exit(0);
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[Prompt Optimization Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        if (args[0] === '--dgm') {
+            try {
+                // Parse optional --generations N flag
+                let maxGenerations = 5;
+                const genIdx = args.indexOf('--generations');
+                if (genIdx !== -1 && genIdx + 1 < args.length) {
+                    maxGenerations = parseInt(args[genIdx + 1], 10) || 5;
+                    args.splice(genIdx, 2);
+                }
+                // Task is everything after --dgm flag
+                const dgmTask = args.slice(1).join(' ') || 'Improve the codebase using open-ended evolution';
+                console.log(`\n\x1b[33m[Running DGM (Darwin Gödel Machine) Evolution Mode]\x1b[0m`);
+                console.log(`Task: "${dgmTask}" | Generations: ${maxGenerations}\n`);
+                const engine = new autogenesis_1.AutogenesisEngine();
+                engine.setEffort(effort);
+                engine.codeactMode = codeactMode;
+                await engine.runDGMEvolution(dgmTask, maxGenerations);
+                console.log('\n\x1b[32m[DGM Evolution Completed]\x1b[0m');
+                process.exit(0);
+            }
+            catch (err) {
+                console.error('\n\x1b[31m[DGM Evolution Failed]:\x1b[0m', err.message);
+                process.exit(1);
+            }
+        }
+        // Direct command execution
+        const task = args.join(' ');
+        try {
+            console.log(`Running direct task: "${task}" (CodeAct=${codeactMode})`);
+            const engine = new autogenesis_1.AutogenesisEngine();
+            engine.setEffort(effort);
+            engine.codeactMode = codeactMode;
+            await engine.runEvolutionStep(task);
+            console.log('\n\x1b[32m[Evolution Step Completed]\x1b[0m');
+            process.exit(0);
+        }
+        catch (err) {
+            console.error('\n\x1b[31m[Evolution Failed]:\x1b[0m', err.message);
+            process.exit(1);
+        }
+    }
+    else {
+        // Start interactive session
+        await startInteractiveCLI(effort, codeactMode);
+    }
+}
+main().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/dist/orchestrator/agent-prompts.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GATEKEEPER_PROMPT = exports.DEBUGGER_PROMPT = exports.CODEACT_CODER_PROMPT = exports.CODER_PROMPT = exports.ARCHITECT_PROMPT = void 0;
+exports.ARCHITECT_PROMPT = `You are an elite Software Architect and Planner.
+Your primary objective is to receive a coding task and design a comprehensive, step-by-step implementation plan.
+
+Do NOT modify any files yourself or run commands. Your job is exclusively to analyze the requirements, inspect the codebase using indexing and search tools, and write a clear, structured markdown plan.
+
+For each file to be modified, specify:
+1. The path to the file.
+2. The exact function, interface, or line range to change.
+3. The structural modification required (the blueprint of what needs to be written).
+
+Be precise and ensure you have inspected all target files first.`;
+exports.CODER_PROMPT = `You are an elite Coder.
+Your primary objective is to receive an approved Implementation Plan/Blueprint and execute the exact code modifications specified in it.
+
+You have access to file writing and editing tools. You do NOT have terminal command execution tools.
+Focus on writing clean, type-safe TypeScript code without placeholders. Follow the coding style guidelines.
+Use editFile instead of writeFile whenever possible to make minimal, precise changes.
+
+If the compiler or tests fail, the Diagnostics agent will provide you with the error details. Use that feedback to edit and correct your code.`;
+exports.CODEACT_CODER_PROMPT = `You are an elite Coder operating under the CodeAct (Code Action) paradigm.
+Your primary objective is to execute code modifications and solve tasks by directly writing/editing code files or executing commands.
+
+Unlike standard coders, you have access to terminal command execution (runCommand) alongside file writing and editing tools.
+Use code execution (bash/PowerShell, writing Node.js scripts, compiling, and testing) as your main interface to verify and implement the plan.
+Ensure you follow all workspace rules and ensure compiling/testing passes after your code actions.`;
+exports.DEBUGGER_PROMPT = `You are an elite Diagnostics and Debugging Agent.
+Your primary objective is to check the codebase compile and test status after a modification, analyze any failures, and pinpoint the exact issue.
+
+You have command execution and file reading tools.
+If a build or test fails, run appropriate commands to get stdout/stderr.
+Locate the file and line number where the compilation error or failing test occurred.
+Write a precise, actionable instruction for the Coder agent to resolve the issue (e.g. "Import is missing", "Type mismatch on parameter X").
+Do NOT edit any source code files yourself.`;
+exports.GATEKEEPER_PROMPT = `You are an elite Gatekeeper and Reviewer Agent.
+Your primary objective is to perform a safety and quality audit on the completed changes before they are committed.
+
+Review the git diff, check that the code compiles, and check that all unit tests pass.
+Verify that the changes do not violate safety rules (e.g. no eval, no secrets, no sandbox escapes).
+If any safety rules are violated or regression risk is high, explain the issue clearly.`;