recoder-code 2.4.7 → 2.5.1

package/dist/src/commands/agents/create.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Agent creation command - Create custom agents from templates
+ */
+export declare function createAgent(): Promise<void>;

package/dist/src/commands/agents/create.js

@@ -0,0 +1,175 @@
+/**
+ * Agent creation command - Create custom agents from templates
+ */
+import inquirer from 'inquirer';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+const AGENTS_DIR_PROJECT = '.recoder/agents';
+const AGENTS_DIR_USER = path.join(os.homedir(), '.recoder-code', 'agents');
+const AGENT_TEMPLATES = [
+    {
+        name: 'explorer',
+        description: 'Code discovery & research specialist',
+        systemPrompt: `You are an expert code explorer and researcher. Your role is to:
+- Search and analyze codebases to understand structure and patterns
+- Find relevant code examples and implementations
+- Identify dependencies and relationships between components
+- Discover best practices and conventions used in the project
+- Provide comprehensive reports on code organization
+
+Always be thorough and cite specific file paths and line numbers.`,
+    },
+    {
+        name: 'coder',
+        description: 'Implementation specialist',
+        systemPrompt: `You are an expert software engineer focused on implementation. Your role is to:
+- Write clean, production-ready code following best practices
+- Implement features with proper error handling and edge cases
+- Follow the project's existing patterns and conventions
+- Write self-documenting code with clear variable names
+- Consider performance and maintainability
+
+Always write complete, working implementations - no placeholders or TODOs.`,
+    },
+    {
+        name: 'reviewer',
+        description: 'Code quality & security specialist',
+        systemPrompt: `You are an expert code reviewer focused on quality and security. Your role is to:
+- Review code for bugs, security vulnerabilities, and performance issues
+- Check adherence to best practices and design patterns
+- Identify potential edge cases and error scenarios
+- Suggest improvements for readability and maintainability
+- Verify proper error handling and input validation
+
+Provide specific, actionable feedback with examples.`,
+    },
+    {
+        name: 'tester',
+        description: 'Test creation specialist',
+        systemPrompt: `You are an expert test engineer. Your role is to:
+- Write comprehensive unit, integration, and e2e tests
+- Cover edge cases and error scenarios
+- Follow testing best practices (AAA pattern, clear assertions)
+- Create meaningful test descriptions
+- Ensure high code coverage
+
+Write tests that are maintainable and serve as documentation.`,
+    },
+    {
+        name: 'documenter',
+        description: 'Documentation specialist',
+        systemPrompt: `You are an expert technical writer. Your role is to:
+- Create clear, comprehensive documentation
+- Write API documentation with examples
+- Document architecture and design decisions
+- Create user guides and tutorials
+- Maintain README files and changelogs
+
+Write documentation that is accessible to both beginners and experts.`,
+    },
+    {
+        name: 'custom',
+        description: 'Start from scratch',
+        systemPrompt: `You are a helpful AI assistant. Customize this prompt for your specific needs.`,
+    },
+];
+export async function createAgent() {
+    console.log(chalk.bold.cyan('\n🤖 Create Custom Agent\n'));
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'template',
+            message: 'Choose a template:',
+            choices: AGENT_TEMPLATES.map(t => ({
+                name: `${t.name} - ${t.description}`,
+                value: t.name,
+            })),
+        },
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Agent name:',
+            validate: (input) => {
+                if (!input)
+                    return 'Name is required';
+                if (!/^[a-z0-9-]+$/.test(input))
+                    return 'Use lowercase letters, numbers, and hyphens only';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description:',
+            default: (answers) => {
+                const template = AGENT_TEMPLATES.find(t => t.name === answers.template);
+                return template?.description || '';
+            },
+        },
+        {
+            type: 'list',
+            name: 'location',
+            message: 'Save location:',
+            choices: [
+                { name: 'Project (.recoder/agents/) - Available in this project only', value: 'project' },
+                { name: 'User (~/.recoder-code/agents/) - Available globally', value: 'user' },
+            ],
+            default: 'project',
+        },
+        {
+            type: 'confirm',
+            name: 'customize',
+            message: 'Customize system prompt now?',
+            default: false,
+        },
+    ]);
+    const template = AGENT_TEMPLATES.find(t => t.name === answers.template);
+    let systemPrompt = template?.systemPrompt || '';
+    if (answers.customize) {
+        const { prompt } = await inquirer.prompt([
+            {
+                type: 'editor',
+                name: 'prompt',
+                message: 'Edit system prompt:',
+                default: systemPrompt,
+            },
+        ]);
+        systemPrompt = prompt;
+    }
+    const dir = answers.location === 'project' ? AGENTS_DIR_PROJECT : AGENTS_DIR_USER;
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, `${answers.name}.md`);
+    if (fs.existsSync(filePath)) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Agent "${answers.name}" already exists. Overwrite?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            console.log(chalk.yellow('\n❌ Cancelled'));
+            return;
+        }
+    }
+    const content = `---
+name: ${answers.name}
+description: ${answers.description}
+template: ${answers.template}
+---
+
+${systemPrompt}
+`;
+    fs.writeFileSync(filePath, content, 'utf-8');
+    console.log(chalk.green(`\n✅ Agent "${answers.name}" created successfully!`));
+    console.log(chalk.gray(`   Location: ${filePath}`));
+    console.log(chalk.cyan('\n💡 Usage:'));
+    console.log(chalk.gray(`   In chat: "Let the ${answers.name} agent help with this"`));
+    console.log(chalk.gray(`   Edit: ${filePath}`));
+    console.log();
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Agent marketplace - Share and discover custom agents
+ */
+export declare function browseMarketplace(): Promise<void>;
+export declare function shareAgent(): Promise<void>;

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

