@stan-chen/simple-cli 0.2.3 → 0.2.4

package/dist/providers/multi.js

@@ -1,28 +0,0 @@
-/**
- * Multi-Provider: Manages multiple LLM models for MoE routing via LiteLLM
- * Each tier can use a different model from any provider
- */
-import { createProviderForModel } from './index.js';
-// Create multi-provider system using LiteLLM
-export const createMultiProvider = (tierConfigs) => {
-    const providerCache = new Map();
-    const getProvider = (tier) => {
-        const cached = providerCache.get(tier);
-        if (cached)
-            return cached;
-        const config = tierConfigs.get(tier);
-        if (!config) {
-            throw new Error(`No configuration for tier ${tier}`);
-        }
-        const provider = createProviderForModel(config.model);
-        providerCache.set(tier, provider);
-        return provider;
-    };
-    return {
-        getProvider,
-        generateWithTier: async (tier, systemPrompt, messages) => {
-            const provider = getProvider(tier);
-            return provider.generateResponse(systemPrompt, messages);
-        }
-    };
-};

package/dist/registry.d.ts

@@ -1,29 +0,0 @@
-/**
- * Tool Registry: Auto-imports tools from src/tools/, skills/, and scripts/
- * Supports built-in tools, MCP tools, and project-specific custom tools
- */
-import { z } from 'zod';
-export type Permission = 'read' | 'write' | 'execute';
-export interface Tool {
-    name: string;
-    description: string;
-    permission: Permission;
-    inputSchema: z.ZodType;
-    execute: (args: Record<string, unknown>) => Promise<unknown>;
-    source?: 'builtin' | 'mcp' | 'project';
-    serverName?: string;
-    specification?: string;
-}
-export type { Tool as ToolModule };
-/**
- * Parses a tool definition from a Markdown file (.md) or string
- * Supports YAML frontmatter as per OpenClaw PRD.
- */
-export declare function getMeta(content: string, filename: string): any;
-export declare const loadTools: () => Promise<Map<string, Tool>>;
-export declare const loadAllTools: () => Promise<Map<string, Tool>>;
-export declare const getToolDefinitions: (tools: Map<string, Tool>) => string;
-export declare const validateToolArgs: (tool: Tool, args: unknown) => {
-    valid: boolean;
-    error?: string;
-};

package/dist/registry.js

