closed-loop-cli 1.0.0

package/dist/tools/search-tools.js

@@ -0,0 +1,271 @@
+"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.searchWeb = searchWeb;
+const https = __importStar(require("https"));
+/**
+ * Strips HTML tags from a string.
+ */
+function stripHtml(text) {
+    return text.replace(/<[^>]*>/g, '').trim();
+}
+/**
+ * Decodes common HTML entities.
+ */
+function decodeEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#x2F;/g, '/')
+        .replace(/&#39;/g, "'");
+}
+/**
+ * Formats results list into a readable string.
+ */
+function formatResults(query, results, source) {
+    let formatted = `Web search results (via ${source}) for: "${query}"\n\n`;
+    results.forEach((res, index) => {
+        formatted += `${index + 1}. ${res.title}\n`;
+        formatted += `   URL: ${res.link}\n`;
+        formatted += `   Snippet: ${res.snippet}\n\n`;
+    });
+    return formatted.trim();
+}
+/**
+ * Searches the web using DuckDuckGo Lite POST interface, falling back to DDG JSON and Wikipedia APIs on failure.
+ */
+async function searchWeb(query) {
+    // 1. Try DuckDuckGo Lite POST
+    try {
+        const results = await fetchDuckDuckGoLite(query);
+        if (results.length > 0) {
+            return formatResults(query, results, 'DuckDuckGo Lite');
+        }
+    }
+    catch (err) {
+        // Ignore and try next fallback
+    }
+    // 2. Try DuckDuckGo Instant Answer JSON API
+    try {
+        const results = await fetchDuckDuckGoApi(query);
+        if (results.length > 0) {
+            return formatResults(query, results, 'DuckDuckGo API');
+        }
+    }
+    catch (err) {
+        // Ignore and try next fallback
+    }
+    // 3. Try Wikipedia Search API
+    try {
+        const results = await fetchWikipedia(query);
+        if (results.length > 0) {
+            return formatResults(query, results, 'Wikipedia');
+        }
+    }
+    catch (err) {
+        // Ignore
+    }
+    return `No search results found for: "${query}". (Web search services are currently rate-limited or unavailable).`;
+}
+/**
+ * DuckDuckGo Lite Scraper
+ */
+function fetchDuckDuckGoLite(query) {
+    return new Promise((resolve, reject) => {
+        const encodedQuery = encodeURIComponent(query);
+        const postData = `q=${encodedQuery}`;
+        const options = {
+            hostname: 'lite.duckduckgo.com',
+            port: 443,
+            path: '/lite/',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Content-Length': Buffer.byteLength(postData),
+                'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5'
+            },
+            timeout: 6000
+        };
+        const req = https.request(options, (res) => {
+            if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+                return reject(new Error(`Status ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const results = parseDuckDuckGoLiteHTML(data);
+                    resolve(results);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', (err) => reject(err));
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Timeout'));
+        });
+        req.write(postData);
+        req.end();
+    });
+}
+function parseDuckDuckGoLiteHTML(html) {
+    const results = [];
+    const resultRegex = /<a[^>]+href="([^"]+)"[^>]+class='result-link'[^>]*>([\s\S]*?)<\/a>[\s\S]*?class='result-snippet'[^>]*>([\s\S]*?)<\/td>/gi;
+    let match;
+    while ((match = resultRegex.exec(html)) !== null && results.length < 8) {
+        const rawLink = match[1];
+        const title = decodeEntities(stripHtml(match[2]));
+        const snippet = decodeEntities(stripHtml(match[3]));
+        if (!title || !snippet)
+            continue;
+        let link = rawLink;
+        if (link.startsWith('//')) {
+            link = 'https:' + link;
+        }
+        if (link.includes('uddg=')) {
+            const uddgMatch = link.match(/uddg=([^&]+)/);
+            if (uddgMatch) {
+                link = decodeURIComponent(uddgMatch[1]);
+            }
+        }
+        results.push({ title, link, snippet });
+    }
+    return results;
+}
+/**
+ * DuckDuckGo Instant Answer API
+ */
+function fetchDuckDuckGoApi(query) {
+    return new Promise((resolve, reject) => {
+        const encodedQuery = encodeURIComponent(query);
+        const url = `https://api.duckduckgo.com/?q=${encodedQuery}&format=json&no_html=1&skip_disambig=1`;
+        const options = {
+            headers: {
+                'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)'
+            },
+            timeout: 5000
+        };
+        https.get(url, options, (res) => {
+            if (res.statusCode !== 200) {
+                return reject(new Error(`Status ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    const results = [];
+                    if (json.AbstractText && json.AbstractURL) {
+                        results.push({
+                            title: json.Heading || query,
+                            link: json.AbstractURL,
+                            snippet: json.AbstractText
+                        });
+                    }
+                    if (json.RelatedTopics && Array.isArray(json.RelatedTopics)) {
+                        for (const topic of json.RelatedTopics) {
+                            if (results.length >= 5)
+                                break;
+                            if (topic.Text && topic.FirstURL) {
+                                results.push({
+                                    title: topic.Text.split(' - ')[0] || 'Topic Details',
+                                    link: topic.FirstURL,
+                                    snippet: topic.Text
+                                });
+                            }
+                        }
+                    }
+                    resolve(results);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }).on('error', (err) => reject(err));
+    });
+}
+/**
+ * Wikipedia Search API
+ */
+function fetchWikipedia(query) {
+    return new Promise((resolve, reject) => {
+        const encodedQuery = encodeURIComponent(query);
+        const url = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodedQuery}&format=json&origin=*`;
+        const options = {
+            headers: {
+                'User-Agent': 'ClosedLoopCodingAgent/1.0 (contact: akara@example.com)'
+            },
+            timeout: 5000
+        };
+        https.get(url, options, (res) => {
+            if (res.statusCode !== 200) {
+                return reject(new Error(`Status ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    const results = [];
+                    if (json.query && Array.isArray(json.query.search)) {
+                        for (const item of json.query.search) {
+                            if (results.length >= 8)
+                                break;
+                            const link = `https://en.wikipedia.org/wiki/${encodeURIComponent(item.title.replace(/ /g, '_'))}`;
+                            const snippet = stripHtml(item.snippet);
+                            results.push({
+                                title: item.title,
+                                link,
+                                snippet
+                            });
+                        }
+                    }
+                    resolve(results);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }).on('error', (err) => reject(err));
+    });
+}

package/dist/tools/shell-tools.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+/**
+ * Executes a terminal command within a specified working directory.
+ * Supports interactive stdin input streams and streams output in real-time.
+ * Safely caps execution time using a timeout.
+ */
+function runCommand(command, cwd = process.cwd(), timeoutMs = 120000 // 2 minutes timeout
+) {
+    return new Promise((resolve) => {
+        const isWindows = process.platform === 'win32';
+        const shell = isWindows ? 'cmd.exe' : '/bin/sh';
+        const args = isWindows ? ['/d', '/s', '/c', command] : ['-c', command];
+        let stdoutData = '';
+        let stderrData = '';
+        let isFinished = false;
+        // Spawn child with stdin inherited so standard keyboard input goes through
+        const child = (0, child_process_1.spawn)(shell, args, {
+            cwd,
+            windowsVerbatimArguments: isWindows,
+            stdio: ['inherit', 'pipe', 'pipe']
+        });
+        const timeout = setTimeout(() => {
+            if (!isFinished) {
+                isFinished = true;
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch (e) { }
+                resolve({
+                    stdout: stdoutData,
+                    stderr: stderrData,
+                    exitCode: 1,
+                    error: `Command timed out after ${timeoutMs}ms.`
+                });
+            }
+        }, timeoutMs);
+        child.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            stdoutData += chunk;
+            process.stdout.write(chunk);
+        });
+        child.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            stderrData += chunk;
+            process.stderr.write(chunk);
+        });
+        child.on('error', (err) => {
+            if (!isFinished) {
+                isFinished = true;
+                clearTimeout(timeout);
+                resolve({
+                    stdout: stdoutData,
+                    stderr: stderrData,
+                    exitCode: 1,
+                    error: err.message
+                });
+            }
+        });
+        child.on('close', (code) => {
+            if (!isFinished) {
+                isFinished = true;
+                clearTimeout(timeout);
+                resolve({
+                    stdout: stdoutData,
+                    stderr: stderrData,
+                    exitCode: code,
+                    error: code !== 0 ? `Command exited with code ${code}` : undefined
+                });
+            }
+        });
+    });
+}

package/dist/tools/skills.js

@@ -0,0 +1,122 @@
+"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.extractAndSaveSkill = extractAndSaveSkill;
+exports.getSkillsSummary = getSkillsSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const dotenv = __importStar(require("dotenv"));
+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]';
+/**
+ * Summarizes the recent successful evolution step and saves it to docs/skills/
+ */
+async function extractAndSaveSkill(task, diffText) {
+    const workspaceRoot = process.cwd();
+    const skillsDir = path.join(workspaceRoot, 'docs', 'skills');
+    if (!fs.existsSync(skillsDir)) {
+        fs.mkdirSync(skillsDir, { recursive: true });
+    }
+    const anthropic = new sdk_1.default({
+        apiKey: apiKey,
+        baseURL: baseURL,
+    });
+    const prompt = `You are a technical documenter. Your task is to analyze the user's refactoring/coding task and the successful git diff, then extract a general reusable development recipe/skill.
+
+Task: "${task}"
+
+Git Diff:
+"""
+${diffText}
+"""
+
+Output your response strictly as a JSON object of a reusable playbook. Do not write any markdown wrappers (like \`\`\`json or \`\`\`), greetings, or conversational headers/footers. Output ONLY the raw JSON.
+
+Format:
+{
+  "id": "hyphenated-lowercase-slug-id",
+  "title": "Clear Action-Oriented Title",
+  "description": "Concise summary of what this recipe achieves",
+  "filesModified": ["src/relative/path/to/file.ts"],
+  "recipe": "Step-by-step general instructions of the technique used, focusing on design patterns, APIs, and syntax."
+}`;
+    try {
+        const response = await anthropic.messages.create({
+            model: defaultModel,
+            max_tokens: 1500,
+            messages: [{ role: 'user', content: prompt }]
+        });
+        const block = response.content.find(b => b.type === 'text');
+        if (block && block.text) {
+            const text = block.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
+            const recipe = JSON.parse(text);
+            const fileName = `${recipe.id}.json`;
+            fs.writeFileSync(path.join(skillsDir, fileName), JSON.stringify(recipe, null, 2), 'utf-8');
+            console.log(`\n\x1b[32m[Skill Registry] Reusable skill saved successfully to docs/skills/${fileName}\x1b[0m`);
+        }
+    }
+    catch (err) {
+        console.error(`\x1b[31m[Skill Registry] Failed to extract skill: ${err.message}\x1b[0m`);
+    }
+}
+/**
+ * Returns a concatenated summary of all available skills for prompt context.
+ */
+function getSkillsSummary() {
+    const workspaceRoot = process.cwd();
+    const skillsDir = path.join(workspaceRoot, 'docs', 'skills');
+    if (!fs.existsSync(skillsDir)) {
+        return 'No custom development skills recorded yet.';
+    }
+    const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.json'));
+    if (files.length === 0) {
+        return 'No custom development skills recorded yet.';
+    }
+    const summaries = [];
+    for (const file of files) {
+        try {
+            const recipe = JSON.parse(fs.readFileSync(path.join(skillsDir, file), 'utf-8'));
+            summaries.push(`- **${recipe.title}** (${recipe.id}): ${recipe.description}\n  Recipe: ${recipe.recipe}`);
+        }
+        catch (e) { }
+    }
+    return summaries.join('\n\n');
+}

package/dist/tools/tui-tools.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+exports.printAgentHeader = printAgentHeader;
+exports.printCollapsibleBlock = printCollapsibleBlock;
+class Spinner {
+    timer = null;
+    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    currentFrame = 0;
+    message;
+    isStarted = false;
+    constructor(message) {
+        this.message = message;
+    }
+    /**
+     * Starts the spinner animation in the terminal.
+     * Hides the terminal cursor for a cleaner look.
+     */
+    start() {
+        if (this.isStarted)
+            return;
+        this.isStarted = true;
+        // Hide cursor
+        process.stdout.write('\x1b[?25l');
+        this.timer = setInterval(() => {
+            const frame = this.frames[this.currentFrame];
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+            // Clear line and write spinner frame with cyan color
+            process.stdout.write(`\r\x1b[36m${frame}\x1b[0m ${this.message}`);
+        }, 80);
+    }
+    /**
+     * Updates the message text displayed alongside the spinner.
+     */
+    update(newMessage) {
+        this.message = newMessage;
+    }
+    /**
+     * Stops the spinner and shows the terminal cursor again.
+     * Prints the final status indicator (green checkmark or red X).
+     */
+    stop(success = true, finalMessage) {
+        if (!this.isStarted)
+            return;
+        this.isStarted = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const msg = finalMessage || this.message;
+        const symbol = success ? '\x1b[32m✔\x1b[0m' : '\x1b[31m✖\x1b[0m';
+        // Clear spinner line, write final result, and restore cursor
+        process.stdout.write(`\r${symbol} ${msg}\n\x1b[?25h`);
+    }
+}
+exports.Spinner = Spinner;
+/**
+ * Prints a beautiful styled header block for the currently active agent.
+ */
+function printAgentHeader(agentRole) {
+    const roles = {
+        architect: { title: 'ARCHITECT / PLANNER', color: '\x1b[35;1m', emoji: '📐' }, // bold magenta
+        coder: { title: 'CODER / IMPLEMENTOR', color: '\x1b[32;1m', emoji: '💻' }, // bold green
+        debugger: { title: 'DIAGNOSTICS & DEBUGGER', color: '\x1b[33;1m', emoji: '🔧' }, // bold yellow
+        gatekeeper: { title: 'GATEKEEPER & REVIEWER', color: '\x1b[36;1m', emoji: '🛡️' } // bold cyan
+    };
+    const details = roles[agentRole.toLowerCase()] || { title: agentRole.toUpperCase(), color: '\x1b[37;1m', emoji: '🤖' };
+    const border = '='.repeat(60);
+    console.log(`\n${details.color}${border}\x1b[0m`);
+    console.log(`${details.color}  ${details.emoji}  ${details.title}\x1b[0m`);
+    console.log(`${details.color}${border}\x1b[0m\n`);
+}
+/**
+ * Renders block contents inside a beautiful box layout with color accents.
+ */
+function printCollapsibleBlock(title, content, color = '\x1b[34m') {
+    console.log(`${color}┌── ${title} ───────────────────────────────────────────────────────────────┐\x1b[0m`);
+    content.split('\n').forEach(line => {
+        console.log(`${color}│\x1b[0m ${line}`);
+    });
+    console.log(`${color}└───────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n`);
+}