@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/cli.js

@@ -1,287 +1,45 @@
 #!/usr/bin/env node
-/**
- * Simple-CLI - Premium TUI agentic coding assistant
- * Powered by @clack/prompts.
- */
 import 'dotenv/config';
-import { text, confirm as clackConfirm, isCancel, select } from '@clack/prompts';
-import pc from 'picocolors';
-import { getContextManager } from './context.js';
-import { createProvider } from './providers/index.js';
-import { createMultiProvider } from './providers/multi.js';
-import { routeTask, loadTierConfig } from './router.js';
-import { executeCommand } from './commands.js';
-import { getMCPManager } from './mcp/manager.js';
-import { listSkills, setActiveSkill, getActiveSkill } from './skills.js';
 import { statSync } from 'fs';
-import { resolve } from 'path';
-import { runSwarm, parseSwarmArgs, printSwarmHelp } from './commands/swarm.js';
-import { jsonrepair } from 'jsonrepair';
-// CLI flags
-const YOLO_MODE = process.argv.includes('--yolo');
-const MOE_MODE = process.argv.includes('--moe');
-const SWARM_MODE = process.argv.includes('--swarm');
-const CLAW_MODE = process.argv.includes('--claw') || process.argv.includes('-claw');
-const DEBUG = process.argv.includes('--debug') || process.env.DEBUG === 'true';
-const VERSION = '0.2.2';
-// Handle --version and --help immediately
-if (process.argv.includes('--version') || process.argv.includes('-v')) {
-    console.log(`Simple-CLI v${VERSION}`);
-    process.exit(0);
-}
-if (process.argv.includes('--help') || process.argv.includes('-h')) {
-    console.log(`
-  ${pc.bgCyan(pc.black(' SIMPLE-CLI '))} ${pc.dim(`v${VERSION}`)}
-
-  ${pc.bold('Usage:')}
-    simple [target_dir] [prompt] [options]
-
-  ${pc.bold('Options:')}
-    --version, -v      Show version
-    --help, -h         Show help
-    --yolo             Skip all confirmation prompts
-    --moe              Enable Mixture of Experts (multi-model)
-    --swarm            Enable Swarm orchestration mode
-    --claw "intent"    Enable OpenClaw JIT agent generation
-    --debug            Enable debug logging
-
-  ${pc.bold('Examples:')}
-    simple . "Build a login page"
-    simple --claw "Security audit this project"
-    simple --moe "Refactor this entire folder"
-  `);
-    process.exit(0);
-}
-// Handle --claw mode (JIT Agent Generation)
-if (CLAW_MODE) {
-    const { execSync } = await import('child_process');
-    const args = process.argv.slice(2).filter(a => !a.startsWith('-'));
-    const intent = args.join(' ') || 'unspecified task';
-    console.log(pc.cyan('🧬 Initiating JIT Agent Generation...'));
-    console.log(pc.dim(`Intent: "${intent}"`));
-    try {
-        const output = execSync(`npx tsx tools/claw.ts run clawJit intent="${intent}"`, {
-            cwd: process.cwd(),
-            encoding: 'utf-8',
-            stdio: 'inherit'
-        });
-        console.log(pc.green('\n✅ JIT Agent ready. Run `simple` to begin.'));
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(pc.red('❌ Failed to initialize Claw mode:'), error);
-        process.exit(1);
-    }
-}
-// Handle --swarm mode
-if (SWARM_MODE) {
-    if (process.argv.includes('--help')) {
-        printSwarmHelp();
-        process.exit(0);
-    }
-    const swarmOptions = parseSwarmArgs(process.argv.slice(2));
-    swarmOptions.yolo = swarmOptions.yolo || YOLO_MODE;
-    runSwarm(swarmOptions).catch(err => {
-        console.error('Swarm error:', err);
-        process.exit(1);
-    });
-}
-else {
-    main().catch(console.error);
-}
-function parseResponse(response) {
-    const thought = response.match(/<thought>([\s\S]*?)<\/thought>/)?.[1]?.trim() || '';
-    const jsonMatch = response.match(/\{[\s\S]*"tool"[\s\S]*\}/);
-    let action = { tool: 'none', message: '', args: {} };
-    if (jsonMatch) {
-        try {
-            action = JSON.parse(jsonrepair(jsonMatch[0]));
-        }
-        catch { /* skip */ }
-    }
-    return { thought, action };
-}
-async function confirm(tool, args, ctx) {
-    if (YOLO_MODE)
-        return true;
-    const t = ctx.getTools().get(tool);
-    if (!t || t.permission === 'read')
-        return true;
-    const confirmed = await clackConfirm({
-        message: `Allow ${pc.cyan(tool)} with args ${pc.dim(JSON.stringify(args))}?`,
-        initialValue: true,
-    });
-    return !isCancel(confirmed) && confirmed;
-}
-async function executeTool(name, args, ctx) {
-    const tool = ctx.getTools().get(name);
-    if (!tool)
-        return `Error: Tool "${name}" not found`;
-    try {
-        const result = await tool.execute(args);
-        return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-    }
-    catch (error) {
-        return `Error: ${error instanceof Error ? error.message : error}`;
-    }
-}
+import { Engine, Context, Registry } from './engine.js';
+import { allBuiltins } from './builtins.js';
+import { createLLM } from './llm.js';
+import { MCP } from './mcp.js';
+import { getActiveSkill } from './skills.js';
+import { showBanner } from './tui.js';
 async function main() {
-    console.clear();
-    const args = process.argv.slice(2).filter(arg => !arg.startsWith('-'));
-    let targetDir = process.cwd();
-    if (args.length > 0) {
-        try {
-            if (statSync(args[0]).isDirectory()) {
-                targetDir = resolve(args[0]);
-                process.chdir(targetDir);
-                // Reload .env from the new directory
-                const { config } = await import('dotenv');
-                config();
-                args.shift();
-            }
-        }
-        catch { /* ignored */ }
-    }
-    console.log(`\n ${pc.bgCyan(pc.black(' SIMPLE-CLI '))} ${pc.dim(`v${VERSION}`)} ${pc.green('●')} ${pc.cyan(targetDir)}\n`);
-    console.log(`${pc.dim('○')} Initializing...`);
-    const ctx = getContextManager(targetDir);
-    await ctx.initialize();
-    console.log(`${pc.green('●')} Ready.`);
-    const mcpManager = getMCPManager();
-    try {
-        const configs = await mcpManager.loadConfig();
-        if (configs.length > 0)
-            await mcpManager.connectAll(configs);
-    }
-    catch (error) {
-        if (DEBUG)
-            console.error('MCP init error:', error);
-    }
-    const tierConfigs = MOE_MODE ? loadTierConfig() : null;
-    const multiProvider = tierConfigs ? createMultiProvider(tierConfigs) : null;
-    const singleProvider = !MOE_MODE ? createProvider() : null;
-    const generate = async (input) => {
-        const history = ctx.getHistory();
-        const fullPrompt = await ctx.buildSystemPrompt();
-        if (MOE_MODE && multiProvider && tierConfigs) {
-            const routing = await routeTask(input, async (prompt) => {
-                return multiProvider.generateWithTier(1, prompt, [{ role: 'user', content: input }]);
-            });
-            if (DEBUG)
-                console.log(pc.dim(`[Routing] Tier: ${routing.tier}`));
-            return multiProvider.generateWithTier(routing.tier, fullPrompt, history.map(m => ({ role: m.role, content: m.content })));
-        }
-        return singleProvider.generateResponse(fullPrompt, history.map(m => ({ role: m.role, content: m.content })));
-    };
-    let isFirstPrompt = true;
-    while (true) {
-        const skill = getActiveSkill();
-        let input;
-        // Support initial prompt from command line
-        if (isFirstPrompt && args.length > 0) {
-            input = args.join(' ');
-            console.log(`\n${pc.magenta('➤')} ${pc.bold(input)}`);
-        }
-        else {
-            input = await text({
-                message: pc.dim(`[@${skill.name}]`) + ' Chat with Simple-CLI',
-                placeholder: 'Ask anything or use /help',
-                validate(value) {
-                    if (value.trim().length === 0)
-                        return 'Input required';
-                }
-            });
-        }
-        isFirstPrompt = false;
-        if (isCancel(input)) {
-            console.log(`\n${pc.dim('—')} Goodbye!`);
-            mcpManager.disconnectAll();
-            process.exit(0);
-        }
-        const trimmedInput = input.trim();
-        // Slash command
-        if (trimmedInput.startsWith('/')) {
-            try {
-                await executeCommand(trimmedInput, {
-                    cwd: ctx.getCwd(),
-                    activeFiles: ctx.getState().activeFiles,
-                    readOnlyFiles: ctx.getState().readOnlyFiles,
-                    history: ctx.getHistory(),
-                    io: {
-                        output: (m) => console.log(`\n${pc.dim('○')} ${m}`),
-                        error: (m) => console.log(`\n${pc.red('✖')} ${m}`),
-                        confirm: async (m) => {
-                            const c = await clackConfirm({ message: m });
-                            return !isCancel(c) && c;
-                        },
-                        prompt: async (m) => {
-                            const p = await text({ message: m });
-                            return isCancel(p) ? '' : p;
-                        }
-                    }
-                });
-            }
-            catch (err) {
-                console.log(`\n${pc.red('✖')} ${pc.red(String(err))}`);
-            }
-            continue;
-        }
-        // Skill switching
-        if (trimmedInput.startsWith('@')) {
-            const skillName = trimmedInput.slice(1).trim();
-            if (skillName === 'list') {
-                const skills = listSkills();
-                const selected = await select({
-                    message: 'Select a skill',
-                    options: skills.map(s => ({ label: `@${s.name} - ${s.description}`, value: s.name }))
-                });
-                if (!isCancel(selected)) {
-                    const newSkill = setActiveSkill(selected);
-                    if (newSkill)
-                        ctx.setSkill(newSkill);
-                }
-            }
-            else {
-                const newSkill = setActiveSkill(skillName);
-                if (newSkill) {
-                    ctx.setSkill(newSkill);
-                    console.log(`\n${pc.cyan('★')} Switched to @${newSkill.name}`);
-                }
-                else {
-                    console.log(`\n${pc.red('✖')} Skill @${skillName} not found.`);
-                }
-            }
+    const args = process.argv.slice(2);
+    // Handle optional directory argument
+    let cwd = process.cwd();
+    let interactive = true;
+    const remainingArgs = [];
+    for (const arg of args) {
+        if (arg === '--non-interactive') {
+            interactive = false;
             continue;
         }
-        ctx.addMessage('user', trimmedInput);
-        let steps = 0;
-        while (steps < 15) {
-            const response = await generate(trimmedInput);
-            const { thought, action } = parseResponse(response);
-            if (thought)
-                console.log(`\n${pc.dim('💭')} ${pc.cyan(thought)}`);
-            if (action.tool !== 'none') {
-                if (await confirm(action.tool, action.args || {}, ctx)) {
-                    console.log(`${pc.yellow('⚙')} ${pc.dim(`Executing ${action.tool}...`)}`);
-                    const result = await executeTool(action.tool, action.args || {}, ctx);
-                    console.log(`${pc.green('✔')} ${pc.dim(result.length > 500 ? result.slice(0, 500) + '...' : result)}`);
-                    ctx.addMessage('assistant', response);
-                    ctx.addMessage('user', `Tool result: ${result}`);
-                    steps++;
-                }
-                else {
-                    console.log(`${pc.yellow('⚠')} Skipped.`);
-                    ctx.addMessage('assistant', response);
-                    break;
+        if (!arg.startsWith('-')) {
+            try {
+                if (statSync(arg).isDirectory()) {
+                    cwd = arg;
+                    process.chdir(cwd);
+                    continue;
                 }
             }
-            else {
-                const msg = action.message || response.replace(/<thought>[\s\S]*?<\/thought>/, '').trim();
-                if (msg)
-                    console.log(`\n${pc.magenta('✦')} ${msg}`);
-                ctx.addMessage('assistant', response);
-                break;
-            }
-        }
-    }
-}
+            catch { }
+        }
+        remainingArgs.push(arg);
+    }
+    const prompt = remainingArgs.filter(a => !a.startsWith('-')).join(' ');
+    const registry = new Registry();
+    allBuiltins.forEach(t => registry.tools.set(t.name, t));
+    await registry.loadProjectTools(cwd);
+    const mcp = new MCP();
+    const provider = createLLM();
+    const engine = new Engine(provider, registry, mcp);
+    const skill = await getActiveSkill(cwd);
+    const ctx = new Context(cwd, skill);
+    showBanner();
+    await engine.run(ctx, prompt || undefined, { interactive });
+}
+main().catch(console.error);

package/dist/engine.d.ts

@@ -0,0 +1,33 @@
+import { MCP } from './mcp.js';
+import { Skill } from './skills.js';
+export interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    execute: (args: any) => Promise<any>;
+}
+export declare class Context {
+    history: Message[];
+    activeFiles: Set<string>;
+    cwd: string;
+    skill: Skill;
+    constructor(cwd: string, skill: Skill);
+    buildPrompt(tools: Map<string, Tool>): Promise<string>;
+}
+export declare class Registry {
+    tools: Map<string, Tool>;
+    loadProjectTools(cwd: string): Promise<void>;
+}
+export declare class Engine {
+    private llm;
+    private registry;
+    private mcp;
+    private learningManager;
+    constructor(llm: any, registry: Registry, mcp: MCP);
+    run(ctx: Context, initialPrompt?: string, options?: {
+        interactive: boolean;
+    }): Promise<void>;
+}

package/dist/engine.js

@@ -0,0 +1,138 @@
+import { readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, relative } from 'path';
+import { pathToFileURL } from 'url';
+import pc from 'picocolors';
+import { text, isCancel } from '@clack/prompts';
+import { LearningManager } from './learnings.js';
+async function getRepoMap(cwd) {
+    const files = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            if (['node_modules', '.git', 'dist'].includes(e.name))
+                continue;
+            const res = join(dir, e.name);
+            if (e.isDirectory())
+                await walk(res);
+            else if (['.ts', '.js', '.py', '.md'].includes(res.slice(-3)))
+                files.push(relative(cwd, res));
+        }
+    }
+    try {
+        await walk(cwd);
+    }
+    catch { }
+    return files.slice(0, 50).join('\n');
+}
+export class Context {
+    history = [];
+    activeFiles = new Set();
+    cwd;
+    skill;
+    constructor(cwd, skill) {
+        this.cwd = cwd;
+        this.skill = skill;
+    }
+    async buildPrompt(tools) {
+        const repoMap = await getRepoMap(this.cwd);
+        const toolDefs = Array.from(tools.values()).map(t => `- ${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(', ')}`;
+    }
+}
+export class Registry {
+    tools = new Map();
+    async loadProjectTools(cwd) {
+        const dir = join(cwd, '.agent', 'tools');
+        if (!existsSync(dir))
+            return;
+        for (const f of await readdir(dir)) {
+            if (f.endsWith('.ts') || f.endsWith('.js')) {
+                const mod = await import(pathToFileURL(join(dir, f)).href);
+                const t = mod.tool || mod.default;
+                if (t?.name)
+                    this.tools.set(t.name, t);
+            }
+        }
+    }
+}
+export class Engine {
+    llm;
+    registry;
+    mcp;
+    learningManager;
+    constructor(llm, registry, mcp) {
+        this.llm = llm;
+        this.registry = registry;
+        this.mcp = mcp;
+        this.learningManager = new LearningManager(process.cwd());
+    }
+    async run(ctx, initialPrompt, options = { interactive: true }) {
+        await this.learningManager.load();
+        let input = initialPrompt;
+        await this.mcp.init();
+        (await this.mcp.getTools()).forEach(t => this.registry.tools.set(t.name, t));
+        // Ensure tools are loaded for the context cwd
+        await this.registry.loadProjectTools(ctx.cwd);
+        while (true) {
+            if (!input) {
+                if (!options.interactive)
+                    break;
+                const res = await text({ message: pc.cyan('Chat') });
+                if (isCancel(res))
+                    break;
+                input = res;
+            }
+            ctx.history.push({ role: 'user', content: input });
+            // RAG: Inject learnings
+            let prompt = await ctx.buildPrompt(this.registry.tools);
+            const userHistory = ctx.history.filter(m => m.role === 'user' && !['Continue.', 'Fix the error.'].includes(m.content));
+            const lastUserMsg = userHistory[userHistory.length - 1]?.content || '';
+            const query = (input && !['Continue.', 'Fix the error.'].includes(input)) ? input : lastUserMsg;
+            const learnings = await this.learningManager.search(query);
+            if (learnings.length > 0) {
+                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;
+            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.'));
+                        }
+                        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}`));
+                        }
+                        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;
+                    }
+                }
+            }
+            console.log(`\n${pc.green('🤖')} ${message || response.raw}\n`);
+            ctx.history.push({ role: 'assistant', content: message || response.raw });
+            input = undefined;
+        }
+    }
+}

package/dist/learnings.d.ts

@@ -0,0 +1,15 @@
+export interface Learning {
+    id: string;
+    task: string;
+    reflection: string;
+    timestamp: number;
+}
+export declare class LearningManager {
+    private learnings;
+    private path;
+    constructor(cwd: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    add(task: string, reflection: string): Promise<void>;
+    search(query: string): Promise<string[]>;
+}

package/dist/learnings.js

@@ -0,0 +1,54 @@
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+export class LearningManager {
+    learnings = [];
+    path;
+    constructor(cwd) {
+        const agentDir = join(cwd, '.agent');
+        if (!existsSync(agentDir)) {
+            try {
+                mkdirSync(agentDir, { recursive: true });
+            }
+            catch { }
+        }
+        this.path = join(agentDir, 'learnings.json');
+    }
+    async load() {
+        if (!existsSync(this.path))
+            return;
+        try {
+            const data = await readFile(this.path, 'utf-8');
+            this.learnings = JSON.parse(data);
+        }
+        catch {
+            this.learnings = [];
+        }
+    }
+    async save() {
+        await writeFile(this.path, JSON.stringify(this.learnings, null, 2));
+    }
+    async add(task, reflection) {
+        this.learnings.push({
+            id: Date.now().toString(),
+            task,
+            reflection,
+            timestamp: Date.now()
+        });
+        await this.save();
+    }
+    async search(query) {
+        if (!query)
+            return [];
+        const keywords = query.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+        if (keywords.length === 0)
+            return [];
+        return this.learnings
+            .filter(l => {
+            const text = (l.task + ' ' + l.reflection).toLowerCase();
+            return keywords.some(k => text.includes(k));
+        })
+            .map(l => l.reflection)
+            .slice(0, 5);
+    }
+}

package/dist/llm.d.ts

@@ -0,0 +1,18 @@
+export interface LLMResponse {
+    thought: string;
+    tool: string;
+    args: any;
+    message?: string;
+    raw: string;
+}
+export declare class LLM {
+    private config;
+    constructor(config: {
+        provider: string;
+        model: string;
+        apiKey?: string;
+    });
+    generate(system: string, history: any[]): Promise<LLMResponse>;
+    private parse;
+}
+export declare const createLLM: (model?: string) => LLM;

package/dist/llm.js

@@ -0,0 +1,66 @@
+import { spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { jsonrepair } from 'jsonrepair';
+import fs from 'fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class LLM {
+    config;
+    constructor(config) {
+        this.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
+            const child = spawn('python3', [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));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            child.stdin.write(JSON.stringify(payload));
+            child.stdin.end();
+        });
+    }
+    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
+            };
+        }
+        catch {
+            return { thought: '', tool: 'none', args: {}, message: raw, raw };
+        }
+    }
+}
+export const createLLM = (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 });
+};