@goldensheepai/toknxr-cli 0.2.0

package/.env

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,21 @@
+# 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/README.md

@@ -0,0 +1,238 @@
+# TokNXR - AI Usage Analytics & Cost Tracking
+
+🚀 **One Command Setup** - Track AI usage across all major providers with comprehensive analytics, cost monitoring, and code quality analysis.
+
+## 🔥 Quick Start (ONE COMMAND!)
+
+### Option 1: Ultimate One-Command Setup (Recommended)
+```bash
+# From the ToknXR-CLI directory, run:
+./toknxr-cli/start.sh
+```
+This single command does **EVERYTHING**:
+- ✅ Sets up all configuration files
+- ✅ Creates environment variables template
+- ✅ Starts the server with all 5 providers
+- ✅ Opens your AI analytics dashboard
+
+### Option 2: NPM Commands
+```bash
+# 1. Navigate to the toknxr-cli directory
+cd toknxr-cli
+
+# 2. One command setup and launch (does everything!)
+npm run launch
+
+# 3. Or use the alias:
+npm run go
+```
+
+### Option 3: Manual Setup (if you prefer)
+```bash
+cd toknxr-cli
+npm run quickstart  # Sets up everything
+# Add your API keys to .env file
+npm start          # Start tracking
+```
+
+**That's it!** 🎉 Your AI usage analytics dashboard will be available at `http://localhost:8788/dashboard`
+
+## 📦 What's Included
+
+✅ **5 AI Providers** with full configuration support:
+- **Ollama-Llama3** (Local AI - Free)
+- **Gemini-Pro** (Google AI - Paid)
+- **Gemini-Free** (Google AI - Free tier)
+- **OpenAI-GPT4** (OpenAI - Paid)
+- **Anthropic-Claude** (Claude - Paid)
+
+✅ **Advanced Analytics**:
+- Real-time token usage tracking
+- Cost monitoring and budget alerts
+- Code quality analysis for coding requests
+- Hallucination detection
+- Effectiveness scoring
+
+✅ **Smart Features**:
+- Automatic provider routing
+- Budget enforcement with alerts
+- Comprehensive logging
+- Web dashboard for visualization
+
+## 🔧 Setup Details
+
+### Environment Variables (.env file)
+```bash
+# Required: Google AI API Key (for Gemini models)
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Optional: OpenAI API Key
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Optional: Anthropic Claude API Key
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: Webhook for budget alerts
+WEBHOOK_URL=https://your-webhook-url.com/alerts
+```
+
+### API Provider Endpoints
+
+Once running, your AI providers will be available at:
+
+| Provider | Endpoint | Status |
+|----------|----------|---------|
+| **Ollama-Llama3** | `http://localhost:8788/ollama` | ✅ Ready |
+| **Gemini-Pro** | `http://localhost:8788/gemini` | ✅ Ready |
+| **Gemini-Free** | `http://localhost:8788/gemini-free` | ✅ Ready |
+| **OpenAI-GPT4** | `http://localhost:8788/openai` | ✅ Ready |
+| **Anthropic-Claude** | `http://localhost:8788/anthropic` | ✅ Ready |
+
+## 💡 Usage Examples
+
+### Using with curl
+```bash
+# Test Gemini-Free (no API key needed for testing)
+curl -X POST http://localhost:8788/gemini-free \
+  -H "Content-Type: application/json" \
+  -d '{"contents":[{"parts":[{"text":"Hello, world!"}]}]}'
+
+# Test with your own API key for full access
+curl -X POST http://localhost:8788/gemini \
+  -H "Content-Type: application/json" \
+  -d '{"contents":[{"parts":[{"text":"Write a Python function"}]}]}'
+```
+
+### Using with JavaScript/Node.js
+```javascript
+const response = await fetch('http://localhost:8788/gemini-free', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    contents: [{ parts: [{ text: 'Your prompt here' }] }]
+  })
+});
+const data = await response.json();
+```
+
+### Using with Python
+```python
+import requests
+
+response = requests.post('http://localhost:8788/gemini-free', json={
+    'contents': [{'parts': [{'text': 'Your prompt here'}]}]
+})
+result = response.json()
+```
+
+## 📊 Analytics & Monitoring
+
+### View Usage Statistics
+```bash
+# View token usage and cost statistics
+npm run cli stats
+
+# Analyze code quality from coding requests
+npm run cli code-analysis
+
+# Check for AI hallucinations
+npm run cli hallucination-analysis
+```
+
+### Dashboard Access
+- **Main Dashboard**: `http://localhost:8788/dashboard`
+- **Health Check**: `http://localhost:8788/health`
+- **API Stats**: `http://localhost:8788/api/stats`
+
+## 🛠️ Advanced Configuration
+
+### Budget Management
+The system includes intelligent budget management:
+
+```bash
+# Initialize budget policies
+npm run cli policy:init
+
+# Monthly limits (configurable in toknxr.policy.json):
+# - Total: $50/month across all providers
+# - Gemini-Pro: $30/month
+# - Gemini-Free: $10/month
+# - OpenAI-GPT4: $20/month
+# - Anthropic-Claude: $15/month
+# - Ollama-Llama3: $0/month (free)
+```
+
+### Custom Configuration
+Edit `toknxr.config.json` to:
+- Add new AI providers
+- Modify token mapping
+- Update API endpoints
+- Configure authentication
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+**Port 8788 already in use:**
+```bash
+# Kill existing process
+pkill -f "npm run start"
+# Then restart
+npm start
+```
+
+**API key not working:**
+- Verify your API keys in the `.env` file
+- Check that keys have the correct permissions
+- Test keys directly with the provider's API
+
+**Ollama not available:**
+- Ensure Ollama is running: `ollama serve`
+- Check that it's accessible at `http://localhost:11434`
+
+### Getting Help
+```bash
+# View all available commands
+npm run cli --help
+
+# Check available Gemini models
+npm run cli models
+
+# Test direct API calls (bypassing proxy)
+npm run cli call --model models/gemini-1.5-flash --prompt "Hello"
+```
+
+## 🚀 Production Deployment
+
+For production use:
+
+1. **Secure your API keys** using your platform's secret management
+2. **Set up proper logging** and monitoring
+3. **Configure webhook alerts** for budget limits
+4. **Use a process manager** like PM2 for stability
+5. **Set up reverse proxy** with proper CORS configuration
+
+## 📈 What's Tracked
+
+For every AI request, TokNXR captures:
+
+- **Token Usage**: Prompt, completion, and total tokens
+- **Cost Calculation**: Real-time cost in USD
+- **Provider Info**: Which AI model was used
+- **Code Quality**: Syntax validation, readability, structure
+- **Effectiveness**: How well the AI understood your request
+- **Hallucinations**: Detection of potential AI fabrications
+- **Business Impact**: Time waste and quality degradation metrics
+
+## 🤝 Contributing
+
+We welcome contributions! Areas where help is needed:
+
+- Additional AI provider integrations
+- Enhanced analytics and visualizations
+- Performance optimizations
+- Testing and documentation
+
+---
+
+**Made with ❤️ for AI developers who want to track and optimize their AI usage**