@@ -1,443 +0,0 @@
-/**
- * Tool Registry: Auto-imports tools from src/tools/, skills/, and scripts/
- * Supports built-in tools, MCP tools, and project-specific custom tools
- */
-import { readdir, readFile, stat } from 'fs/promises';
-import { spawn } from 'child_process';
-import { join, dirname, basename, extname } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { z } from 'zod';
-import { getMCPManager } from './mcp/manager.js';
-import YAML from 'yaml';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const TOOLS_DIR = join(__dirname, 'tools');
-/**
- * Extract documentation from the beginning of a file (comments)
- */
-function extractDocFromComments(content) {
-    const lines = content.split('\n');
-    let doc = '';
-    let inDoc = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('/**') || trimmed.startsWith('"""')) {
-            inDoc = true;
-            continue;
-        }
-        if (inDoc && (trimmed.endsWith('*/') || trimmed.endsWith('"""'))) {
-            inDoc = false;
-            break;
-        }
-        if (inDoc) {
-            doc += trimmed.replace(/^\* ?/, '') + '\n';
-        }
-        else if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
-            doc += trimmed.replace(/^(\/\/|#) ?/, '') + '\n';
-        }
-        else if (trimmed && !trimmed.startsWith('import') && !trimmed.startsWith('from')) {
-            break;
-        }
-    }
-    return doc.trim();
-}
-/**
- * Parses a tool definition from a Markdown file (.md) or string
- * Supports YAML frontmatter as per OpenClaw PRD.
- */
-export function getMeta(content, filename) {
-    let meta = {
-        name: basename(filename, extname(filename)),
-        description: '',
-        command: '',
-        parameters: {},
-        permission: 'execute'
-    };
-    // 1. Try YAML frontmatter (OpenClaw style)
-    if (content.startsWith('---')) {
-        const end = content.indexOf('---', 3);
-        if (end > -1) {
-            try {
-                const yamlStr = content.slice(3, end);
-                const yamlMeta = YAML.parse(yamlStr);
-                if (yamlMeta) {
-                    return { ...meta, ...yamlMeta };
-                }
-            }
-            catch {
-                // Fall back to manual parsing if YAML fails
-            }
-        }
-    }
-    // 2. Fallback to manual Markdown section parsing
-    const lines = content.split('\n');
-    let currentSection = '';
-    for (const line of lines) {
-        if (line.startsWith('# ')) {
-            meta.name = line.replace('# ', '').trim();
-        }
-        else if (line.startsWith('## ')) {
-            currentSection = line.replace('## ', '').trim().toLowerCase();
-        }
-        else if (currentSection === 'command' && line.trim()) {
-            meta.command = line.trim();
-        }
-        else if (currentSection === 'parameters' && line.trim().startsWith('- ')) {
-            const match = line.match(/- (\w+): (\w+)(?: - (.+))?/);
-            if (match) {
-                meta.parameters[match[1]] = { type: match[2], description: match[3] || '' };
-            }
-        }
-        else if (!currentSection && line.trim() && !line.startsWith('#')) {
-            meta.description += line.trim() + ' ';
-        }
-    }
-    meta.description = meta.description.trim();
-    return meta;
-}
-// Helper to create a Tool from metadata (JSON or MD)
-function createScriptTool(meta, source, spec) {
-    let inputSchema = z.object({}).passthrough();
-    if (meta.parameters && typeof meta.parameters === 'object') {
-        const shape = {};
-        for (const [key, param] of Object.entries(meta.parameters)) {
-            const p = param;
-            let schema = z.string();
-            if (p.type === 'number' || p === 'number')
-                schema = z.number();
-            else if (p.type === 'boolean' || p === 'boolean')
-                schema = z.boolean();
-            else if (p.type === 'array' || p === 'array')
-                schema = z.array(z.any());
-            else if (p.type === 'object' || p === 'object')
-                schema = z.object({}).passthrough();
-            if (typeof p === 'object' && p.description) {
-                schema = schema.describe(p.description);
-            }
-            shape[key] = schema;
-        }
-        inputSchema = z.object(shape).passthrough();
-    }
-    return {
-        name: meta.name,
-        description: meta.description || `Script tool: ${meta.command}`,
-        permission: meta.permission || 'execute',
-        inputSchema,
-        source,
-        specification: spec,
-        execute: async (args) => {
-            return new Promise((resolve, reject) => {
-                let finalCommand = meta.command;
-                const isWindows = process.platform === 'win32';
-                if (isWindows && finalCommand.endsWith('.ps1')) {
-                    finalCommand = `powershell -ExecutionPolicy Bypass -File ${finalCommand}`;
-                }
-                const env = { ...process.env, TOOL_INPUT: JSON.stringify(args) };
-                // Pass arguments as INPUT_{NAME} for OpenClaw parity
-                for (const [key, value] of Object.entries(args)) {
-                    env[`INPUT_${key.toUpperCase()}`] = typeof value === 'string' ? value : JSON.stringify(value);
-                }
-                const child = spawn(finalCommand, {
-                    shell: true,
-                    cwd: process.cwd(),
-                    env,
-                });
-                let stdout = '';
-                let stderr = '';
-                child.stdout?.on('data', (data) => stdout += data.toString());
-                child.stderr?.on('data', (data) => stderr += data.toString());
-                child.on('close', (code) => {
-                    if (code === 0)
-                        resolve(stdout.trim());
-                    else
-                        reject(new Error(`Exit ${code}: ${stderr.trim()}`));
-                });
-                child.stdin?.write(JSON.stringify(args));
-                child.stdin?.end();
-            });
-        }
-    };
-}
-/**
- * Recursively search for a documentation file (.md or .json) for a given tool name
- */
-async function findDocInDir(dir, baseName) {
-    const files = await readdir(dir);
-    for (const f of files) {
-        if (basename(f, extname(f)) === baseName && (f.endsWith('.md') || f.endsWith('.json') || f.endsWith('.txt'))) {
-            const content = await readFile(join(dir, f), 'utf-8');
-            return { content, file: f };
-        }
-    }
-    return null;
-}
-// Helper to load tools from a specific directory (recursive)
-async function loadToolsFromDir(dir, source) {
-    const tools = new Map();
-    try {
-        const items = await readdir(dir);
-        for (const item of items) {
-            const fullPath = join(dir, item);
-            const s = await stat(fullPath);
-            if (s.isDirectory()) {
-                // Recursive call for subdirectories
-                const subTools = await loadToolsFromDir(fullPath, source);
-                for (const [name, tool] of subTools) {
-                    tools.set(name, tool);
-                }
-                // Special case: Folder named ' heavy_lifting' might have 'heavy_lifting.md' inside it
-                if (!tools.has(item)) {
-                    const doc = await findDocInDir(fullPath, item);
-                    if (doc && doc.file.endsWith('.md')) {
-                        const meta = getMeta(doc.content, doc.file);
-                        if (meta && meta.command) {
-                            tools.set(meta.name, createScriptTool(meta, source, doc.content));
-                        }
-                    }
-                }
-                continue;
-            }
-            const ext = extname(item);
-            const base = basename(item, ext);
-            // 1. Native Node tools
-            if (ext === '.ts' || ext === '.js' || ext === '.mjs') {
-                if (item.includes('.test.'))
-                    continue;
-                try {
-                    // Peek at file content to see if it looks like a module with exports
-                    // This avoids executing scripts with top-level side effects during import
-                    const content = await readFile(fullPath, 'utf-8');
-                    if (!content.includes('export ')) {
-                        // Fall through to Case 2 (Generic Script)
-                    }
-                    else {
-                        const module = await import(pathToFileURL(fullPath).href);
-                        const toolDef = module.tool || module;
-                        if (toolDef.name && toolDef.execute) {
-                            const schema = toolDef.inputSchema || toolDef.schema;
-                            tools.set(toolDef.name, {
-                                name: toolDef.name,
-                                description: toolDef.description || 'No description',
-                                permission: toolDef.permission || 'read',
-                                inputSchema: schema || z.object({}),
-                                execute: toolDef.execute,
-                                source,
-                            });
-                            continue;
-                        }
-                    }
-                }
-                catch { /* might be a script, fall through */ }
-            }
-            // 2. Generic Script with internal docs or companion meta file
-            if (ext !== '.md' && ext !== '.txt' && ext !== '.json') {
-                try {
-                    const content = await readFile(fullPath, 'utf-8');
-                    const internalDoc = extractDocFromComments(content);
-                    // Check for companion meta file in the SAME directory
-                    const companion = await findDocInDir(dir, base);
-                    let meta = null;
-                    let specContent = internalDoc;
-                    if (companion) {
-                        if (companion.file.endsWith('.json')) {
-                            meta = JSON.parse(companion.content);
-                        }
-                        else {
-                            meta = getMeta(companion.content, companion.file);
-                            specContent = companion.content;
-                        }
-                    }
-                    else if (internalDoc) {
-                        meta = getMeta(internalDoc, item);
-                        if (!meta.command) {
-                            if (ext === '.py')
-                                meta.command = `python ${fullPath}`;
-                            else if (ext === '.sh')
-                                meta.command = `bash ${fullPath}`;
-                            else if (ext === '.ps1')
-                                meta.command = `powershell ${fullPath}`;
-                            else
-                                meta.command = fullPath;
-                        }
-                    }
-                    if (meta && meta.name && meta.command) {
-                        tools.set(meta.name, createScriptTool(meta, source, specContent));
-                    }
-                }
-                catch { /* skip errors */ }
-            }
-            // 3. Standalone Meta/Documentation Tools
-            if (ext === '.json' || ext === '.md' || ext === '.txt') {
-                if (Array.from(tools.values()).some(t => t.name === base))
-                    continue;
-                try {
-                    const content = await readFile(fullPath, 'utf-8');
-                    let meta = null;
-                    if (ext === '.json') {
-                        meta = JSON.parse(content);
-                    }
-                    else {
-                        meta = getMeta(content, item);
-                    }
-                    if (meta && meta.name && meta.command) {
-                        tools.set(meta.name, createScriptTool(meta, source, content));
-                    }
-                }
-                catch { /* skip */ }
-            }
-        }
-    }
-    catch (error) {
-        // Directory might not exist
-    }
-    return tools;
-}
-// Load all tools from the tools directory
-export const loadTools = async () => {
-    const customDirs = ['skills', 'scripts', 'tools', '.simple-cli/tools'];
-    const builtinTools = await loadToolsFromDir(TOOLS_DIR, 'builtin');
-    const allProjectTools = new Map();
-    // Local project dirs
-    for (const d of customDirs) {
-        const dirPath = join(process.cwd(), d);
-        const tools = await loadToolsFromDir(dirPath, 'project');
-        for (const [name, tool] of tools) {
-            allProjectTools.set(name, tool);
-        }
-    }
-    // Global OpenClaw skills (from PRD)
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    const globalClawDir = join(home, '.openclaw', 'workspace', 'skills');
-    const globalTools = await loadToolsFromDir(globalClawDir, 'project');
-    for (const [name, tool] of globalTools) {
-        if (!allProjectTools.has(name)) {
-            allProjectTools.set(name, tool);
-        }
-    }
-    return new Map([...builtinTools, ...allProjectTools]);
-};
-// Load MCP tools and merge with built-in tools
-export const loadAllTools = async () => {
-    const tools = await loadTools();
-    try {
-        const mcpManager = getMCPManager();
-        const mcpTools = mcpManager.getAllTools();
-        for (const mcpTool of mcpTools) {
-            const toolName = `mcp_${mcpTool.serverName}_${mcpTool.name}`;
-            tools.set(toolName, {
-                name: toolName,
-                description: mcpTool.description,
-                permission: 'execute',
-                inputSchema: z.object(mcpTool.inputSchema).passthrough(),
-                execute: mcpTool.execute,
-                source: 'mcp',
-                serverName: mcpTool.serverName,
-            });
-        }
-    }
-    catch {
-        // MCP not configured, skip
-    }
-    return tools;
-};
-// Get tool definitions for LLM prompt
-export const getToolDefinitions = (tools) => {
-    const sections = [];
-    const builtinTools = [];
-    const projectTools = [];
-    const mcpTools = [];
-    const isClaw = process.argv.includes('--claw') || process.argv.includes('-claw');
-    for (const tool of tools.values()) {
-        if (tool.source === 'mcp') {
-            mcpTools.push(tool);
-        }
-        else if (tool.source === 'project') {
-            projectTools.push(tool);
-        }
-        else {
-            builtinTools.push(tool);
-        }
-    }
-    if (builtinTools.length > 0) {
-        sections.push('## Built-in Tools\n');
-        for (const tool of builtinTools) {
-            sections.push(formatToolDefinition(tool));
-        }
-    }
-    if (projectTools.length > 0) {
-        sections.push('\n## Project Skills (Custom Tools)\n');
-        for (const tool of projectTools) {
-            sections.push(formatToolDefinition(tool));
-        }
-    }
-    if (mcpTools.length > 0) {
-        sections.push('\n## MCP Tools\n');
-        for (const tool of mcpTools) {
-            sections.push(formatToolDefinition(tool));
-        }
-    }
-    return sections.join('\n');
-};
-// Format a single tool definition
-function formatToolDefinition(tool) {
-    const lines = [
-        `### ${tool.name}`,
-        tool.description,
-        `Permission: ${tool.permission}`,
-    ];
-    if (tool.serverName) {
-        lines.push(`Server: ${tool.serverName}`);
-    }
-    // Extract parameters from schema
-    if (tool.inputSchema && 'shape' in tool.inputSchema) {
-        const shape = tool.inputSchema.shape;
-        const params = Object.entries(shape)
-            .map(([key, value]) => {
-            const zodType = value;
-            const description = zodType.description || '';
-            const typeName = getTypeName(zodType);
-            const optional = zodType.isOptional() ? '?' : '';
-            return `  - ${key}${optional}: ${typeName}${description ? ` - ${description}` : ''}`;
-        })
-            .join('\n');
-        if (params) {
-            lines.push('Parameters:');
-            lines.push(params);
-        }
-    }
-    return lines.join('\n') + '\n';
-}
-// Get human-readable type name from Zod type
-function getTypeName(zodType) {
-    const def = zodType._def;
-    if (def.typeName === 'ZodString')
-        return 'string';
-    if (def.typeName === 'ZodNumber')
-        return 'number';
-    if (def.typeName === 'ZodBoolean')
-        return 'boolean';
-    if (def.typeName === 'ZodArray')
-        return 'array';
-    if (def.typeName === 'ZodObject')
-        return 'object';
-    if (def.typeName === 'ZodEnum')
-        return `enum(${def.values.join('|')})`;
-    if (def.typeName === 'ZodOptional')
-        return getTypeName(def.innerType);
-    if (def.typeName === 'ZodDefault')
-        return getTypeName(def.innerType);
-    return def.typeName?.replace('Zod', '').toLowerCase() || 'unknown';
-}
-// Validate tool arguments
-export const validateToolArgs = (tool, args) => {
-    try {
-        tool.inputSchema.parse(args);
-        return { valid: true };
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            const messages = error.errors.map(e => `${e.path.join('.')}: ${e.message}`);
-            return { valid: false, error: messages.join('; ') };
-        }
-        return { valid: false, error: String(error) };
-    }
-};