@@ -0,0 +1,151 @@
+/**
+ * Agent marketplace - Share and discover custom agents
+ */
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const AGENTS_DIR_PROJECT = '.recoder/agents';
+const AGENTS_DIR_USER = path.join(os.homedir(), '.recoder-code', 'agents');
+const MARKETPLACE_URL = 'https://recoder.xyz/api/agents';
+export async function browseMarketplace() {
+    console.log(chalk.bold.cyan('\n🏪 Agent Marketplace\n'));
+    console.log(chalk.gray('Discover and install community agents\n'));
+    try {
+        // Fetch agents from marketplace
+        const response = await fetch(`${MARKETPLACE_URL}/list`);
+        if (!response.ok) {
+            throw new Error('Failed to fetch agents');
+        }
+        const agents = await response.json();
+        if (agents.length === 0) {
+            console.log(chalk.yellow('No agents available yet'));
+            console.log(chalk.gray('Be the first to share: recoder agents share'));
+            return;
+        }
+        const choices = agents.map(a => ({
+            name: `${a.name} - ${a.description} ${chalk.gray(`(by ${a.author})`)}`,
+            value: a.id,
+        }));
+        const { agentId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'agentId',
+                message: 'Select an agent to install:',
+                choices,
+                pageSize: 10,
+            },
+        ]);
+        const agent = agents.find(a => a.id === agentId);
+        if (!agent)
+            return;
+        const { location } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'location',
+                message: 'Install location:',
+                choices: [
+                    { name: 'Project (.recoder/agents/)', value: 'project' },
+                    { name: 'User (~/.recoder-code/agents/)', value: 'user' },
+                ],
+            },
+        ]);
+        await installAgent(agent, location);
+        console.log(chalk.green(`\n✅ Installed: ${agent.name}`));
+        console.log(chalk.cyan('💡 Usage:'));
+        console.log(chalk.gray(`   In chat: "Let the ${agent.name} agent help"`));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n❌ Error: ${err.message}`));
+        console.log(chalk.gray('Marketplace coming soon!'));
+    }
+}
+export async function shareAgent() {
+    console.log(chalk.bold.cyan('\n📤 Share Agent to Marketplace\n'));
+    // List local agents
+    const localAgents = [];
+    if (fs.existsSync(AGENTS_DIR_PROJECT)) {
+        fs.readdirSync(AGENTS_DIR_PROJECT)
+            .filter(f => f.endsWith('.md'))
+            .forEach(f => localAgents.push(`project:${f.replace('.md', '')}`));
+    }
+    if (fs.existsSync(AGENTS_DIR_USER)) {
+        fs.readdirSync(AGENTS_DIR_USER)
+            .filter(f => f.endsWith('.md'))
+            .forEach(f => localAgents.push(`user:${f.replace('.md', '')}`));
+    }
+    if (localAgents.length === 0) {
+        console.log(chalk.yellow('No custom agents found'));
+        console.log(chalk.gray('Create one first: recoder agents new'));
+        return;
+    }
+    const { agent } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'agent',
+            message: 'Select agent to share:',
+            choices: localAgents,
+        },
+    ]);
+    const [location, name] = agent.split(':');
+    const dir = location === 'project' ? AGENTS_DIR_PROJECT : AGENTS_DIR_USER;
+    const filePath = path.join(dir, `${name}.md`);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // Parse frontmatter
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match) {
+        console.log(chalk.red('Invalid agent format'));
+        return;
+    }
+    const frontmatter = match[1];
+    const description = frontmatter.match(/description: (.+)/)?.[1] || 'No description';
+    const { author, confirm } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'author',
+            message: 'Your name:',
+            validate: (input) => input.length > 0 || 'Name required',
+        },
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Share "${name}" to marketplace?`,
+            default: true,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.yellow('\n❌ Cancelled'));
+        return;
+    }
+    try {
+        const response = await fetch(`${MARKETPLACE_URL}/share`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name,
+                description,
+                author,
+                content,
+                version: '1.0.0',
+            }),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to share agent');
+        }
+        console.log(chalk.green(`\n✅ Agent shared successfully!`));
+        console.log(chalk.gray('   View at: https://recoder.xyz/agents'));
+    }
+    catch (err) {
+        console.log(chalk.red(`\n❌ Error: ${err.message}`));
+        console.log(chalk.gray('Marketplace coming soon!'));
+    }
+}
+async function installAgent(agent, location) {
+    const dir = location === 'project' ? AGENTS_DIR_PROJECT : AGENTS_DIR_USER;
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, `${agent.name}.md`);
+    fs.writeFileSync(filePath, agent.content, 'utf-8');
+}

