overai 1.4.0

package/dist/cli/commands/providers.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * Providers command - List and manage LLM providers
+ *
+ * Supports:
+ * - list: List all registered providers (60+ AI SDK v6 providers)
+ * - doctor: Check environment variables for selected provider
+ * - test: Run a small test request to verify provider works
+ * - info: Show provider details
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const providers_1 = require("../../llm/providers");
+const types_1 = require("../../llm/providers/ai-sdk/types");
+const env_1 = require("../runtime/env");
+const pretty_logger_1 = require("../../utils/pretty-logger");
+function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function formatSuccess(data) {
+    return { success: true, data };
+}
+function formatError(code, message, meta) {
+    return meta !== undefined
+        ? { success: false, error: { code, message }, meta }
+        : { success: false, error: { code, message } };
+}
+const ERROR_CODES = {
+    INVALID_ARGS: 'INVALID_ARGS',
+    MISSING_ARG: 'MISSING_ARG',
+    PROVIDER_NOT_FOUND: 'PROVIDER_NOT_FOUND',
+    UNKNOWN: 'UNKNOWN_ERROR',
+};
+const BUILTIN_PROVIDERS = ['openai', 'anthropic', 'google', 'gemini', 'oai', 'claude'];
+const PROVIDER_MODELS = {
+    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-4', 'gpt-3.5-turbo', 'gpt-5', 'gpt-5-mini'],
+    anthropic: ['claude-sonnet-4-20250514', 'claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307', 'claude-opus-4-5'],
+    google: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+    xai: ['grok-4', 'grok-3', 'grok-3-fast', 'grok-3-mini'],
+    groq: ['llama-3.3-70b-versatile', 'mixtral-8x7b-32768', 'gemma2-9b-it'],
+    mistral: ['mistral-large-latest', 'mistral-medium-latest', 'mistral-small-latest'],
+    deepseek: ['deepseek-chat', 'deepseek-reasoner'],
+    cerebras: ['llama3.1-8b', 'llama3.3-70b'],
+};
+async function execute(args, options) {
+    const subcommand = args[0] || 'list';
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    switch (subcommand) {
+        case 'list':
+            await listProvidersCommand(options, outputFormat);
+            break;
+        case 'doctor':
+            await doctorCommand(args[1] || options.provider, options, outputFormat);
+            break;
+        case 'test':
+            await testCommand(args[1] || options.provider, args[2] || options.model, options, outputFormat);
+            break;
+        case 'info':
+            await providerInfoCommand(args[1], options, outputFormat);
+            break;
+        default:
+            await listProvidersCommand(options, outputFormat);
+    }
+}
+async function listProvidersCommand(options, outputFormat) {
+    const registry = (0, providers_1.getDefaultRegistry)();
+    const registeredProviders = registry.list();
+    const providers = registeredProviders.map(name => {
+        const isBuiltin = BUILTIN_PROVIDERS.includes(name);
+        return {
+            name,
+            registered: true,
+            available: (0, providers_1.isProviderAvailable)(name),
+            hasApiKey: (0, env_1.hasApiKey)(name),
+            isBuiltin,
+            models: PROVIDER_MODELS[name]
+        };
+    });
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({
+            providers: providers.map(p => ({
+                name: p.name,
+                registered: p.registered,
+                available: p.available,
+                has_api_key: p.hasApiKey,
+                is_builtin: p.isBuiltin,
+                models: options.verbose ? p.models : undefined
+            })),
+            total: providers.length,
+            builtin_count: providers.filter(p => p.isBuiltin).length,
+            custom_count: providers.filter(p => !p.isBuiltin).length
+        }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.heading('Registered LLM Providers');
+        // Built-in providers
+        const builtinProviders = providers.filter(p => p.isBuiltin);
+        if (builtinProviders.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain('\n  Built-in:');
+            for (const provider of builtinProviders) {
+                const status = provider.available ? '✅' : '❌';
+                const keyStatus = provider.hasApiKey ? '🔑' : '⚠️ No API key';
+                await pretty_logger_1.PrettyLogger.plain(`    ${status} ${provider.name} ${keyStatus}`);
+                if (options.verbose && provider.models) {
+                    for (const model of provider.models) {
+                        await pretty_logger_1.PrettyLogger.dim(`        - ${model}`);
+                    }
+                }
+            }
+        }
+        // Custom providers
+        const customProviders = providers.filter(p => !p.isBuiltin);
+        if (customProviders.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain('\n  Custom:');
+            for (const provider of customProviders) {
+                const status = provider.available ? '✅' : '❌';
+                await pretty_logger_1.PrettyLogger.plain(`    ${status} ${provider.name}`);
+            }
+        }
+        await pretty_logger_1.PrettyLogger.newline();
+        await pretty_logger_1.PrettyLogger.info('Register custom providers with registerProvider():');
+        await pretty_logger_1.PrettyLogger.dim('  import { registerProvider } from "overai";');
+        await pretty_logger_1.PrettyLogger.dim('  registerProvider("cloudflare", CloudflareProvider);');
+        await pretty_logger_1.PrettyLogger.newline();
+        await pretty_logger_1.PrettyLogger.info('Set API keys via environment variables:');
+        await pretty_logger_1.PrettyLogger.dim('  OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY');
+    }
+}
+/**
+ * Doctor command - Check environment variables for a provider
+ */
+async function doctorCommand(providerName, options, outputFormat) {
+    // Get all AI SDK providers
+    const allProviders = Object.entries(types_1.AISDK_PROVIDERS);
+    if (providerName) {
+        // Check specific provider
+        const resolved = types_1.PROVIDER_ALIASES[providerName.toLowerCase()] || providerName.toLowerCase();
+        const providerInfo = types_1.AISDK_PROVIDERS[resolved];
+        if (!providerInfo) {
+            if (outputFormat === 'json') {
+                outputJson(formatError(ERROR_CODES.INVALID_ARGS, `Unknown provider: ${providerName}`));
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.error(`Unknown provider: ${providerName}`);
+                await pretty_logger_1.PrettyLogger.info(`Available providers: ${Object.keys(types_1.AISDK_PROVIDERS).slice(0, 10).join(', ')}...`);
+            }
+            return;
+        }
+        const hasKey = !!process.env[providerInfo.envKey];
+        const keyValue = process.env[providerInfo.envKey];
+        const maskedKey = keyValue ? `${keyValue.slice(0, 4)}...${keyValue.slice(-4)}` : 'not set';
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                provider: resolved,
+                env_key: providerInfo.envKey,
+                has_key: hasKey,
+                key_preview: hasKey ? maskedKey : null,
+                package: providerInfo.package,
+                description: providerInfo.description,
+                modalities: providerInfo.modalities,
+                status: hasKey ? 'ready' : 'missing_key'
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading(`Provider Doctor: ${resolved}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Package: ${providerInfo.package}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Description: ${providerInfo.description || 'N/A'}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Environment Variable: ${providerInfo.envKey}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Status: ${hasKey ? '✅ Ready' : '❌ Missing API Key'}`);
+            if (hasKey) {
+                await pretty_logger_1.PrettyLogger.dim(`  Key Preview: ${maskedKey}`);
+            }
+            else {
+                await pretty_logger_1.PrettyLogger.newline();
+                await pretty_logger_1.PrettyLogger.info(`Set the API key with:`);
+                await pretty_logger_1.PrettyLogger.dim(`  export ${providerInfo.envKey}=your-api-key`);
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.plain('  Modalities:');
+            const m = providerInfo.modalities;
+            await pretty_logger_1.PrettyLogger.plain(`    Text/Chat: ${m.chat ? '✅' : '❌'}  Embeddings: ${m.embeddings ? '✅' : '❌'}  Image: ${m.image ? '✅' : '❌'}`);
+            await pretty_logger_1.PrettyLogger.plain(`    Audio: ${m.audio ? '✅' : '❌'}  Speech: ${m.speech ? '✅' : '❌'}  Tools: ${m.tools ? '✅' : '❌'}`);
+        }
+    }
+    else {
+        // Check all providers
+        const results = allProviders.map(([name, info]) => ({
+            name,
+            envKey: info.envKey,
+            hasKey: !!process.env[info.envKey],
+            description: info.description
+        }));
+        const ready = results.filter(r => r.hasKey);
+        const missing = results.filter(r => !r.hasKey);
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                total: results.length,
+                ready: ready.length,
+                missing: missing.length,
+                providers: results
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.heading('Provider Environment Check');
+            await pretty_logger_1.PrettyLogger.plain(`\n  Total Providers: ${results.length}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Ready: ${ready.length} ✅`);
+            await pretty_logger_1.PrettyLogger.plain(`  Missing Keys: ${missing.length} ⚠️`);
+            if (ready.length > 0) {
+                await pretty_logger_1.PrettyLogger.plain('\n  Ready Providers:');
+                for (const p of ready.slice(0, 10)) {
+                    await pretty_logger_1.PrettyLogger.plain(`    ✅ ${p.name}`);
+                }
+                if (ready.length > 10) {
+                    await pretty_logger_1.PrettyLogger.dim(`    ... and ${ready.length - 10} more`);
+                }
+            }
+            await pretty_logger_1.PrettyLogger.newline();
+            await pretty_logger_1.PrettyLogger.info('Run "providers doctor <name>" for detailed info on a specific provider');
+        }
+    }
+}
+/**
+ * Test command - Run a small test request to verify provider works
+ */
+async function testCommand(providerName, modelName, options, outputFormat) {
+    if (!providerName) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Provider name required. Usage: providers test <provider> [model]'));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error('Provider name required. Usage: providers test <provider> [model]');
+        }
+        return;
+    }
+    const resolved = types_1.PROVIDER_ALIASES[providerName.toLowerCase()] || providerName.toLowerCase();
+    const providerInfo = types_1.AISDK_PROVIDERS[resolved];
+    if (!providerInfo) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.INVALID_ARGS, `Unknown provider: ${providerName}`));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error(`Unknown provider: ${providerName}`);
+        }
+        return;
+    }
+    // Check API key
+    if (!process.env[providerInfo.envKey]) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, `Missing API key: ${providerInfo.envKey}`));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error(`Missing API key: ${providerInfo.envKey}`);
+            await pretty_logger_1.PrettyLogger.info(`Set it with: export ${providerInfo.envKey}=your-api-key`);
+        }
+        return;
+    }
+    // Get default model
+    const model = modelName || PROVIDER_MODELS[resolved]?.[0] || 'default';
+    const modelString = `${resolved}/${model}`;
+    if (outputFormat !== 'json') {
+        await pretty_logger_1.PrettyLogger.info(`Testing ${modelString}...`);
+    }
+    const startTime = Date.now();
+    try {
+        // Try to use the backend resolver
+        const { resolveBackend } = await Promise.resolve().then(() => __importStar(require('../../llm/backend-resolver')));
+        const { provider } = await resolveBackend(modelString);
+        // Make a minimal test request
+        const result = await provider.generateText({
+            messages: [{ role: 'user', content: 'Say "test ok" and nothing else.' }],
+            temperature: 0,
+            maxTokens: 10
+        });
+        const latency = Date.now() - startTime;
+        const responseText = result.text?.slice(0, 50) || '[no response]';
+        if (outputFormat === 'json') {
+            outputJson(formatSuccess({
+                provider: resolved,
+                model,
+                status: 'success',
+                latency_ms: latency,
+                response_preview: responseText,
+                usage: result.usage
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.plain(`\n  ✅ Test Passed`);
+            await pretty_logger_1.PrettyLogger.plain(`  Provider: ${resolved}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Model: ${model}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Latency: ${latency}ms`);
+            await pretty_logger_1.PrettyLogger.dim(`  Response: "${responseText}"`);
+            if (result.usage) {
+                await pretty_logger_1.PrettyLogger.dim(`  Tokens: ${result.usage.totalTokens || 'N/A'}`);
+            }
+        }
+    }
+    catch (error) {
+        const latency = Date.now() - startTime;
+        const errorMessage = error.message || String(error);
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.UNKNOWN, errorMessage, {
+                provider: resolved,
+                model,
+                latency_ms: latency
+            }));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error(`Test Failed: ${errorMessage}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Provider: ${resolved}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Model: ${model}`);
+            await pretty_logger_1.PrettyLogger.plain(`  Latency: ${latency}ms`);
+        }
+    }
+}
+async function providerInfoCommand(name, options, outputFormat) {
+    if (!name) {
+        if (outputFormat === 'json') {
+            outputJson(formatError(ERROR_CODES.MISSING_ARG, 'Provider name required'));
+        }
+        else {
+            await pretty_logger_1.PrettyLogger.error('Provider name required. Usage: providers info <name>');
+        }
+        return;
+    }
+    const registry = (0, providers_1.getDefaultRegistry)();
+    const isRegistered = registry.has(name);
+    const isBuiltin = BUILTIN_PROVIDERS.includes(name.toLowerCase());
+    const available = (0, providers_1.isProviderAvailable)(name);
+    const models = PROVIDER_MODELS[name.toLowerCase()];
+    if (outputFormat === 'json') {
+        outputJson(formatSuccess({
+            name,
+            registered: isRegistered,
+            available,
+            is_builtin: isBuiltin,
+            has_api_key: (0, env_1.hasApiKey)(name),
+            models: models || []
+        }));
+    }
+    else {
+        await pretty_logger_1.PrettyLogger.heading(`Provider: ${name}`);
+        await pretty_logger_1.PrettyLogger.plain(`  Registered: ${isRegistered ? '✅ Yes' : '❌ No'}`);
+        await pretty_logger_1.PrettyLogger.plain(`  Available: ${available ? '✅ Yes' : '❌ No'}`);
+        await pretty_logger_1.PrettyLogger.plain(`  Type: ${isBuiltin ? 'Built-in' : 'Custom'}`);
+        await pretty_logger_1.PrettyLogger.plain(`  API Key: ${(0, env_1.hasApiKey)(name) ? '🔑 Set' : '⚠️ Not set'}`);
+        if (models && models.length > 0) {
+            await pretty_logger_1.PrettyLogger.plain('\n  Models:');
+            for (const model of models) {
+                await pretty_logger_1.PrettyLogger.dim(`    - ${model}`);
+            }
+        }
+    }
+}

