recoder-code 2.4.7 → 2.5.0

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.js

@@ -3,6 +3,7 @@
  */
 import chalk from 'chalk';
 import { listAgents, createAgentFromTemplate } from './agents/list.js';
+import { createAgent } from './agents/create.js';
 const listCommand = {
     command: 'list',
     describe: 'List all available agents',
@@ -11,6 +12,14 @@ const listCommand = {
         process.exit(0);
     },
 };
+const createInteractiveCommand = {
+    command: 'new',
+    describe: 'Create a custom agent interactively',
+    handler: async () => {
+        await createAgent();
+        process.exit(0);
+    },
+};
 const createCommand = {
     command: 'create <name>',
     describe: 'Create a new agent from template',
@@ -47,7 +56,12 @@ 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(createCommand)
+        .demandCommand(0)
+        .version(false),
     handler: async () => {
         await listAgents();
         process.exit(0);

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}`));
+    }
+}

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

@@ -6,6 +6,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { getOllamaProvider, getOpenRouterProvider, getAnthropicProvider, getOpenAIProvider, getGroqProvider, parseModelId, } from '../providers/index.js';
+import { selectModel } from './models/select.js';
+import { compareModels } from './models/compare.js';
 const CONFIG_DIR = path.join(os.homedir(), '.recoder-code');
 const CUSTOM_MODELS_FILE = path.join(CONFIG_DIR, 'custom-models.json');
 const DEFAULT_MODEL_FILE = path.join(CONFIG_DIR, 'default-model.json');
@@ -162,11 +164,29 @@ const setDefaultCommand = {
         process.exit(0);
     },
 };
+const selectCommand = {
+    command: 'select',
+    describe: 'Interactive model selection with fuzzy search',
+    handler: async () => {
+        await selectModel();
+        process.exit(0);
+    },
+};
+const compareCommand = {
+    command: 'compare',
+    describe: 'Compare multiple models side-by-side',
+    handler: async () => {
+        await compareModels();
+        process.exit(0);
+    },
+};
 export const modelsCommand = {
     command: 'models',
     describe: 'Manage AI models',
     builder: (yargs) => yargs
         .command(listCommand)
+        .command(selectCommand)
+        .command(compareCommand)
         .command(addCommand)
         .command(removeCommand)
         .command(setDefaultCommand)

package/dist/src/commands/providers/health.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Provider health monitoring
+ */
+export declare function monitorProviders(): Promise<void>;

package/dist/src/commands/providers/health.js

@@ -0,0 +1,90 @@
+/**
+ * Provider health monitoring
+ */
+import chalk from 'chalk';
+import { getProviderRegistry } from '../../providers/registry.js';
+async function checkProviderHealth(provider) {
+    const start = Date.now();
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        let endpoint = provider.baseUrl;
+        if (provider.engine === 'openai') {
+            endpoint = `${provider.baseUrl}/models`;
+        }
+        else if (provider.engine === 'ollama') {
+            endpoint = `${provider.baseUrl}/api/tags`;
+        }
+        const response = await fetch(endpoint, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...provider.headers,
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        const responseTime = Date.now() - start;
+        if (response.ok) {
+            return {
+                provider: provider.id,
+                name: provider.name,
+                status: 'online',
+                responseTime,
+            };
+        }
+        else {
+            return {
+                provider: provider.id,
+                name: provider.name,
+                status: 'error',
+                error: `HTTP ${response.status}`,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            provider: provider.id,
+            name: provider.name,
+            status: 'offline',
+            error: err.message || 'Connection failed',
+        };
+    }
+}
+export async function monitorProviders() {
+    console.log(chalk.bold.cyan('\n🏥 Provider Health Monitor\n'));
+    console.log(chalk.gray('Checking all providers...\n'));
+    const registry = getProviderRegistry();
+    const providers = registry.getAllProviders();
+    const results = [];
+    for (const provider of providers) {
+        const status = await checkProviderHealth(provider);
+        results.push(status);
+    }
+    // Display results
+    console.log(chalk.bold('Status Report:'));
+    console.log(chalk.gray('─'.repeat(60)));
+    const online = results.filter(r => r.status === 'online');
+    const offline = results.filter(r => r.status === 'offline');
+    const errors = results.filter(r => r.status === 'error');
+    online.forEach(r => {
+        console.log(chalk.green('✓') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`(${r.responseTime}ms)`));
+    });
+    errors.forEach(r => {
+        console.log(chalk.yellow('⚠') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`- ${r.error}`));
+    });
+    offline.forEach(r => {
+        console.log(chalk.red('✗') + ' ' +
+            chalk.bold(r.name) + ' ' +
+            chalk.gray(`- ${r.error}`));
+    });
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.green(`${online.length} online`) + ' | ' +
+        chalk.yellow(`${errors.length} errors`) + ' | ' +
+        chalk.red(`${offline.length} offline`));
+    console.log();
+}

package/dist/src/commands/providers.js

@@ -6,6 +6,8 @@ import { listProviderModels } from './providers/models.js';
 import { pullModel } from './providers/pull.js';
 import { configureProvider } from './providers/config.js';
 import { RecoderAuthService } from '../services/RecoderAuthService.js';
+import { detectAndReport } from '../providers/local-detection.js';
+import { monitorProviders } from './providers/health.js';
 const listCommand = {
     command: 'list',
     describe: 'List all available providers',
@@ -20,6 +22,22 @@ const listCommand = {
         process.exit(0);
     },
 };
+const detectCommand = {
+    command: 'detect',
+    describe: 'Detect running local AI servers',
+    handler: async () => {
+        await detectAndReport();
+        process.exit(0);
+    },
+};
+const healthCommand = {
+    command: 'health',
+    describe: 'Monitor provider health status',
+    handler: async () => {
+        await monitorProviders();
+        process.exit(0);
+    },
+};
 const modelsCommand = {
     command: 'models [provider]',
     describe: 'List models from all providers',
@@ -80,6 +98,8 @@ export const providersCommand = {
     describe: 'Manage AI providers (Ollama, OpenRouter, etc.)',
     builder: (yargs) => yargs
         .command(listCommand)
+        .command(detectCommand)
+        .command(healthCommand)
         .command(modelsCommand)
         .command(pullCommand)
         .command(configCommand)

package/dist/src/providers/local-detection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Local Provider Detection - Auto-detect running local AI servers
+ */
+import type { AIProvider } from './types.js';
+export declare function detectLocalProviders(): Promise<AIProvider[]>;
+export declare function detectAndReport(): Promise<void>;

package/dist/src/providers/local-detection.js

@@ -0,0 +1,86 @@
+/**
+ * Local Provider Detection - Auto-detect running local AI servers
+ */
+const LOCAL_PROVIDERS = [
+    {
+        id: 'lmstudio',
+        name: 'LM Studio',
+        port: 1234,
+        baseUrl: 'http://localhost:1234/v1',
+        engine: 'openai',
+    },
+    {
+        id: 'ollama',
+        name: 'Ollama',
+        port: 11434,
+        baseUrl: 'http://localhost:11434',
+        engine: 'ollama',
+    },
+    {
+        id: 'llamacpp',
+        name: 'llama.cpp',
+        port: 8080,
+        baseUrl: 'http://localhost:8080/v1',
+        engine: 'openai',
+    },
+    {
+        id: 'vllm',
+        name: 'vLLM',
+        port: 8000,
+        baseUrl: 'http://localhost:8000/v1',
+        engine: 'openai',
+    },
+];
+async function checkServer(url) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1000);
+        const response = await fetch(url, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectLocalProviders() {
+    const detected = [];
+    for (const provider of LOCAL_PROVIDERS) {
+        const isRunning = await checkServer(provider.baseUrl);
+        if (isRunning) {
+            detected.push({
+                id: provider.id,
+                name: provider.name,
+                engine: provider.engine,
+                baseUrl: provider.baseUrl,
+                isLocal: true,
+                isEnabled: true,
+                isBuiltin: false,
+                supportsStreaming: true,
+            });
+        }
+    }
+    return detected;
+}
+export async function detectAndReport() {
+    console.log('🔍 Detecting local AI servers...\n');
+    const detected = await detectLocalProviders();
+    if (detected.length === 0) {
+        console.log('❌ No local AI servers detected');
+        console.log('\n💡 Start one of these:');
+        LOCAL_PROVIDERS.forEach(p => {
+            console.log(`   • ${p.name} (port ${p.port})`);
+        });
+    }
+    else {
+        console.log('✅ Detected local servers:\n');
+        detected.forEach(p => {
+            console.log(`   • ${p.name} - ${p.baseUrl}`);
+        });
+        console.log('\n💡 Use with: recoder --provider ' + detected[0].id);
+    }
+    console.log();
+}

package/dist/src/providers/registry.js

@@ -11,8 +11,8 @@ const PROVIDERS_FILE = path.join(CONFIG_DIR, 'providers.json');
 const CUSTOM_PROVIDERS_DIR = path.join(CONFIG_DIR, 'custom_providers');
 const DEFAULT_CONFIG = {
     version: '1.0',
-    defaultProvider: 'anthropic',
-    defaultModel: 'claude-sonnet-4-20250514',
+    defaultProvider: 'openrouter',
+    defaultModel: 'anthropic/claude-sonnet-4-20250514',
     customProviders: [],
     lastUpdated: new Date().toISOString(),
 };