codehere 0.2.2 → 0.3.0-rc.10

package/dist/learning.js

@@ -1,232 +0,0 @@
-/**
- * Self-Correction & Learning System
- * Learn from errors and improve over time
- */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-// Learning data file path
-function getLearningDataPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '..');
-    return join(agentDir, 'data', 'learning.json');
-}
-/**
- * Load learning data
- */
-export function loadLearningData() {
-    const dataPath = getLearningDataPath();
-    if (!existsSync(dataPath)) {
-        return {
-            errorPatterns: [],
-            successfulOperations: [],
-            performanceMetrics: [],
-            corrections: [],
-        };
-    }
-    try {
-        const content = readFileSync(dataPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch (error) {
-        return {
-            errorPatterns: [],
-            successfulOperations: [],
-            performanceMetrics: [],
-            corrections: [],
-        };
-    }
-}
-/**
- * Save learning data
- */
-export function saveLearningData(data) {
-    const dataPath = getLearningDataPath();
-    const dataDir = dirname(dataPath);
-    // Ensure directory exists
-    if (!existsSync(dataDir)) {
-        mkdirSync(dataDir, { recursive: true });
-    }
-    writeFileSync(dataPath, JSON.stringify(data, null, 2), 'utf-8');
-}
-/**
- * Record an error for learning
- */
-export function recordError(error) {
-    const data = loadLearningData();
-    const errorMessage = error.originalError.message.toLowerCase();
-    // Find or create error pattern
-    let pattern = data.errorPatterns.find(p => errorMessage.includes(p.pattern.toLowerCase()) ||
-        p.pattern.toLowerCase().includes(errorMessage));
-    if (!pattern) {
-        // Extract key words from error
-        const words = errorMessage.split(/\s+/).filter(w => w.length > 4);
-        const keyPattern = words.slice(0, 3).join(' ');
-        pattern = {
-            pattern: keyPattern,
-            category: error.errorType,
-            count: 0,
-            lastSeen: new Date().toISOString(),
-            solutions: [],
-        };
-        data.errorPatterns.push(pattern);
-    }
-    pattern.count++;
-    pattern.lastSeen = new Date().toISOString();
-    saveLearningData(data);
-}
-/**
- * Record successful operation
- */
-export function recordSuccess(operation) {
-    const data = loadLearningData();
-    if (!data.successfulOperations.includes(operation)) {
-        data.successfulOperations.push(operation);
-        // Keep only last 100
-        if (data.successfulOperations.length > 100) {
-            data.successfulOperations.shift();
-        }
-    }
-    saveLearningData(data);
-}
-/**
- * Get correction strategy for an error
- */
-export function getCorrectionStrategy(error) {
-    const data = loadLearningData();
-    const errorMessage = error.originalError.message.toLowerCase();
-    // Find matching pattern
-    const pattern = data.errorPatterns.find(p => errorMessage.includes(p.pattern.toLowerCase()) ||
-        p.pattern.toLowerCase().includes(errorMessage));
-    if (pattern && pattern.solutions.length > 0) {
-        // Return most recent successful solution
-        return pattern.solutions[pattern.solutions.length - 1];
-    }
-    // Check corrections history
-    const similarCorrection = data.corrections
-        .filter(c => c.success)
-        .find(c => errorMessage.includes(c.error.toLowerCase()) || c.error.toLowerCase().includes(errorMessage));
-    if (similarCorrection) {
-        return similarCorrection.correction;
-    }
-    return null;
-}
-/**
- * Record a correction attempt
- */
-export function recordCorrection(error, correction, success) {
-    const data = loadLearningData();
-    data.corrections.push({
-        error,
-        correction,
-        timestamp: new Date().toISOString(),
-        success,
-    });
-    // Keep only last 50 corrections
-    if (data.corrections.length > 50) {
-        data.corrections.shift();
-    }
-    // If successful, add to pattern solutions
-    if (success) {
-        const errorLower = error.toLowerCase();
-        const pattern = data.errorPatterns.find(p => errorLower.includes(p.pattern.toLowerCase()) ||
-            p.pattern.toLowerCase().includes(errorLower));
-        if (pattern && !pattern.solutions.includes(correction)) {
-            pattern.solutions.push(correction);
-            // Keep only last 5 solutions per pattern
-            if (pattern.solutions.length > 5) {
-                pattern.solutions.shift();
-            }
-        }
-    }
-    saveLearningData(data);
-}
-/**
- * Update performance metrics
- */
-export function updatePerformanceMetrics(operation, time, success) {
-    const data = loadLearningData();
-    let metric = data.performanceMetrics.find(m => m.operation === operation);
-    if (!metric) {
-        metric = {
-            operation,
-            avgTime: time,
-            successRate: success ? 1.0 : 0.0,
-            lastOptimized: new Date().toISOString(),
-        };
-        data.performanceMetrics.push(metric);
-    }
-    else {
-        // Update running average
-        metric.avgTime = (metric.avgTime * 0.9) + (time * 0.1);
-        metric.successRate = (metric.successRate * 0.9) + (success ? 1.0 : 0.0);
-        metric.lastOptimized = new Date().toISOString();
-    }
-    saveLearningData(data);
-}
-/**
- * Get performance insights
- */
-export function getPerformanceInsights() {
-    const data = loadLearningData();
-    const slowOperations = data.performanceMetrics
-        .filter(m => m.avgTime > 5000) // > 5 seconds
-        .map(m => m.operation);
-    const unreliableOperations = data.performanceMetrics
-        .filter(m => m.successRate < 0.8) // < 80% success rate
-        .map(m => m.operation);
-    const recommendations = [];
-    if (slowOperations.length > 0) {
-        recommendations.push(`Consider optimizing: ${slowOperations.join(', ')}`);
-    }
-    if (unreliableOperations.length > 0) {
-        recommendations.push(`Improve reliability: ${unreliableOperations.join(', ')}`);
-    }
-    const frequentErrors = data.errorPatterns
-        .filter(p => p.count > 5)
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 3);
-    if (frequentErrors.length > 0) {
-        recommendations.push(`Address frequent errors: ${frequentErrors.map(e => e.pattern).join(', ')}`);
-    }
-    return {
-        slowOperations,
-        unreliableOperations,
-        recommendations,
-    };
-}
-/**
- * Format learning insights for display
- */
-export function formatLearningInsights() {
-    const data = loadLearningData();
-    const insights = getPerformanceInsights();
-    let output = 'Learning Insights\n';
-    output += '────────────────────────────────────────────────────\n\n';
-    if (data.errorPatterns.length > 0) {
-        output += 'Error Patterns:\n';
-        const topErrors = data.errorPatterns
-            .sort((a, b) => b.count - a.count)
-            .slice(0, 5);
-        for (const pattern of topErrors) {
-            output += `  • ${pattern.pattern} (${pattern.count} times)\n`;
-            if (pattern.solutions.length > 0) {
-                output += `    Solutions: ${pattern.solutions.length} known\n`;
-            }
-        }
-        output += '\n';
-    }
-    if (insights.recommendations.length > 0) {
-        output += 'Recommendations:\n';
-        for (const rec of insights.recommendations) {
-            output += `  • ${rec}\n`;
-        }
-        output += '\n';
-    }
-    if (data.successfulOperations.length > 0) {
-        output += `Successful Operations: ${data.successfulOperations.length}\n`;
-    }
-    return output;
-}
-//# sourceMappingURL=learning.js.map

package/dist/log.js

@@ -1,31 +0,0 @@
-import { writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-// Log file path: use agent/data if in agent directory, otherwise use current directory
-function getLogPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '..');
-    // Check if we're in the agent directory structure
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'logs.jsonl');
-    }
-    // Otherwise use current directory
-    return join(process.cwd(), 'agent', 'data', 'logs.jsonl');
-}
-const LOG_FILE = getLogPath();
-export function initLogFile() {
-    const logDir = join(process.cwd(), 'agent', 'data');
-    if (!existsSync(logDir)) {
-        mkdirSync(logDir, { recursive: true });
-    }
-    // Create empty log file if it doesn't exist
-    if (!existsSync(LOG_FILE)) {
-        writeFileSync(LOG_FILE, '');
-    }
-}
-export function logEntry(entry) {
-    const jsonLine = JSON.stringify(entry) + '\n';
-    appendFileSync(LOG_FILE, jsonLine, 'utf-8');
-}
-//# sourceMappingURL=log.js.map

