@goldensheepai/toknxr-cli 0.2.0

package/lib/cli.js

@@ -0,0 +1,382 @@
+import 'dotenv/config';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { startProxyServer } from './proxy.js';
+import { login } from './auth.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createClient } from '@supabase/supabase-js';
+import open from 'open';
+import { syncInteractions } from './sync.js';
+// Gracefully handle broken pipe (e.g., piping output to `head`)
+process.stdout.on('error', (err) => {
+    if (err && err.code === 'EPIPE')
+        process.exit(0);
+});
+process.stderr.on('error', (err) => {
+    if (err && err.code === 'EPIPE')
+        process.exit(0);
+});
+const program = new Command();
+// ASCII Art Welcome Screen with gradient colors
+const asciiArt = `
+${chalk.blue('  ████████╗')}${chalk.hex('#6B5BED')('  ██████╗ ')}${chalk.hex('#9B5BED')(' ██╗  ██╗')}${chalk.hex('#CB5BED')(' ███╗   ██╗')}${chalk.hex('#ED5B9B')(' ██╗  ██╗')}${chalk.hex('#ED5B6B')(' ██████╗ ')}
+${chalk.blue('  ╚══██╔══╝')}${chalk.hex('#6B5BED')(' ██╔═══██╗')}${chalk.hex('#9B5BED')(' ██║ ██╔╝')}${chalk.hex('#CB5BED')(' ████╗  ██║')}${chalk.hex('#ED5B9B')(' ╚██╗██╔╝')}${chalk.hex('#ED5B6B')(' ██╔══██╗')}
+${chalk.blue('     ██║   ')}${chalk.hex('#6B5BED')(' ██║   ██║')}${chalk.hex('#9B5BED')(' █████╔╝ ')}${chalk.hex('#CB5BED')(' ██╔██╗ ██║')}${chalk.hex('#ED5B9B')('  ╚███╔╝ ')}${chalk.hex('#ED5B6B')(' ██████╔╝')}
+${chalk.blue('     ██║   ')}${chalk.hex('#6B5BED')(' ██║   ██║')}${chalk.hex('#9B5BED')(' ██╔═██╗ ')}${chalk.hex('#CB5BED')(' ██║╚██╗██║')}${chalk.hex('#ED5B9B')('  ██╔██╗ ')}${chalk.hex('#ED5B6B')(' ██╔══██╗')}
+${chalk.blue('     ██║   ')}${chalk.hex('#6B5BED')(' ╚██████╔╝')}${chalk.hex('#9B5BED')(' ██║  ██╗')}${chalk.hex('#CB5BED')(' ██║ ╚████║')}${chalk.hex('#ED5B9B')(' ██╔╝ ██╗')}${chalk.hex('#ED5B6B')(' ██║  ██║')}
+${chalk.blue('     ╚═╝   ')}${chalk.hex('#6B5BED')('  ╚═════╝ ')}${chalk.hex('#9B5BED')(' ╚═╝  ╚═╝')}${chalk.hex('#CB5BED')(' ╚═╝  ╚═══╝')}${chalk.hex('#ED5B9B')(' ╚═╝  ╚═╝')}${chalk.hex('#ED5B6B')(' ╚═╝  ╚═╝')}
+
+${chalk.cyan('Tips for getting started:')}
+${chalk.white('1. Start tracking:')} ${chalk.yellow('toknxr start')} ${chalk.gray('- Launch the proxy server')}
+${chalk.white('2. View analytics:')} ${chalk.yellow('toknxr stats')} ${chalk.gray('- See token usage and code quality')}
+${chalk.white('3. Deep dive:')} ${chalk.yellow('toknxr code-analysis')} ${chalk.gray('- Detailed quality insights')}
+${chalk.white('4. Code review:')} ${chalk.yellow('toknxr review')} ${chalk.gray('- Review AI-generated code')}
+${chalk.white('5. Login:')} ${chalk.yellow('toknxr login')} ${chalk.gray('- Authenticate with your account')}
+${chalk.white('6. Set limits:')} ${chalk.yellow('toknxr policy:init')} ${chalk.gray('- Configure spending policies')}
+${chalk.white('7. Need help?')} ${chalk.yellow('toknxr --help')} ${chalk.gray('- View all commands')}
+
+${chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}
+
+${chalk.hex('#FFD700')('🐑 Powered by Golden Sheep AI')}
+
+`;
+console.log(asciiArt);
+// --- Supabase Client ---
+const supabaseUrl = process.env.SUPABASE_URL || '';
+const supabaseKey = process.env.SUPABASE_KEY || '';
+if (!supabaseUrl || !supabaseKey) {
+    console.error(chalk.red('Error: Supabase URL or Key not found in environment variables.'));
+    process.exit(1);
+}
+const supabase = createClient(supabaseUrl, supabaseKey);
+program
+    .name('toknxr')
+    .description('AI Effectiveness & Code Quality Analysis CLI')
+    .version('0.1.0');
+program
+    .command('start')
+    .description('Start the TokNxr proxy server to monitor AI interactions.')
+    .action(() => {
+    console.log(chalk.green('Starting TokNxr proxy server...'));
+    startProxyServer();
+});
+program
+    .command('sync')
+    .description('Sync local interaction logs to the Supabase dashboard.')
+    .option('--clear', 'Clear the log file after a successful sync.')
+    .action(async (options) => {
+    await syncInteractions(supabase, options);
+});
+program
+    .command('stats')
+    .description('Display token usage statistics from the local log.')
+    .action(() => {
+    const logFilePath = path.resolve(process.cwd(), 'interactions.log');
+    if (!fs.existsSync(logFilePath)) {
+        console.log(chalk.yellow('No interactions logged yet. Use the `start` command to begin tracking.'));
+        return;
+    }
+    const fileContent = fs.readFileSync(logFilePath, 'utf8');
+    const lines = fileContent.trim().split('\n');
+    const interactions = lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch (error) {
+            console.warn(`Skipping invalid log entry: ${line}`);
+            return null;
+        }
+    }).filter((interaction) => interaction !== null);
+    const stats = interactions.reduce((acc, interaction) => {
+        if (!acc[interaction.provider]) {
+            acc[interaction.provider] = {
+                totalTokens: 0, promptTokens: 0, completionTokens: 0, requestCount: 0, costUSD: 0,
+                codingCount: 0, avgQualityScore: 0, avgEffectivenessScore: 0, qualitySum: 0, effectivenessSum: 0
+            };
+        }
+        acc[interaction.provider].totalTokens += interaction.totalTokens;
+        acc[interaction.provider].promptTokens += interaction.promptTokens;
+        acc[interaction.provider].completionTokens += interaction.completionTokens;
+        acc[interaction.provider].requestCount += 1;
+        acc[interaction.provider].costUSD += interaction.costUSD || 0;
+        if (interaction.taskType === 'coding') {
+            acc[interaction.provider].codingCount += 1;
+            if (interaction.codeQualityScore !== undefined) {
+                acc[interaction.provider].qualitySum += interaction.codeQualityScore;
+            }
+            if (interaction.effectivenessScore !== undefined) {
+                acc[interaction.provider].effectivenessSum += interaction.effectivenessScore;
+            }
+        }
+        return acc;
+    }, {});
+    // Calculate averages
+    for (const provider in stats) {
+        const p = stats[provider];
+        if (p.codingCount > 0) {
+            p.avgQualityScore = Math.round(p.qualitySum / p.codingCount);
+            p.avgEffectivenessScore = Math.round(p.effectivenessSum / p.codingCount);
+        }
+    }
+    const grandTotals = Object.values(stats).reduce((acc, s) => {
+        acc.totalTokens += s.totalTokens;
+        acc.promptTokens += s.promptTokens;
+        acc.completionTokens += s.completionTokens;
+        acc.requestCount += s.requestCount;
+        acc.costUSD += s.costUSD;
+        acc.codingCount += s.codingCount;
+        acc.qualitySum += s.qualitySum;
+        acc.effectivenessSum += s.effectivenessSum;
+        return acc;
+    }, { totalTokens: 0, promptTokens: 0, completionTokens: 0, requestCount: 0, costUSD: 0, codingCount: 0, qualitySum: 0, effectivenessSum: 0 });
+    // Calculate grand averages
+    const codingTotal = grandTotals.codingCount;
+    const avgQuality = codingTotal > 0 ? Math.round(grandTotals.qualitySum / codingTotal) : 0;
+    const avgEffectiveness = codingTotal > 0 ? Math.round(grandTotals.effectivenessSum / codingTotal) : 0;
+    console.log(chalk.bold.underline('Token Usage Statistics'));
+    for (const provider in stats) {
+        console.log(chalk.bold(`\nProvider: ${provider}`));
+        console.log(`  Total Requests: ${stats[provider].requestCount}`);
+        console.log(chalk.cyan(`  Total Tokens: ${stats[provider].totalTokens}`));
+        console.log(`    - Prompt Tokens: ${stats[provider].promptTokens}`);
+        console.log(`    - Completion Tokens: ${stats[provider].completionTokens}`);
+        console.log(chalk.green(`  Cost (USD): $${(stats[provider].costUSD).toFixed(4)}`));
+        if (stats[provider].codingCount > 0) {
+            console.log(chalk.blue(`  Code Quality: ${stats[provider].avgQualityScore}/100 (avg)`));
+            console.log(chalk.magenta(`  Effectiveness: ${stats[provider].avgEffectivenessScore}/100 (avg, ${stats[provider].codingCount} coding requests)`));
+        }
+    }
+    console.log(chalk.bold(`\nGrand Totals`));
+    console.log(`  Requests: ${grandTotals.requestCount}`);
+    console.log(chalk.cyan(`  Tokens: ${grandTotals.totalTokens}`));
+    console.log(`    - Prompt: ${grandTotals.promptTokens}`);
+    console.log(`    - Completion: ${grandTotals.completionTokens}`);
+    console.log(chalk.green(`  Cost (USD): $${(grandTotals.costUSD).toFixed(4)}`));
+    if (codingTotal > 0) {
+        console.log(`\n${chalk.bold('Code Quality Insights:')}`);
+        console.log(chalk.blue(`  Coding Requests: ${codingTotal}`));
+        console.log(chalk.blue(`  Avg Code Quality: ${avgQuality}/100`));
+        console.log(chalk.magenta(`  Avg Effectiveness: ${avgEffectiveness}/100`));
+        if (avgQuality < 70) {
+            console.log(chalk.red('  ⚠️  Low code quality - consider reviewing AI-generated code more carefully'));
+        }
+        if (avgEffectiveness < 70) {
+            console.log(chalk.red('  ⚠️  Low effectiveness - prompts may need improvement or different AI model'));
+        }
+    }
+});
+program
+    .command('init')
+    .description('Scaffold .env and toknxr.config.json in the current directory')
+    .action(() => {
+    const envPath = path.resolve(process.cwd(), '.env');
+    if (!fs.existsSync(envPath)) {
+        fs.writeFileSync(envPath, 'GEMINI_API_KEY=\n');
+        console.log(chalk.green(`Created ${envPath}`));
+    }
+    else {
+        console.log(chalk.yellow(`Skipped ${envPath} (exists)`));
+    }
+    const configPath = path.resolve(process.cwd(), 'toknxr.config.json');
+    if (!fs.existsSync(configPath)) {
+        const config = {
+            providers: [
+                {
+                    name: 'Gemini-Pro',
+                    routePrefix: '/gemini',
+                    targetUrl: 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent',
+                    apiKeyEnvVar: 'GEMINI_API_KEY',
+                    authHeader: 'x-goog-api-key',
+                    tokenMapping: {
+                        prompt: 'usageMetadata.promptTokenCount',
+                        completion: 'usageMetadata.candidatesTokenCount',
+                        total: 'usageMetadata.totalTokenCount'
+                    }
+                }
+            ]
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(chalk.green(`Created ${configPath}`));
+    }
+    else {
+        console.log(chalk.yellow(`Skipped ${configPath} (exists)`));
+    }
+    const policyPath = path.resolve(process.cwd(), 'toknxr.policy.json');
+    if (!fs.existsSync(policyPath)) {
+        const policy = {
+            version: '1',
+            monthlyUSD: 50,
+            perProviderMonthlyUSD: { 'Gemini-Pro': 30 },
+            webhookUrl: ''
+        };
+        fs.writeFileSync(policyPath, JSON.stringify(policy, null, 2));
+        console.log(chalk.green(`Created ${policyPath}`));
+    }
+    else {
+        console.log(chalk.yellow(`Skipped ${policyPath} (exists)`));
+    }
+});
+program
+    .command('tail')
+    .description('Follow interactions.log and pretty-print new lines')
+    .action(() => {
+    const logFilePath = path.resolve(process.cwd(), 'interactions.log');
+    if (!fs.existsSync(logFilePath)) {
+        console.log(chalk.yellow('No interactions.log found. Start the proxy first.'));
+        return;
+    }
+    console.log(chalk.gray(`Tailing ${logFilePath}... (Ctrl+C to stop)`));
+    fs.watchFile(logFilePath, { interval: 500 }, () => {
+        const content = fs.readFileSync(logFilePath, 'utf8').trim();
+        const lines = content.split('\n');
+        const last = lines[lines.length - 1];
+        try {
+            const j = JSON.parse(last);
+            console.log(`${chalk.bold(j.provider)} ${chalk.gray(j.timestamp)} id=${j.requestId} model=${j.model} tokens=${j.totalTokens} cost=$${(j.costUSD || 0).toFixed(4)}`);
+        }
+        catch {
+            console.log(last);
+        }
+    });
+});
+program
+    .command('dashboard')
+    .description('Open the minimal dashboard served by the proxy (/dashboard)')
+    .action(async () => {
+    const url = 'http://localhost:3000/dashboard'; // Assuming Next.js app serves the dashboard
+    console.log(chalk.gray(`Opening ${url}...`));
+    await open(url);
+});
+program
+    .command('policy:init')
+    .description('Scaffold toknxr.policy.json from the foundation starter pack if missing')
+    .action(() => {
+    const dest = path.resolve(process.cwd(), 'toknxr.policy.json');
+    if (fs.existsSync(dest)) {
+        console.log(chalk.yellow(`Skipped ${dest} (exists)`));
+        return;
+    }
+    // Fallback scaffold using sensible defaults if starter pack path is unavailable
+    const fallback = {
+        version: '1',
+        monthlyUSD: 50,
+        perProviderMonthlyUSD: { 'Gemini-Pro': 30 },
+        webhookUrl: ''
+    };
+    fs.writeFileSync(dest, JSON.stringify(fallback, null, 2));
+    console.log(chalk.green(`Created ${dest}`));
+});
+program
+    .command('code-analysis')
+    .description('Show detailed code quality analysis from coding interactions')
+    .action(() => {
+    const logFilePath = path.resolve(process.cwd(), 'interactions.log');
+    if (!fs.existsSync(logFilePath)) {
+        console.log(chalk.yellow('No interactions logged yet. Use the `start` command to begin tracking.'));
+        return;
+    }
+    const fileContent = fs.readFileSync(logFilePath, 'utf8');
+    const lines = fileContent.trim().split('\n');
+    const interactions = lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch (error) {
+            console.warn(`Skipping invalid log entry: ${line}`);
+            return null;
+        }
+    }).filter((interaction) => interaction !== null);
+    if (interactions.length === 0) {
+        console.log(chalk.yellow('No coding interactions found. Code analysis requires coding requests to the proxy.'));
+        return;
+    }
+    console.log(chalk.bold.underline('AI Code Quality Analysis'));
+    // Language distribution
+    const langStats = interactions.reduce((acc, i) => {
+        const lang = i.codeQualityMetrics?.language || 'unknown';
+        if (!acc[lang])
+            acc[lang] = 0;
+        acc[lang]++;
+        return acc;
+    }, {});
+    console.log(chalk.bold('\nLanguage Distribution:'));
+    for (const [lang, count] of Object.entries(langStats)) {
+        console.log(`  ${lang}: ${count} requests`);
+    }
+    // Quality score distribution
+    const qualityRanges = { excellent: 0, good: 0, fair: 0, poor: 0 };
+    const effectivenessRanges = { excellent: 0, good: 0, fair: 0, poor: 0 };
+    interactions.forEach((i) => {
+        const q = i.codeQualityScore || 0;
+        const e = i.effectivenessScore || 0;
+        if (q >= 90)
+            qualityRanges.excellent++;
+        else if (q >= 75)
+            qualityRanges.good++;
+        else if (q >= 60)
+            qualityRanges.fair++;
+        else
+            qualityRanges.poor++;
+        if (e >= 90)
+            effectivenessRanges.excellent++;
+        else if (e >= 75)
+            effectivenessRanges.good++;
+        else if (e >= 60)
+            effectivenessRanges.fair++;
+        else
+            effectivenessRanges.poor++;
+    });
+    console.log(chalk.bold('\nCode Quality Scores:'));
+    console.log(chalk.green(`  Excellent (90-100): ${qualityRanges.excellent}`));
+    console.log(chalk.blue(`  Good (75-89): ${qualityRanges.good}`));
+    console.log(chalk.yellow(`  Fair (60-74): ${qualityRanges.fair}`));
+    console.log(chalk.red(`  Poor (0-59): ${qualityRanges.poor}`));
+    console.log(chalk.bold('\nEffectiveness Scores (Prompt ↔ Result):'));
+    console.log(chalk.green(`  Excellent (90-100): ${effectivenessRanges.excellent}`));
+    console.log(chalk.blue(`  Good (75-89): ${effectivenessRanges.good}`));
+    console.log(chalk.yellow(`  Fair (60-74): ${effectivenessRanges.fair}`));
+    console.log(chalk.red(`  Poor (0-59): ${effectivenessRanges.poor}`));
+    // Recent examples with low scores
+    const lowQuality = interactions.filter((i) => (i.codeQualityScore || 0) < 70).slice(-3);
+    if (lowQuality.length > 0) {
+        console.log(chalk.bold('\n🔍 Recent Low-Quality Code Examples:'));
+        lowQuality.forEach((i, idx) => {
+            console.log(`\n${idx + 1}. Quality: ${i.codeQualityScore}/100${i.effectivenessScore ? ` | Effectiveness: ${i.effectivenessScore}/100` : ''}`);
+            console.log(`   Provider: ${i.provider} | Model: ${i.model}`);
+            if (i.userPrompt) {
+                const prompt = i.userPrompt.substring(0, 100);
+                console.log(`   Prompt: ${prompt}${i.userPrompt.length > 100 ? '...' : ''}`);
+            }
+            if (i.codeQualityMetrics && i.codeQualityMetrics.potentialIssues && i.codeQualityMetrics.potentialIssues.length > 0) {
+                console.log(`   Issues: ${i.codeQualityMetrics.potentialIssues.join(', ')}`);
+            }
+        });
+    }
+    // Improvement suggestions
+    const avgQuality = interactions.reduce((sum, i) => sum + (i.codeQualityScore || 0), 0) / interactions.length;
+    const avgEffectiveness = interactions.reduce((sum, i) => sum + (i.effectivenessScore || 0), 0) / interactions.length;
+    console.log(chalk.bold('\n💡 Improvement Suggestions:'));
+    if (avgQuality < 70) {
+        console.log('  • Consider reviewing AI-generated code more carefully before use');
+        console.log('  • Try more specific, detailed prompts for complex tasks');
+    }
+    if (avgEffectiveness < 70) {
+        console.log('  • Improve prompt clarity - be more specific about requirements');
+        console.log('  • Consider using different AI models for different types of tasks');
+        console.log('  • Break complex requests into smaller, focused prompts');
+    }
+    if (avgQuality >= 80 && avgEffectiveness >= 80) {
+        console.log('  • Great! Your AI coding setup is working well');
+        console.log('  • Consider establishing code review processes for edge cases');
+    }
+    console.log(`\n${chalk.gray('Total coding interactions analyzed: ' + interactions.length)}`);
+});
+program
+    .command('login')
+    .description('Authenticate with your TokNxr account')
+    .action(async () => {
+    console.log(chalk.blue('Starting CLI authentication process...'));
+    await login();
+});
+program.parse(process.argv);

