closed-loop-cli 1.0.0

package/dist/orchestrator/mutation-strategies.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutationStrategy = void 0;
+exports.selectMutationStrategy = selectMutationStrategy;
+exports.generateMutationPrompt = generateMutationPrompt;
+/**
+ * DGM Mutation Strategies
+ *
+ * จาก DGM paper: open-ended evolution ต้องการ diversity ของ mutation types
+ * ไม่ใช่แค่ refactor อย่างเดียว — เพื่อสำรวจ search space ที่กว้างขึ้น
+ */
+var MutationStrategy;
+(function (MutationStrategy) {
+    /** เพิ่ม feature ใหม่เข้าไปในระบบ */
+    MutationStrategy["ADD_FEATURE"] = "add_feature";
+    /** Refactor code เดิมให้อ่านง่ายขึ้น / ลด duplication */
+    MutationStrategy["REFACTOR"] = "refactor";
+    /** Optimize performance หรือ token efficiency */
+    MutationStrategy["OPTIMIZE"] = "optimize";
+    /** เพิ่ม unit tests เพื่อเพิ่ม coverage */
+    MutationStrategy["ADD_TESTS"] = "add_tests";
+    /** แก้ bug ที่ตรวจพบจาก test failures */
+    MutationStrategy["FIX_BUG"] = "fix_bug";
+    /** ปรับปรุง system prompt / agent prompt */
+    MutationStrategy["IMPROVE_PROMPT"] = "improve_prompt";
+})(MutationStrategy || (exports.MutationStrategy = MutationStrategy = {}));
+/**
+ * เลือก mutation strategy ที่เหมาะสมจาก archive history + task context
+ *
+ * DGM approach: strategy selection ควร adaptive ตาม population history
+ * — ถ้า fitness ต่ำ → ลอง ADD_TESTS หรือ FIX_BUG ก่อน
+ * — ถ้า fitness สูงแล้ว → ลอง ADD_FEATURE หรือ OPTIMIZE
+ * — ถ้า task พูดถึง bug → เลือก FIX_BUG ก่อน
+ */
+function selectMutationStrategy(archive, task, currentFitness = 0) {
+    const taskLower = task.toLowerCase();
+    // 1. Task-based override: ถ้า task บ่งชี้ strategy ชัดเจน
+    if (taskLower.includes('fix') || taskLower.includes('bug') || taskLower.includes('error')) {
+        return {
+            strategy: MutationStrategy.FIX_BUG,
+            rationale: 'Task description indicates a bug fix is needed'
+        };
+    }
+    if (taskLower.includes('test') || taskLower.includes('coverage')) {
+        return {
+            strategy: MutationStrategy.ADD_TESTS,
+            rationale: 'Task description requests test improvements'
+        };
+    }
+    if (taskLower.includes('prompt') || taskLower.includes('instruction')) {
+        return {
+            strategy: MutationStrategy.IMPROVE_PROMPT,
+            rationale: 'Task description targets prompt engineering'
+        };
+    }
+    if (taskLower.includes('refactor') || taskLower.includes('clean') || taskLower.includes('reformat')) {
+        return {
+            strategy: MutationStrategy.REFACTOR,
+            rationale: 'Task description requests code refactoring'
+        };
+    }
+    if (taskLower.includes('optim') || taskLower.includes('speed') || taskLower.includes('performance') || taskLower.includes('token')) {
+        return {
+            strategy: MutationStrategy.OPTIMIZE,
+            rationale: 'Task description requests optimization'
+        };
+    }
+    if (taskLower.includes('add') || taskLower.includes('implement') || taskLower.includes('create') || taskLower.includes('new feature')) {
+        return {
+            strategy: MutationStrategy.ADD_FEATURE,
+            rationale: 'Task description requests adding a new feature'
+        };
+    }
+    // 2. Fitness-based heuristic: ถ้า fitness ต่ำ → focus on fixing
+    if (currentFitness < 0.7) {
+        return {
+            strategy: MutationStrategy.FIX_BUG,
+            rationale: `Low fitness (${(currentFitness * 100).toFixed(1)}%) — prioritizing stability fixes`
+        };
+    }
+    // 3. Archive diversity: ตรวจสอบว่า strategy ไหนถูกใช้ไปน้อยสุดใน archive
+    const recentHistory = archive.getRecentHistory(8);
+    if (recentHistory.length > 0) {
+        const strategyCounts = {};
+        for (const s of Object.values(MutationStrategy)) {
+            strategyCounts[s] = 0;
+        }
+        for (const entry of recentHistory) {
+            if (entry.mutationStrategy && strategyCounts[entry.mutationStrategy] !== undefined) {
+                strategyCounts[entry.mutationStrategy]++;
+            }
+        }
+        // เลือก strategy ที่ถูกใช้น้อยสุด (diversity promotion)
+        const leastUsed = Object.entries(strategyCounts)
+            .sort((a, b) => a[1] - b[1])[0];
+        if (leastUsed && leastUsed[1] < 2) {
+            return {
+                strategy: leastUsed[0],
+                rationale: `Diversity promotion: "${leastUsed[0]}" has been used least (${leastUsed[1]}x in recent history)`
+            };
+        }
+    }
+    // 4. Default: ADD_FEATURE (DGM paper prefers expansive mutations)
+    return {
+        strategy: MutationStrategy.ADD_FEATURE,
+        rationale: 'Default open-ended evolution strategy: expanding capabilities'
+    };
+}
+/**
+ * สร้าง task prompt เฉพาะ mutation strategy
+ * ให้ Agent ทราบว่ากำลังทำ mutation ประเภทใด
+ */
+function generateMutationPrompt(strategy, originalTask, context) {
+    const parentInfo = context?.parentEntry
+        ? `\n[DGM Context] Building upon parent snapshot: ${context.parentEntry.id} (fitness: ${(context.parentEntry.fitness * 100).toFixed(1)}%)`
+        : '';
+    const fitnessInfo = context?.currentFitness !== undefined
+        ? `\n[DGM Context] Current system fitness: ${(context.currentFitness * 100).toFixed(1)}% (test pass rate)`
+        : '';
+    const fileInfo = context?.targetFile
+        ? `\n[DGM Context] Primary target file: ${context.targetFile}`
+        : '';
+    const dgmHeader = `[DGM Mutation: ${strategy.toUpperCase()}]${parentInfo}${fitnessInfo}${fileInfo}\n\n`;
+    switch (strategy) {
+        case MutationStrategy.ADD_FEATURE:
+            return dgmHeader +
+                `Your mutation goal is to ADD A NEW FEATURE. Implement the following capability:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Create new files or add new exported functions/classes as needed\n` +
+                `- Do not break existing functionality\n` +
+                `- Ensure all new code compiles and existing tests still pass\n` +
+                `- The feature should integrate cleanly with the existing codebase`;
+        case MutationStrategy.REFACTOR:
+            return dgmHeader +
+                `Your mutation goal is to REFACTOR existing code for better quality:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Improve readability, reduce duplication, or strengthen type safety\n` +
+                `- Preserve all existing behavior exactly (zero functional change)\n` +
+                `- All existing tests must still pass after refactoring`;
+        case MutationStrategy.OPTIMIZE:
+            return dgmHeader +
+                `Your mutation goal is to OPTIMIZE for performance or efficiency:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Focus on reducing token usage, execution time, or memory\n` +
+                `- Preserve correctness — all tests must still pass\n` +
+                `- Measure and report the optimization impact if possible`;
+        case MutationStrategy.ADD_TESTS:
+            return dgmHeader +
+                `Your mutation goal is to ADD UNIT TESTS to improve coverage:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Add tests to src/tests/dynamic/ directory as .ts files\n` +
+                `- Tests must export a default function or a run() function\n` +
+                `- Prioritize testing edge cases and untested public functions\n` +
+                `- Do not modify existing test files (protected by Campbell Regime)`;
+        case MutationStrategy.FIX_BUG:
+            return dgmHeader +
+                `Your mutation goal is to FIX A BUG or stability issue:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Diagnose the root cause carefully before making changes\n` +
+                `- Make the minimal change required to fix the issue\n` +
+                `- Add a regression test if appropriate\n` +
+                `- All tests must pass after the fix`;
+        case MutationStrategy.IMPROVE_PROMPT:
+            return dgmHeader +
+                `Your mutation goal is to IMPROVE AGENT PROMPTS for better performance:\n${originalTask}\n\n` +
+                `Guidelines:\n` +
+                `- Edit src/orchestrator/system-prompt.txt or src/orchestrator/agent-prompts.ts\n` +
+                `- Make prompts more concise, clear, and effective\n` +
+                `- Preserve all existing agent capabilities\n` +
+                `- Build compiles and tests pass after changes`;
+        default:
+            return dgmHeader + originalTask;
+    }
+}

