recoder-code 2.5.1 → 2.5.3

package/dist/src/commands/context/index.js

@@ -3,8 +3,8 @@
  * Manage .recoder/ project context
  */
 import { Command } from 'commander';
-import { createContextInitCommand } from './init';
-import { createContextEditCommand } from './edit';
+import { createContextInitCommand } from './init.js';
+import { createContextEditCommand } from './edit.js';
 export function createContextCommand() {
     const command = new Command('context')
         .description('Manage .recoder/ project context directory')

package/dist/src/commands/mcp/marketplace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Marketplace Command
+ * Browse and install MCP servers from curated catalog
+ */
+import type { CommandModule } from 'yargs';
+export declare const marketplaceCommand: CommandModule;

package/dist/src/commands/mcp/marketplace.js

@@ -0,0 +1,448 @@
+/**
+ * MCP Marketplace Command
+ * Browse and install MCP servers from curated catalog
+ */
+import { loadSettings, SettingScope } from '../../config/settings.js';
+import * as readline from 'readline';
+// Curated catalog of popular MCP servers
+const MARKETPLACE_CATALOG = [
+    // Featured
+    {
+        id: 'filesystem',
+        name: 'Filesystem',
+        description: 'Read, write, and manage files and directories',
+        category: 'filesystem',
+        author: 'Anthropic',
+        verified: true,
+        featured: true,
+        toolCount: 14,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-filesystem',
+            args: ['/workspace'],
+        },
+        tags: ['files', 'read', 'write'],
+    },
+    {
+        id: 'github',
+        name: 'GitHub',
+        description: 'Interact with GitHub repos, issues, and PRs',
+        category: 'git',
+        author: 'Anthropic',
+        verified: true,
+        featured: true,
+        toolCount: 26,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-github',
+            envRequired: ['GITHUB_PERSONAL_ACCESS_TOKEN'],
+        },
+        tags: ['github', 'git', 'repos'],
+    },
+    {
+        id: 'puppeteer',
+        name: 'Puppeteer',
+        description: 'Browser automation with Chrome',
+        category: 'browser',
+        author: 'Anthropic',
+        verified: true,
+        featured: true,
+        toolCount: 7,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-puppeteer',
+        },
+        tags: ['browser', 'automation'],
+    },
+    {
+        id: 'brave-search',
+        name: 'Brave Search',
+        description: 'Web search using Brave Search API',
+        category: 'search',
+        author: 'Anthropic',
+        verified: true,
+        featured: true,
+        toolCount: 2,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-brave-search',
+            envRequired: ['BRAVE_API_KEY'],
+        },
+        tags: ['search', 'web'],
+    },
+    // Database
+    {
+        id: 'postgres',
+        name: 'PostgreSQL',
+        description: 'Query and manage PostgreSQL databases',
+        category: 'database',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 5,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-postgres',
+            envRequired: ['POSTGRES_CONNECTION_STRING'],
+        },
+        tags: ['database', 'postgres', 'sql'],
+    },
+    {
+        id: 'sqlite',
+        name: 'SQLite',
+        description: 'Local SQLite database operations',
+        category: 'database',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 4,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-sqlite',
+            args: ['--db-path', './database.db'],
+        },
+        tags: ['database', 'sqlite'],
+    },
+    {
+        id: 'supabase',
+        name: 'Supabase',
+        description: 'Supabase database, auth, and storage',
+        category: 'database',
+        author: 'supabase',
+        verified: true,
+        featured: false,
+        toolCount: 15,
+        installCommand: {
+            type: 'npx',
+            command: '-y supabase-mcp-server',
+            envRequired: ['SUPABASE_URL', 'SUPABASE_SERVICE_KEY'],
+        },
+        tags: ['database', 'supabase'],
+    },
+    // AI & Tools
+    {
+        id: 'sequential-thinking',
+        name: 'Sequential Thinking',
+        description: 'Dynamic problem-solving through thought sequences',
+        category: 'ai',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 1,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-sequential-thinking',
+        },
+        tags: ['thinking', 'reasoning'],
+    },
+    {
+        id: 'memory',
+        name: 'Memory',
+        description: 'Persistent memory using knowledge graph',
+        category: 'ai',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 9,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-memory',
+        },
+        tags: ['memory', 'knowledge-graph'],
+    },
+    // Git
+    {
+        id: 'git',
+        name: 'Git',
+        description: 'Local git repository operations',
+        category: 'git',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 8,
+        installCommand: {
+            type: 'uvx',
+            command: 'mcp-server-git',
+            args: ['--repository', '.'],
+        },
+        tags: ['git', 'version-control'],
+    },
+    // Productivity
+    {
+        id: 'slack',
+        name: 'Slack',
+        description: 'Read and send Slack messages',
+        category: 'communication',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 6,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-slack',
+            envRequired: ['SLACK_BOT_TOKEN', 'SLACK_TEAM_ID'],
+        },
+        tags: ['slack', 'messaging'],
+    },
+    {
+        id: 'notion',
+        name: 'Notion',
+        description: 'Read and write Notion pages and databases',
+        category: 'productivity',
+        author: 'notion',
+        verified: true,
+        featured: false,
+        toolCount: 8,
+        installCommand: {
+            type: 'npx',
+            command: '-y @notionhq/notion-mcp-server',
+            envRequired: ['NOTION_API_KEY'],
+        },
+        tags: ['notion', 'notes'],
+    },
+    // Other
+    {
+        id: 'fetch',
+        name: 'Fetch',
+        description: 'Make HTTP requests and fetch web content',
+        category: 'other',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 2,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-fetch',
+        },
+        tags: ['http', 'fetch', 'api'],
+    },
+    {
+        id: 'time',
+        name: 'Time',
+        description: 'Get current time in any timezone',
+        category: 'other',
+        author: 'Anthropic',
+        verified: true,
+        featured: false,
+        toolCount: 2,
+        installCommand: {
+            type: 'npx',
+            command: '-y @modelcontextprotocol/server-time',
+        },
+        tags: ['time', 'timezone'],
+    },
+];
+const CATEGORY_LABELS = {
+    browser: 'Browser',
+    database: 'Database',
+    devtools: 'DevTools',
+    filesystem: 'Filesystem',
+    git: 'Git & VCS',
+    search: 'Search',
+    cloud: 'Cloud',
+    productivity: 'Productivity',
+    ai: 'AI & ML',
+    communication: 'Communication',
+    other: 'Other',
+};
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+async function listMarketplace(category, search) {
+    let servers = MARKETPLACE_CATALOG;
+    if (category) {
+        servers = servers.filter((s) => s.category === category);
+    }
+    if (search) {
+        const q = search.toLowerCase();
+        servers = servers.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q) ||
+            s.tags.some((t) => t.includes(q)));
+    }
+    if (servers.length === 0) {
+        console.log('No servers found matching your criteria.');
+        return;
+    }
+    console.log('\n📦 MCP Server Marketplace\n');
+    console.log('─'.repeat(60));
+    // Group by category
+    const grouped = new Map();
+    for (const server of servers) {
+        const list = grouped.get(server.category) || [];
+        list.push(server);
+        grouped.set(server.category, list);
+    }
+    for (const [cat, catServers] of grouped) {
+        console.log(`\n${CATEGORY_LABELS[cat]}:`);
+        for (const server of catServers) {
+            const verified = server.verified ? '✓' : ' ';
+            const featured = server.featured ? '★' : ' ';
+            console.log(`  ${featured}${verified} ${server.id.padEnd(20)} ${server.name.padEnd(18)} (${server.toolCount} tools)`);
+            console.log(`      ${server.description}`);
+        }
+    }
+    console.log('\n─'.repeat(60));
+    console.log('★ = Featured  ✓ = Verified\n');
+    console.log('Install with: recoder mcp marketplace install <id>');
+    console.log('Categories: ' + Object.keys(CATEGORY_LABELS).join(', '));
+}
+async function installFromMarketplace(serverId, scope, envValues) {
+    const server = MARKETPLACE_CATALOG.find((s) => s.id === serverId);
+    if (!server) {
+        console.error(`Server "${serverId}" not found in marketplace.`);
+        console.log('\nAvailable servers:');
+        MARKETPLACE_CATALOG.forEach((s) => console.log(`  - ${s.id}: ${s.name}`));
+        return;
+    }
+    // Parse env values from command line
+    const envMap = {};
+    for (const env of envValues) {
+        const [key, ...valueParts] = env.split('=');
+        if (key && valueParts.length > 0) {
+            envMap[key] = valueParts.join('=');
+        }
+    }
+    // Check for required env vars
+    const missingEnv = server.installCommand.envRequired?.filter((key) => !envMap[key] && !process.env[key]);
+    if (missingEnv && missingEnv.length > 0) {
+        console.log(`\n${server.name} requires the following environment variables:\n`);
+        for (const key of missingEnv) {
+            const value = await prompt(`  ${key}: `);
+            if (value) {
+                envMap[key] = value;
+            }
+        }
+        // Check again
+        const stillMissing = server.installCommand.envRequired?.filter((key) => !envMap[key]);
+        if (stillMissing && stillMissing.length > 0) {
+            console.error(`\nMissing required environment variables: ${stillMissing.join(', ')}`);
+            return;
+        }
+    }
+    // Build the server config
+    const { installCommand } = server;
+    let command;
+    let args;
+    switch (installCommand.type) {
+        case 'npx':
+            command = 'npx';
+            args = installCommand.command.split(' ').filter(Boolean);
+            if (installCommand.args) {
+                args.push(...installCommand.args);
+            }
+            break;
+        case 'uvx':
+            command = 'uvx';
+            args = [installCommand.command];
+            if (installCommand.args) {
+                args.push(...installCommand.args);
+            }
+            break;
+        default:
+            command = installCommand.command;
+            args = installCommand.args || [];
+    }
+    // Save to settings
+    const settingsScope = scope === 'user' ? SettingScope.User : SettingScope.Workspace;
+    const settings = loadSettings(process.cwd());
+    const newServer = {
+        command,
+        args,
+        env: Object.keys(envMap).length > 0 ? envMap : undefined,
+        description: server.description,
+        trust: server.verified,
+    };
+    const existingSettings = settings.forScope(settingsScope).settings;
+    const mcpServers = existingSettings.mcpServers || {};
+    if (mcpServers[serverId]) {
+        console.log(`Server "${serverId}" is already installed. Updating...`);
+    }
+    mcpServers[serverId] = newServer;
+    settings.setValue(settingsScope, 'mcpServers', mcpServers);
+    console.log(`\n✅ ${server.name} installed successfully!`);
+    console.log(`   ID: ${serverId}`);
+    console.log(`   Command: ${command} ${args.join(' ')}`);
+    if (Object.keys(envMap).length > 0) {
+        console.log(`   Environment: ${Object.keys(envMap).join(', ')}`);
+    }
+    console.log(`   Scope: ${scope}`);
+    console.log(`\nThe server will be available on your next recoder session.`);
+}
+export const marketplaceCommand = {
+    command: 'marketplace [action]',
+    describe: 'Browse and install MCP servers from marketplace',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'Action to perform',
+        type: 'string',
+        choices: ['list', 'install', 'search'],
+        default: 'list',
+    })
+        .option('category', {
+        alias: 'c',
+        describe: 'Filter by category',
+        type: 'string',
+        choices: Object.keys(CATEGORY_LABELS),
+    })
+        .option('search', {
+        alias: 'q',
+        describe: 'Search servers by name or tags',
+        type: 'string',
+    })
+        .option('id', {
+        describe: 'Server ID to install',
+        type: 'string',
+    })
+        .option('scope', {
+        alias: 's',
+        describe: 'Configuration scope',
+        type: 'string',
+        default: 'project',
+        choices: ['user', 'project'],
+    })
+        .option('env', {
+        alias: 'e',
+        describe: 'Environment variables (KEY=value)',
+        type: 'array',
+        string: true,
+        default: [],
+    })
+        .example('$0 mcp marketplace', 'List all available servers')
+        .example('$0 mcp marketplace --category database', 'List database servers')
+        .example('$0 mcp marketplace install --id github -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_xxx', 'Install GitHub server')
+        .example('$0 mcp marketplace search --query search', 'Search for servers'),
+    handler: async (argv) => {
+        const action = argv.action;
+        const category = argv.category;
+        const search = argv.search;
+        const id = argv.id;
+        const scope = argv.scope;
+        const env = argv.env;
+        switch (action) {
+            case 'install':
+                if (!id) {
+                    console.error('Please specify a server ID with --id');
+                    console.log('Example: recoder mcp marketplace install --id github');
+                    return;
+                }
+                await installFromMarketplace(id, scope, env);
+                break;
+            case 'search':
+                await listMarketplace(category, search || argv._[2]?.toString());
+                break;
+            case 'list':
+            default:
+                await listMarketplace(category, search);
+                break;
+        }
+    },
+};