package/interactions.log

@@ -0,0 +1,8 @@
+{"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."}

package/lib/ai-analytics.js

@@ -0,0 +1,296 @@
+import fs from 'fs';
+import path from 'path';
+import { HallucinationDetector } from './hallucination-detector.js';
+/**
+ * Enhanced AI Analytics with hallucination tracking
+ */
+export class AIAnalytics {
+    constructor(logFilePath) {
+        this.detector = new HallucinationDetector();
+        this.logFilePath = logFilePath || path.resolve(process.cwd(), 'interactions.log');
+    }
+    /**
+     * Analyze a single interaction for hallucinations and business impact
+     */
+    analyzeInteraction(userPrompt, aiResponse, context) {
+        // Run hallucination detection
+        const hallucinationDetection = this.detector.detectHallucination(userPrompt, aiResponse);
+        // Calculate business impact if hallucination detected
+        let businessImpact;
+        if (hallucinationDetection.isLikelyHallucination) {
+            businessImpact = this.detector.calculateBusinessImpact(hallucinationDetection.confidence, 1, // This interaction
+            context.costUSD);
+        }
+        return {
+            timestamp: new Date().toISOString(),
+            provider: context.provider,
+            model: context.model,
+            userPrompt,
+            aiResponse,
+            taskType: context.taskType,
+            costUSD: context.costUSD,
+            totalTokens: context.totalTokens,
+            codeQualityScore: context.codeQualityScore,
+            effectivenessScore: context.effectivenessScore,
+            hallucinationDetection,
+            businessImpact
+        };
+    }
+    /**
+     * Generate comprehensive analytics from interaction logs
+     */
+    generateAnalytics() {
+        if (!fs.existsSync(this.logFilePath)) {
+            return this.getEmptyAnalytics();
+        }
+        const fileContent = fs.readFileSync(this.logFilePath, 'utf8');
+        const lines = fileContent.trim().split('\n');
+        const interactions = [];
+        // Parse all interactions
+        for (const line of lines) {
+            try {
+                const interaction = JSON.parse(line);
+                if (interaction.userPrompt && interaction.aiResponse) {
+                    interactions.push(interaction);
+                }
+            }
+            catch (error) {
+                // Skip malformed lines
+                continue;
+            }
+        }
+        if (interactions.length === 0) {
+            return this.getEmptyAnalytics();
+        }
+        return this.aggregateAnalytics(interactions);
+    }
+    /**
+     * Aggregate analytics from interaction data
+     */
+    aggregateAnalytics(interactions) {
+        const totalInteractions = interactions.length;
+        // Calculate hallucination metrics
+        const hallucinations = interactions.filter(i => i.hallucinationDetection?.isLikelyHallucination);
+        const hallucinationCount = hallucinations.length;
+        const hallucinationRate = (hallucinationCount / totalInteractions) * 100;
+        const avgConfidence = hallucinations.length > 0
+            ? hallucinations.reduce((sum, h) => sum + (h.hallucinationDetection?.confidence || 0), 0) / hallucinations.length
+            : 0;
+        // Category breakdown
+        const byCategory = {};
+        hallucinations.forEach(h => {
+            h.hallucinationDetection?.evidence.forEach(evidence => {
+                byCategory[evidence.type] = (byCategory[evidence.type] || 0) + 1;
+            });
+        });
+        // Provider comparison
+        const providerStats = {};
+        interactions.forEach(interaction => {
+            if (!providerStats[interaction.provider]) {
+                providerStats[interaction.provider] = [];
+            }
+            providerStats[interaction.provider].push(interaction);
+        });
+        const providerComparison = {};
+        Object.entries(providerStats).forEach(([provider, providerInteractions]) => {
+            const providerHallucinations = providerInteractions.filter(i => i.hallucinationDetection?.isLikelyHallucination);
+            const providerHallucinationRate = (providerHallucinations.length / providerInteractions.length) * 100;
+            const avgQualityScore = providerInteractions.reduce((sum, i) => sum + (i.codeQualityScore || 0), 0) / providerInteractions.length;
+            const avgEffectivenessScore = providerInteractions.reduce((sum, i) => sum + (i.effectivenessScore || 0), 0) / providerInteractions.length;
+            // Calculate business impact for this provider
+            const totalCost = providerInteractions.reduce((sum, i) => sum + i.costUSD, 0);
+            const businessImpact = this.detector.calculateBusinessImpact(providerHallucinationRate, providerInteractions.length, totalCost / providerInteractions.length);
+            providerComparison[provider] = {
+                totalInteractions: providerInteractions.length,
+                hallucinationRate: Math.round(providerHallucinationRate * 10) / 10,
+                avgQualityScore: Math.round(avgQualityScore),
+                avgEffectivenessScore: Math.round(avgEffectivenessScore),
+                businessImpact
+            };
+        });
+        // Calculate overall business impact
+        const totalCost = interactions.reduce((sum, i) => sum + i.costUSD, 0);
+        const avgCostPerInteraction = totalCost / totalInteractions;
+        const overallBusinessImpact = this.detector.calculateBusinessImpact(hallucinationRate, totalInteractions, avgCostPerInteraction);
+        const hallucinationMetrics = {
+            totalAnalyses: totalInteractions,
+            hallucinationCount,
+            hallucinationRate: Math.round(hallucinationRate * 10) / 10,
+            avgConfidence: Math.round(avgConfidence),
+            byCategory,
+            byProvider: Object.fromEntries(Object.entries(providerComparison).map(([provider, stats]) => [provider, stats.hallucinationRate])),
+            businessImpact: overallBusinessImpact
+        };
+        // Generate trends (last 30 days)
+        const trends = this.generateTrends(interactions);
+        // Generate recommendations
+        const recommendations = this.generateRecommendations(hallucinationMetrics, providerComparison);
+        return {
+            totalInteractions,
+            hallucinationMetrics,
+            providerComparison,
+            trends,
+            recommendations
+        };
+    }
+    /**
+     * Generate trend data from interactions
+     */
+    generateTrends(interactions) {
+        const last30Days = new Date();
+        last30Days.setDate(last30Days.getDate() - 30);
+        const recentInteractions = interactions.filter(i => new Date(i.timestamp) >= last30Days);
+        // Group by day
+        const dailyGroups = {};
+        recentInteractions.forEach(interaction => {
+            const date = new Date(interaction.timestamp).toISOString().split('T')[0];
+            if (!dailyGroups[date]) {
+                dailyGroups[date] = [];
+            }
+            dailyGroups[date].push(interaction);
+        });
+        // Calculate daily metrics
+        const hallucinationRateOverTime = Object.entries(dailyGroups)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([date, dayInteractions]) => {
+            const hallucinations = dayInteractions.filter(i => i.hallucinationDetection?.isLikelyHallucination);
+            const rate = dayInteractions.length > 0 ? (hallucinations.length / dayInteractions.length) * 100 : 0;
+            return { date, rate: Math.round(rate * 10) / 10 };
+        });
+        const qualityScoreOverTime = Object.entries(dailyGroups)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([date, dayInteractions]) => {
+            const avgQuality = dayInteractions.reduce((sum, i) => sum + (i.codeQualityScore || 0), 0) / dayInteractions.length;
+            return { date, score: Math.round(avgQuality) };
+        });
+        const costEfficiencyOverTime = Object.entries(dailyGroups)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([date, dayInteractions]) => {
+            const totalCost = dayInteractions.reduce((sum, i) => sum + i.costUSD, 0);
+            const avgQuality = dayInteractions.reduce((sum, i) => sum + (i.codeQualityScore || 0), 0) / dayInteractions.length;
+            const efficiency = totalCost > 0 ? (avgQuality / totalCost) * 1000 : 0; // Quality per dollar
+            return { date, efficiency: Math.round(efficiency * 10) / 10 };
+        });
+        return {
+            hallucinationRateOverTime,
+            qualityScoreOverTime,
+            costEfficiencyOverTime
+        };
+    }
+    /**
+     * Generate actionable recommendations
+     */
+    generateRecommendations(metrics, providerComparison) {
+        const recommendations = [];
+        // Hallucination rate recommendations
+        if (metrics.hallucinationRate > 20) {
+            recommendations.push(`🚨 CRITICAL: Hallucination rate is ${metrics.hallucinationRate}%. Consider reviewing AI-generated content more carefully.`);
+        }
+        else if (metrics.hallucinationRate > 10) {
+            recommendations.push(`⚠️ WARNING: Hallucination rate is ${metrics.hallucinationRate}%. Monitor closely and verify important information.`);
+        }
+        else if (metrics.hallucinationRate > 5) {
+            recommendations.push(`ℹ️ Hallucination rate is ${metrics.hallucinationRate}%. Generally acceptable but watch for patterns.`);
+        }
+        // Provider-specific recommendations
+        const worstProvider = Object.entries(providerComparison)
+            .sort(([, a], [, b]) => (b.hallucinationRate || 0) - (a.hallucinationRate || 0))[0];
+        if (worstProvider && (worstProvider[1].hallucinationRate || 0) > 15) {
+            recommendations.push(`🔄 Consider reducing usage of ${worstProvider[0]} (hallucination rate: ${worstProvider[1].hallucinationRate}%) or improve prompt quality.`);
+        }
+        // Business impact recommendations
+        if (metrics.businessImpact.estimatedDevTimeWasted > 5) {
+            recommendations.push(`⏱️ Hallucinations are wasting ~${metrics.businessImpact.estimatedDevTimeWasted} hours of development time. Consider AI response verification workflows.`);
+        }
+        if (metrics.businessImpact.roiImpact > 10) {
+            recommendations.push(`💰 Hallucinations are reducing ROI by ${metrics.businessImpact.roiImpact}%. Review AI usage strategy and prompt engineering.`);
+        }
+        // Quality improvement recommendations
+        const bestProvider = Object.entries(providerComparison)
+            .sort(([, a], [, b]) => (b.avgQualityScore || 0) - (a.avgQualityScore || 0))[0];
+        if (bestProvider && (bestProvider[1].avgQualityScore || 0) > 80) {
+            recommendations.push(`✅ ${bestProvider[0]} shows good performance (quality: ${bestProvider[1].avgQualityScore}/100). Consider using it more for critical tasks.`);
+        }
+        // Category-specific recommendations
+        if (metrics.byCategory.fabrication > metrics.byCategory.contradiction) {
+            recommendations.push(`🔧 High fabrication rate detected. Focus on improving technical prompt specificity and providing more context.`);
+        }
+        if (metrics.byCategory.contradiction > 3) {
+            recommendations.push(`⚖️ Multiple contradictions detected. Consider breaking complex requests into smaller, focused prompts.`);
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('✨ AI hallucination metrics look good! Continue monitoring for any emerging patterns.');
+        }
+        return recommendations;
+    }
+    /**
+     * Get empty analytics for when no data is available
+     */
+    getEmptyAnalytics() {
+        return {
+            totalInteractions: 0,
+            hallucinationMetrics: {
+                totalAnalyses: 0,
+                hallucinationCount: 0,
+                hallucinationRate: 0,
+                avgConfidence: 0,
+                byCategory: {},
+                byProvider: {},
+                businessImpact: {
+                    estimatedDevTimeWasted: 0,
+                    qualityDegradationScore: 0,
+                    roiImpact: 0,
+                    costOfHallucinations: 0
+                }
+            },
+            providerComparison: {},
+            trends: {
+                hallucinationRateOverTime: [],
+                qualityScoreOverTime: [],
+                costEfficiencyOverTime: []
+            },
+            recommendations: ['No data available yet. Start using AI through the proxy to see analytics.']
+        };
+    }
+    /**
+     * Export analytics to JSON file
+     */
+    exportAnalytics(filePath) {
+        const analytics = this.generateAnalytics();
+        const exportPath = filePath || path.resolve(process.cwd(), 'ai-analytics.json');
+        fs.writeFileSync(exportPath, JSON.stringify(analytics, null, 2));
+        console.log(`AI analytics exported to ${exportPath}`);
+    }
+    /**
+     * Get real-time hallucination rate for a specific provider
+     */
+    getProviderHallucinationRate(provider, hours = 24) {
+        if (!fs.existsSync(this.logFilePath))
+            return 0;
+        const cutoffTime = new Date(Date.now() - hours * 60 * 60 * 1000);
+        const fileContent = fs.readFileSync(this.logFilePath, 'utf8');
+        const lines = fileContent.trim().split('\n');
+        let providerInteractions = 0;
+        let providerHallucinations = 0;
+        for (const line of lines) {
+            try {
+                const interaction = JSON.parse(line);
+                const interactionTime = new Date(interaction.timestamp);
+                if (interactionTime >= cutoffTime && interaction.provider === provider) {
+                    providerInteractions++;
+                    if (interaction.hallucinationDetection?.isLikelyHallucination) {
+                        providerHallucinations++;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return providerInteractions > 0 ? (providerHallucinations / providerInteractions) * 100 : 0;
+    }
+}
+/**
+ * Global AI analytics instance
+ */
+export const aiAnalytics = new AIAnalytics();

package/lib/auth.js

@@ -0,0 +1,73 @@
+import * as http from 'http';
+import open from 'open';
+import chalk from 'chalk';
+import * as keytar from 'keytar'; // Import keytar
+const CLI_LOGIN_PORT = 8789;
+const WEB_APP_URL = 'http://localhost:3000';
+const SERVICE_NAME = 'toknxr-cli'; // A unique name for our service in the keychain
+const ACCOUNT_NAME = 'default-user'; // A generic account name for the stored token
+// Function to securely store the token
+const storeToken = async (token) => {
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
+    console.log(chalk.green('Supabase JWT securely stored in system keychain.'));
+};
+// Function to retrieve the token
+const getToken = async () => {
+    return await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+};
+export const login = async () => {
+    const server = new Promise((resolve, reject) => {
+        const s = http.createServer(async (req, res) => {
+            // Handle CORS preflight requests
+            res.setHeader('Access-Control-Allow-Origin', WEB_APP_URL);
+            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/token') {
+                const chunks = [];
+                for await (const chunk of req) {
+                    chunks.push(chunk);
+                }
+                const requestBody = Buffer.concat(chunks).toString();
+                const { token: supabaseJwt } = JSON.parse(requestBody); // Supabase JWT
+                if (supabaseJwt) {
+                    console.log(chalk.green('CLI authentication successful!'));
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true }));
+                    s.close();
+                    resolve(supabaseJwt); // Resolve with the Supabase JWT
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'No token provided' }));
+                    s.close();
+                    reject(new Error('No token provided'));
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        s.listen(CLI_LOGIN_PORT, async () => {
+            const loginUrl = `${WEB_APP_URL}/cli-login?port=${CLI_LOGIN_PORT}`;
+            console.log(chalk.yellow('Your browser has been opened to complete the login process.'));
+            await open(loginUrl);
+        });
+    });
+    try {
+        const supabaseJwt = await server; // Get the Supabase JWT
+        await storeToken(supabaseJwt); // Store the Supabase JWT securely
+        console.log(chalk.cyan('Authentication complete. You can now use TokNxr CLI commands.'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red('Login failed:', message));
+    }
+};
+// Export getToken for other parts of the CLI to use
+export { getToken };