package/dist/migrate.js

@@ -1,133 +0,0 @@
-/**
- * Migration Assistant
- * Help with framework upgrades and API migrations
- */
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { chatWithContext } from './chat.js';
-import { getEnhancedContext } from './context.js';
-/**
- * Plan a framework migration
- */
-export async function planMigration(from, to, files) {
-    // Get context about the codebase
-    const context = await getEnhancedContext(`Migrate from ${from} to ${to}`, {
-        primaryChunks: 20,
-        includeRelationships: true,
-    });
-    // Identify files that need migration
-    const filesToMigrate = files || context.primaryChunks.map(c => c.filepath);
-    // Create migration steps
-    const steps = [
-        {
-            step: 1,
-            description: `Update dependencies from ${from} to ${to}`,
-            files: ['package.json', 'requirements.txt', 'pom.xml'].filter(f => filesToMigrate.some(ft => ft.includes(f))),
-            risk: 'low',
-        },
-        {
-            step: 2,
-            description: `Update import statements from ${from} to ${to}`,
-            files: filesToMigrate.filter(f => f.endsWith('.ts') || f.endsWith('.js') || f.endsWith('.py')),
-            risk: 'medium',
-        },
-        {
-            step: 3,
-            description: `Update API calls and method signatures`,
-            files: filesToMigrate,
-            risk: 'high',
-        },
-        {
-            step: 4,
-            description: `Update configuration files`,
-            files: filesToMigrate.filter(f => f.includes('config') || f.includes('settings') || f.includes('.env')),
-            risk: 'medium',
-        },
-        {
-            step: 5,
-            description: `Run tests and fix breaking changes`,
-            files: [],
-            risk: 'high',
-        },
-    ];
-    // Estimate time based on file count
-    const fileCount = filesToMigrate.length;
-    const estimatedHours = Math.ceil(fileCount / 10) * 2; // 2 hours per 10 files
-    const estimatedTime = `${estimatedHours} hour(s)`;
-    return {
-        from,
-        to,
-        files: filesToMigrate,
-        steps,
-        estimatedTime,
-    };
-}
-/**
- * Generate migration code for a file
- */
-export async function generateMigration(filepath, from, to) {
-    const fullPath = join(process.cwd(), filepath);
-    if (!existsSync(fullPath)) {
-        throw new Error(`File not found: ${filepath}`);
-    }
-    const original = readFileSync(fullPath, 'utf-8');
-    // Get context
-    const context = await getEnhancedContext(`Migrate ${filepath} from ${from} to ${to}`, {
-        primaryChunks: 15,
-        includeRelationships: true,
-    });
-    // Create migration prompt
-    const migrationPrompt = `Migrate this code from ${from} to ${from}:
-
-File: ${filepath}
-Original code:
-\`\`\`
-${original}
-\`\`\`
-
-Provide the migrated code with ${to} syntax and explain the key changes.`;
-    const contextResults = [{
-            filepath,
-            content: original,
-            score: 1.0,
-        }, ...context.primaryChunks];
-    const migratedResponse = await chatWithContext(migrationPrompt, contextResults);
-    // Extract code from response
-    const codeMatch = migratedResponse.match(/```[\s\S]*?```/);
-    const migrated = codeMatch
-        ? codeMatch[0].replace(/```\w*\n?/g, '').replace(/```/g, '').trim()
-        : migratedResponse;
-    // Extract changes
-    const changes = [];
-    const changeMatches = migratedResponse.match(/(?:change|update|replace)[^\.]+\./gi);
-    if (changeMatches) {
-        changes.push(...changeMatches.slice(0, 5));
-    }
-    return {
-        original,
-        migrated,
-        changes,
-    };
-}
-/**
- * Format migration plan for display
- */
-export function formatMigrationPlan(plan) {
-    let output = `Migration Plan: ${plan.from} → ${plan.to}\n`;
-    output += `Files to migrate: ${plan.files.length}\n`;
-    output += `Estimated time: ${plan.estimatedTime}\n\n`;
-    output += 'Steps:\n';
-    for (const step of plan.steps) {
-        const riskIcon = {
-            low: '✓',
-            medium: '⚠',
-            high: '✗',
-        }[step.risk];
-        output += `  ${riskIcon} Step ${step.step}: ${step.description}\n`;
-        if (step.files.length > 0) {
-            output += `    Files: ${step.files.length}\n`;
-        }
-    }
-    return output;
-}
-//# sourceMappingURL=migrate.js.map