codehere 0.2.2 → 0.3.0-rc.10

package/dist/tools/parser.js

@@ -1,158 +0,0 @@
-/**
- * Tool Call Parser
- * Parse tool calls from LLM responses
- * Handles JSON extraction and validation
- */
-/**
- * Parse tool calls from LLM response
- * Handles various formats:
- * - JSON object: {"tool": "bash", "parameters": {...}}
- * - JSON array: [{"tool": "bash", ...}, ...]
- * - Markdown code blocks: ```json {...} ```
- * - Inline JSON: tool: bash, params: {...}
- */
-export function parseToolCalls(response) {
-    const calls = [];
-    // 1. Try to parse the entire response as JSON (Handles Test 1 & 2)
-    try {
-        const parsed = JSON.parse(response.trim());
-        if (Array.isArray(parsed)) {
-            parsed.forEach(item => {
-                const validated = validateToolCall(item);
-                if (validated)
-                    calls.push(validated);
-            });
-        }
-        else {
-            const validated = validateToolCall(parsed);
-            if (validated)
-                calls.push(validated);
-        }
-        if (calls.length > 0)
-            return calls;
-    }
-    catch {
-        // Not valid JSON, continue to other methods
-    }
-    // 2. Try to extract JSON from markdown code blocks (Handles Test 3)
-    const codeBlockMatch = response.match(/```(?:json)?\s*(\[[\s\S]*?\]|{[\s\S]*?})\s*```/);
-    if (codeBlockMatch) {
-        try {
-            const parsed = JSON.parse(codeBlockMatch[1]);
-            if (Array.isArray(parsed)) {
-                parsed.forEach(item => {
-                    const validated = validateToolCall(item);
-                    if (validated)
-                        calls.push(validated);
-                });
-            }
-            else {
-                const validated = validateToolCall(parsed);
-                if (validated)
-                    calls.push(validated);
-            }
-            return calls;
-        }
-        catch {
-            // Fall through to other parsing methods
-        }
-    }
-    // 3. Try to find JSON object/array in response (Fallback)
-    const jsonMatch = response.match(/(\[[\s\S]*?\]|{[\s\S]*?})/);
-    if (jsonMatch) {
-        try {
-            const parsed = JSON.parse(jsonMatch[1]);
-            if (Array.isArray(parsed)) {
-                parsed.forEach(item => {
-                    const validated = validateToolCall(item);
-                    if (validated)
-                        calls.push(validated);
-                });
-            }
-            else {
-                const validated = validateToolCall(parsed);
-                if (validated)
-                    calls.push(validated);
-            }
-            // Only return if we actually found valid tool calls
-            if (calls.length > 0)
-                return calls;
-        }
-        catch {
-            // Fall through to other parsing methods
-        }
-    }
-    // 4. Try to parse structured text format (Handles Test 5 - Error Recovery)
-    // Format: tool: name, parameters: {...}
-    const textMatch = response.match(/tool:\s*(\w+)[\s\S]*?parameters?:\s*({[\s\S]*?})/i);
-    if (textMatch) {
-        try {
-            const toolName = textMatch[1];
-            const paramsStr = textMatch[2];
-            const parameters = JSON.parse(paramsStr);
-            const call = validateToolCall({ tool: toolName, parameters });
-            if (call) {
-                calls.push(call);
-            }
-        }
-        catch {
-            // Ignore parsing errors
-        }
-    }
-    return calls;
-}
-/**
- * Validate and normalize a tool call
- */
-function validateToolCall(call) {
-    if (!call || typeof call !== 'object') {
-        return null;
-    }
-    // Check required fields
-    if (!call.tool || typeof call.tool !== 'string') {
-        return null;
-    }
-    // Normalize parameters
-    const parameters = call.parameters || call.params || call.args || {};
-    if (typeof parameters !== 'object') {
-        return null;
-    }
-    return {
-        tool: call.tool.trim().toLowerCase(),
-        parameters,
-        id: call.id || call.callId || undefined,
-    };
-}
-/**
- * Handle partial/malformed responses
- * Attempts to fix common issues
- */
-export function fixToolCall(response) {
-    let fixed = response;
-    // Fix common JSON issues
-    // 1. Missing quotes around keys
-    fixed = fixed.replace(/([{,]\s*)(\w+)(\s*:)/g, '$1"$2"$3');
-    // 2. Single quotes instead of double quotes
-    fixed = fixed.replace(/'/g, '"');
-    // 3. Trailing commas
-    fixed = fixed.replace(/,(\s*[}\]])/g, '$1');
-    // 4. Comments in JSON
-    fixed = fixed.replace(/\/\/.*$/gm, '');
-    fixed = fixed.replace(/\/\*[\s\S]*?\*\//g, '');
-    return fixed;
-}
-/**
- * Extract tool calls with error recovery
- * Tries multiple parsing strategies
- */
-export function extractToolCalls(response) {
-    // Try normal parsing first
-    let calls = parseToolCalls(response);
-    // If no calls found, try fixing common issues
-    if (calls.length === 0) {
-        const fixed = fixToolCall(response);
-        calls = parseToolCalls(fixed);
-    }
-    return calls;
-}
-//# sourceMappingURL=parser.js.map

package/dist/tools/registry.js

@@ -1,302 +0,0 @@
-/**
- * Tool Registry
- * Central registry for all available tools
- * Provides tool lookup and description access
- */
-import { executeBash, BASH_TOOL_DESCRIPTION } from './bash.js';
-import { viewFile, createFile, strReplace, undoEdit, EDIT_TOOL_DESCRIPTION } from './edit.js';
-import { searchCodebase, SEARCH_TOOL_DESCRIPTION } from './search.js';
-import { GitTool, GIT_TOOL_DESCRIPTION } from './git-tool.js';
-/**
- * Tool Registry
- * Singleton registry for all tools
- */
-export class ToolRegistry {
-    tools = new Map();
-    constructor() {
-        this.registerAllTools();
-    }
-    /**
-     * Register all available tools
-     */
-    registerAllTools() {
-        // Bash Tool
-        this.register({
-            name: 'bash',
-            description: 'Execute shell commands safely',
-            modelDescription: BASH_TOOL_DESCRIPTION,
-            execute: async (command, options) => {
-                return await executeBash(command, options);
-            },
-            parameters: {
-                command: {
-                    type: 'string',
-                    required: true,
-                    description: 'Shell command to execute',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Bash options (cwd, timeout, maxOutputSize, env)',
-                },
-            },
-        });
-        // Edit Tool - view
-        this.register({
-            name: 'edit_view',
-            description: 'View file content',
-            modelDescription: EDIT_TOOL_DESCRIPTION,
-            execute: async (filepath, options) => {
-                return viewFile(filepath, options);
-            },
-            parameters: {
-                filepath: {
-                    type: 'string',
-                    required: true,
-                    description: 'File path to view',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Edit options (cwd, createIfNotExists)',
-                },
-            },
-        });
-        // Edit Tool - create
-        this.register({
-            name: 'edit_create',
-            description: 'Create a new file',
-            modelDescription: EDIT_TOOL_DESCRIPTION,
-            execute: async (filepath, content, options) => {
-                return createFile(filepath, content, options);
-            },
-            parameters: {
-                filepath: {
-                    type: 'string',
-                    required: true,
-                    description: 'File path to create',
-                },
-                content: {
-                    type: 'string',
-                    required: true,
-                    description: 'File content',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Edit options (cwd, createIfNotExists)',
-                },
-            },
-        });
-        // Edit Tool - str_replace
-        this.register({
-            name: 'edit_replace',
-            description: 'Replace string in file (exact match required)',
-            modelDescription: EDIT_TOOL_DESCRIPTION,
-            execute: async (filepath, oldString, newString, options) => {
-                return strReplace(filepath, oldString, newString, options);
-            },
-            parameters: {
-                filepath: {
-                    type: 'string',
-                    required: true,
-                    description: 'File path to edit',
-                },
-                oldString: {
-                    type: 'string',
-                    required: true,
-                    description: 'String to replace (must match exactly)',
-                },
-                newString: {
-                    type: 'string',
-                    required: true,
-                    description: 'Replacement string',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Edit options (cwd)',
-                },
-            },
-        });
-        // Edit Tool - undo
-        this.register({
-            name: 'edit_undo',
-            description: 'Undo last edit',
-            modelDescription: EDIT_TOOL_DESCRIPTION,
-            execute: async (filepath, options) => {
-                return undoEdit(filepath, options);
-            },
-            parameters: {
-                filepath: {
-                    type: 'string',
-                    required: true,
-                    description: 'File path to undo',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Edit options (cwd)',
-                },
-            },
-        });
-        // Search Tool
-        this.register({
-            name: 'search',
-            description: 'Search codebase using intelligent retrieval',
-            modelDescription: SEARCH_TOOL_DESCRIPTION,
-            execute: async (query, options) => {
-                return await searchCodebase(query, options);
-            },
-            parameters: {
-                query: {
-                    type: 'string',
-                    required: true,
-                    description: 'Search query',
-                },
-                options: {
-                    type: 'object',
-                    required: false,
-                    description: 'Search options (baseDir, maxResults, fileTypes, minScore)',
-                },
-            },
-        });
-        // Git Tool
-        this.register({
-            name: 'git',
-            description: 'Git version control operations (COMMIT, BRANCH, MERGE, DIFF, LOG)',
-            modelDescription: GIT_TOOL_DESCRIPTION,
-            execute: async (operation, params) => {
-                const gitTool = new GitTool();
-                switch (operation.toLowerCase()) {
-                    case 'commit':
-                        return await gitTool.commit(params?.message || 'Codehere commit', params?.files);
-                    case 'branch':
-                        return await gitTool.branch(params?.branch || 'main', params?.create || false, params?.switchTo || false);
-                    case 'merge':
-                        return await gitTool.merge(params?.branch || 'main', params?.strategy || 'merge');
-                    case 'diff':
-                        return await gitTool.diff(params?.source, params?.target, params?.filepath);
-                    case 'log':
-                        return await gitTool.log(params?.limit || 10, params?.filepath);
-                    case 'status':
-                        return await gitTool.status();
-                    default:
-                        return {
-                            success: false,
-                            output: '',
-                            error: `Unknown git operation: ${operation}`,
-                        };
-                }
-            },
-            parameters: {
-                operation: {
-                    type: 'string',
-                    required: true,
-                    description: 'Git operation: commit, branch, merge, diff, log, status',
-                },
-                message: {
-                    type: 'string',
-                    required: false,
-                    description: 'Commit message (for commit operation)',
-                },
-                branch: {
-                    type: 'string',
-                    required: false,
-                    description: 'Branch name (for branch/merge operations)',
-                },
-                files: {
-                    type: 'array',
-                    required: false,
-                    description: 'File paths (for commit operation)',
-                },
-                source: {
-                    type: 'string',
-                    required: false,
-                    description: 'Source commit/branch (for diff operation)',
-                },
-                target: {
-                    type: 'string',
-                    required: false,
-                    description: 'Target commit/branch (for diff operation)',
-                },
-                limit: {
-                    type: 'number',
-                    required: false,
-                    description: 'Number of commits to return (for log operation)',
-                },
-            },
-        });
-    }
-    /**
-     * Register a tool
-     */
-    register(tool) {
-        if (this.tools.has(tool.name)) {
-            throw new Error(`Tool "${tool.name}" is already registered`);
-        }
-        this.tools.set(tool.name, tool);
-    }
-    /**
-     * Get a tool by name
-     */
-    get(name) {
-        return this.tools.get(name);
-    }
-    /**
-     * Get all tools
-     */
-    getAll() {
-        return Array.from(this.tools.values());
-    }
-    /**
-     * Get all tool names
-     */
-    getNames() {
-        return Array.from(this.tools.keys());
-    }
-    /**
-     * Check if a tool exists
-     */
-    has(name) {
-        return this.tools.has(name);
-    }
-    /**
-     * Get tool descriptions for the model
-     * Returns formatted string with all tool descriptions
-     */
-    getModelDescriptions() {
-        const tools = this.getAll();
-        return tools.map(tool => {
-            return `## ${tool.name}\n${tool.modelDescription}`;
-        }).join('\n\n---\n\n');
-    }
-    /**
-     * Get tool list summary for the model
-     * Returns compact list of available tools
-     */
-    getToolList() {
-        const tools = this.getAll();
-        return tools.map(tool => {
-            return `- ${tool.name}: ${tool.description}`;
-        }).join('\n');
-    }
-}
-// Singleton instance
-let registryInstance = null;
-/**
- * Get the global tool registry instance
- */
-export function getToolRegistry() {
-    if (!registryInstance) {
-        registryInstance = new ToolRegistry();
-    }
-    return registryInstance;
-}
-/**
- * Reset the registry (for testing)
- */
-export function resetToolRegistry() {
-    registryInstance = null;
-}
-//# sourceMappingURL=registry.js.map

package/dist/tools/search.js

@@ -1,100 +0,0 @@
-/**
- * Search Tool
- * Leverages our intelligent retrieval (competitive advantage)
- * Provides semantic codebase search with AST-based context
- */
-import { searchIntelligent } from '../search.js';
-/**
- * Search codebase using intelligent retrieval
- *
- * This is our competitive advantage - uses AST-based context retrieval
- * instead of naive cosine similarity
- */
-export async function searchCodebase(query, options = {}) {
-    try {
-        const result = await searchIntelligent(query, {
-            baseDir: options.baseDir || process.cwd(),
-            maxTokens: 2000, // Default token limit
-        });
-        // Filter results by maxResults if specified
-        let chunks = result.chunks;
-        if (options.maxResults) {
-            chunks = chunks.slice(0, options.maxResults);
-        }
-        // Apply file type filter if specified
-        if (options.fileTypes && options.fileTypes.length > 0) {
-            chunks = chunks.filter(chunk => {
-                const ext = chunk.filepath.split('.').pop()?.toLowerCase();
-                return ext && options.fileTypes.includes(ext);
-            });
-        }
-        // Apply min score filter if specified
-        if (options.minScore) {
-            chunks = chunks.filter(chunk => chunk.score >= options.minScore);
-        }
-        return {
-            success: true,
-            results: chunks,
-            totalChunks: chunks.length,
-            reductionPercent: result.reductionPercent,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            results: [],
-            totalChunks: 0,
-            reductionPercent: 0,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Tool description for the model
- * This highlights our competitive advantage
- */
-export const SEARCH_TOOL_DESCRIPTION = `
-Search Tool - Intelligent codebase search (Our Competitive Advantage)
-
-DESCRIPTION:
-Search codebase using intelligent retrieval with AST-based context understanding.
-This is more powerful than naive cosine similarity - understands code structure.
-
-AVAILABLE OPERATIONS:
-- searchCodebase(query, options): Search codebase with intelligent retrieval
-
-FEATURES (Our Competitive Advantage):
-1. **AST-Based Context**: Understands code structure, not just text similarity
-2. **Caller/Callee Analysis**: Finds related functions automatically
-3. **Type-Aware Search**: Understands TypeScript/JavaScript types
-4. **Token Optimization**: Reduces context size by 80-90% while maintaining relevance
-5. **Intelligent Chunking**: Chunks code semantically, not just by size
-
-SEARCH OPTIONS:
-- baseDir: Base directory (default: current directory)
-- maxResults: Maximum results (default: 15)
-- fileTypes: Filter by file types (e.g., ['ts', 'tsx'])
-- minScore: Minimum relevance score 0-1 (default: 0.3)
-
-RETURNS:
-- results: Array of code chunks with metadata
-- Each chunk includes: filepath, content, score, metadata
-- reductionPercent: Token reduction achieved (typically 80-90%)
-
-EXAMPLES:
-- searchCodebase('How does authentication work?')
-- searchCodebase('Find all API endpoints', { fileTypes: ['ts'] })
-- searchCodebase('Where is user validation?', { maxResults: 10 })
-
-ADVANTAGES OVER NAIVE SEARCH:
-1. **Semantic Understanding**: Understands code meaning, not just keywords
-2. **Context-Aware**: Includes related functions, types, imports
-3. **Efficient**: 80-90% token reduction while maintaining accuracy
-4. **Accurate**: AST-based matching is more precise than text similarity
-
-REQUIREMENTS:
-- Codebase must be indexed first (run 'codehere index')
-- Indexing creates embeddings and AST analysis
-- Search uses both embeddings and AST for best results
-`;
-//# sourceMappingURL=search.js.map

package/dist/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/utils/check-api-status.js

@@ -1,100 +0,0 @@
-/**
- * Utility: Check API Status
- * Checks if any AI provider API is available
- */
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Load .env
-try {
-    const agentDir = join(__dirname, '../../..');
-    config({ path: join(agentDir, '.env') });
-}
-catch { }
-config();
-export async function checkAPIStatus() {
-    const hasKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.COHERE_API_KEY);
-    if (!hasKey) {
-        return {
-            available: false,
-            rateLimited: false,
-            message: 'No API key found (ANTHROPIC_API_KEY, OPENAI_API_KEY, or COHERE_API_KEY)',
-            canProceed: false,
-        };
-    }
-    try {
-        // Quick health check with whichever provider is available
-        if (process.env.ANTHROPIC_API_KEY) {
-            const r = await fetch('https://api.anthropic.com/v1/messages', {
-                method: 'POST',
-                headers: { 'x-api-key': process.env.ANTHROPIC_API_KEY, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
-                body: JSON.stringify({ model: 'claude-sonnet-4-20250514', max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
-            });
-            if (!r.ok && r.status === 429)
-                throw Object.assign(new Error('Rate limited'), { status: 429 });
-            if (!r.ok)
-                throw new Error(`Anthropic API error: ${r.status}`);
-        }
-        else if (process.env.OPENAI_API_KEY) {
-            const r = await fetch('https://api.openai.com/v1/models', {
-                headers: { 'Authorization': `Bearer ${process.env.OPENAI_API_KEY}` },
-            });
-            if (!r.ok && r.status === 429)
-                throw Object.assign(new Error('Rate limited'), { status: 429 });
-            if (!r.ok)
-                throw new Error(`OpenAI API error: ${r.status}`);
-        }
-        else if (process.env.COHERE_API_KEY) {
-            const { CohereClient } = require('cohere-ai');
-            const client = new CohereClient({ token: process.env.COHERE_API_KEY });
-            await client.embed({ texts: ['test'], model: 'embed-english-v3.0', inputType: 'search_document' });
-        }
-        return {
-            available: true,
-            rateLimited: false,
-            message: 'API is available and ready',
-            canProceed: true,
-        };
-    }
-    catch (error) {
-        const errorMsg = error?.message || String(error);
-        const statusCode = error?.status || error?.statusCode;
-        // Check for rate limiting
-        const isRateLimit = statusCode === 429 ||
-            errorMsg.includes('429') ||
-            errorMsg.includes('rate limit') ||
-            errorMsg.includes('TooManyRequests') ||
-            errorMsg.includes('1000 API calls');
-        if (isRateLimit) {
-            return {
-                available: false,
-                rateLimited: true,
-                message: 'API rate limit reached. Trial key limited to 1000 calls/month.',
-                canProceed: false,
-            };
-        }
-        // Other error (network, auth, etc.)
-        return {
-            available: false,
-            rateLimited: false,
-            message: `API error: ${errorMsg.substring(0, 100)}`,
-            canProceed: false,
-        };
-    }
-}
-// CLI usage
-if (import.meta.url === `file://${process.argv[1]}`) {
-    checkAPIStatus().then(status => {
-        if (status.canProceed) {
-            console.log('✅', status.message);
-            process.exit(0);
-        }
-        else {
-            console.log('❌', status.message);
-            process.exit(1);
-        }
-    });
-}
-//# sourceMappingURL=check-api-status.js.map