package/dist/src/commands/agents.js

@@ -3,14 +3,53 @@
  */
 import chalk from 'chalk';
 import { listAgents, createAgentFromTemplate } from './agents/list.js';
+import { createAgent } from './agents/create.js';
+import { browseMarketplace, shareAgent } from './agents/marketplace.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
+async function requireAuth() {
+    const authService = new RecoderAuthService();
+    const session = await authService.getSession();
+    if (!session) {
+        console.error('❌ Please login first: recoder auth login');
+        process.exit(1);
+    }
+}
 const listCommand = {
     command: 'list',
     describe: 'List all available agents',
     handler: async () => {
+        await requireAuth();
         await listAgents();
         process.exit(0);
     },
 };
+const createInteractiveCommand = {
+    command: 'new',
+    describe: 'Create a custom agent interactively',
+    handler: async () => {
+        await requireAuth();
+        await createAgent();
+        process.exit(0);
+    },
+};
+const marketplaceCommand = {
+    command: 'browse',
+    describe: 'Browse agent marketplace',
+    handler: async () => {
+        await requireAuth();
+        await browseMarketplace();
+        process.exit(0);
+    },
+};
+const shareCommand = {
+    command: 'share',
+    describe: 'Share your agent to marketplace',
+    handler: async () => {
+        await requireAuth();
+        await shareAgent();
+        process.exit(0);
+    },
+};
 const createCommand = {
     command: 'create <name>',
     describe: 'Create a new agent from template',
@@ -29,6 +68,7 @@ const createCommand = {
         default: 'project',
     }),
     handler: async (argv) => {
+        await requireAuth();
         const location = argv.location === 'user' ? 'user' : 'project';
         const filePath = createAgentFromTemplate(argv.template || 'coder', argv.name, location);
         if (filePath) {
@@ -47,8 +87,16 @@ const createCommand = {
 export const agentsCommand = {
     command: 'agents',
     describe: 'Manage AI agents (built-in and custom)',
-    builder: (yargs) => yargs.command(listCommand).command(createCommand).demandCommand(0).version(false),
+    builder: (yargs) => yargs
+        .command(listCommand)
+        .command(createInteractiveCommand)
+        .command(marketplaceCommand)
+        .command(shareCommand)
+        .command(createCommand)
+        .demandCommand(0)
+        .version(false),
     handler: async () => {
+        await requireAuth();
         await listAgents();
         process.exit(0);
     },

package/dist/src/commands/configure.js

@@ -4,10 +4,18 @@
 import * as readline from 'readline';
 import { getProviderRegistry } from '../providers/registry.js';
 import { BUILTIN_PROVIDERS } from '../providers/types.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
 export const configureCommand = {
     command: 'configure',
     describe: 'Interactive configuration wizard',
     handler: async () => {
+        // Require authentication
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,

package/dist/src/commands/connect-cmd.js

@@ -2,10 +2,18 @@
  * Connect command module - Add custom providers interactively
  */
 import { connectProvider } from './connect.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
 export const connectCommand = {
     command: 'connect',
     describe: 'Add a custom AI provider (LM Studio, vLLM, etc.)',
     handler: async () => {
+        // Require authentication
+        const authService = new RecoderAuthService();
+        const session = await authService.getSession();
+        if (!session) {
+            console.error('❌ Please login first: recoder auth login');
+            process.exit(1);
+        }
         await connectProvider();
         process.exit(0);
     },

package/dist/src/commands/hints.js

@@ -3,10 +3,20 @@
  */
 import chalk from 'chalk';
 import { loadHints, createHintsFile, hasHints } from '../utils/hints.js';
+import { RecoderAuthService } from '../services/RecoderAuthService.js';
+async function requireAuth() {
+    const authService = new RecoderAuthService();
+    const session = await authService.getSession();
+    if (!session) {
+        console.error('❌ Please login first: recoder auth login');
+        process.exit(1);
+    }
+}
 const showCommand = {
     command: 'show',
     describe: 'Show current project hints',
     handler: async () => {
+        await requireAuth();
         const hints = loadHints();
         if (hints) {
             console.log(chalk.cyan(`\n📋 Hints from ${hints.filePath}\n`));
@@ -24,6 +34,7 @@ const initCommand = {
     command: 'init',
     describe: 'Create a .recoderhints file',
     handler: async () => {
+        await requireAuth();
         if (hasHints()) {
             console.log(chalk.yellow('\n⚠️  Hints file already exists'));
             const hints = loadHints();
@@ -44,6 +55,7 @@ export const hintsCommand = {
     describe: 'Manage project hints (.recoderhints)',
     builder: (yargs) => yargs.command(showCommand).command(initCommand).demandCommand(0).version(false),
     handler: async () => {
+        await requireAuth();
         const hints = loadHints();
         if (hints) {
             console.log(chalk.cyan(`\n📋 Project hints: ${hints.filePath}`));

package/dist/src/commands/models/compare.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Multi-model comparison mode
+ */
+export declare function compareModels(): Promise<void>;

package/dist/src/commands/models/compare.js

@@ -0,0 +1,92 @@
+/**
+ * Multi-model comparison mode
+ */
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getProviderRegistry } from '../../providers/registry.js';
+export async function compareModels() {
+    console.log(chalk.bold.cyan('\n⚖️  Multi-Model Comparison\n'));
+    const registry = getProviderRegistry();
+    const providers = registry.getAllProviders();
+    // Get available models
+    const modelChoices = [];
+    for (const provider of providers) {
+        try {
+            const models = await registry.getModels(provider.id);
+            models.forEach(m => {
+                modelChoices.push(`${provider.id}/${m.id}`);
+            });
+        }
+        catch {
+            // Skip
+        }
+    }
+    if (modelChoices.length < 2) {
+        console.log(chalk.red('❌ Need at least 2 models to compare'));
+        return;
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'models',
+            message: 'Select models to compare (2-4):',
+            choices: modelChoices.slice(0, 20),
+            validate: (input) => {
+                if (input.length < 2)
+                    return 'Select at least 2 models';
+                if (input.length > 4)
+                    return 'Select at most 4 models';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'prompt',
+            message: 'Enter prompt to test:',
+            validate: (input) => input.length > 0 || 'Prompt required',
+        },
+    ]);
+    console.log(chalk.cyan('\n🔄 Running comparison...\n'));
+    const results = [];
+    for (const model of answers.models) {
+        const start = Date.now();
+        try {
+            // Simulate API call (replace with actual implementation)
+            const response = `Response from ${model}`;
+            const responseTime = Date.now() - start;
+            results.push({
+                model,
+                response,
+                responseTime,
+            });
+        }
+        catch (err) {
+            results.push({
+                model,
+                response: '',
+                responseTime: Date.now() - start,
+                error: err.message,
+            });
+        }
+    }
+    // Display results
+    console.log(chalk.bold('Comparison Results:'));
+    console.log(chalk.gray('═'.repeat(60)));
+    results.forEach((result, i) => {
+        console.log(chalk.bold.cyan(`\n${i + 1}. ${result.model}`));
+        console.log(chalk.gray(`   Response time: ${result.responseTime}ms`));
+        if (result.error) {
+            console.log(chalk.red(`   Error: ${result.error}`));
+        }
+        else {
+            console.log(chalk.white(`   ${result.response.substring(0, 200)}...`));
+        }
+    });
+    console.log(chalk.gray('\n═'.repeat(60)));
+    // Show fastest
+    const fastest = results.filter(r => !r.error).sort((a, b) => a.responseTime - b.responseTime)[0];
+    if (fastest) {
+        console.log(chalk.green(`\n⚡ Fastest: ${fastest.model} (${fastest.responseTime}ms)`));
+    }
+    console.log();
+}

package/dist/src/commands/models/select.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Interactive model selection with fuzzy search
+ */
+export declare function selectModel(): Promise<void>;

package/dist/src/commands/models/select.js

@@ -0,0 +1,62 @@
+/**
+ * Interactive model selection with fuzzy search
+ */
+import inquirer from 'inquirer';
+import { getProviderRegistry } from '../../providers/registry.js';
+import chalk from 'chalk';
+export async function selectModel() {
+    console.log(chalk.bold.cyan('\n🤖 Select AI Model\n'));
+    const registry = getProviderRegistry();
+    const providers = registry.getAllProviders();
+    // Gather all models from all providers
+    const allModels = [];
+    for (const provider of providers) {
+        try {
+            const models = await registry.getModels(provider.id);
+            models.forEach(model => {
+                const contextInfo = model.contextLength ? ` (${Math.round(model.contextLength / 1000)}k ctx)` : '';
+                const freeTag = model.isFree ? chalk.green(' [FREE]') : '';
+                const providerTag = chalk.gray(` - ${provider.name}`);
+                allModels.push({
+                    name: `${model.id}${contextInfo}${freeTag}${providerTag}`,
+                    value: `${provider.id}/${model.id}`,
+                    provider: provider.id,
+                    contextLength: model.contextLength,
+                    isFree: model.isFree,
+                });
+            });
+        }
+        catch (err) {
+            // Skip providers that fail to load models
+        }
+    }
+    if (allModels.length === 0) {
+        console.log(chalk.red('❌ No models available'));
+        console.log(chalk.gray('   Run: recoder providers detect'));
+        return;
+    }
+    // Sort: free models first, then by context length
+    allModels.sort((a, b) => {
+        if (a.isFree && !b.isFree)
+            return -1;
+        if (!a.isFree && b.isFree)
+            return 1;
+        return (b.contextLength || 0) - (a.contextLength || 0);
+    });
+    const answer = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'model',
+            message: 'Select a model:',
+            choices: allModels.slice(0, 30),
+            pageSize: 15,
+        },
+    ]);
+    const selected = allModels.find(m => m.value === answer.model);
+    if (selected) {
+        console.log(chalk.green(`\n✅ Selected: ${selected.value}`));
+        console.log(chalk.cyan('\n💡 Usage:'));
+        console.log(chalk.gray(`   recoder --model ${selected.value}`));
+        console.log(chalk.gray(`   Or set as default: recoder models set-default ${selected.value}`));
+    }
+}