package/lib/code-analysis.js

@@ -0,0 +1,304 @@
+/**
+ * Analyzes code quality and provides metrics
+ */
+export function analyzeCodeQuality(code, language) {
+    const metrics = {
+        syntaxValid: true,
+        linesOfCode: 0,
+        complexity: 0,
+        hasFunctions: false,
+        hasClasses: false,
+        hasTests: false,
+        estimatedReadability: 5,
+        potentialIssues: [],
+        language: detectLanguage(code) || language
+    };
+    if (!code || code.trim().length === 0) {
+        return metrics;
+    }
+    const lines = code.split('\n').filter(l => l.trim());
+    metrics.linesOfCode = lines.length;
+    // Detect language if not provided
+    const detectedLang = metrics.language || 'unknown';
+    // Basic complexity analysis
+    metrics.complexity = calculateComplexity(lines, detectedLang);
+    // Check for structural elements based on language
+    switch (detectedLang) {
+        case 'javascript':
+        case 'typescript':
+            metrics.hasFunctions = /function\s+\w+|const\s+\w+\s*=.*=>|class\s+\w+/.test(code);
+            metrics.hasClasses = /class\s+\w+/.test(code);
+            metrics.hasTests = /describe|test|it\(/.test(code);
+            // Syntax validation (basic)
+            metrics.syntaxValid = validateJSTypescript(code, detectedLang);
+            // Readability scoring
+            metrics.estimatedReadability = calculateJSReadability(code);
+            break;
+        case 'python':
+            metrics.hasFunctions = /def\s+\w+/.test(code);
+            metrics.hasClasses = /class\s+\w+/.test(code);
+            metrics.hasTests = /def test_|unittest|pytest/.test(code);
+            metrics.syntaxValid = validatePython(code);
+            metrics.estimatedReadability = calculatePythonReadability(code);
+            break;
+        default:
+            metrics.potentialIssues.push('Language not recognized for detailed analysis');
+    }
+    // Common issues
+    if (lines.length > 100) {
+        metrics.potentialIssues.push('Very long file - consider splitting');
+    }
+    if (!metrics.syntaxValid) {
+        metrics.potentialIssues.push('Potential syntax errors detected');
+    }
+    return metrics;
+}
+/**
+ * Calculate an effectiveness score comparing prompt to code output
+ */
+export function scoreEffectiveness(userPrompt, aiResponse, extractedCode) {
+    const code = extractedCode || aiResponse;
+    const score = {
+        promptClarityMatch: 0,
+        codeCompleteness: 0,
+        codeCorrectness: 0,
+        codeEfficiency: 0,
+        overallEffectiveness: 0
+    };
+    if (!userPrompt || !code)
+        return score;
+    const prompt = userPrompt.toLowerCase();
+    const response = aiResponse.toLowerCase();
+    // Analyze how well the AI understood the request
+    score.promptClarityMatch = analyzePromptMatch(prompt, response, code);
+    // Analyze code quality and completeness
+    const metrics = analyzeCodeQuality(code);
+    score.codeCorrectness = calculateCorrectnessScore(metrics);
+    score.codeCompleteness = analyzeCompleteness(prompt, code);
+    score.codeEfficiency = estimateEfficiencyScore(code, metrics);
+    // Calculate overall effectiveness (weighted average)
+    score.overallEffectiveness = Math.round((score.promptClarityMatch * 0.3) +
+        (score.codeCompleteness * 0.25) +
+        (score.codeCorrectness * 0.25) +
+        (score.codeEfficiency * 0.2));
+    return score;
+}
+/**
+ * Extract code blocks from AI responses
+ */
+export function extractCodeFromResponse(response) {
+    // Common code block patterns
+    const codeBlockRegex = /```(\w+)?\n?([\s\S]*?)```/g;
+    const match = codeBlockRegex.exec(response);
+    if (match) {
+        return {
+            code: match[2].trim(),
+            language: match[1]?.toLowerCase()
+        };
+    }
+    // Look for inline code that might be a complete solution
+    const inlineCodeRegex = /`([^`\n]+)`/g;
+    const inlineMatches = Array.from(response.matchAll(inlineCodeRegex));
+    if (inlineMatches.length > 0) {
+        // If multiple inline codes, combine them
+        const combined = inlineMatches.map(m => m[1]).join('\n\n');
+        if (combined.length > 50) { // Arbitrary threshold for "substantial" code
+            return { code: combined };
+        }
+    }
+    return null;
+}
+/**
+ * Detect programming language from code content
+ */
+function detectLanguage(code) {
+    if (/(?:import|export|function|const|let|var)\s+/.test(code)) {
+        return code.includes('interface') || code.includes(': string') ? 'typescript' : 'javascript';
+    }
+    if (/def\s+|import\s+|class\s+/.test(code) && /:/.test(code)) {
+        return 'python';
+    }
+    // Add more language detection as needed...
+    return undefined;
+}
+/**
+ * Calculate code complexity score
+ */
+function calculateComplexity(lines, language) {
+    let complexity = 1; // Base complexity
+    for (const line of lines) {
+        // Control flow increases complexity
+        if (/(if|for|while|switch|try|catch)/.test(line)) {
+            complexity += 0.5;
+        }
+        // Nested blocks
+        const indentLevel = line.length - line.trimStart().length;
+        complexity += indentLevel * 0.1;
+        // Function/class definitions
+        if (/(function|def|class)/.test(line)) {
+            complexity += 1;
+        }
+    }
+    return Math.min(complexity, 10); // Cap at 10
+}
+/**
+ * Basic JavaScript/TypeScript validation
+ */
+function validateJSTypescript(code, lang) {
+    try {
+        // Basic bracket matching
+        const brackets = { '(': 0, '[': 0, '{': 0 };
+        for (const char of code) {
+            if (char === '(')
+                brackets['(']++;
+            if (char === ')')
+                brackets['(']--;
+            if (char === '[')
+                brackets['[']++;
+            if (char === ']')
+                brackets['[']--;
+            if (char === '{')
+                brackets['{']++;
+            if (char === '}')
+                brackets['{']--;
+            if (brackets['('] < 0 || brackets['['] < 0 || brackets['{'] < 0) {
+                return false;
+            }
+        }
+        return brackets['('] === 0 && brackets['['] === 0 && brackets['{'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Basic Python validation
+ */
+function validatePython(code) {
+    // Basic indentation check
+    const lines = code.split('\n');
+    let indentLevel = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const currentIndent = line.length - line.trimStart().length;
+        if (currentIndent > indentLevel + 4)
+            return false; // Too much indentation
+        indentLevel = currentIndent;
+    }
+    return true;
+}
+/**
+ * Calculate readability for JS/TS
+ */
+function calculateJSReadability(code) {
+    let score = 5; // Base score
+    // Length factors
+    if (code.length > 2000)
+        score -= 2;
+    if (code.split('\n').length > 50)
+        score -= 1;
+    // Good practices
+    if (code.includes('//') || code.includes('/*'))
+        score += 1; // Has comments
+    if (/\w+_\w+/.test(code))
+        score -= 1; // Poor naming (underscores in JS)
+    if (/[a-z][A-Z]/.test(code.replace(/const|let|var/g, '')))
+        score += 1; // camelCase
+    return Math.max(1, Math.min(10, score));
+}
+/**
+ * Calculate readability for Python
+ */
+function calculatePythonReadability(code) {
+    let score = 7; // Python typically more readable
+    // Length factors
+    if (code.length > 1500)
+        score -= 1.5;
+    if (code.split('\n').length > 40)
+        score -= 1;
+    // Good practices
+    if (code.includes('#'))
+        score += 0.5; // Has comments
+    if (/"""[\s\S]*?"""/.test(code))
+        score += 1; // Has docstrings
+    if (/_/.test(code.replace(/__\w+__/g, '')))
+        score -= 0.5; // Uses underscores (good)
+    return Math.max(1, Math.min(10, score));
+}
+/**
+ * Analyze how well AI response matches the user's prompt
+ */
+function analyzePromptMatch(prompt, response, code) {
+    let match = 0;
+    // Keywords from prompt appearing in code
+    const promptWords = prompt.split(/\s+/).filter(w => w.length > 3);
+    const codeContent = code.toLowerCase();
+    const matchingWords = promptWords.filter(word => codeContent.includes(word.toLowerCase()));
+    match += (matchingWords.length / Math.max(promptWords.length, 1)) * 40;
+    // Check if response acknowledges the request
+    if (response.includes('here') || response.includes('below') || response.includes('code')) {
+        match += 20;
+    }
+    // Has explanation or context
+    if (response.length > code.length * 2) {
+        match += 15;
+    }
+    return Math.min(100, match);
+}
+/**
+ * Calculate correctness score from metrics
+ */
+function calculateCorrectnessScore(metrics) {
+    let score = 50; // Base score
+    if (metrics.syntaxValid)
+        score += 25;
+    else
+        score -= 20;
+    if (metrics.estimatedReadability > 6)
+        score += 15;
+    else if (metrics.estimatedReadability < 4)
+        score -= 10;
+    if (metrics.potentialIssues.length === 0)
+        score += 10;
+    return Math.max(0, Math.min(100, score));
+}
+/**
+ * Analyze code completeness
+ */
+function analyzeCompleteness(prompt, code) {
+    let completeness = 50; // Base
+    // Look for completion indicators
+    if (/(function|def|class)\s+\w+/.test(code))
+        completeness += 20;
+    if (/(return|yield|export)/.test(code))
+        completeness += 15;
+    // Check if code has implementation (not just skeleton)
+    const lines = code.split('\n').length;
+    if (lines > 10)
+        completeness += 10;
+    if (/(todo|fixme|implement)/i.test(code))
+        completeness -= 15;
+    return Math.max(0, Math.min(100, completeness));
+}
+/**
+ * Estimate efficiency score
+ */
+function estimateEfficiencyScore(code, metrics) {
+    let score = 60; // Base
+    // Complexity affects efficiency
+    if (metrics.complexity < 3)
+        score += 20;
+    else if (metrics.complexity > 7)
+        score -= 20;
+    // Length considerations
+    if (metrics.linesOfCode > 100)
+        score -= 10;
+    // Look for inefficient patterns
+    if (/while.*true|for.*;.*;.*\+\+/.test(code)) {
+        if (!/(break|return)/.test(code))
+            score -= 15; // Potential infinite loops
+    }
+    return Math.max(0, Math.min(100, score));
+}