package/dist/repoMap.d.ts

@@ -1,5 +0,0 @@
-/**
- * RepoMap: Symbol-aware context generation
- * Uses ts-morph for TypeScript/JavaScript and simple parsing for others.
- */
-export declare const generateRepoMap: (rootDir?: string) => Promise<string>;

package/dist/repoMap.js

@@ -1,79 +0,0 @@
-/**
- * RepoMap: Symbol-aware context generation
- * Uses ts-morph for TypeScript/JavaScript and simple parsing for others.
- */
-import { Project, ScriptTarget } from 'ts-morph';
-import { readdir, readFile } from 'fs/promises';
-import { join, extname, relative } from 'path';
-const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage']);
-const TS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx']);
-export const generateRepoMap = async (rootDir = '.') => {
-    const fileMaps = [];
-    // Initialize ts-morph project
-    const project = new Project({
-        compilerOptions: { target: ScriptTarget.ESNext, allowJs: true },
-        skipAddingFilesFromTsConfig: true,
-        useInMemoryFileSystem: true // Don't actually load files until we say so
-    });
-    const stack = [rootDir];
-    const validFiles = [];
-    // 1. Walk directory to find files
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (IGNORED_DIRS.has(entry.name))
-                    continue;
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    stack.push(fullPath);
-                }
-                else if (entry.isFile()) {
-                    validFiles.push(fullPath);
-                }
-            }
-        }
-        catch { /* ignore access errors */ }
-    }
-    // 2. Process Files in parallel
-    // Limit to 50 files for now to avoid context explosion
-    const filesToProcess = validFiles.slice(0, 50);
-    const results = await Promise.all(filesToProcess.map(async (filePath) => {
-        const ext = extname(filePath);
-        const relPath = relative(rootDir, filePath);
-        if (TS_EXTENSIONS.has(ext)) {
-            try {
-                const content = await readFile(filePath, 'utf-8');
-                const sourceFile = project.createSourceFile(filePath, content, { overwrite: true });
-                const symbols = [];
-                sourceFile.getClasses().forEach((c) => symbols.push(`class ${c.getName()}`));
-                sourceFile.getFunctions().forEach((f) => symbols.push(`func ${f.getName()}`));
-                sourceFile.getInterfaces().forEach((i) => symbols.push(`interface ${i.getName()}`));
-                sourceFile.getTypeAliases().forEach((t) => symbols.push(`type ${t.getName()}`));
-                sourceFile.getVariableStatements().forEach((v) => {
-                    v.getDeclarations().forEach((d) => symbols.push(`const ${d.getName()}`));
-                });
-                return { path: relPath, symbols };
-            }
-            catch (e) {
-                return null;
-            }
-        }
-        else {
-            return { path: relPath, symbols: [] };
-        }
-    }));
-    for (const res of results) {
-        if (res)
-            fileMaps.push(res);
-    }
-    if (fileMaps.length === 0)
-        return 'No source files found.';
-    return fileMaps.map(fm => {
-        if (fm.symbols.length === 0)
-            return `📄 ${fm.path}`;
-        const syms = fm.symbols.map(s => `    ${s}`).join('\n');
-        return `📄 ${fm.path}\n${syms}`;
-    }).join('\n\n');
-};

