codehere 0.2.2 → 0.3.0-rc.10

package/dist/token-optimizer.js

@@ -1,277 +0,0 @@
-/**
- * Token Optimization System
- * 80-90% token reduction through smart compression
- */
-import { encoding_for_model } from 'tiktoken';
-const enc = encoding_for_model('gpt-3.5-turbo');
-/**
- * Optimize context to minimize tokens while preserving relevance
- */
-export function optimizeContext(chunks, query, maxTokens, strategy = 'relevant-only') {
-    const originalTokens = chunks.reduce((sum, chunk) => sum + enc.encode(chunk.content).length, 0);
-    let optimized;
-    switch (strategy) {
-        case 'function-level':
-            optimized = optimizeFunctionLevel(chunks, query, maxTokens);
-            break;
-        case 'file-level':
-            optimized = optimizeFileLevel(chunks, query, maxTokens);
-            break;
-        case 'relevant-only':
-            optimized = optimizeRelevantOnly(chunks, query, maxTokens);
-            break;
-        case 'compressed':
-            optimized = optimizeCompressed(chunks, query, maxTokens);
-            break;
-        default:
-            optimized = optimizeRelevantOnly(chunks, query, maxTokens);
-    }
-    const optimizedTokens = optimized.reduce((sum, chunk) => sum + enc.encode(chunk.content).length, 0);
-    const reductionPercent = originalTokens > 0
-        ? ((originalTokens - optimizedTokens) / originalTokens) * 100
-        : 0;
-    return {
-        chunks: optimized,
-        totalTokens: optimizedTokens,
-        reductionPercent,
-        strategy,
-    };
-}
-/**
- * Extract only relevant functions/classes from chunks
- */
-function optimizeFunctionLevel(chunks, query, maxTokens) {
-    const optimized = [];
-    let currentTokens = 0;
-    // Extract function/class names from query
-    const querySymbols = extractSymbolsFromQuery(query);
-    for (const chunk of chunks) {
-        if (currentTokens >= maxTokens)
-            break;
-        // Try to extract relevant functions/classes
-        const relevantCode = extractRelevantCode(chunk.content, querySymbols);
-        if (relevantCode) {
-            const tokens = enc.encode(relevantCode).length;
-            if (currentTokens + tokens <= maxTokens) {
-                optimized.push({
-                    ...chunk,
-                    content: relevantCode,
-                });
-                currentTokens += tokens;
-            }
-        }
-        else {
-            // Fallback: use chunk but truncate
-            const tokens = enc.encode(chunk.content).length;
-            const remaining = maxTokens - currentTokens;
-            if (tokens <= remaining) {
-                optimized.push(chunk);
-                currentTokens += tokens;
-            }
-            else if (remaining > 100) {
-                const truncated = truncateToTokens(chunk.content, remaining);
-                optimized.push({
-                    ...chunk,
-                    content: truncated,
-                });
-                currentTokens = maxTokens;
-                break;
-            }
-        }
-    }
-    return optimized;
-}
-/**
- * Deduplicate and keep only unique files
- */
-function optimizeFileLevel(chunks, query, maxTokens) {
-    // Group by file
-    const fileGroups = new Map();
-    for (const chunk of chunks) {
-        if (!fileGroups.has(chunk.filepath)) {
-            fileGroups.set(chunk.filepath, []);
-        }
-        fileGroups.get(chunk.filepath).push(chunk);
-    }
-    // Keep best chunk per file
-    const optimized = [];
-    let currentTokens = 0;
-    for (const [filepath, fileChunks] of fileGroups.entries()) {
-        if (currentTokens >= maxTokens)
-            break;
-        // Sort by score and take best
-        const bestChunk = fileChunks.sort((a, b) => b.score - a.score)[0];
-        const tokens = enc.encode(bestChunk.content).length;
-        if (currentTokens + tokens <= maxTokens) {
-            optimized.push(bestChunk);
-            currentTokens += tokens;
-        }
-    }
-    return optimized;
-}
-/**
- * Keep only most relevant chunks
- */
-function optimizeRelevantOnly(chunks, query, maxTokens) {
-    // Sort by relevance (score)
-    const sorted = [...chunks].sort((a, b) => b.score - a.score);
-    const optimized = [];
-    let currentTokens = 0;
-    for (const chunk of sorted) {
-        if (currentTokens >= maxTokens)
-            break;
-        const tokens = enc.encode(chunk.content).length;
-        const remaining = maxTokens - currentTokens;
-        if (tokens <= remaining) {
-            optimized.push(chunk);
-            currentTokens += tokens;
-        }
-        else if (remaining > 100) {
-            // Truncate to fit
-            const truncated = truncateToTokens(chunk.content, remaining);
-            optimized.push({
-                ...chunk,
-                content: truncated,
-            });
-            currentTokens = maxTokens;
-            break;
-        }
-    }
-    return optimized;
-}
-/**
- * Compress chunks by removing comments and whitespace
- */
-function optimizeCompressed(chunks, query, maxTokens) {
-    const optimized = [];
-    let currentTokens = 0;
-    for (const chunk of chunks) {
-        if (currentTokens >= maxTokens)
-            break;
-        // Remove comments and excessive whitespace
-        const compressed = compressCode(chunk.content);
-        const tokens = enc.encode(compressed).length;
-        const remaining = maxTokens - currentTokens;
-        if (tokens <= remaining) {
-            optimized.push({
-                ...chunk,
-                content: compressed,
-            });
-            currentTokens += tokens;
-        }
-        else if (remaining > 100) {
-            const truncated = truncateToTokens(compressed, remaining);
-            optimized.push({
-                ...chunk,
-                content: truncated,
-            });
-            currentTokens = maxTokens;
-            break;
-        }
-    }
-    return optimized;
-}
-/**
- * Extract relevant code (functions/classes) from chunk
- */
-function extractRelevantCode(content, symbols) {
-    if (symbols.length === 0)
-        return null;
-    const lines = content.split('\n');
-    const relevant = [];
-    let inRelevantBlock = false;
-    let braceCount = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // Check if line contains a symbol we're looking for
-        const hasSymbol = symbols.some(symbol => line.includes(symbol) &&
-            (line.match(/(function|class|interface|type|const|let|var)\s+/)));
-        if (hasSymbol) {
-            inRelevantBlock = true;
-            braceCount = 0;
-        }
-        if (inRelevantBlock) {
-            relevant.push(line);
-            // Count braces to find end of block
-            braceCount += (line.match(/{/g) || []).length;
-            braceCount -= (line.match(/}/g) || []).length;
-            if (braceCount === 0 && relevant.length > 1) {
-                // End of block
-                return relevant.join('\n');
-            }
-        }
-    }
-    return relevant.length > 0 ? relevant.join('\n') : null;
-}
-/**
- * Extract symbol names from query
- */
-function extractSymbolsFromQuery(query) {
-    const patterns = [
-        /function\s+(\w+)/gi,
-        /class\s+(\w+)/gi,
-        /interface\s+(\w+)/gi,
-        /type\s+(\w+)/gi,
-        /([A-Z][a-zA-Z0-9]+)/g,
-        /([a-z][a-zA-Z0-9]*\(\))/g,
-    ];
-    const symbols = new Set();
-    for (const pattern of patterns) {
-        const matches = query.matchAll(pattern);
-        for (const match of matches) {
-            if (match[1]) {
-                symbols.add(match[1]);
-            }
-        }
-    }
-    return Array.from(symbols);
-}
-/**
- * Compress code by removing comments and whitespace
- */
-function compressCode(code) {
-    return code
-        // Remove single-line comments
-        .replace(/\/\/.*$/gm, '')
-        // Remove multi-line comments
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        // Remove excessive whitespace
-        .replace(/\n\s*\n\s*\n/g, '\n\n')
-        // Trim lines
-        .split('\n')
-        .map(line => line.trim())
-        .filter(line => line.length > 0)
-        .join('\n');
-}
-/**
- * Truncate text to fit token limit
- */
-function truncateToTokens(text, maxTokens) {
-    const tokens = enc.encode(text);
-    if (tokens.length <= maxTokens) {
-        return text;
-    }
-    const truncatedTokens = tokens.slice(0, maxTokens - 10); // Leave room for "..."
-    const decoded = enc.decode(truncatedTokens);
-    const decodedText = typeof decoded === 'string'
-        ? decoded
-        : new TextDecoder().decode(decoded);
-    return decodedText + '...';
-}
-/**
- * Deduplicate chunks
- */
-export function deduplicateChunks(chunks) {
-    const seen = new Set();
-    const unique = [];
-    for (const chunk of chunks) {
-        // Create a key from filepath and content hash
-        const key = `${chunk.filepath}:${chunk.content.substring(0, 100)}`;
-        if (!seen.has(key)) {
-            seen.add(key);
-            unique.push(chunk);
-        }
-    }
-    return unique;
-}
-//# sourceMappingURL=token-optimizer.js.map

