@stan-chen/simple-cli 0.2.1

package/dist/commands/swarm.js

@@ -0,0 +1,236 @@
+/**
+ * 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
+      }
+    ]
+  }
+`);
+}

package/dist/commands.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Slash Commands System
+ * Based on Aider's commands.py
+ */
+export interface CommandContext {
+    cwd: string;
+    activeFiles: Set<string>;
+    readOnlyFiles: Set<string>;
+    history: Array<{
+        role: string;
+        content: string;
+    }>;
+    io: {
+        output: (message: string) => void;
+        error: (message: string) => void;
+        confirm: (message: string) => Promise<boolean>;
+        prompt: (message: string) => Promise<string>;
+    };
+}
+export interface Command {
+    name: string;
+    aliases: string[];
+    description: string;
+    execute: (args: string, context: CommandContext) => Promise<string | void>;
+}
+export declare function parseCommand(input: string): {
+    command: string;
+    args: string;
+} | null;
+export declare const commands: Command[];
+export declare function findCommand(name: string): Command | undefined;
+export declare function executeCommand(input: string, context: CommandContext): Promise<string | void>;

package/dist/commands.js

@@ -0,0 +1,427 @@
+/**
+ * Slash Commands System
+ * Based on Aider's commands.py
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { relative, resolve } from 'path';
+import { getMCPManager } from './mcp/manager.js';
+import { getStagedDiff } from './tools/git.js';
+import { execute as grepExecute } from './tools/grep.js';
+import { execute as globExecute } from './tools/glob.js';
+// Parse command line into command and args
+export function parseCommand(input) {
+    if (!input.startsWith('/')) {
+        return null;
+    }
+    const trimmed = input.slice(1).trim();
+    const spaceIndex = trimmed.indexOf(' ');
+    if (spaceIndex === -1) {
+        return { command: trimmed.toLowerCase(), args: '' };
+    }
+    return {
+        command: trimmed.slice(0, spaceIndex).toLowerCase(),
+        args: trimmed.slice(spaceIndex + 1).trim(),
+    };
+}
+// Built-in commands
+export const commands = [
+    // File Management
+    {
+        name: 'add',
+        aliases: ['a'],
+        description: 'Add files to the chat context',
+        execute: async (args, ctx) => {
+            if (!args) {
+                ctx.io.output('Usage: /add <file_pattern>');
+                return;
+            }
+            const patterns = args.split(/\s+/);
+            let added = 0;
+            for (const pattern of patterns) {
+                // Check if it's a glob pattern
+                if (pattern.includes('*')) {
+                    const result = await globExecute({ pattern, cwd: ctx.cwd, ignore: [], maxResults: 1000, includeDirectories: false });
+                    for (const file of result.matches) {
+                        const fullPath = resolve(ctx.cwd, file);
+                        if (!ctx.activeFiles.has(fullPath)) {
+                            ctx.activeFiles.add(fullPath);
+                            ctx.io.output(`Added ${file}`);
+                            added++;
+                        }
+                    }
+                }
+                else {
+                    const fullPath = resolve(ctx.cwd, pattern);
+                    if (existsSync(fullPath)) {
+                        if (!ctx.activeFiles.has(fullPath)) {
+                            ctx.activeFiles.add(fullPath);
+                            ctx.io.output(`Added ${pattern}`);
+                            added++;
+                        }
+                    }
+                    else {
+                        // File doesn't exist - offer to create it
+                        const create = await ctx.io.confirm(`File ${pattern} doesn't exist. Create it?`);
+                        if (create) {
+                            await writeFile(fullPath, '');
+                            ctx.activeFiles.add(fullPath);
+                            ctx.io.output(`Created and added ${pattern}`);
+                            added++;
+                        }
+                    }
+                }
+            }
+            ctx.io.output(`Added ${added} file(s) to the chat`);
+        },
+    },
+    {
+        name: 'drop',
+        aliases: ['d', 'remove'],
+        description: 'Remove files from the chat context',
+        execute: async (args, ctx) => {
+            if (!args) {
+                // Drop all files
+                const count = ctx.activeFiles.size;
+                ctx.activeFiles.clear();
+                ctx.io.output(`Dropped all ${count} file(s)`);
+                return;
+            }
+            const patterns = args.split(/\s+/);
+            let dropped = 0;
+            for (const pattern of patterns) {
+                const fullPath = resolve(ctx.cwd, pattern);
+                if (ctx.activeFiles.has(fullPath)) {
+                    ctx.activeFiles.delete(fullPath);
+                    ctx.io.output(`Dropped ${pattern}`);
+                    dropped++;
+                }
+            }
+            ctx.io.output(`Dropped ${dropped} file(s)`);
+        },
+    },
+    {
+        name: 'ls',
+        aliases: ['files', 'list'],
+        description: 'List files in the chat context',
+        execute: async (args, ctx) => {
+            if (ctx.activeFiles.size === 0 && ctx.readOnlyFiles.size === 0) {
+                ctx.io.output('No files in chat context');
+                return;
+            }
+            if (ctx.activeFiles.size > 0) {
+                ctx.io.output('\nEditable files:');
+                for (const file of ctx.activeFiles) {
+                    ctx.io.output(`  ${relative(ctx.cwd, file)}`);
+                }
+            }
+            if (ctx.readOnlyFiles.size > 0) {
+                ctx.io.output('\nRead-only files:');
+                for (const file of ctx.readOnlyFiles) {
+                    ctx.io.output(`  ${relative(ctx.cwd, file)}`);
+                }
+            }
+        },
+    },
+    {
+        name: 'read-only',
+        aliases: ['ro'],
+        description: 'Add files as read-only context',
+        execute: async (args, ctx) => {
+            if (!args) {
+                // Convert all active files to read-only
+                for (const file of ctx.activeFiles) {
+                    ctx.readOnlyFiles.add(file);
+                }
+                ctx.activeFiles.clear();
+                ctx.io.output('Converted all files to read-only');
+                return;
+            }
+            const patterns = args.split(/\s+/);
+            for (const pattern of patterns) {
+                if (pattern.includes('*')) {
+                    const result = await globExecute({ pattern, cwd: ctx.cwd, maxResults: 1000, includeDirectories: false });
+                    for (const file of result.matches) {
+                        const fullPath = resolve(ctx.cwd, file);
+                        ctx.readOnlyFiles.add(fullPath);
+                        ctx.io.output(`Added ${file} as read-only`);
+                    }
+                }
+                else {
+                    const fullPath = resolve(ctx.cwd, pattern);
+                    if (existsSync(fullPath)) {
+                        ctx.readOnlyFiles.add(fullPath);
+                        ctx.io.output(`Added ${pattern} as read-only`);
+                    }
+                }
+            }
+        },
+    },
+    // Git Integration
+    {
+        name: 'git',
+        aliases: [],
+        description: 'Run a git command',
+        execute: async (args, ctx) => {
+            const { spawnSync } = await import('child_process');
+            const result = spawnSync('git', args.split(/\s+/), {
+                cwd: ctx.cwd,
+                encoding: 'utf-8',
+            });
+            if (result.stdout)
+                ctx.io.output(result.stdout);
+            if (result.stderr)
+                ctx.io.error(result.stderr);
+        },
+    },
+    {
+        name: 'diff',
+        aliases: [],
+        description: 'Show git diff of changes',
+        execute: async (args, ctx) => {
+            const { spawnSync } = await import('child_process');
+            const gitArgs = args ? args.split(/\s+/) : [];
+            const result = spawnSync('git', ['diff', '--no-color', ...gitArgs], {
+                cwd: ctx.cwd,
+                encoding: 'utf-8',
+            });
+            if (result.stdout) {
+                ctx.io.output(result.stdout);
+            }
+            else {
+                ctx.io.output('No changes');
+            }
+        },
+    },
+    {
+        name: 'commit',
+        aliases: [],
+        description: 'Commit staged changes with AI-generated message',
+        execute: async (args, ctx) => {
+            const diff = getStagedDiff(ctx.cwd);
+            if (!diff) {
+                ctx.io.output('No staged changes to commit');
+                return;
+            }
+            const message = args || 'Update files';
+            const { spawnSync } = await import('child_process');
+            const result = spawnSync('git', ['commit', '-m', message], {
+                cwd: ctx.cwd,
+                encoding: 'utf-8',
+            });
+            if (result.stdout)
+                ctx.io.output(result.stdout);
+            if (result.stderr)
+                ctx.io.error(result.stderr);
+        },
+    },
+    // Search
+    {
+        name: 'search',
+        aliases: ['grep', 'find'],
+        description: 'Search for pattern in files',
+        execute: async (args, ctx) => {
+            if (!args) {
+                ctx.io.output('Usage: /search <pattern> [path]');
+                return;
+            }
+            const parts = args.split(/\s+/);
+            const pattern = parts[0];
+            const path = parts[1] || ctx.cwd;
+            const result = await grepExecute({
+                pattern,
+                path,
+                maxResults: 50,
+                ignoreCase: true,
+                contextLines: 2,
+                filesOnly: false,
+                includeHidden: false,
+            });
+            if (result.matches.length === 0) {
+                ctx.io.output('No matches found');
+                return;
+            }
+            ctx.io.output(`Found ${result.count} matches in ${result.files.length} file(s):`);
+            for (const match of result.matches.slice(0, 20)) {
+                ctx.io.output(`  ${match.file}:${match.line}: ${match.text.trim()}`);
+            }
+            if (result.truncated) {
+                ctx.io.output(`  ... and more (truncated)`);
+            }
+        },
+    },
+    // Chat Management
+    {
+        name: 'clear',
+        aliases: ['reset'],
+        description: 'Clear chat history',
+        execute: async (args, ctx) => {
+            ctx.history.length = 0;
+            ctx.io.output('Chat history cleared');
+        },
+    },
+    {
+        name: 'undo',
+        aliases: [],
+        description: 'Undo the last git commit made by the AI',
+        execute: async (args, ctx) => {
+            const { spawnSync } = await import('child_process');
+            const result = spawnSync('git', ['reset', '--soft', 'HEAD~1'], {
+                cwd: ctx.cwd,
+                encoding: 'utf-8',
+            });
+            if (result.status === 0) {
+                ctx.io.output('Undid last commit');
+            }
+            else {
+                ctx.io.error('Failed to undo commit');
+            }
+        },
+    },
+    // Context
+    {
+        name: 'tokens',
+        aliases: [],
+        description: 'Show approximate token count',
+        execute: async (args, ctx) => {
+            let totalChars = 0;
+            for (const file of ctx.activeFiles) {
+                try {
+                    const content = await readFile(file, 'utf-8');
+                    totalChars += content.length;
+                }
+                catch { }
+            }
+            for (const file of ctx.readOnlyFiles) {
+                try {
+                    const content = await readFile(file, 'utf-8');
+                    totalChars += content.length;
+                }
+                catch { }
+            }
+            for (const msg of ctx.history) {
+                totalChars += msg.content.length;
+            }
+            // Rough estimate: ~4 chars per token
+            const estimatedTokens = Math.ceil(totalChars / 4);
+            ctx.io.output(`Approximate tokens: ${estimatedTokens.toLocaleString()}`);
+            ctx.io.output(`  Files: ${ctx.activeFiles.size} editable, ${ctx.readOnlyFiles.size} read-only`);
+            ctx.io.output(`  History: ${ctx.history.length} messages`);
+        },
+    },
+    // MCP
+    {
+        name: 'mcp',
+        aliases: [],
+        description: 'MCP server management',
+        execute: async (args, ctx) => {
+            const manager = getMCPManager();
+            const parts = args.split(/\s+/);
+            const subcommand = parts[0] || 'status';
+            switch (subcommand) {
+                case 'status': {
+                    const statuses = manager.getAllServerStatuses();
+                    if (statuses.size === 0) {
+                        ctx.io.output('No MCP servers configured');
+                        return;
+                    }
+                    ctx.io.output('MCP Servers:');
+                    for (const [name, status] of statuses) {
+                        ctx.io.output(`  ${name}: ${status}`);
+                    }
+                    break;
+                }
+                case 'tools': {
+                    const tools = manager.getAllTools();
+                    if (tools.length === 0) {
+                        ctx.io.output('No MCP tools available');
+                        return;
+                    }
+                    ctx.io.output(`MCP Tools (${tools.length}):`);
+                    for (const tool of tools) {
+                        ctx.io.output(`  ${tool.name} (${tool.serverName}): ${tool.description}`);
+                    }
+                    break;
+                }
+                case 'connect': {
+                    await manager.connectAll();
+                    ctx.io.output('Connected to MCP servers');
+                    break;
+                }
+                case 'disconnect': {
+                    await manager.disconnectAll();
+                    ctx.io.output('Disconnected from MCP servers');
+                    break;
+                }
+                default:
+                    ctx.io.output('Usage: /mcp [status|tools|connect|disconnect]');
+            }
+        },
+    },
+    // Web
+    {
+        name: 'web',
+        aliases: ['url', 'fetch'],
+        description: 'Fetch a URL and add to context',
+        execute: async (args, ctx) => {
+            if (!args) {
+                ctx.io.output('Usage: /web <url>');
+                return;
+            }
+            const { execute: scrapeExecute } = await import('./tools/scraper.js');
+            const result = await scrapeExecute({ url: args, convertToMarkdown: true, verifySSL: true, timeout: 10000 });
+            if (result.error) {
+                ctx.io.error(`Failed to fetch: ${result.error}`);
+                return;
+            }
+            ctx.io.output(`Fetched ${args} (${result.content.length} chars)`);
+            // Add to history as context
+            ctx.history.push({
+                role: 'user',
+                content: `Content from ${args}:\n\n${result.content}`,
+            });
+        },
+    },
+    // Help
+    {
+        name: 'help',
+        aliases: ['h', '?'],
+        description: 'Show available commands',
+        execute: async (args, ctx) => {
+            ctx.io.output('\nAvailable commands:\n');
+            for (const cmd of commands) {
+                const aliases = cmd.aliases.length > 0 ? ` (${cmd.aliases.join(', ')})` : '';
+                ctx.io.output(`  /${cmd.name}${aliases}`);
+                ctx.io.output(`    ${cmd.description}\n`);
+            }
+        },
+    },
+    // Exit
+    {
+        name: 'exit',
+        aliases: ['quit', 'q'],
+        description: 'Exit the CLI',
+        execute: async (args, ctx) => {
+            ctx.io.output('Goodbye!');
+            process.exit(0);
+        },
+    },
+];
+// Find command by name or alias
+export function findCommand(name) {
+    const lower = name.toLowerCase();
+    return commands.find(cmd => cmd.name === lower || cmd.aliases.includes(lower));
+}
+// Execute a command
+export async function executeCommand(input, context) {
+    const parsed = parseCommand(input);
+    if (!parsed) {
+        return undefined; // Not a command
+    }
+    const command = findCommand(parsed.command);
+    if (!command) {
+        context.io.error(`Unknown command: /${parsed.command}. Type /help for available commands.`);
+        return;
+    }
+    return command.execute(parsed.args, context);
+}