@stan-chen/simple-cli 0.2.3 → 0.2.5

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,73 @@
+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
+            // 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));
+                }
+                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 });
+};

package/dist/mcp.d.ts

@@ -0,0 +1,132 @@
+export declare class MCP {
+    private clients;
+    init(): Promise<void>;
+    getTools(): Promise<{
+        execute: (args: any) => Promise<{
+            [x: string]: unknown;
+            content: ({
+                type: "text";
+                text: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "image";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "audio";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "resource";
+                resource: {
+                    uri: string;
+                    text: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                } | {
+                    uri: string;
+                    blob: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                };
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                name: string;
+                type: "resource_link";
+                description?: string | undefined;
+                mimeType?: string | undefined;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                icons?: {
+                    src: string;
+                    mimeType?: string | undefined;
+                    sizes?: string[] | undefined;
+                    theme?: "light" | "dark" | undefined;
+                }[] | undefined;
+                title?: string | undefined;
+            })[];
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+            structuredContent?: Record<string, unknown> | undefined;
+            isError?: boolean | undefined;
+        } | {
+            [x: string]: unknown;
+            toolResult: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        }>;
+        source: "mcp";
+        server: string;
+        inputSchema: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: Record<string, object> | undefined;
+            required?: string[] | undefined;
+        };
+        name: string;
+        description?: string | undefined;
+        outputSchema?: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: Record<string, object> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+        annotations?: {
+            title?: string | undefined;
+            readOnlyHint?: boolean | undefined;
+            destructiveHint?: boolean | undefined;
+            idempotentHint?: boolean | undefined;
+            openWorldHint?: boolean | undefined;
+        } | undefined;
+        execution?: {
+            taskSupport?: "optional" | "required" | "forbidden" | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    }[]>;
+}

package/dist/mcp.js

@@ -0,0 +1,43 @@
+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';
+export class MCP {
+    clients = new Map();
+    async init() {
+        const configPath = join(process.cwd(), 'mcp.json');
+        if (!existsSync(configPath))
+            return;
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const servers = config.mcpServers || config.servers || {};
+        for (const [name, cfg] of Object.entries(servers)) {
+            try {
+                const client = new Client({ name: 'simple-cli', version: '1.0.0' }, { capabilities: {} });
+                const transport = new StdioClientTransport({
+                    command: cfg.command,
+                    args: cfg.args || [],
+                    env: { ...process.env, ...(cfg.env || {}) }
+                });
+                await client.connect(transport);
+                this.clients.set(name, client);
+                console.log(`✓ Connected to MCP: ${name}`);
+            }
+            catch (e) {
+                console.error(`✗ Failed to connect to MCP ${name}:`, e);
+            }
+        }
+    }
+    async getTools() {
+        const all = [];
+        for (const [name, client] of this.clients) {
+            const { tools } = await client.listTools();
+            all.push(...tools.map(t => ({
+                ...t,
+                execute: (args) => client.callTool({ name: t.name, arguments: args }),
+                source: 'mcp',
+                server: name
+            })));
+        }
+        return all;
+    }
+}

package/dist/skills.d.ts

@@ -1,25 +1,14 @@
-/**
- * Skills/Presets System
- * Based on OpenHands skills and Aider prompts
- * Provides specialized behavior presets for different tasks
- */
 export interface Skill {
     name: string;
-    description: string;
+    description?: string;
     systemPrompt: string;
     tools?: string[];
-    modelPreference?: string;
-    autoActions?: string[];
 }
 export declare const builtinSkills: Record<string, Skill>;
-export declare function getActiveSkill(): Skill;
+export declare function loadSkillFromFile(path: string): Promise<Skill | null>;
+export declare function getActiveSkill(cwd?: string): Promise<Skill>;
 export declare function setActiveSkill(name: string): Skill | undefined;
 export declare function listSkills(): Skill[];
-export declare function loadSkillFromFile(path: string): Promise<Skill | null>;
-export declare function saveSkillToFile(skill: Skill, path: string): Promise<void>;
 export declare function loadCustomSkills(dir: string): Promise<Record<string, Skill>>;
-export declare function buildSkillPrompt(skill: Skill, context?: {
-    files?: string[];
-    repoMap?: string;
-    history?: string;
-}): string;
+export declare function buildSkillPrompt(skill: Skill, context?: any): string;
+export declare function saveSkillToFile(skill: Skill, path: string): Promise<void>;