@goldensheepai/toknxr-cli 0.2.0 → 0.2.2

package/lib/plugin-system.js

@@ -0,0 +1,266 @@
+/**
+ * Plugin System for TokNxr Code Analysis
+ * Allows extensible analysis capabilities for custom analyzers
+ */
+/**
+ * Plugin registry and management
+ */
+export class PluginManager {
+    constructor() {
+        this.plugins = new Map();
+    }
+    /**
+     * Register a new plugin
+     */
+    register(plugin) {
+        this.plugins.set(plugin.name, plugin);
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregister(name) {
+        return this.plugins.delete(name);
+    }
+    /**
+     * Get all registered plugins
+     */
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * Get plugins that support a specific language
+     */
+    getPluginsForLanguage(language) {
+        return Array.from(this.plugins.values())
+            .filter(plugin => plugin.supportedLanguages.includes(language));
+    }
+    /**
+     * Analyze code using all applicable plugins
+     */
+    analyzeWithPlugins(code, baseMetrics, plugins) {
+        const applicablePlugins = plugins || this.getPluginsForLanguage(baseMetrics.language || 'unknown');
+        // Apply plugin analyses
+        for (const plugin of applicablePlugins) {
+            if (plugin.analyzeQuality && plugin.validateSyntax && plugin.calculateReadability) {
+                try {
+                    const pluginResults = plugin.analyzeQuality(code, baseMetrics.language || 'unknown');
+                    // Merge plugin results
+                    if (pluginResults.pluginMetrics) {
+                        baseMetrics.pluginMetrics = {
+                            ...baseMetrics.pluginMetrics,
+                            [plugin.name]: pluginResults.pluginMetrics
+                        };
+                    }
+                    // Override base metrics if plugin provides better validation
+                    if (pluginResults.syntaxValid !== undefined) {
+                        const pluginValid = plugin.validateSyntax(code, baseMetrics.language || 'unknown');
+                        if (!pluginValid && baseMetrics.syntaxValid) {
+                            // Plugin detected issues that base validation missed
+                            baseMetrics.syntaxValid = false;
+                            baseMetrics.potentialIssues.push(`${plugin.name}: syntax validation failed`);
+                        }
+                    }
+                    // Enhance readability if plugin provides better calculation
+                    if (pluginResults.estimatedReadability !== undefined) {
+                        const pluginReadability = plugin.calculateReadability(code, baseMetrics.language || 'unknown');
+                        // Use the better (higher) readability score
+                        if (pluginReadability > baseMetrics.estimatedReadability) {
+                            baseMetrics.estimatedReadability = pluginReadability;
+                        }
+                    }
+                    // Add potential issues from plugin
+                    if (pluginResults.potentialIssues && pluginResults.potentialIssues.length > 0) {
+                        baseMetrics.potentialIssues.push(...pluginResults.potentialIssues.map(issue => `${plugin.name}: ${issue}`));
+                    }
+                }
+                catch (error) {
+                    console.warn(`Plugin ${plugin.name} failed during analysis:`, error);
+                }
+            }
+        }
+        return baseMetrics;
+    }
+    /**
+     * Score effectiveness using plugins
+     */
+    scoreEffectivenessWithPlugins(userPrompt, aiResponse, baseScore, extractedCode, plugins) {
+        const code = extractedCode || aiResponse;
+        const codeMetrics = { language: this.detectLanguageFromCode(code) };
+        const applicablePlugins = plugins || this.getPluginsForLanguage(codeMetrics.language || 'unknown');
+        // Apply plugin effectiveness analysis
+        for (const plugin of applicablePlugins) {
+            if (plugin.analyzeEffectiveness) {
+                try {
+                    const pluginResults = plugin.analyzeEffectiveness(userPrompt, aiResponse, extractedCode);
+                    // Apply hallucination detection
+                    if (plugin.detectHallucinations) {
+                        const hallucinations = plugin.detectHallucinations(code, codeMetrics.language || 'unknown');
+                        if (hallucinations.length > 0) {
+                            const avgConfidence = hallucinations.reduce((sum, h) => sum + h.confidence, 0) / hallucinations.length;
+                            baseScore.hallucinationRisk = (baseScore.hallucinationRisk || 0) + (avgConfidence * 0.3);
+                        }
+                    }
+                    // Merge other effectiveness metrics
+                    Object.assign(baseScore, pluginResults);
+                }
+                catch (error) {
+                    console.warn(`Plugin ${plugin.name} failed during effectiveness scoring:`, error);
+                }
+            }
+        }
+        return baseScore;
+    }
+    /**
+     * Detect language from code (helper method)
+     */
+    detectLanguageFromCode(code) {
+        if (/(?:import|export|function|const|let|var)\s+/.test(code)) {
+            return code.includes('interface') || code.includes(': string') ? 'typescript' : 'javascript';
+        }
+        if (/package\s+\w+|func\s+\w+\(/.test(code))
+            return 'go';
+        if (/fn\s+\w+|use\s+std::/.test(code))
+            return 'rust';
+        if (/public\s+class|import\s+java\./.test(code))
+            return 'java';
+        if (/#include\s+<|std::|cout\s+<<|int\s+main\(/.test(code))
+            return 'cpp';
+        return undefined;
+    }
+}
+/**
+ * Built-in security analyzer plugin
+ */
+export const SecurityAnalyzerPlugin = {
+    name: 'security-analyzer',
+    version: '1.0.0',
+    description: 'Analyzes code for security vulnerabilities',
+    supportedLanguages: ['javascript', 'typescript', 'python', 'go', 'rust', 'java', 'cpp'],
+    analyzeQuality(code, language) {
+        const issues = [];
+        let securityScore = 100;
+        // Common security issues across languages
+        if (code.includes('eval(') || code.includes('Function(')) {
+            issues.push('Use of eval() or Function() constructor - potential code injection');
+            securityScore -= 30;
+        }
+        if (code.includes('innerHTML') || code.includes('outerHTML')) {
+            issues.push('Direct HTML manipulation - potential XSS vulnerability');
+            securityScore -= 20;
+        }
+        if (/(password|secret|key).*=\s*["'][^"']*["']/.test(code)) {
+            issues.push('Hardcoded credentials detected');
+            securityScore -= 40;
+        }
+        // Language-specific checks
+        switch (language) {
+            case 'javascript':
+            case 'typescript':
+                if (code.includes('document.cookie')) {
+                    issues.push('Direct cookie manipulation without secure flags');
+                    securityScore -= 15;
+                }
+                break;
+            case 'python':
+                if (code.includes('exec(') || code.includes('eval(')) {
+                    issues.push('Use of exec() or eval() in Python - code injection risk');
+                    securityScore -= 30;
+                }
+                break;
+        }
+        return {
+            potentialIssues: issues,
+            securityScore: Math.max(0, securityScore)
+        };
+    },
+    detectHallucinations(code, language) {
+        const detections = [];
+        // Check for obviously incorrect API usage patterns
+        if (language === 'javascript' && code.includes('fs.readFile') && !code.includes('import fs')) {
+            detections.push({
+                confidence: 85,
+                type: 'missing_import',
+                message: 'Using fs.readFile without importing fs module'
+            });
+        }
+        if (language === 'python' && code.includes('import requests') && code.includes('requests.get') && !code.includes('response.raise_for_status()')) {
+            detections.push({
+                confidence: 60,
+                type: 'missing_error_handling',
+                message: 'HTTP request without proper error handling'
+            });
+        }
+        return detections;
+    }
+};
+/**
+ * Performance analyzer plugin
+ */
+export const PerformanceAnalyzerPlugin = {
+    name: 'performance-analyzer',
+    version: '1.0.0',
+    description: 'Analyzes code for performance bottlenecks',
+    supportedLanguages: ['javascript', 'typescript', 'python', 'go', 'rust', 'java', 'cpp'],
+    analyzeQuality(code, language) {
+        const issues = [];
+        let performanceScore = 100;
+        // Detect performance anti-patterns
+        if (/(for.*for|while.*while)/.test(code)) {
+            issues.push('Nested loops detected - potential O(n²) complexity');
+            performanceScore -= 15;
+        }
+        // Memory leaks in JavaScript
+        if (/(setInterval|setTimeout)/.test(code) && !code.includes('clearInterval') && !code.includes('clearTimeout')) {
+            issues.push('Timer without cleanup - potential memory leak');
+            performanceScore -= 20;
+        }
+        // Inefficient string concatenation
+        if (/(\w+\s*\+\s*\w+.*){3,}/.test(code) && !code.includes('join(')) {
+            issues.push('Inefficient string concatenation - consider using array join');
+            performanceScore -= 10;
+        }
+        return {
+            potentialIssues: issues,
+            performanceScore: Math.max(0, performanceScore)
+        };
+    }
+};
+/**
+ * Framework detector plugin
+ */
+export const FrameworkDetectorPlugin = {
+    name: 'framework-detector',
+    version: '1.0.0',
+    description: 'Detects and analyzes framework-specific code',
+    supportedLanguages: ['javascript', 'typescript', 'python'],
+    analyzeQuality(code, language) {
+        let framework;
+        if (code.includes('import React') || code.includes('from "react"')) {
+            framework = 'react';
+        }
+        else if (code.includes('import Vue') || code.includes('from "vue"')) {
+            framework = 'vue';
+        }
+        else if (code.includes('import { Component }') && code.includes('@Component')) {
+            framework = 'angular';
+        }
+        else if (code.includes('from flask import') || code.includes('import flask')) {
+            framework = 'flask';
+        }
+        else if (code.includes('from django') || code.includes('import django')) {
+            framework = 'django';
+        }
+        else if (code.includes('from fastapi import') || code.includes('import fastapi')) {
+            framework = 'fastapi';
+        }
+        return {
+            framework
+        };
+    }
+};
+// Export default plugin manager instance
+export const pluginManager = new PluginManager();
+// Register built-in plugins
+pluginManager.register(SecurityAnalyzerPlugin);
+pluginManager.register(PerformanceAnalyzerPlugin);
+pluginManager.register(FrameworkDetectorPlugin);

package/lib/sync.js

@@ -13,9 +13,16 @@ export async function syncInteractions(supabase, options) {
     }
     // Set auth in Supabase
     setAuthToken(token);
-    const logFilePath = path.resolve(process.cwd(), 'interactions.log');
+    // Resolve interactions.log robustly across run contexts (repo root vs toknxr-cli)
+    const candidatePaths = [
+        path.resolve(process.cwd(), 'interactions.log'),
+        path.resolve(process.cwd(), 'toknxr-cli', 'interactions.log'),
+        // When executed from built JS in lib/, __dirname points to lib; go up one
+        path.resolve(__dirname, '../interactions.log'),
+    ];
+    const logFilePath = candidatePaths.find(p => fs.existsSync(p)) || candidatePaths[0];
     if (!fs.existsSync(logFilePath)) {
-        console.log(chalk.yellow('No interactions.log file found. Nothing to sync.'));
+        console.log(chalk.yellow('No interactions.log file found in current directory or toknxr-cli/. Nothing to sync.'));
         return;
     }
     const fileContent = fs.readFileSync(logFilePath, 'utf8');
@@ -30,7 +37,7 @@ export async function syncInteractions(supabase, options) {
             const log = JSON.parse(line);
             logs.push(log);
         }
-        catch (error) {
+        catch {
             console.warn(`Skipping invalid log entry: ${line}`);
         }
     }
@@ -71,6 +78,16 @@ export async function syncInteractions(supabase, options) {
             timestamp: new Date(log.timestamp).toISOString(),
             request_details: log.userPrompt || '',
             response_details: log.aiResponse || log.extractedCode || '',
+            // Rich metrics from CLI analysis
+            code_quality_score: log.codeQualityScore,
+            effectiveness_score: log.effectivenessScore,
+            language: log.codeQualityMetrics?.language,
+            syntax_valid: log.codeQualityMetrics?.syntaxValid,
+            readability_score: log.codeQualityMetrics?.estimatedReadability,
+            hallucination_detected: log.hallucinationDetection?.isLikelyHallucination,
+            hallucination_confidence: log.hallucinationDetection?.confidence,
+            prompt_clarity_match: log.hallucinationDetection?.promptClarityMatch,
+            task_type: log.taskType,
         };
         interactions.push(interaction);
     }
@@ -89,7 +106,12 @@ export async function syncInteractions(supabase, options) {
         console.log(`Successfully synced ${interactions.length} interactions.`);
     }
     if (options.clear) {
-        fs.writeFileSync(logFilePath, '');
-        console.log(chalk.gray('Local interactions.log has been cleared.'));
+        try {
+            fs.writeFileSync(logFilePath, '');
+            console.log(chalk.gray('Local interactions.log has been cleared.'));
+        }
+        catch {
+            console.log(chalk.yellow('Could not clear interactions.log. Proceeding without clearing.'));
+        }
     }
 }

package/lib/ui.js

@@ -0,0 +1,132 @@
+import chalk from 'chalk';
+import readline from 'readline';
+export const createStatsOverview = (cost, requests, waste, hallucinations) => `
+  ${chalk.bold.blue('📊 TokNXR Analytics Overview')}
+  ${chalk.gray('------------------------------------')}
+  ${chalk.cyan('Total Cost:')} ${chalk.green(`$${cost.toFixed(2)}`)}
+  ${chalk.cyan('Total Requests:')} ${chalk.green(requests)}
+  ${chalk.cyan('Estimated Waste:')} ${chalk.yellow(`${waste.toFixed(2)}%`)}
+  ${chalk.cyan('Hallucination Rate:')} ${chalk.red(`${hallucinations.toFixed(2)}%`)}
+`;
+export const createProviderTable = async (stats) => {
+    let table = `${chalk.bold.blue('🤖 Provider Performance')}\n`;
+    table += `${chalk.gray('----------------------------------------------------------------')}\n`;
+    table += `${chalk.bold('Provider')} | ${chalk.bold('Tokens')} | ${chalk.bold('Cost')} | ${chalk.bold('Quality')} | ${chalk.bold('Effectiveness')}\n`;
+    table += `${chalk.gray('----------------------------------------------------------------')}\n`;
+    for (const provider in stats) {
+        const { totalTokens, costUSD, avgQualityScore, avgEffectivenessScore } = stats[provider];
+        table += `${provider.padEnd(15)} | ${totalTokens.toLocaleString().padEnd(10)} | ${`$${costUSD.toFixed(2)}`.padEnd(8)} | ${`${avgQualityScore}/100`.padEnd(10)} | ${`${avgEffectivenessScore}/100`}\n`;
+    }
+    return table;
+};
+export const createQualityBreakdown = (interactions) => {
+    const qualityScores = interactions.map(i => i.codeQualityScore || 0);
+    const averageQuality = qualityScores.reduce((a, b) => a + b, 0) / qualityScores.length;
+    return `
+    ${chalk.bold.magenta('🔍 Code Quality Breakdown')}
+    ${chalk.gray('------------------------------------')}
+    ${chalk.cyan('Average Quality Score:')} ${chalk.green(`${averageQuality.toFixed(2)}/100`)}
+  `;
+};
+export const createOperationProgress = (title, steps) => {
+    let currentStep = 0;
+    const spinner = {
+        updateProgress: (step) => {
+            currentStep = step;
+            console.log(`${chalk.blue(`[${currentStep + 1}/${steps.length}]`)} ${steps[currentStep]}`);
+        },
+        succeed: (message) => {
+            console.log(chalk.green(message));
+        },
+        fail: (message) => {
+            console.log(chalk.red(message));
+        },
+    };
+    console.log(chalk.bold.blue(title));
+    return spinner;
+};
+export const createInteractiveMenu = (options) => {
+    return new Promise(resolve => {
+        console.log(chalk.bold.blue('MENU'));
+        options.forEach(option => console.log(option.name));
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Choose an option: ', answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+};
+export const createBox = (title, content, options) => {
+    const { borderColor, titleColor } = options;
+    const color = chalk[borderColor] || chalk.gray;
+    const titleColored = chalk[titleColor] || chalk.white;
+    let box = color('┌' + '─'.repeat(title.length + 2) + '┐\n');
+    box += color('│ ') + titleColored(title) + color(' │\n');
+    box += color('├' + '─'.repeat(title.length + 2) + '┤\n');
+    content.forEach(line => {
+        box +=
+            color('│ ') +
+                line +
+                color(' '.repeat(Math.max(0, title.length - line.length + 2))) +
+                color(' │\n');
+    });
+    box += color('└' + '─'.repeat(title.length + 2) + '┘');
+    return box;
+};
+export const createCostChart = (data) => {
+    // Basic chart for demonstration
+    let chart = `${chalk.bold.blue('Cost Trend (Last 7 Days)')}\n`;
+    const max = Math.max(...data);
+    data.forEach(value => {
+        const bar = '█'.repeat(Math.round((value / max) * 20));
+        chart += `${chalk.green(bar)}\n`;
+    });
+    return chart;
+};
+export const createPaginatedDisplay = (data, pageSize, currentPage, render, title) => {
+    let display = title ? `${chalk.bold.blue(title)}\n` : '';
+    data.forEach((item, index) => {
+        display += render(item, (currentPage - 1) * pageSize + index);
+    });
+    return display;
+};
+export const createFilterInterface = (currentFilters) => {
+    return new Promise(resolve => {
+        console.log('Filtering interface is not implemented in this mock.');
+        resolve(currentFilters);
+    });
+};
+export const createSearchInterface = (fields) => {
+    return new Promise(resolve => {
+        console.log('Search interface is not implemented in this mock.');
+        resolve({ query: 'test', fields });
+    });
+};
+export class InteractiveDataExplorer {
+    constructor(data) {
+        this.data = data;
+    }
+    setPageSize(_size) { } // Mock implementation
+    setPage(_page) { } // Mock implementation
+    getCurrentPageData() {
+        return this.data;
+    }
+    getPaginationInfo() {
+        return { totalItems: this.data.length, totalPages: 1 };
+    }
+}
+export class CliStateManager {
+    static getPreferences() {
+        return {};
+    }
+    static updateSessionBudget(_amount, _provider) { } // Mock implementation
+    static loadState() {
+        return { budgets: {} };
+    }
+}
+export const filterAndSearchInteractions = (interactions, _filters, _search) => {
+    return interactions;
+};

package/package.json

@@ -1,38 +1,71 @@
 {
   "name": "@goldensheepai/toknxr-cli",
-  "version": "0.2.0",
-  "license": "ISC",
+  "version": "0.2.2",
+  "description": "CLI-powered AI effectiveness & code quality analysis tool - 100% Local",
+  "license": "MIT",
   "type": "module",
+  "private": false,
   "bin": {
     "toknxr": "lib/cli.js"
   },
+  "main": "lib/cli.js",
+  "files": [
+    "lib/**/*",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "code-quality",
+    "analytics",
+    "token-tracking",
+    "developer-tools",
+    "local-first",
+    "proxy",
+    "gemini",
+    "openai",
+    "anthropic"
+  ],
   "scripts": {
-    "start": "tsx src/cli.ts start",
-    "cli": "tsx src/cli.ts",
     "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "dev": "tsx watch src/cli.ts",
+    "lint": "echo 'Lint CLI code with root ESLint config'",
+    "typecheck": "tsc --noEmit",
+    "cli": "tsx src/cli.ts",
+    "start": "tsx src/cli.ts start",
+    "test": "tsx --test --test-reporter=verbose src/**/*.test.ts",
+    "test:watch": "tsx --test --watch src/**/*.test.ts"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^2.47.1",
-    "commander": "^14.0.1",
-    "chalk": "^5.6.2",
     "axios": "^1.12.2",
-    "open": "^10.2.0",
-    "keytar": "^7.9.0",
-    "ora": "^9.0.0",
-    "cli-spinners": "^3.3.0",
+    "boxen": "^7.1.1",
+    "chalk": "^5.6.2",
     "cli-cursor": "^5.0.0",
-    "onetime": "^7.0.0",
+    "cli-progress": "^3.12.0",
+    "cli-spinners": "^3.3.0",
+    "cli-table3": "^0.6.4",
+    "commander": "^14.0.1",
+    "dotenv": "^16.4.5",
+    "inquirer": "^12.0.0",
     "is-interactive": "^2.0.0",
-    "@types/keytar": "^4.4.0",
-    "dotenv": "^16.4.5"
+    "onetime": "^7.0.0",
+    "open": "^10.2.0",
+    "ora": "^9.0.0"
   },
   "devDependencies": {
-    "@types/node": "^24.6.2",
     "@types/chalk": "^2.2.4",
+    "@types/node": "^24.6.2",
     "@types/open": "^6.2.1",
-    "typescript": "^5.9.3",
+    "@vitest/ui": "^3.2.4",
+    "esbuild": "^0.25.10",
     "tsx": "^4.20.6",
-    "esbuild": "^0.25.10"
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   }
 }

package/.env

@@ -1,21 +0,0 @@
-# TokNXR Environment Variables
-# Copy this file to .env and fill in your actual API keys
-
-# Google AI API Key (used for both Gemini-Pro and Gemini-Free)
-GEMINI_API_KEY=AIzaSyCtrQ8e5H66vbrAozWlWUmCcObJmrI2ovg
-
-# OpenAI API Key
-OPENAI_API_KEY=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
-
-# Anthropic Claude API Key
-ANTHROPIC_API_KEY=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
-
-# Supabase Configuration
-SUPABASE_URL=https://your-project.supabase.co
-SUPABASE_SERVICE_ROLE_KEY=your_service_role_key
-# Optional: Webhook URL for budget alerts
-# WEBHOOK_URL=https://your-webhook-url.com/alerts
-SUPABASE_URL=https://pkdytotoptkknghtsomn.supabase.co
-SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBrZHl0b3RvcHRra25naHRzb21uIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTk3MjI1OTgsImV4cCI6MjA3NTI5ODU5OH0.Y3RVJvx7w-eGD4Nv2aVv8jnkUKhmA2vpkBs7_rFzEoQ
-# Optional: Custom port for the proxy server (default: 8788)
-# PORT=8788

package/.env.example

@@ -1,21 +0,0 @@
-# TokNXR Environment Variables
-# Copy this file to .env and fill in your actual API keys
-
-# Google AI API Key (used for both Gemini-Pro and Gemini-Free)
-GEMINI_API_KEY=AIzaSyCtrQ8e5H66vbrAozWlWUmCcObJmrI2ovg
-
-# OpenAI API Key
-OPENAI_API_KEY=your-openai-api-key-here
-
-# Anthropic Claude API Key
-ANTHROPIC_API_KEY=your-anthropic-api-key-here
-
-# Optional: Webhook URL for budget alerts
-# WEBHOOK_URL=https://your-webhook-url.com/alerts
-SUPABASE_URL=your-supabase-url
-SUPABASE_ANON_KEY=your-anon-key
-SUPABASE_SERVICE_ROLE_KEY=your-service-role-key
-SUPABASE_JWT_SECRET=your-jwt-secret
-
-# Optional: Custom port for the proxy server (default: 8787)
-PORT=8787

package/interactions.log

@@ -1,8 +0,0 @@
-{"timestamp":"2025-10-05T20:14:35.420Z","provider":"Gemini-Pro","model":"unknown","promptTokens":9,"completionTokens":2056,"totalTokens":3506,"costUSD":0,"taskType":"chat"}
-{"timestamp":"2025-10-05T20:18:24.093Z","provider":"Gemini-Pro","model":"unknown","promptTokens":9,"completionTokens":2236,"totalTokens":3564,"costUSD":0,"taskType":"chat"}
-{"timestamp":"2025-10-05T20:21:58.826Z","provider":"Gemini-Pro","model":"unknown","promptTokens":9,"completionTokens":2054,"totalTokens":3322,"costUSD":0,"taskType":"chat"}
-{"requestId":"84870610-70c2-4b31-834f-6c55f92c8495","timestamp":"2025-10-05T20:49:46.035Z","provider":"Gemini-Pro","model":"gemini-2.5-flash","promptTokens":2,"completionTokens":519,"totalTokens":1930,"costUSD":0.3117,"taskType":"chat"}
-{"timestamp":"2025-10-05T21:44:57.972Z","provider":"Gemini-Pro","model":"gemini-2.5-flash","promptTokens":150,"completionTokens":200,"totalTokens":350,"costUSD":0.05,"taskType":"coding","userPrompt":"Create a React component for a todo list","aiResponse":"Here's a React todo component...","extractedCode":"function TodoList() {\n  const [todos, setTodos] = useState([]);\n  return (\n    <div>\n      <h1>My Todos</h1>\n      {/* Todo implementation */}\n    </div>\n  );\n}","codeQualityScore":85,"codeQualityMetrics":{"syntaxValid":true,"estimatedReadability":0.8,"hasFunctions":true,"hasClasses":false,"linesOfCode":12,"potentialIssues":[]},"effectivenessScore":88}
-{"timestamp":"2025-10-05T21:59:57.974Z","provider":"OpenAI-GPT4","model":"gpt-4","promptTokens":80,"completionTokens":120,"totalTokens":200,"costUSD":0.02,"taskType":"coding","userPrompt":"Write a Python function to calculate fibonacci","aiResponse":"def fibonacci(n):...","extractedCode":"def fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)","codeQualityScore":92,"codeQualityMetrics":{"syntaxValid":true,"estimatedReadability":0.9,"hasFunctions":true,"hasClasses":false,"linesOfCode":4,"potentialIssues":[]},"effectivenessScore":95}
-{"timestamp":"2025-10-05T22:09:57.974Z","provider":"Gemini-Pro","model":"gemini-2.5-flash","promptTokens":200,"completionTokens":300,"totalTokens":500,"costUSD":0.08,"taskType":"coding","userPrompt":"Create a TypeScript API endpoint","aiResponse":"Here's a TypeScript API endpoint...","extractedCode":"import express from 'express';\n\nconst app = express();\n\napp.get('/api/users', async (req, res) => {\n  // Implementation here\n});\n\nexport default app;","codeQualityScore":78,"codeQualityMetrics":{"syntaxValid":true,"estimatedReadability":0.7,"hasFunctions":true,"hasClasses":false,"linesOfCode":8,"potentialIssues":["Missing error handling"]},"effectivenessScore":82}
-{"requestId":"b8d3c1cc-c3c5-427a-b9f3-0af12b7e8e8d","timestamp":"2025-10-05T22:19:07.944Z","provider":"Gemini-Pro","model":"gemini-2.5-flash","promptTokens":13,"completionTokens":1133,"totalTokens":2206,"costUSD":0.68175,"taskType":"coding","extractedCode":"/**\n * Calculates the factorial of a non-negative integer using recursion.\n *\n * @param {number} n The non-negative integer for which to calculate the factorial.\n * @returns {number} The factorial of n.\n * @throws {Error} If n is a negative number.\n * @throws {Error} If n is not an integer.\n */\nfunction factorial(n) {\n  // Input validation: Factorial is traditionally defined for non-negative integers.\n  if (n < 0) {\n    throw new Error(\"Factorial is not defined for negative numbers.\");\n  }\n  if (!Number.isInteger(n)) {\n    throw new Error(\"Factorial is only defined for integer numbers.\");\n  }\n\n  // Base Case: This is where the recursion stops.\n  // The factorial of 0 is 1, and the factorial of 1 is 1.\n  if (n === 0 || n === 1) {\n    return 1;\n  }\n\n  // Recursive Step: The function calls itself with a smaller input.\n  // n! = n * (n-1)!\n  return n * factorial(n - 1);\n}\n\n// --- Examples ---\nconsole.log(`Factorial of 0: ${factorial(0)}`);   // Expected: 1\nconsole.log(`Factorial of 1: ${factorial(1)}`);   // Expected: 1\nconsole.log(`Factorial of 5: ${factorial(5)}`);   // Expected: 120 (5 * 4 * 3 * 2 * 1)\nconsole.log(`Factorial of 7: ${factorial(7)}`);   // Expected: 5040 (7 * 6 * 5 * 4 * 3 * 2 * 1)\nconsole.log(`Factorial of 10: ${factorial(10)}`); // Expected: 3628800\n\n// --- Error Handling Examples ---\ntry {\n  console.log(`Factorial of -3: ${factorial(-3)}`);\n} catch (error) {\n  console.error(`Error: ${error.message}`); // Expected: Error: Factorial is not defined for negative numbers.\n}\n\ntry {\n  console.log(`Factorial of 3.5: ${factorial(3.5)}`);\n} catch (error) {\n  console.error(`Error: ${error.message}`); // Expected: Error: Factorial is only defined for integer numbers.\n}\n\ntry {\n    console.log(`Factorial of \"abc\": ${factorial(\"abc\")}`);\n} catch (error) {\n    console.error(`Error: ${error.message}`); // Expected: Error: Factorial is only defined for integer numbers.\n}","codeQualityMetrics":{"syntaxValid":true,"linesOfCode":47,"complexity":10,"hasFunctions":true,"hasClasses":false,"hasTests":false,"estimatedReadability":6,"potentialIssues":[],"language":"javascript"},"codeQualityScore":100,"effectivenessScore":68,"userPrompt":"Write a JavaScript function to calculate the factorial of a number using recursion","aiResponse":"Here's a JavaScript function to calculate the factorial of a number using recursion, along with explanations and examples:\n\n```javascript\n/**\n * Calculates the factorial of a non-negative integer using recursion.\n *\n * @param {number} n The non-negative integer for which to calculate the factorial.\n * @returns {number} The factorial of n.\n * @throws {Error} If n is a negative number.\n * @throws {Error} If n is not an integer.\n */\nfunction factorial(n) {\n  // Input validation: Factorial is traditionally defined for non-negative integers.\n  if (n < 0) {\n    throw new Error(\"Factorial is not defined for negative numbers.\");\n  }\n  if (!Number.isInteger(n)) {\n    throw new Error(\"Factorial is only defined for integer numbers.\");\n  }\n\n  // Base Case: This is where the recursion stops.\n  // The factorial of 0 is 1, and the factorial of 1 is 1.\n  if (n === 0 || n === 1) {\n    return 1;\n  }\n\n  // Recursive Step: The function calls itself with a smaller input.\n  // n! = n * (n-1)!\n  return n * factorial(n - 1);\n}\n\n// --- Examples ---\nconsole.log(`Factorial of 0: ${factorial(0)}`);   // Expected: 1\nconsole.log(`Factorial of 1: ${factorial(1)}`);   // Expected: 1\nconsole.log(`Factorial of 5: ${factorial(5)}`);   // Expected: 120 (5 * 4 * 3 * 2 * 1)\nconsole.log(`Factorial of 7: ${factorial(7)}`);   // Expected: 5040 (7 * 6 * 5 * 4 * 3 * 2 * 1)\nconsole.log(`Factorial of 10: ${factorial(10)}`); // Expected: 3628800\n\n// --- Error Handling Examples ---\ntry {\n  console.log(`Factorial of -3: ${factorial(-3)}`);\n} catch (error) {\n  console.error(`Error: ${error.message}`); // Expected: Error: Factorial is not defined for negative numbers.\n}\n\ntry {\n  console.log(`Factorial of 3.5: ${factorial(3.5)}`);\n} catch (error) {\n  console.error(`Error: ${error.message}`); // Expected: Error: Factorial is only defined for integer numbers.\n}\n\ntry {\n    console.log(`Factorial of \"abc\": ${factorial(\"abc\")}`);\n} catch (error) {\n    console.error(`Error: ${error.message}`); // Expected: Error: Factorial is only defined for integer numbers.\n}\n```\n\n### How it works (Recursive Breakdown):\n\nLet's trace `factorial(3)`:\n\n1.  `factorial(3)` is called.\n    *   `n` is 3. It's not 0 or 1.\n    *   It returns `3 * factorial(2)`.\n\n2.  `factorial(2)` is called (from inside the first call).\n    *   `n` is 2. It's not 0 or 1.\n    *   It returns `2 * factorial(1)`.\n\n3.  `factorial(1)` is called (from inside the second call).\n    *   `n` is 1. **This hits the base case!**\n    *   It returns `1`.\n\n4.  Now, the execution unwinds:\n    *   The `factorial(2)` call receives `1` from `factorial(1)`.\n    *   It calculates `2 * 1 = 2`.\n    *   It returns `2`.\n\n5.  Finally, the `factorial(3)` call receives `2` from `factorial(2)`.\n    *   It calculates `3 * 2 = 6`.\n    *   It returns `6`.\n\nThe result `6` is then printed.\n\n### Key Concepts:\n\n1.  **Base Case:** Every recursive function *must* have one or more base cases. This is a condition where the function stops calling itself and returns a direct value. Without a base case, the function would call itself indefinitely, leading to a \"Stack Overflow\" error. For factorial, `factorial(0) = 1` and `factorial(1) = 1` are the base cases.\n2.  **Recursive Step:** This is where the function calls itself with a modified (usually smaller or simpler) input. The idea is to break down the problem into a smaller instance of the *same* problem. For factorial, `n! = n * (n-1)!` is the recursive step. The problem `n!` is solved by using the solution to `(n-1)!`.\n3.  **Input Validation:** It's good practice to add checks for invalid inputs (like negative numbers or non-integers for factorial) to make the function more robust."}