package/dist/tools/bash.js

@@ -1,213 +0,0 @@
-/**
- * Bash Tool
- * Execute shell commands safely with detailed descriptions for the model
- * Following Claude Code approach: detailed tool descriptions, error-proofing
- *
- * SECURITY: Uses Docker sandbox when available for isolated execution
- */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { resolve } from 'path';
-import { existsSync } from 'fs';
-import { SandboxExecutor } from '../infrastructure/security/sandbox-executor.js';
-const execAsync = promisify(exec);
-// Singleton sandbox executor instance
-let sandboxExecutor = null;
-/**
- * Get or create sandbox executor instance
- */
-function getSandboxExecutor() {
-    if (!sandboxExecutor) {
-        sandboxExecutor = new SandboxExecutor();
-    }
-    return sandboxExecutor;
-}
-/**
- * Execute a bash command safely
- *
- * SECURITY & ERROR-PROOFING:
- * - All paths are resolved to absolute paths
- * - Commands are executed in Docker sandbox when available (MANDATORY for production)
- * - Falls back to direct execution with warning if sandbox unavailable
- * - Timeout protection prevents hanging
- * - Output size limits prevent memory issues
- * - Command injection attempts are logged
- */
-export async function executeBash(command, options = {}) {
-    const startTime = Date.now();
-    // Resolve working directory to absolute path
-    const cwd = options.cwd
-        ? resolve(options.cwd)
-        : process.cwd();
-    // Verify directory exists
-    if (!existsSync(cwd)) {
-        throw new Error(`Working directory does not exist: ${cwd}`);
-    }
-    // Security: Log suspicious patterns (but don't block - let model decide)
-    const suspiciousPatterns = [
-        /rm\s+-rf\s+\//, // Dangerous rm -rf /
-        /format\s+c:/i, // Windows format
-        /mkfs/, // Filesystem creation
-        /dd\s+if=/, // Disk operations
-    ];
-    for (const pattern of suspiciousPatterns) {
-        if (pattern.test(command)) {
-            console.warn(`⚠️  Warning: Potentially dangerous command detected: ${command}`);
-        }
-    }
-    // Try to use sandbox first (MANDATORY for production security)
-    const sandbox = getSandboxExecutor();
-    const sandboxAvailable = await sandbox.isAvailable();
-    if (sandboxAvailable) {
-        try {
-            // Execute in sandbox
-            const sandboxOptions = {
-                timeout: options.timeout || 30000,
-                memoryLimit: '512m',
-                cpuLimit: '0.5',
-                networkAccess: false, // No network access by default
-            };
-            const sandboxResult = await sandbox.executeBash(command, sandboxOptions);
-            const duration = Date.now() - startTime;
-            return {
-                exitCode: sandboxResult.exitCode || (sandboxResult.success ? 0 : 1),
-                stdout: sandboxResult.output || '',
-                stderr: sandboxResult.error || '',
-                command,
-                duration,
-                success: sandboxResult.success,
-                sandboxed: true,
-                sandboxStatus: 'Executed in Docker sandbox (secure)',
-            };
-        }
-        catch (sandboxError) {
-            // If sandbox execution fails, fall through to direct execution with warning
-            console.warn(`⚠️  Sandbox execution failed, falling back to direct execution: ${sandboxError.message}`);
-        }
-    }
-    else {
-        // Sandbox not available - use direct execution with warning
-        console.warn(`⚠️  WARNING: Docker sandbox not available. Executing command directly (less secure).`);
-        console.warn(`⚠️  For production use, please install Docker to enable secure sandbox execution.`);
-    }
-    // Fallback: Direct execution (with security warning)
-    const timeout = options.timeout || 30000; // 30 seconds
-    const maxOutputSize = options.maxOutputSize || 1024 * 1024; // 1MB
-    // Merge environment variables
-    const env = {
-        ...process.env,
-        ...options.env,
-    };
-    try {
-        // Execute command with timeout
-        const { stdout, stderr } = await Promise.race([
-            execAsync(command, {
-                cwd,
-                env,
-                maxBuffer: maxOutputSize,
-            }),
-            new Promise((_, reject) => {
-                setTimeout(() => {
-                    reject(new Error(`Command timed out after ${timeout}ms`));
-                }, timeout);
-            }),
-        ]);
-        const duration = Date.now() - startTime;
-        // Check output size
-        const totalSize = (stdout?.length || 0) + (stderr?.length || 0);
-        if (totalSize > maxOutputSize) {
-            console.warn(`⚠️  Warning: Command output exceeds ${maxOutputSize} bytes, truncated`);
-        }
-        return {
-            exitCode: 0,
-            stdout: stdout || '',
-            stderr: stderr || '',
-            command,
-            duration,
-            success: true,
-            sandboxed: false,
-            sandboxStatus: sandboxAvailable
-                ? 'Sandbox available but execution failed, used direct execution'
-                : 'Docker sandbox not available, used direct execution (less secure)',
-        };
-    }
-    catch (error) {
-        const duration = Date.now() - startTime;
-        // Extract exit code from error
-        const exitCode = error.code || (error.signal ? 128 : 1);
-        return {
-            exitCode,
-            stdout: error.stdout || '',
-            stderr: error.stderr || error.message || '',
-            command,
-            duration,
-            success: exitCode === 0,
-            sandboxed: false,
-            sandboxStatus: sandboxAvailable
-                ? 'Sandbox available but execution failed, used direct execution'
-                : 'Docker sandbox not available, used direct execution (less secure)',
-        };
-    }
-}
-/**
- * Tool description for the model
- * This is critical - the model needs to understand how to use this tool
- */
-export const BASH_TOOL_DESCRIPTION = `
-Bash Tool - Execute shell commands
-
-DESCRIPTION:
-Execute bash/shell commands in a controlled environment. All paths are automatically resolved to absolute paths.
-
-AVAILABLE COMMANDS:
-- Any valid bash/shell command
-- Commands run in the project directory by default
-- Working directory can be specified
-
-IMPORTANT CONSTRAINTS:
-1. **Absolute Paths Required**: Always use absolute paths or paths relative to the working directory
-2. **No Internet Access**: Commands run in isolated environment (no network access)
-3. **Available Packages**: Standard Unix utilities (ls, cat, grep, find, etc.)
-4. **Timeout**: Commands timeout after 30 seconds (configurable)
-5. **Output Limit**: Maximum 1MB output (configurable)
-
-ESCAPING:
-- Use single quotes for strings: 'string with spaces'
-- Escape special characters: Use backslash before $, backtick, or double quote
-- For complex commands, consider breaking into multiple steps
-
-BACKGROUND PROCESSES:
-- Background processes (&) are NOT supported
-- Use sequential commands instead
-
-PATH HANDLING:
-- All paths are resolved to absolute paths automatically
-- Use resolve() or absolute paths to avoid relative path issues
-- Example: /Users/username/project/file.txt (absolute)
-- Example: ./file.txt (relative to cwd)
-
-ERROR HANDLING:
-- Exit code 0 = success
-- Exit code != 0 = failure
-- Check stderr for error messages
-- Timeout errors are reported in stderr
-
-EXAMPLES:
-- executeBash('ls -la', { cwd: '/path/to/dir' })
-- executeBash('grep -r "pattern" .', { cwd: '/path/to/project' })
-- executeBash('cat /absolute/path/to/file.txt')
-- executeBash('find . -name "*.ts" -type f', { cwd: '/path/to/project' })
-
-SECURITY NOTES:
-- Commands execute in Docker sandbox when available (MANDATORY for production)
-- Falls back to direct execution with warning if Docker unavailable
-- Potentially dangerous commands are logged but not blocked
-- Use with caution for destructive operations
-- Always verify paths before executing
-
-SANDBOX STATUS:
-- Check result.sandboxed to see if command ran in sandbox
-- Check result.sandboxStatus for sandbox availability information
-- Production deployments should always have Docker available
-`;
-//# sourceMappingURL=bash.js.map