@stan-chen/simple-cli 0.2.5 → 0.2.7

package/dist/engine.js

@@ -3,7 +3,7 @@ import { existsSync } from 'fs';
 import { join, relative } from 'path';
 import { pathToFileURL } from 'url';
 import pc from 'picocolors';
-import { text, isCancel } from '@clack/prompts';
+import { text, isCancel, log, spinner } from '@clack/prompts';
 import { LearningManager } from './learnings.js';
 async function getRepoMap(cwd) {
     const files = [];
@@ -36,7 +36,14 @@ export class Context {
     }
     async buildPrompt(tools) {
         const repoMap = await getRepoMap(this.cwd);
-        const toolDefs = Array.from(tools.values()).map(t => `- ${t.name}: ${t.description}`).join('\n');
+        const toolDefs = Array.from(tools.values()).map(t => {
+            const schema = t.inputSchema;
+            if (schema && schema.shape) {
+                const args = Object.keys(schema.shape).join(', ');
+                return `- ${t.name}(${args}): ${t.description}`;
+            }
+            return `- ${t.name}: ${t.description}`;
+        }).join('\n');
         return `${this.skill.systemPrompt}\n\n## Tools\n${toolDefs}\n\n## Repository\n${repoMap}\n\n## Active Files\n${Array.from(this.activeFiles).map(f => relative(this.cwd, f)).join(', ')}`;
     }
 }
