@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/commands/index.js

@@ -1,376 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import * as ui from '../lib/ui.js';
-import { Agent, summarizeHistory } from '../lib/agent.js';
-import { getGitManager } from '../lib/git.js';
-import { getContextManager } from '../context.js';
-import { createProvider } from '../providers/index.js';
-import { createMultiProvider } from '../providers/multi.js';
-import { routeTask, loadTierConfig } from '../router.js';
-import { getMCPManager } from '../mcp/manager.js';
-import { getActiveSkill, setActiveSkill, listSkills } from '../skills.js';
-import { createFileWatcher } from '../watcher.js';
-import 'dotenv/config';
-export default class Chat extends Command {
-    static description = 'Start an interactive coding session';
-    static flags = {
-        yolo: Flags.boolean({
-            description: 'Auto-approve all tool executions',
-            default: false,
-        }),
-        moe: Flags.boolean({
-            description: 'Enable Mix of Experts routing',
-            default: false,
-        }),
-        watch: Flags.boolean({
-            description: 'Watch files for AI comments',
-            default: false,
-        }),
-        skill: Flags.string({
-            description: 'Initial skill/mode (code, architect, test, etc.)',
-            default: 'code',
-        }),
-        'auto-commit': Flags.boolean({
-            description: 'Auto-commit after successful changes',
-            default: false,
-        }),
-        'auto-lint': Flags.boolean({
-            description: 'Auto-lint after file changes',
-            default: true,
-        }),
-        'auto-test': Flags.boolean({
-            description: 'Auto-run tests after changes',
-            default: false,
-        }),
-        'test-cmd': Flags.string({
-            description: 'Test command to run',
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Chat);
-        // Show banner
-        ui.intro('Simple-CLI v0.2.0');
-        ui.log(`Mode: ${flags.moe ? 'MoE' : 'Single'} | ${flags.yolo ? 'YOLO' : 'Safe'} | Skill: @${flags.skill}`);
-        // Initialize context
-        const ctx = getContextManager();
-        await ctx.initialize();
-        ui.success(`Loaded ${ctx.getTools().size} tools`);
-        // Set initial skill
-        const skill = setActiveSkill(flags.skill);
-        if (skill) {
-            ctx.setSkill(skill);
-        }
-        // Initialize git
-        const git = getGitManager();
-        const isGitRepo = await git.isRepo();
-        if (isGitRepo) {
-            const branch = await git.currentBranch();
-            ui.log(`Git: ${branch || 'detached HEAD'}`);
-        }
-        // Initialize MCP
-        const mcpManager = getMCPManager();
-        try {
-            const configs = await mcpManager.loadConfig();
-            if (configs.length > 0) {
-                await ui.spin(`Connecting to ${configs.length} MCP server(s)`, async () => {
-                    await mcpManager.connectAll(configs);
-                });
-            }
-        }
-        catch {
-            // MCP not configured
-        }
-        // Initialize providers
-        const tierConfigs = flags.moe ? loadTierConfig() : null;
-        const multiProvider = tierConfigs ? createMultiProvider(tierConfigs) : null;
-        const singleProvider = !flags.moe ? createProvider() : null;
-        // Initialize file watcher
-        let watcher = null;
-        if (flags.watch) {
-            watcher = createFileWatcher({
-                root: ctx.getCwd(),
-                onAIComment: (path, comments) => {
-                    ui.note(comments.map(c => `Line ${c.line}: ${c.text}`).join('\n'), `AI Comments in ${path}`);
-                },
-            });
-            ui.success('File watcher active');
-        }
-        // Generate function
-        const generate = async (messages) => {
-            const fullPrompt = await ctx.buildSystemPrompt();
-            const llmMessages = messages.map(m => ({ role: m.role, content: m.content }));
-            if (flags.moe && multiProvider && tierConfigs) {
-                const userMsg = messages.find(m => m.role === 'user')?.content || '';
-                const routing = await routeTask(userMsg, async (prompt) => {
-                    return multiProvider.generateWithTier(1, prompt, [{ role: 'user', content: userMsg }]);
-                });
-                return multiProvider.generateWithTier(routing.tier, fullPrompt, llmMessages);
-            }
-            return singleProvider.generateResponse(fullPrompt, llmMessages);
-        };
-        // Tool execution
-        const executeTool = async (name, args) => {
-            const tools = ctx.getTools();
-            const tool = tools.get(name);
-            if (!tool) {
-                throw new Error(`Tool not found: ${name}`);
-            }
-            // Permission check
-            if (!flags.yolo && tool.permission !== 'read') {
-                const confirmed = await ui.confirm({
-                    message: `Execute ${name}?`,
-                    initialValue: false,
-                });
-                if (ui.isCancel(confirmed) || !confirmed) {
-                    return 'Cancelled by user';
-                }
-            }
-            return tool.execute(args);
-        };
-        // Create agent
-        const agent = new Agent({
-            config: {
-                maxReflections: 3,
-                autoLint: flags['auto-lint'],
-                autoTest: flags['auto-test'],
-                autoCommit: flags['auto-commit'],
-                testCommand: flags['test-cmd'],
-            },
-            git,
-            generateFn: generate,
-            executeTool,
-            lintFn: flags['auto-lint'] ? async (file) => {
-                const { execute } = await import('../tools/linter.js');
-                const result = await execute({ path: file, fix: false });
-                return { passed: result.passed, output: result.output };
-            } : undefined,
-            testFn: flags['auto-test'] && flags['test-cmd'] ? async () => {
-                const { execute } = await import('../tools/runCommand.js');
-                const result = await execute({ command: flags['test-cmd'] });
-                return { passed: result.exitCode === 0, output: result.stdout + result.stderr };
-            } : undefined,
-        });
-        // Main loop
-        while (true) {
-            const currentSkill = getActiveSkill();
-            const input = await ui.text({
-                message: `[${currentSkill.name}]`,
-                placeholder: 'Type a message or /help...',
-            });
-            if (ui.isCancel(input)) {
-                break;
-            }
-            const message = input.trim();
-            if (!message)
-                continue;
-            // Handle slash commands
-            if (message.startsWith('/')) {
-                await handleCommand(message, ctx, git, mcpManager);
-                continue;
-            }
-            // Handle skill switching
-            if (message.startsWith('@')) {
-                const skillName = message.slice(1).trim();
-                if (skillName === 'list') {
-                    ui.note(listSkills().map(s => `@${s.name} - ${s.description}`).join('\n'), 'Available Skills');
-                }
-                else {
-                    const newSkill = setActiveSkill(skillName);
-                    if (newSkill) {
-                        ctx.setSkill(newSkill);
-                        ui.success(`Switched to @${newSkill.name}`);
-                    }
-                    else {
-                        ui.error(`Unknown skill: @${skillName}`);
-                    }
-                }
-                continue;
-            }
-            // Add watch context if available
-            let fullMessage = message;
-            if (watcher) {
-                const watchPrompt = watcher.getActionableCommentsPrompt();
-                if (watchPrompt) {
-                    fullMessage = `${watchPrompt}\n\nUser request: ${message}`;
-                }
-            }
-            // Process with agent
-            try {
-                ctx.addMessage('user', message);
-                const history = ctx.getHistory();
-                // Summarize if too long
-                const summarizedHistory = await summarizeHistory(history, generate, 20);
-                const systemPrompt = await ctx.buildSystemPrompt();
-                const result = await agent.process(fullMessage, summarizedHistory, systemPrompt);
-                // Add response to history
-                if (result.response.action && 'message' in result.response.action) {
-                    ctx.addMessage('assistant', result.response.action.message);
-                }
-            }
-            catch (error) {
-                ui.error(`Error: ${error instanceof Error ? error.message : error}`);
-            }
-        }
-        // Cleanup
-        watcher?.stop();
-        await mcpManager.disconnectAll();
-        ui.outro('Goodbye!');
-    }
-}
-/**
- * Handle slash commands
- */
-async function handleCommand(input, ctx, git, mcpManager) {
-    const [cmd, ...args] = input.slice(1).split(/\s+/);
-    const argsStr = args.join(' ');
-    switch (cmd.toLowerCase()) {
-        case 'help':
-        case 'h':
-            ui.note(`
-/add <file>     - Add file to context
-/drop [file]    - Remove file from context
-/ls             - List files in context
-/clear          - Clear chat history
-/diff           - Show git diff
-/status         - Show git status
-/commit [msg]   - Commit changes
-/undo           - Undo last commit
-/tokens         - Show token estimate
-/mcp [cmd]      - MCP management
-/skill <name>   - Switch skill
-/exit           - Exit
-`, 'Commands');
-            break;
-        case 'add':
-        case 'a':
-            if (argsStr) {
-                const added = ctx.addFile(argsStr);
-                if (added) {
-                    ui.success(`Added ${argsStr}`);
-                }
-                else {
-                    ui.error(`File not found: ${argsStr}`);
-                }
-            }
-            else {
-                ui.error('Usage: /add <file>');
-            }
-            break;
-        case 'drop':
-        case 'd':
-            if (argsStr) {
-                ctx.removeFile(argsStr);
-                ui.success(`Dropped ${argsStr}`);
-            }
-            else {
-                // Drop all
-                const files = ctx.getFiles();
-                for (const f of [...files.active, ...files.readOnly]) {
-                    ctx.removeFile(f);
-                }
-                ui.success('Dropped all files');
-            }
-            break;
-        case 'ls':
-        case 'files':
-            const files = ctx.getFiles();
-            if (files.active.length === 0 && files.readOnly.length === 0) {
-                ui.log('No files in context');
-            }
-            else {
-                ui.showFileStatus([
-                    ...files.active.map(f => ({ path: f, status: 'modified' })),
-                    ...files.readOnly.map(f => ({ path: f, status: 'readonly' })),
-                ]);
-            }
-            break;
-        case 'clear':
-            ctx.clearHistory();
-            ui.success('Chat history cleared');
-            break;
-        case 'diff':
-            const diff = await git.diff();
-            if (diff) {
-                ui.showDiff(diff);
-            }
-            else {
-                ui.log('No changes');
-            }
-            break;
-        case 'status':
-            const status = await git.status();
-            ui.log(`Branch: ${status.current}`);
-            if (status.modified.length)
-                ui.log(`Modified: ${status.modified.join(', ')}`);
-            if (status.created.length)
-                ui.log(`Created: ${status.created.join(', ')}`);
-            if (status.deleted.length)
-                ui.log(`Deleted: ${status.deleted.join(', ')}`);
-            if (status.not_added.length)
-                ui.log(`Untracked: ${status.not_added.join(', ')}`);
-            break;
-        case 'commit':
-            const commitDiff = await git.stagedDiff();
-            if (!commitDiff && !(await git.status()).staged.length) {
-                await git.addAll();
-            }
-            const result = await git.commit({ message: argsStr || 'Update' });
-            if (result) {
-                ui.success(`Committed: ${result.hash} ${result.message}`);
-            }
-            else {
-                ui.error('Nothing to commit');
-            }
-            break;
-        case 'undo':
-            if (await git.undoLastCommit()) {
-                ui.success('Undid last commit');
-            }
-            else {
-                ui.error('Failed to undo');
-            }
-            break;
-        case 'tokens':
-            const tokens = await ctx.estimateTokenCount();
-            ui.showTokens(tokens);
-            break;
-        case 'mcp':
-            const subCmd = args[0];
-            if (subCmd === 'status') {
-                const statuses = mcpManager.getAllServerStatuses();
-                for (const [name, status] of statuses) {
-                    ui.log(`${name}: ${status}`);
-                }
-            }
-            else if (subCmd === 'tools') {
-                const tools = mcpManager.getAllTools();
-                for (const tool of tools) {
-                    ui.log(`${tool.name} (${tool.serverName}): ${tool.description}`);
-                }
-            }
-            else {
-                ui.log('Usage: /mcp [status|tools]');
-            }
-            break;
-        case 'skill':
-            if (argsStr) {
-                const newSkill = setActiveSkill(argsStr);
-                if (newSkill) {
-                    ctx.setSkill(newSkill);
-                    ui.success(`Switched to @${newSkill.name}`);
-                }
-                else {
-                    ui.error(`Unknown skill: ${argsStr}`);
-                }
-            }
-            else {
-                ui.note(listSkills().map(s => `@${s.name} - ${s.description}`).join('\n'), 'Available Skills');
-            }
-            break;
-        case 'exit':
-        case 'quit':
-        case 'q':
-            process.exit(0);
-        default:
-            ui.error(`Unknown command: /${cmd}`);
-    }
-}

package/dist/commands/mcp/status.d.ts

@@ -1,6 +0,0 @@
-import { Command } from '@oclif/core';
-export default class MCPStatus extends Command {
-    static description: string;
-    static examples: string[];
-    run(): Promise<void>;
-}

package/dist/commands/mcp/status.js

@@ -1,31 +0,0 @@
-import { Command } from '@oclif/core';
-import * as ui from '../../lib/ui.js';
-import { getMCPManager, MCPServerStatus } from '../../mcp/manager.js';
-export default class MCPStatus extends Command {
-    static description = 'Show MCP server status';
-    static examples = ['<%= config.bin %> mcp status'];
-    async run() {
-        const manager = getMCPManager();
-        const statuses = manager.getAllServerStatuses();
-        if (statuses.size === 0) {
-            ui.log('No MCP servers configured');
-            ui.note('Create a mcp.json file to configure MCP servers', 'Hint');
-            return;
-        }
-        ui.log('MCP Servers:\n');
-        const statusIcon = {
-            [MCPServerStatus.CONNECTED]: ui.theme.success('●'),
-            [MCPServerStatus.CONNECTING]: ui.theme.warning('○'),
-            [MCPServerStatus.DISCONNECTED]: ui.theme.muted('○'),
-            [MCPServerStatus.ERROR]: ui.theme.error('●'),
-        };
-        for (const [name, status] of statuses) {
-            ui.log(`  ${statusIcon[status]} ${name}: ${status}`);
-        }
-        // Show tool count
-        const tools = manager.getAllTools();
-        const resources = manager.getAllResources();
-        const prompts = manager.getAllPrompts();
-        ui.log(`\nDiscovered: ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`);
-    }
-}

package/dist/commands/swarm.d.ts

@@ -1,36 +0,0 @@
-/**
- * Swarm Command - Run multiple agents in parallel
- */
-import { type SwarmTask, type CoordinatorOptions } from '../swarm/index.js';
-export interface SwarmCliOptions {
-    tasksFile?: string;
-    task?: string;
-    scope?: string;
-    concurrency?: number;
-    timeout?: number;
-    yolo?: boolean;
-    branch?: string;
-}
-/**
- * Parse swarm options from command line arguments
- */
-export declare function parseSwarmArgs(args: string[]): SwarmCliOptions;
-/**
- * Load tasks from a JSON file
- */
-export declare function loadTasksFromFile(filePath: string): {
-    tasks: SwarmTask[];
-    options?: Partial<CoordinatorOptions>;
-};
-/**
- * Create tasks from a glob pattern
- */
-export declare function createTasksFromScope(task: string, scope: string, type?: SwarmTask['type']): Promise<SwarmTask[]>;
-/**
- * Run swarm orchestrator
- */
-export declare function runSwarm(options: SwarmCliOptions): Promise<void>;
-/**
- * Print swarm help
- */
-export declare function printSwarmHelp(): void;

package/dist/commands/swarm.js

@@ -1,236 +0,0 @@
-/**
- * Swarm Command - Run multiple agents in parallel
- */
-import { readFileSync, existsSync } from 'fs';
-import { SwarmCoordinator } from '../swarm/index.js';
-import { execute as globExecute } from '../tools/glob.js';
-/**
- * Parse swarm options from command line arguments
- */
-export function parseSwarmArgs(args) {
-    const options = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--tasks' && args[i + 1]) {
-            options.tasksFile = args[++i];
-        }
-        else if (arg === '--task' && args[i + 1]) {
-            options.task = args[++i];
-        }
-        else if (arg === '--scope' && args[i + 1]) {
-            options.scope = args[++i];
-        }
-        else if (arg === '--concurrency' && args[i + 1]) {
-            options.concurrency = parseInt(args[++i], 10);
-        }
-        else if (arg === '--timeout' && args[i + 1]) {
-            options.timeout = parseInt(args[++i], 10);
-        }
-        else if (arg === '--branch' && args[i + 1]) {
-            options.branch = args[++i];
-        }
-        else if (arg === '--yolo') {
-            options.yolo = true;
-        }
-        else if (!arg.startsWith('--') && !options.tasksFile && existsSync(arg)) {
-            // Positional argument - tasks file
-            options.tasksFile = arg;
-        }
-    }
-    return options;
-}
-/**
- * Load tasks from a JSON file
- */
-export function loadTasksFromFile(filePath) {
-    if (!existsSync(filePath)) {
-        throw new Error(`Tasks file not found: ${filePath}`);
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    const data = JSON.parse(content);
-    // Support both { tasks: [...] } and [...] formats
-    if (Array.isArray(data)) {
-        return { tasks: data };
-    }
-    const tasks = data.tasks || [];
-    const options = {};
-    if (data.session) {
-        if (data.session.concurrency)
-            options.concurrency = data.session.concurrency;
-        if (data.session.timeout)
-            options.timeout = data.session.timeout;
-        if (data.session.branch)
-            options.branch = data.session.branch;
-    }
-    return { tasks, options };
-}
-/**
- * Create tasks from a glob pattern
- */
-export async function createTasksFromScope(task, scope, type = 'implement') {
-    const result = await globExecute({ pattern: scope, maxResults: 100, includeDirectories: false });
-    return result.matches.map((file, i) => ({
-        id: `task-${i}`,
-        type,
-        description: `${task} in ${file}`,
-        scope: { files: [file] },
-        dependencies: [],
-        priority: 2,
-        timeout: 300000,
-        retries: 2,
-    }));
-}
-/**
- * Run swarm orchestrator
- */
-export async function runSwarm(options) {
-    console.log('\n🐝 Simple-CLI Swarm Mode\n');
-    let tasks = [];
-    let coordinatorOptions = {};
-    // Load tasks from file or create from options
-    if (options.tasksFile) {
-        console.log(`📄 Loading tasks from ${options.tasksFile}...`);
-        const loaded = loadTasksFromFile(options.tasksFile);
-        tasks = loaded.tasks;
-        coordinatorOptions = loaded.options || {};
-    }
-    else if (options.task && options.scope) {
-        console.log(`🔍 Creating tasks from scope: ${options.scope}...`);
-        tasks = await createTasksFromScope(options.task, options.scope);
-    }
-    else if (options.task) {
-        // Single task
-        tasks = [{
-                id: 'single-task',
-                type: 'implement',
-                description: options.task,
-                scope: {},
-                dependencies: [],
-                priority: 1,
-                timeout: options.timeout || 300000,
-                retries: 2,
-            }];
-    }
-    if (tasks.length === 0) {
-        console.error('❌ No tasks to run. Provide --tasks <file> or --task "description"');
-        process.exit(1);
-    }
-    console.log(`📋 ${tasks.length} task(s) to execute\n`);
-    // Apply CLI options
-    if (options.concurrency)
-        coordinatorOptions.concurrency = options.concurrency;
-    if (options.timeout)
-        coordinatorOptions.timeout = options.timeout;
-    if (options.branch)
-        coordinatorOptions.branch = options.branch;
-    if (options.yolo !== undefined)
-        coordinatorOptions.yolo = options.yolo;
-    // Create coordinator
-    const coordinator = new SwarmCoordinator({
-        cwd: process.cwd(),
-        ...coordinatorOptions,
-    });
-    // Add event handlers
-    coordinator.on('task:start', (task, workerId) => {
-        console.log(`🚀 [${workerId}] Starting: ${task.description.slice(0, 60)}...`);
-    });
-    coordinator.on('task:complete', (task, result) => {
-        const status = result.success ? '✅' : '⚠️';
-        console.log(`${status} [${task.id}] Done in ${result.duration}ms`);
-        if (result.filesChanged.length > 0) {
-            console.log(`   Files: ${result.filesChanged.join(', ')}`);
-        }
-    });
-    coordinator.on('task:fail', (task, error) => {
-        console.error(`❌ [${task.id}] Failed: ${error.message}`);
-    });
-    coordinator.on('task:retry', (task, attempt) => {
-        console.log(`🔄 [${task.id}] Retry attempt ${attempt}`);
-    });
-    // Add tasks
-    coordinator.addTasks(tasks);
-    // Run swarm
-    const startTime = Date.now();
-    console.log(`⏱️  Starting swarm with concurrency: ${coordinatorOptions.concurrency || 4}\n`);
-    try {
-        const result = await coordinator.run();
-        // Print summary
-        console.log('\n' + '═'.repeat(50));
-        console.log('📊 SWARM COMPLETE');
-        console.log('═'.repeat(50));
-        console.log(`   Total Tasks:    ${result.total}`);
-        console.log(`   Completed:      ${result.completed} ✅`);
-        console.log(`   Failed:         ${result.failed} ❌`);
-        console.log(`   Skipped:        ${result.skipped} ⏭️`);
-        console.log(`   Duration:       ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
-        console.log(`   Success Rate:   ${(result.successRate * 100).toFixed(1)}%`);
-        if (result.failedTasks.length > 0) {
-            console.log('\n❌ Failed Tasks:');
-            for (const f of result.failedTasks) {
-                console.log(`   - ${f.task.id}: ${f.error}`);
-            }
-        }
-        console.log('═'.repeat(50) + '\n');
-        // Exit with error code if any failures
-        if (result.failed > 0) {
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error(`\n❌ Swarm error: ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
-    }
-}
-/**
- * Print swarm help
- */
-export function printSwarmHelp() {
-    console.log(`
-🐝 Simple-CLI Swarm Mode
-
-USAGE
-  simple --swarm [options]
-
-OPTIONS
-  --tasks <file>       Load tasks from JSON file
-  --task "desc"        Single task description
-  --scope "pattern"    Glob pattern for files (creates task per file)
-  --concurrency <n>    Max parallel workers (default: 4)
-  --timeout <ms>       Task timeout in milliseconds
-  --branch <name>      Git branch for changes
-  --yolo               Auto-approve all actions
-
-EXAMPLES
-  # Run tasks from file
-  simple --swarm --tasks tasks.json
-
-  # Single task
-  simple --swarm --yolo --task "add tests to all files"
-
-  # Task per file matching pattern
-  simple --swarm --yolo --task "add JSDoc" --scope "src/**/*.ts"
-
-  # With concurrency limit
-  simple --swarm --concurrency 2 --tasks tasks.json
-
-TASKS FILE FORMAT
-  {
-    "session": {
-      "concurrency": 4,
-      "timeout": 300000,
-      "branch": "feature/swarm"
-    },
-    "tasks": [
-      {
-        "id": "task-1",
-        "type": "implement",
-        "description": "Add validation",
-        "scope": { "files": ["src/api.ts"] },
-        "priority": 1,
-        "timeout": 60000,
-        "retries": 2
-      }
-    ]
-  }
-`);
-}