package/dist/router.d.ts

@@ -1,41 +0,0 @@
-/**
- * MoE Router: Mix of Experts task routing
- * Routes tasks to appropriate model tiers based on complexity
- */
-import { z } from 'zod';
-export type Tier = 1 | 2 | 3 | 4 | 5;
-export interface TierConfig {
-    tier: Tier;
-    role: string;
-    model: string;
-    provider: 'openai' | 'anthropic' | 'gemini';
-}
-export interface RoutingDecision {
-    tier: Tier;
-    complexity: number;
-    contextRequired: 'high' | 'low';
-    risk: 'high' | 'low';
-    reasoning: string;
-}
-export declare const RoutingResponseSchema: z.ZodObject<{
-    complexity: z.ZodNumber;
-    contextRequired: z.ZodEnum<["high", "low"]>;
-    risk: z.ZodEnum<["high", "low"]>;
-    recommendedTier: z.ZodNumber;
-    reasoning: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    complexity: number;
-    contextRequired: "high" | "low";
-    risk: "high" | "low";
-    recommendedTier: number;
-    reasoning: string;
-}, {
-    complexity: number;
-    contextRequired: "high" | "low";
-    risk: "high" | "low";
-    recommendedTier: number;
-    reasoning: string;
-}>;
-export declare const loadTierConfig: () => Map<Tier, TierConfig>;
-export declare const routeTask: (task: string, orchestratorCall: (prompt: string) => Promise<string>) => Promise<RoutingDecision>;
-export declare const formatRoutingDecision: (decision: RoutingDecision, tiers: Map<Tier, TierConfig>) => string;