package/dist/orchestrator/prompt-benchmark.js

@@ -0,0 +1,102 @@
+"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.calculatePromptScore = calculatePromptScore;
+exports.benchmarkPrompt = benchmarkPrompt;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const shell_tools_1 = require("../tools/shell-tools");
+const task_agent_1 = require("./task-agent");
+/**
+ * Calculates a prompt utility score where higher is better.
+ * Combines time and token cost with configurable weights.
+ */
+function calculatePromptScore(timeSeconds, totalTokens) {
+    const timeWeight = 0.4;
+    const tokenWeight = 0.6;
+    if (totalTokens === 0 || timeSeconds === 0)
+        return 0;
+    return 100000 / (timeSeconds * timeWeight + totalTokens * tokenWeight);
+}
+/**
+ * Benchmarks a system prompt on a standard task.
+ * Returns token usage, execution time, and compilation success.
+ * The workspace is reset before and after the benchmark to avoid side-effects.
+ */
+async function benchmarkPrompt(systemPrompt) {
+    const benchmarkTask = "Create a typescript helper file src/tools/math-helper.ts that exports a sum(a: number, b: number) function. Ensure it compiles. Do not change any other files.";
+    // Clear any previous math-helper.ts file
+    const helperPath = path.join(process.cwd(), 'src/tools/math-helper.ts');
+    if (fs.existsSync(helperPath)) {
+        fs.unlinkSync(helperPath);
+    }
+    // Reset workspace to clean baseline
+    await (0, shell_tools_1.runCommand)('git reset --hard HEAD');
+    await (0, shell_tools_1.runCommand)('git clean -fd');
+    const startTime = Date.now();
+    let success = false;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let timeSeconds = 0;
+    try {
+        // Delegate to Task Agent directly with the specified system prompt override
+        const report = await (0, task_agent_1.runTaskAgent)(benchmarkTask, { systemPrompt });
+        timeSeconds = report.timeSeconds;
+        inputTokens = report.inputTokens;
+        outputTokens = report.outputTokens;
+        // Verify compile
+        const buildRes = await (0, shell_tools_1.runCommand)('npm run build');
+        if (buildRes.exitCode === 0) {
+            success = true;
+        }
+    }
+    catch (err) {
+        // Failed to execute task or compile
+    }
+    finally {
+        // Clean up changes
+        if (fs.existsSync(helperPath)) {
+            fs.unlinkSync(helperPath);
+        }
+        await (0, shell_tools_1.runCommand)('git reset --hard HEAD');
+        await (0, shell_tools_1.runCommand)('git clean -fd');
+    }
+    if (!timeSeconds) {
+        timeSeconds = (Date.now() - startTime) / 1000;
+    }
+    const totalTokens = inputTokens + outputTokens;
+    const score = success ? calculatePromptScore(timeSeconds, totalTokens) : 0;
+    return { success, time: timeSeconds, tokens: totalTokens, score };
+}