package/dist/src/commands/mcp.js

@@ -7,6 +7,7 @@ import { addCommand } from './mcp/add.js';
 import { removeCommand } from './mcp/remove.js';
 import { listCommand } from './mcp/list.js';
 import { detectCommand } from './mcp/detect.js';
+import { marketplaceCommand } from './mcp/marketplace.js';
 export const mcpCommand = {
     command: 'mcp',
     describe: 'Manage MCP servers',
@@ -15,6 +16,7 @@ export const mcpCommand = {
         .command(removeCommand)
         .command(listCommand)
         .command(detectCommand)
+        .command(marketplaceCommand)
         .demandCommand(1, 'You need at least one command before continuing.')
         .version(false),
     handler: () => {

package/dist/src/commands/parallel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 'recoder parallel' command
+ * Run tasks in parallel using git worktrees
+ *
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+import type { CommandModule } from 'yargs';
+interface ParallelArgs {
+    prompt?: string;
+    'existing-branch'?: string;
+    list?: boolean;
+    cleanup?: boolean;
+}
+export declare const parallelCommand: CommandModule<{}, ParallelArgs>;
+interface ParallelFinishArgs {
+    worktree?: string;
+    branch?: string;
+}
+export declare const parallelFinishCommand: CommandModule<{}, ParallelFinishArgs>;
+export {};

package/dist/src/commands/parallel.js

@@ -0,0 +1,133 @@
+/**
+ * 'recoder parallel' command
+ * Run tasks in parallel using git worktrees
+ *
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+import { startParallelMode, finishParallelMode, listParallelWorktrees, cleanupStaleWorktrees, } from '../parallel/index.js';
+export const parallelCommand = {
+    command: 'parallel [prompt]',
+    describe: 'Run tasks in parallel using git worktrees',
+    builder: (yargs) => yargs
+        .positional('prompt', {
+        type: 'string',
+        describe: 'Task prompt to execute in parallel mode',
+    })
+        .option('existing-branch', {
+        alias: 'b',
+        type: 'string',
+        describe: 'Resume work on an existing parallel branch',
+    })
+        .option('list', {
+        alias: 'l',
+        type: 'boolean',
+        describe: 'List active parallel mode worktrees',
+    })
+        .option('cleanup', {
+        alias: 'c',
+        type: 'boolean',
+        describe: 'Clean up stale parallel mode worktrees',
+    })
+        .example([
+        ['$0 parallel "implement user auth"', 'Start parallel task with new branch'],
+        ['$0 parallel -b recoder/user-auth-123 "continue work"', 'Resume existing branch'],
+        ['$0 parallel --list', 'List active parallel worktrees'],
+        ['$0 parallel --cleanup', 'Clean up stale worktrees'],
+    ]),
+    handler: async (argv) => {
+        const cwd = process.cwd();
+        // Handle list command
+        if (argv.list) {
+            console.log('\n📋 Active parallel mode worktrees:\n');
+            const worktrees = await listParallelWorktrees(cwd);
+            if (worktrees.length === 0) {
+                console.log('   No active parallel worktrees found.\n');
+            }
+            else {
+                for (const wt of worktrees) {
+                    console.log(`   📁 ${wt}`);
+                }
+                console.log();
+            }
+            return;
+        }
+        // Handle cleanup command
+        if (argv.cleanup) {
+            console.log('\n🧹 Cleaning up stale parallel mode worktrees...\n');
+            const cleaned = await cleanupStaleWorktrees(cwd);
+            if (cleaned === 0) {
+                console.log('   No stale worktrees to clean up.\n');
+            }
+            else {
+                console.log(`\n✅ Cleaned up ${cleaned} stale worktree(s).\n`);
+            }
+            return;
+        }
+        // Require prompt for starting parallel mode
+        if (!argv.prompt) {
+            console.log('\n⚠️  Please provide a task prompt.\n');
+            console.log('Usage:');
+            console.log('  recoder parallel "your task description"');
+            console.log('  recoder parallel --existing-branch <branch> "continue task"');
+            console.log('  recoder parallel --list');
+            console.log('  recoder parallel --cleanup\n');
+            return;
+        }
+        try {
+            // Start parallel mode
+            const params = await startParallelMode(cwd, argv.prompt, argv['existing-branch']);
+            console.log('\n📍 You can now work in the worktree directory:');
+            console.log(`   cd ${params.worktreePath}\n`);
+            console.log('💡 When done, run your task and then call:');
+            console.log('   recoder parallel finish\n');
+            // Store the worktree info for later
+            console.log('Worktree info stored. Use "recoder parallel finish" when done.');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`\n❌ Failed to start parallel mode: ${message}\n`);
+            process.exit(1);
+        }
+    },
+};
+export const parallelFinishCommand = {
+    command: 'parallel-finish',
+    describe: 'Finish parallel mode and commit changes',
+    builder: (yargs) => yargs
+        .option('worktree', {
+        alias: 'w',
+        type: 'string',
+        describe: 'Path to the worktree to finish',
+    })
+        .option('branch', {
+        alias: 'b',
+        type: 'string',
+        describe: 'Branch name of the worktree',
+    }),
+    handler: async (argv) => {
+        const cwd = process.cwd();
+        // If worktree and branch provided, use them
+        if (argv.worktree && argv.branch) {
+            try {
+                const result = await finishParallelMode(argv.worktree, argv.branch, cwd);
+                if (result.success) {
+                    console.log(`\n✅ ${result.message}\n`);
+                }
+                else {
+                    console.error(`\n❌ ${result.message}\n`);
+                    process.exit(1);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`\n❌ Failed to finish parallel mode: ${message}\n`);
+                process.exit(1);
+            }
+            return;
+        }
+        // Otherwise, try to detect from current directory
+        console.log('\n⚠️  Please provide worktree and branch:');
+        console.log('   recoder parallel-finish --worktree <path> --branch <branch>\n');
+        console.log('Or use "recoder parallel --list" to see active worktrees.\n');
+    },
+};