@@ -76,7 +83,7 @@ export class Engine {
         await this.registry.loadProjectTools(ctx.cwd);
         while (true) {
             if (!input) {
-                if (!options.interactive)
+                if (!options.interactive || !process.stdout.isTTY)
                     break;
                 const res = await text({ message: pc.cyan('Chat') });
                 if (isCancel(res))
@@ -94,43 +101,81 @@ export class Engine {
                 prompt += `\n\n## Past Learnings\n${learnings.map(l => `- ${l}`).join('\n')}`;
             }
             const response = await this.llm.generate(prompt, ctx.history);
-            const { thought, tool, args, message } = response;
+            const { thought, tool, args, message, tools } = response;
             if (thought)
-                console.log(pc.dim(`💭 ${thought}`));
-            if (tool && tool !== 'none') {
-                const t = this.registry.tools.get(tool);
-                if (t) {
-                    console.log(pc.yellow(`⚙ Executing ${tool}...`));
-                    try {
-                        const result = await t.execute(args);
-                        // Reload tools if create_tool was used
-                        if (tool === 'create_tool') {
-                            await this.registry.loadProjectTools(ctx.cwd);
-                            console.log(pc.magenta('🔄 Tools reloaded.'));
+                log.info(pc.dim(thought));
+            // Determine execution list
+            const executionList = tools && tools.length > 0
+                ? tools
+                : (tool && tool !== 'none' ? [{ tool, args }] : []);
+            if (executionList.length > 0) {
+                let allExecuted = true;
+                for (const item of executionList) {
+                    const tName = item.tool;
+                    const tArgs = item.args;
+                    const t = this.registry.tools.get(tName);
+                    if (t) {
+                        const s = spinner();
+                        s.start(`Executing ${tName}...`);
+                        let toolExecuted = false;
+                        try {
+                            const result = await t.execute(tArgs);
+                            s.stop(`Executed ${tName}`);
+                            toolExecuted = true;
+                            // Reload tools if create_tool was used
+                            if (tName === 'create_tool') {
+                                await this.registry.loadProjectTools(ctx.cwd);
+                                log.success('Tools reloaded.');
+                            }
+                            // Add individual tool execution to history to keep context updated
+                            // We mock a single tool response for history consistency
+                            ctx.history.push({
+                                role: 'assistant',
+                                content: JSON.stringify({ thought: '', tool: tName, args: tArgs })
+                            });
+                            ctx.history.push({ role: 'user', content: `Result: ${JSON.stringify(result)}` });
+                            // --- Supervisor Loop (QA & Reflection) ---
+                            log.step(`[Supervisor] Verifying work from ${tName}...`);
+                            let qaPrompt = `Analyze the result of the tool execution: ${JSON.stringify(result)}. Did it satisfy the user's request: "${input || userHistory.pop()?.content}"? If specific files were mentioned (like flask app), check if they exist or look correct based on the tool output.`;
+                            if (tName === 'delegate_cli') {
+                                qaPrompt += " Since this was delegated to an external CLI, be extra critical. Does the output explicitly confirm file creation?";
+                            }
+                            const qaCheck = await this.llm.generate(qaPrompt, [...ctx.history, { role: 'user', content: qaPrompt }]);
+                            log.step(`[Supervisor] ${qaCheck.message || qaCheck.thought}`);
+                            if (qaCheck.message && qaCheck.message.toLowerCase().includes('fail')) {
+                                log.error(`[Supervisor] QA FAILED for ${tName}. Asking for retry...`);
+                                input = "The previous attempt failed. Please retry or fix the issue.";
+                                allExecuted = false;
+                                break; // Stop batch execution on failure
+                            }
+                            else {
+                                log.success('[Supervisor] QA PASSED. Work verified.');
+                                // Optional: Learnings can be aggregated or skipped for batch to save tokens/time
+                            }
                         }
-                        ctx.history.push({ role: 'assistant', content: JSON.stringify(response) });
-                        ctx.history.push({ role: 'user', content: `Result: ${JSON.stringify(result)}` });
-                        // Reflection: Learning loop
-                        const reflectPrompt = "Analyze the previous tool execution. What went well? What failed? Summarize as a concise learning point for future reference.";
-                        const reflection = await this.llm.generate(reflectPrompt, [...ctx.history, { role: 'user', content: reflectPrompt }]);
-                        if (reflection.message) {
-                            // Find the relevant task description
-                            const userHistory = ctx.history.filter(m => m.role === 'user' && !['Continue.', 'Fix the error.'].includes(m.content));
-                            const task = (input && !['Continue.', 'Fix the error.'].includes(input)) ? input : (userHistory[userHistory.length - 1]?.content || 'Task');
-                            await this.learningManager.add(task, reflection.message);
-                            console.log(pc.blue(`📝 Learning stored: ${reflection.message}`));
+                        catch (e) {
+                            if (!toolExecuted)
+                                s.stop(`Error executing ${tName}`);
+                            else
+                                log.error(`Error during verification: ${e.message}`);
+                            ctx.history.push({ role: 'user', content: `Error executing ${tName}: ${e.message}` });
+                            input = 'Fix the error.';
+                            allExecuted = false;
+                            break;
                         }
-                        input = 'The previous tool execution was successful. Proceed with the next step.';
-                        continue;
-                    }
-                    catch (e) {
-                        ctx.history.push({ role: 'user', content: `Error: ${e.message}` });
-                        input = 'Fix the error.';
-                        continue;
                     }
                 }
+                if (allExecuted) {
+                    input = 'The tool executions were verified. Proceed.';
+                }
+                continue;
+            }
+            if (message || response.raw) {
+                console.log();
+                console.log(pc.blue('Agent:'));
+                console.log(message || response.raw);
+                console.log();
             }
-            console.log(`\n${pc.green('🤖')} ${message || response.raw}\n`);
             ctx.history.push({ role: 'assistant', content: message || response.raw });
             input = undefined;
         }

package/dist/llm.d.ts

@@ -4,15 +4,21 @@ export interface LLMResponse {
     args: any;
     message?: string;
     raw: string;
+    tools?: {
+        tool: string;
+        args: any;
+    }[];
 }
+export type LLMConfig = {
+    provider: string;
+    model: string;
+    apiKey?: string;
+};
 export declare class LLM {
-    private config;
-    constructor(config: {
-        provider: string;
-        model: string;
-        apiKey?: string;
-    });
+    private configs;
+    constructor(config: LLMConfig | LLMConfig[]);
     generate(system: string, history: any[]): Promise<LLMResponse>;
+    private getEnvKey;
     private parse;
 }
 export declare const createLLM: (model?: string) => LLM;

package/dist/llm.js

@@ -1,73 +1,179 @@
-import { spawn } from 'child_process';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
+import { generateText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { jsonrepair } from 'jsonrepair';
-import fs from 'fs';
-const __dirname = dirname(fileURLToPath(import.meta.url));
 export class LLM {
-    config;
+    configs;
     constructor(config) {
-        this.config = config;
+        this.configs = Array.isArray(config) ? config : [config];
     }
     async generate(system, history) {
-        const payload = {
-            ...this.config,
-            messages: [{ role: 'system', content: system }, ...history],
-            api_key: this.config.apiKey || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY || process.env.ANTHROPIC_API_KEY
-        };
-        return new Promise((resolve, reject) => {
-            // Find python bridge
-            let py = join(__dirname, 'anyllm.py');
-            if (!fs.existsSync(py))
-                py = join(process.cwd(), 'src/lib/anyllm.py'); // Fallback
-            // Try to find a working python command
-            const getPyCmd = () => {
-                const isWin = process.platform === 'win32';
-                // On Windows, preferred is 'python' or 'py' if they aren't store aliases
-                // On Linux/Mac, preferred is 'python3'
-                return isWin ? 'python' : 'python3';
-            };
-            const child = spawn(getPyCmd(), [py]);
-            let out = '';
-            let err = '';
-            child.stdout.on('data', d => out += d);
-            child.stderr.on('data', d => err += d);
-            child.on('close', code => {
-                if (code !== 0)
-                    return reject(new Error(err));
-                try {
-                    const res = JSON.parse(out);
-                    if (res.error)
-                        return reject(new Error(res.error));
-                    resolve(this.parse(res.content));
+        let lastError = null;
+        const lastUserMessage = history.filter(m => m.role === 'user').pop()?.content || '';
+        for (const config of this.configs) {
+            try {
+                const providerName = config.provider.toLowerCase();
+                // --- Meta-Orchestrator Delegation (Ralph Mode) ---
+                if (['codex', 'gemini', 'claude'].includes(providerName)) {
+                    console.log(`\n[Ralph] I found an expert for this! specialized agent: ${providerName} CLI...`);
+                    // We return a TOOL call. This ensures the Engine sees an action was taken,
+                    // triggers the execution (which we will define in builtins), and then
+                    // triggers the QA/Reflection loop.
+                    return {
+                        thought: `Task is complex. Delegating to specialized agent: ${providerName}.`,
+                        tool: 'delegate_cli',
+                        args: {
+                            cli: providerName,
+                            task: lastUserMessage
+                        },
+                        message: '', // No message yet, the tool output will provide it
+                        raw: ''
+                    };
+                }
+                // --- Fallback: Internal API Logic ---
+                const modelName = config.model;
+                let model;
+                const apiKey = config.apiKey || this.getEnvKey(providerName);
+                if (providerName === 'openai') {
+                    model = createOpenAI({ apiKey })(modelName);
+                }
+                else if (providerName === 'anthropic') {
+                    model = createAnthropic({ apiKey });
+                    model = model(modelName);
+                }
+                else if (providerName === 'google' || providerName === 'gemini') { // This handles the API fallback if CLI isn't meant
+                    model = createGoogleGenerativeAI({ apiKey });
+                    model = model(modelName);
                 }
-                catch (e) {
-                    reject(e);
+                else {
+                    continue; // Skip unsupported
                 }
-            });
-            child.stdin.write(JSON.stringify(payload));
-            child.stdin.end();
-        });
+                const { text } = await generateText({
+                    model,
+                    system,
+                    messages: history,
+                });
+                return this.parse(text);
+            }
+            catch (e) {
+                lastError = e;
+                console.warn(`[LLM] Provider ${config.provider}:${config.model} failed, trying next...`);
+            }
+        }
+        throw new Error(`All LLM providers failed. Last error: ${lastError?.message}`);
+    }
+    getEnvKey(providerName) {
+        if (providerName === 'openai')
+            return process.env.OPENAI_API_KEY;
+        if (providerName === 'anthropic')
+            return process.env.ANTHROPIC_API_KEY;
+        if (providerName === 'google' || providerName === 'gemini')
+            return process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
+        return undefined;
     }
     parse(raw) {
-        try {
-            const repaired = jsonrepair(raw.trim().match(/\{[\s\S]*\}/)?.[0] || raw);
-            const p = JSON.parse(repaired);
-            return {
-                thought: p.thought || '',
-                tool: (p.tool || p.command || 'none').toLowerCase(),
-                args: p.args || p.parameters || {},
-                message: p.message || '',
-                raw
-            };
+        const tools = [];
+        let thought = '';
+        let message = '';
+        const rawTrimmed = raw.trim();
+        // 1. Attempt to extract multiple JSON objects
+        let braceBalance = 0;
+        let startIndex = -1;
+        let inString = false;
+        let escape = false;
+        for (let i = 0; i < rawTrimmed.length; i++) {
+            const char = rawTrimmed[i];
+            if (inString) {
+                if (escape) {
+                    escape = false;
+                }
+                else if (char === '\\') {
+                    escape = true;
+                }
+                else if (char === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+            }
+            else if (char === '{') {
+                if (braceBalance === 0) {
+                    startIndex = i;
+                }
+                braceBalance++;
+            }
+            else if (char === '}') {
+                braceBalance--;
+                if (braceBalance === 0 && startIndex !== -1) {
+                    const jsonStr = rawTrimmed.substring(startIndex, i + 1);
+                    try {
+                        const repaired = jsonrepair(jsonStr);
+                        const obj = JSON.parse(repaired);
+                        // Extract tool call
+                        if (obj.tool && obj.tool !== 'none') {
+                            tools.push({ tool: obj.tool.toLowerCase(), args: obj.args || obj.parameters || {} });
+                        }
+                        // Aggregate thought and message
+                        if (obj.thought)
+                            thought += (thought ? '\n' : '') + obj.thought;
+                        if (obj.message)
+                            message += (message ? '\n' : '') + obj.message;
+                    }
+                    catch (e) {
+                        // Ignore malformed blocks inside mixed content
+                    }
+                    startIndex = -1;
+                }
+            }
         }
-        catch {
-            return { thought: '', tool: 'none', args: {}, message: raw, raw };
+        // 2. Fallback: If no tools found via loop, try single block extraction (legacy behavior)
+        if (tools.length === 0) {
+            try {
+                const jsonPart = rawTrimmed.match(/\{[\s\S]*\}/)?.[0] || rawTrimmed;
+                const repaired = jsonrepair(jsonPart);
+                const p = JSON.parse(repaired);
+                return {
+                    thought: p.thought || '',
+                    tool: (p.tool || p.command || 'none').toLowerCase(),
+                    args: p.args || p.parameters || {},
+                    message: p.message || '',
+                    raw
+                };
+            }
+            catch {
+                return { thought: '', tool: 'none', args: {}, message: raw, raw };
+            }
         }
+        return {
+            thought: thought.trim(),
+            tool: tools[0]?.tool || 'none',
+            args: tools[0]?.args || {},
+            message: message.trim(),
+            raw,
+            tools
+        };
     }
 }
 export const createLLM = (model) => {
+    // Primary model
     const m = model || process.env.MODEL || 'openai:gpt-5.2-codex';
     const [p, n] = m.includes(':') ? m.split(':') : ['openai', m];
-    return new LLM({ provider: p, model: n });
+    // Define Failover Chain
+    const configs = [{ provider: p, model: n }];
+    // Add fallbacks if they aren't the primary
+    const fallbacks = [
+        { provider: 'anthropic', model: 'claude-3-7-sonnet-latest' },
+        { provider: 'google', model: 'gemini-2.0-flash-001' },
+        { provider: 'openai', model: 'gpt-4o' }
+    ];
+    for (const f of fallbacks) {
+        // Prevent duplicate provider/model combinations
+        if (!(f.provider === p && f.model === n)) {
+            configs.push(f);
+        }
+    }
+    return new LLM(configs);
 };

package/dist/mcp.js

@@ -2,6 +2,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
+import { log } from '@clack/prompts';
 export class MCP {
     clients = new Map();
     async init() {
@@ -20,10 +21,10 @@ export class MCP {
                 });
                 await client.connect(transport);
                 this.clients.set(name, client);
-                console.log(`✓ Connected to MCP: ${name}`);
+                log.success(`Connected to MCP: ${name}`);
             }
             catch (e) {
-                console.error(`✗ Failed to connect to MCP ${name}:`, e);
+                log.error(`Failed to connect to MCP ${name}: ${e}`);
             }
         }
     }

package/dist/scheduler.d.ts

@@ -0,0 +1,23 @@
+export interface ScheduledTask {
+    id: string;
+    cron: string;
+    prompt: string;
+    description: string;
+    lastRun: number;
+    enabled: boolean;
+    failureCount: number;
+}
+export declare class Scheduler {
+    private static instance;
+    private tasks;
+    private filePath;
+    private constructor();
+    static getInstance(cwd?: string): Scheduler;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    scheduleTask(cron: string, prompt: string, description: string): Promise<string>;
+    getDueTasks(): Promise<ScheduledTask[]>;
+    private shouldRun;
+    private matchCron;
+    markTaskRun(id: string, success: boolean): Promise<void>;
+}

package/dist/scheduler.js

@@ -0,0 +1,145 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { existsSync } from 'fs';
+export class Scheduler {
+    static instance;
+    tasks = [];
+    filePath;
+    constructor(cwd) {
+        this.filePath = join(cwd, '.agent', 'scheduler.json');
+    }
+    static getInstance(cwd = process.cwd()) {
+        if (!Scheduler.instance) {
+            Scheduler.instance = new Scheduler(cwd);
+        }
+        return Scheduler.instance;
+    }
+    async load() {
+        if (existsSync(this.filePath)) {
+            try {
+                const content = await readFile(this.filePath, 'utf-8');
+                this.tasks = JSON.parse(content);
+            }
+            catch (e) {
+                console.error('Failed to load scheduler config:', e);
+                this.tasks = [];
+            }
+        }
+        else {
+            this.tasks = [];
+        }
+    }
+    async save() {
+        try {
+            const dir = dirname(this.filePath);
+            if (!existsSync(dir)) {
+                await mkdir(dir, { recursive: true });
+            }
+            await writeFile(this.filePath, JSON.stringify(this.tasks, null, 2));
+        }
+        catch (e) {
+            console.error('Failed to save scheduler config:', e);
+        }
+    }
+    async scheduleTask(cron, prompt, description) {
+        await this.load();
+        const id = Math.random().toString(36).substring(2, 9);
+        this.tasks.push({
+            id,
+            cron,
+            prompt,
+            description,
+            lastRun: Date.now(), // Set to now to avoid immediate catch-up
+            enabled: true,
+            failureCount: 0
+        });
+        await this.save();
+        return id;
+    }
+    async getDueTasks() {
+        await this.load();
+        const now = new Date();
+        const due = [];
+        for (const task of this.tasks) {
+            if (!task.enabled)
+                continue;
+            // Check catch-up (max 24h back)
+            if (this.shouldRun(task, now)) {
+                due.push(task);
+            }
+        }
+        return due;
+    }
+    shouldRun(task, now) {
+        // Start checking from lastRun + 1 minute
+        let cursor = new Date(task.lastRun + 60000);
+        // Safety: don't check more than 24 hours back
+        const cutoff = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+        if (cursor < cutoff)
+            cursor = cutoff;
+        // Align cursor to seconds 0
+        cursor.setSeconds(0, 0);
+        // Iterate minute by minute up to now
+        while (cursor <= now) {
+            if (this.matchCron(task.cron, cursor)) {
+                return true;
+            }
+            cursor = new Date(cursor.getTime() + 60000);
+        }
+        return false;
+    }
+    matchCron(cron, date) {
+        const parts = cron.split(/\s+/);
+        if (parts.length < 5)
+            return false;
+        const [min, hour, day, month, dayWeek] = parts;
+        const check = (val, current) => {
+            if (val === '*')
+                return true;
+            // Handle lists: 1,2,3
+            if (val.includes(',')) {
+                return val.split(',').some(v => check(v, current));
+            }
+            // Handle steps: */5 or 1-10/2
+            if (val.includes('/')) {
+                const [base, step] = val.split('/');
+                const stepNum = parseInt(step);
+                if (isNaN(stepNum))
+                    return false;
+                if (base === '*')
+                    return current % stepNum === 0;
+                // Treat range with step later if needed, simple */n is most common
+                return check(base, current) && (current % stepNum === 0);
+            }
+            // Handle ranges: 1-5
+            if (val.includes('-')) {
+                const [start, end] = val.split('-').map(Number);
+                return current >= start && current <= end;
+            }
+            return parseInt(val) === current;
+        };
+        return check(min, date.getMinutes()) &&
+            check(hour, date.getHours()) &&
+            check(day, date.getDate()) &&
+            check(month, date.getMonth() + 1) &&
+            check(dayWeek, date.getDay());
+    }
+    async markTaskRun(id, success) {
+        await this.load();
+        const task = this.tasks.find(t => t.id === id);
+        if (task) {
+            task.lastRun = Date.now();
+            if (!success) {
+                task.failureCount++;
+                if (task.failureCount >= 3) {
+                    task.enabled = false;
+                    console.warn(`[Scheduler] Task '${task.description}' (${task.id}) has failed 3 times in a row. Auto-disabling (forgetting) it.`);
+                }
+            }
+            else {
+                task.failureCount = 0;
+            }
+            await this.save();
+        }
+    }
+}

package/dist/swarm/remote_worker.d.ts

@@ -0,0 +1,14 @@
+import { Server } from './server.js';
+export declare class RemoteWorker {
+    private server;
+    constructor(server: Server);
+    run(prompt: string): Promise<{
+        status: string;
+        message: string;
+        tool: string;
+    } | {
+        status: string;
+        message: any;
+        tool?: undefined;
+    }>;
+}

package/dist/swarm/remote_worker.js

@@ -0,0 +1,9 @@
+export class RemoteWorker {
+    server;
+    constructor(server) {
+        this.server = server;
+    }
+    async run(prompt) {
+        return this.server.handle(prompt);
+    }
+}

package/dist/swarm/server.d.ts

@@ -0,0 +1,17 @@
+import { Engine } from '../engine.js';
+export declare class Server {
+    private engine;
+    constructor(engine?: Engine);
+    handle(input: string | {
+        tool_name: string;
+        args: any;
+    }): Promise<{
+        status: string;
+        message: string;
+        tool: string;
+    } | {
+        status: string;
+        message: any;
+        tool?: undefined;
+    }>;
+}