package/dist/orchestrator/prompt-optimizer.js

@@ -0,0 +1,169 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPromptOptimization = runPromptOptimization;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const dotenv = __importStar(require("dotenv"));
+const shell_tools_1 = require("../tools/shell-tools");
+const tui_tools_1 = require("../tools/tui-tools");
+const state_manager_1 = require("./state-manager");
+const prompt_benchmark_1 = require("./prompt-benchmark");
+dotenv.config();
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
+const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
+const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
+const FALLBACK_PROMPT = `You are an elite coding agent designed to operate inside a codebase workspace.
+Your primary objective is to fulfill the user's coding tasks accurately and cleanly.
+
+You have access to a set of local tools to read, write, edit files and execute terminal commands.
+Always prefer editing precise parts of files using editFile instead of overwriting the whole file with writeFile unless it is a new file.
+When running commands, verify compilation and test outcomes. If a test fails, you must attempt to fix the issues (Self-Healing).
+
+Be concise and professional. Formulate plans before making changes.`;
+/**
+ * Loads the current baseline system prompt from disk, falling back to a hardcoded default.
+ */
+function loadBaselinePrompt(promptPath) {
+    if (fs.existsSync(promptPath)) {
+        return fs.readFileSync(promptPath, 'utf-8');
+    }
+    return FALLBACK_PROMPT;
+}
+/**
+ * Generates an optimized candidate system prompt using an LLM refinement call.
+ */
+async function generateCandidatePrompt(baselinePrompt) {
+    const anthropic = new sdk_1.default({ apiKey, baseURL });
+    const optimizerPrompt = `You are an expert system prompt engineer. Your goal is to optimize the following system prompt for an autonomous coding agent.
+You need to make the prompt more concise, remove redundancy, and explicitly instruct the agent to reduce token waste and thinking overhead, while ensuring it retains all functionality (using file-tools, rulez, self-healing, compiling, running tests).
+
+Here is the Current System Prompt:
+"""
+${baselinePrompt}
+"""
+
+Provide your output strictly as the new optimized system prompt. Do not write any markdown wrappers (like \`\`\` or \`\`\`txt), explanations, greetings, or conversational headers/footers. Output ONLY the raw optimized system prompt text.`;
+    const response = await anthropic.messages.create({
+        model: defaultModel,
+        max_tokens: 1500,
+        messages: [{ role: 'user', content: optimizerPrompt }]
+    });
+    const block = response.content.find(b => b.type === 'text');
+    if (!block || !block.text) {
+        throw new Error('Failed to retrieve system prompt candidate from LLM.');
+    }
+    return block.text.trim();
+}
+/**
+ * Runs the full prompt optimization and benchmarking pipeline:
+ *  1. Benchmark the baseline prompt
+ *  2. Generate an optimized candidate via LLM
+ *  3. Benchmark the candidate
+ *  4. Compare scores and commit if improved
+ */
+async function runPromptOptimization() {
+    const workspaceRoot = process.cwd();
+    const promptPath = path.join(workspaceRoot, 'src/orchestrator/system-prompt.txt');
+    const baselinePrompt = loadBaselinePrompt(promptPath);
+    // --- Step 1: Benchmark baseline ---
+    console.log(`\n\x1b[35m=== STEP 1: BENCHMARKING BASELINE SYSTEM PROMPT ===\x1b[0m`);
+    const baselineReport = await (0, prompt_benchmark_1.benchmarkPrompt)(baselinePrompt);
+    console.log(`Baseline Prompt Benchmark Result:`);
+    console.log(`- Success: ${baselineReport.success ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m'}`);
+    console.log(`- Time:    ${baselineReport.time.toFixed(1)}s`);
+    console.log(`- Tokens:  ${baselineReport.tokens}`);
+    console.log(`- Score:   ${baselineReport.score.toFixed(2)}`);
+    // --- Step 2: Generate candidate ---
+    console.log(`\n\x1b[35m=== STEP 2: GENERATING OPTIMIZED CANDIDATE SYSTEM PROMPT ===\x1b[0m`);
+    const optimizerSpinner = new tui_tools_1.Spinner('AGP - Optimizer: Refinement model generating optimized system prompt...');
+    optimizerSpinner.start();
+    let candidatePrompt = '';
+    try {
+        candidatePrompt = await generateCandidatePrompt(baselinePrompt);
+        optimizerSpinner.stop(true, 'AGP - Optimizer: Prompt candidate generated.');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        optimizerSpinner.stop(false, 'AGP - Optimizer: Prompt candidate generation failed.');
+        throw new Error(`Prompt Optimization Failed: ${message}`);
+    }
+    console.log('\n\x1b[33m┌── Candidate System Prompt ──────────────────────────────────────────────────────┐\x1b[0m');
+    candidatePrompt.split('\n').forEach(line => console.log(`\x1b[33m│\x1b[0m ${line}`));
+    console.log('\x1b[33m└─────────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
+    // --- Step 3: Benchmark candidate ---
+    console.log(`\x1b[35m=== STEP 3: BENCHMARKING CANDIDATE SYSTEM PROMPT ===\x1b[0m`);
+    const candidateReport = await (0, prompt_benchmark_1.benchmarkPrompt)(candidatePrompt);
+    console.log(`Candidate Prompt Benchmark Result:`);
+    console.log(`- Success: ${candidateReport.success ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m'}`);
+    console.log(`- Time:    ${candidateReport.time.toFixed(1)}s`);
+    console.log(`- Tokens:  ${candidateReport.tokens}`);
+    console.log(`- Score:   ${candidateReport.score.toFixed(2)}`);
+    // --- Step 4: Compare and commit ---
+    console.log(`\x1b[35m=== STEP 4: COMPARING PERFORMANCE METRICS ===\x1b[0m`);
+    console.log(`Baseline Score:  \x1b[1m${baselineReport.score.toFixed(2)}\x1b[0m`);
+    console.log(`Candidate Score: \x1b[1m${candidateReport.score.toFixed(2)}\x1b[0m`);
+    const approved = candidateReport.success && candidateReport.score > baselineReport.score;
+    if (approved) {
+        console.log(`\n\x1b[32;1m[Optimization Approved] Candidate prompt is more efficient. Overwriting system-prompt.txt...\x1b[0m`);
+        fs.writeFileSync(promptPath, candidatePrompt, 'utf-8');
+        // Commit the changes to Git
+        await (0, shell_tools_1.runCommand)('git add src/orchestrator/system-prompt.txt');
+        await (0, shell_tools_1.runCommand)('git commit -m "chore: optimize Task Agent system prompt via automated benchmarking loop"');
+        console.log(`\x1b[32m[Git Status] System prompt snapshot committed to repository HEAD.\x1b[0m`);
+    }
+    else {
+        console.log(`\n\x1b[31;1m[Optimization Rejected] Candidate prompt did not improve performance. Retaining baseline.\x1b[0m`);
+    }
+    (0, state_manager_1.updateEvolutionState)({
+        lastPromptOptimization: {
+            success: candidateReport.success,
+            baselineScore: baselineReport.score,
+            candidateScore: candidateReport.score,
+            approved,
+            time: new Date().toISOString()
+        }
+    });
+    (0, state_manager_1.appendHistory)({
+        cycle: (0, state_manager_1.getEvolutionState)().currentCycle,
+        type: 'prompt_opt',
+        description: `Optimized system prompt. Baseline: ${baselineReport.score.toFixed(2)}, Candidate: ${candidateReport.score.toFixed(2)}`,
+        success: approved
+    });
+}

package/dist/orchestrator/refactor-scanner.js

@@ -0,0 +1,222 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutonomousRefactorProposal = getAutonomousRefactorProposal;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const dotenv = __importStar(require("dotenv"));
+const tui_tools_1 = require("../tools/tui-tools");
+const repo_map_1 = require("../tools/repo-map");
+dotenv.config();
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
+const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
+const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
+/**
+ * Reads the last N lines of the evolution log file.
+ */
+function readRecentEvolutionLog(workspaceRoot, maxLines) {
+    const logPath = path.join(workspaceRoot, 'evolution.log');
+    if (!fs.existsSync(logPath))
+        return '';
+    try {
+        const fullLog = fs.readFileSync(logPath, 'utf-8');
+        const lines = fullLog.split('\n');
+        return lines.slice(-maxLines).join('\n');
+    }
+    catch (e) {
+        return '';
+    }
+}
+/**
+ * Reads the Learnings.md file if present.
+ */
+function readLearnings(workspaceRoot) {
+    const learningsPath = path.join(workspaceRoot, 'Learnings.md');
+    if (!fs.existsSync(learningsPath))
+        return '';
+    try {
+        return fs.readFileSync(learningsPath, 'utf-8');
+    }
+    catch (e) {
+        return '';
+    }
+}
+/**
+ * Step 1: Ask the LLM to select 2 candidate files for refactoring
+ * based on the repo map, logs, and learnings.
+ */
+async function selectCandidateFiles(anthropic, repoMap, evolutionLog, learningsMd) {
+    const candidatePrompt = `You are an expert software architect. Your goal is to select the top 2 files in this codebase that would benefit most from refactoring (improving type-safety, code duplication, helper functions cleanup, or performance).
+Review the codebase map, past evolution logs, and lessons learned.
+
+Codebase Repository Map:
+${repoMap}
+
+Last 40 lines of evolution logs (shows recent runs/warnings/failures):
+${evolutionLog || 'No log history available.'}
+
+Learnings Registry (shows past insights):
+${learningsMd || 'No past learnings recorded.'}
+
+Output your response strictly as a JSON object containing a list of 2 candidate target files (relative paths). Do not include any other text, markdown blocks, or formatting, just the raw JSON.
+
+Format:
+{
+  "candidates": [
+    { "targetFile": "relative/path/to/file1.ts" },
+    { "targetFile": "relative/path/to/file2.ts" }
+  ]
+}`;
+    const response = await anthropic.messages.create({
+        model: defaultModel,
+        max_tokens: 4000,
+        messages: [{ role: 'user', content: candidatePrompt }]
+    });
+    const block = response.content.find(b => b.type === 'text');
+    if (!block || !block.text) {
+        console.error('DEBUG - candidateResponse content:', JSON.stringify(response.content));
+        throw new Error('Failed to retrieve candidates from LLM.');
+    }
+    const text = block.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
+    const json = JSON.parse(text);
+    const candidates = json.candidates || [];
+    if (candidates.length === 0) {
+        throw new Error('No candidates identified by the LLM.');
+    }
+    return candidates;
+}
+/**
+ * Reads the contents of candidate files from disk for context.
+ */
+function readCandidateFileContents(workspaceRoot, candidates) {
+    let fileContext = '';
+    for (const cand of candidates) {
+        const fullPath = path.join(workspaceRoot, cand.targetFile);
+        if (fs.existsSync(fullPath)) {
+            try {
+                const fileContent = fs.readFileSync(fullPath, 'utf-8');
+                fileContext += `\n--- FILE: ${cand.targetFile} ---\n${fileContent}\n`;
+            }
+            catch (e) {
+                fileContext += `\n--- FILE: ${cand.targetFile} (Could not read file contents) ---\n`;
+            }
+        }
+        else {
+            fileContext += `\n--- FILE: ${cand.targetFile} (File not found on disk) ---\n`;
+        }
+    }
+    return fileContext;
+}
+/**
+ * Step 2: Ask the LLM to evaluate the candidate file contents and select the single
+ * best refactoring proposal.
+ */
+async function evaluateAndSelectWinner(anthropic, fileContext) {
+    const evaluationPrompt = `You are an expert software architect. Analyze the actual code content of the candidate files below and select the single best refactoring proposal.
+Evaluate each file and design a specific refactor goal.
+Score each proposal out of 10 based on:
+1. Impact (readability, duplication reduction, safety, performance).
+2. Feasibility (compilation safety, low risk of breaking tests).
+
+Candidate File Contents:
+${fileContext}
+
+Output your response strictly as a JSON object containing the winning proposal's target file and the specific refactoring goal. Do not include any other text, markdown blocks, or formatting, just the raw JSON.
+
+Format:
+{
+  "winningProposal": {
+    "targetFile": "relative/path/to/file.ts",
+    "refactorGoal": "A concise, specific description of the refactoring goal (e.g., 'Refactor search-tools to use strong interfaces instead of any[]')",
+    "impactScore": 8.5,
+    "feasibilityScore": 9.0
+  }
+}`;
+    const response = await anthropic.messages.create({
+        model: defaultModel,
+        max_tokens: 4000,
+        messages: [{ role: 'user', content: evaluationPrompt }]
+    });
+    const block = response.content.find(b => b.type === 'text');
+    if (!block || !block.text) {
+        throw new Error('Failed to retrieve evaluation from LLM.');
+    }
+    const text = block.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
+    const json = JSON.parse(text);
+    const winningProposal = json.winningProposal;
+    if (!winningProposal || !winningProposal.targetFile || !winningProposal.refactorGoal) {
+        throw new Error('Invalid JSON structure returned for winning proposal.');
+    }
+    return {
+        targetFile: winningProposal.targetFile,
+        refactorGoal: winningProposal.refactorGoal
+    };
+}
+/**
+ * Generates a refactoring proposal by scanning the codebase repository map,
+ * evolution logs, and learnings. Uses a two-pass LLM strategy:
+ *  1. Select candidate files
+ *  2. Evaluate actual code and pick the winner
+ */
+async function getAutonomousRefactorProposal() {
+    const workspaceRoot = process.cwd();
+    const repoMap = (0, repo_map_1.generateRepoMap)(workspaceRoot);
+    const scanSpinner = new tui_tools_1.Spinner('AGP - Scan: Auditing codebase structure for optimizations...');
+    scanSpinner.start();
+    // Context gathering
+    const evolutionLog = readRecentEvolutionLog(workspaceRoot, 40);
+    const learningsMd = readLearnings(workspaceRoot);
+    const anthropic = new sdk_1.default({ apiKey, baseURL });
+    try {
+        // Step 1: Select 2 target candidate files
+        const candidates = await selectCandidateFiles(anthropic, repoMap, evolutionLog, learningsMd);
+        // Step 2: Read candidate file contents
+        const fileContext = readCandidateFileContents(workspaceRoot, candidates);
+        // Step 3: Evaluate and select winner
+        const proposal = await evaluateAndSelectWinner(anthropic, fileContext);
+        console.log(`\n\x1b[32m✔\x1b[0m AGP - Scan: Selected best proposal: ${proposal.targetFile}`);
+        scanSpinner.stop(true, 'AGP - Scan: Codebase audit complete.');
+        return proposal;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        scanSpinner.stop(false, 'AGP - Scan: Codebase audit failed.');
+        throw new Error(`Refactoring Analysis Failed: ${message}`);
+    }
+}