package/dist/cli/commands/query-rewrite.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Query Rewrite command - Rewrite queries for better search results
+ */
+export interface QueryRewriteOptions {
+    model?: string;
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    strategy?: string;
+    count?: number;
+}
+export declare function execute(args: string[], options: QueryRewriteOptions): Promise<void>;

package/dist/cli/commands/query-rewrite.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Query Rewrite command - Rewrite queries for better search results
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const query_rewriter_1 = require("../../agent/query-rewriter");
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+async function execute(args, options) {
+    const query = args.join(' ');
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    const config = (0, resolve_1.resolveConfig)(options);
+    if (!query) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a query to rewrite'));
+        }
+        else {
+            await pretty.error('Please provide a query to rewrite');
+            await pretty.dim('Usage: overai query-rewrite "your search query"');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const startTime = Date.now();
+    try {
+        if (outputFormat !== 'json') {
+            await pretty.info(`Rewriting query: "${query}"`);
+        }
+        const agent = (0, query_rewriter_1.createQueryRewriterAgent)({
+            llm: config.model,
+            verbose: options.verbose,
+            defaultStrategy: options.strategy
+        });
+        const result = await agent.rewrite(query);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                originalQuery: query,
+                rewrittenQueries: result.rewritten,
+                strategy: result.strategy,
+                confidence: result.confidence
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else {
+            await pretty.heading('Rewritten Queries');
+            for (let i = 0; i < result.rewritten.length; i++) {
+                await pretty.plain(`  ${i + 1}. ${result.rewritten[i]}`);
+            }
+            await pretty.newline();
+            await pretty.dim(`Strategy: ${result.strategy}`);
+            await pretty.success(`Completed in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(errors_1.ERROR_CODES.UNKNOWN, error instanceof Error ? error.message : String(error)));
+        }
+        else {
+            await pretty.error(error instanceof Error ? error.message : String(error));
+        }
+        process.exit(cli_spec_1.EXIT_CODES.RUNTIME_ERROR);
+    }
+}

package/dist/cli/commands/repo-map.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI command: repo-map
+ * Repository structure visualization and symbol extraction
+ */
+export declare function execute(args: string[], options: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/repo-map.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * CLI command: repo-map
+ * Repository structure visualization and symbol extraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const repo_map_1 = require("../features/repo-map");
+async function execute(args, options) {
+    const subcommand = args[0] || 'tree';
+    const isJson = Boolean(options.output === 'json' || options.json);
+    switch (subcommand) {
+        case 'tree':
+            await handleTree(args.slice(1), options, isJson);
+            break;
+        case 'symbols':
+            await handleSymbols(args.slice(1), options, isJson);
+            break;
+        case 'help':
+        default:
+            if (subcommand !== 'help' && !subcommand.startsWith('-')) {
+                // Treat as path for tree command
+                await handleTree([subcommand, ...args.slice(1)], options, isJson);
+            }
+            else {
+                showHelp(isJson);
+            }
+    }
+}
+async function handleTree(args, options, isJson) {
+    const rootPath = args[0] || process.cwd();
+    const maxDepth = options.depth || 5;
+    const includeSymbols = Boolean(options.symbols);
+    const map = (0, repo_map_1.createRepoMap)({
+        rootPath,
+        maxDepth,
+        includeSymbols
+    });
+    try {
+        const result = await map.generate();
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                root: result.root,
+                totalFiles: result.totalFiles,
+                totalDirectories: result.totalDirectories,
+                symbolCount: result.symbols.length
+            }, null, 2));
+        }
+        else {
+            console.log(result.summary);
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+async function handleSymbols(args, options, isJson) {
+    const rootPath = args[0] || process.cwd();
+    const maxDepth = options.depth || 5;
+    const map = (0, repo_map_1.createRepoMap)({
+        rootPath,
+        maxDepth,
+        includeSymbols: true
+    });
+    try {
+        const result = await map.generate();
+        if (isJson) {
+            console.log(JSON.stringify({
+                success: true,
+                symbols: result.symbols,
+                count: result.symbols.length
+            }, null, 2));
+        }
+        else {
+            console.log(`Symbols in ${rootPath}:\n`);
+            const byType = {};
+            for (const sym of result.symbols) {
+                if (!byType[sym.type])
+                    byType[sym.type] = [];
+                byType[sym.type].push(sym);
+            }
+            for (const [type, symbols] of Object.entries(byType)) {
+                console.log(`${type}s (${symbols.length}):`);
+                for (const sym of symbols.slice(0, 20)) {
+                    const exported = sym.exported ? ' [exported]' : '';
+                    console.log(`  ${sym.name}${exported} (line ${sym.line})`);
+                }
+                if (symbols.length > 20) {
+                    console.log(`  ... and ${symbols.length - 20} more`);
+                }
+                console.log();
+            }
+        }
+    }
+    catch (error) {
+        if (isJson) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+function showHelp(isJson) {
+    const help = {
+        command: 'repo-map',
+        description: 'Repository structure visualization and symbol extraction',
+        subcommands: {
+            tree: 'Show repository tree structure',
+            symbols: 'Extract and list code symbols'
+        },
+        flags: {
+            '--depth': 'Maximum directory depth (default: 5)',
+            '--symbols': 'Include symbols in tree output',
+            '--json': 'Output in JSON format'
+        },
+        examples: [
+            'overai repo-map',
+            'overai repo-map tree ./src',
+            'overai repo-map tree --depth 3',
+            'overai repo-map symbols ./src',
+            'overai repo-map tree --symbols'
+        ]
+    };
+    if (isJson) {
+        console.log(JSON.stringify(help, null, 2));
+    }
+    else {
+        console.log('Repo Map - Repository visualization\n');
+        console.log('Subcommands:');
+        for (const [cmd, desc] of Object.entries(help.subcommands)) {
+            console.log(`  ${cmd.padEnd(12)} ${desc}`);
+        }
+        console.log('\nFlags:');
+        for (const [flag, desc] of Object.entries(help.flags)) {
+            console.log(`  ${flag.padEnd(12)} ${desc}`);
+        }
+        console.log('\nExamples:');
+        for (const ex of help.examples) {
+            console.log(`  ${ex}`);
+        }
+    }
+}

package/dist/cli/commands/reranker.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reranker command - Document reranking
+ */
+export interface RerankerOptions {
+    verbose?: boolean;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    provider?: string;
+}
+export declare function execute(args: string[], options: RerankerOptions): Promise<void>;