@goldensheepai/toknxr-cli 0.2.0 → 0.3.0

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,129 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+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 = async (options) => {
+    const { choice } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'choice',
+            message: 'Select an operation:',
+            choices: options,
+        },
+    ]);
+    return choice;
+};
+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/lib/utils.js

@@ -0,0 +1,117 @@
+import axios from 'axios';
+import * as fs from 'node:fs';
+// Helper to resolve dot notation paths (copied from proxy.ts for consistency)
+const getValueFromPath = (obj, path) => {
+    if (!path || !obj)
+        return 0;
+    try {
+        const result = path.split('.').reduce((res, prop) => res && typeof res === 'object' && prop in res ? res[prop] : undefined, obj);
+        return Number(result) || 0;
+    }
+    catch {
+        return 0;
+    }
+};
+// Minimal payload for testing various providers
+const TEST_PAYLOADS = {
+    'gemini': {
+        contents: [{ parts: [{ text: "Hello" }] }]
+    },
+    'openai': {
+        model: "gpt-3.5-turbo",
+        messages: [{ role: "user", content: "Hello" }]
+    },
+    'anthropic': {
+        model: "claude-3-opus-20240229",
+        messages: [{ role: "user", content: "Hello" }],
+        max_tokens: 10
+    },
+    'ollama': {
+        model: "llama3",
+        prompt: "Hello",
+        stream: false
+    }
+};
+export async function testConnection(provider, apiKey) {
+    const proxyUrl = `http://localhost:8788${provider.routePrefix}`;
+    const testPayload = TEST_PAYLOADS[provider.name.toLowerCase().split('-')[0]] || TEST_PAYLOADS['gemini']; // Default to gemini payload
+    if (!testPayload) {
+        return { ok: false, message: `No test payload defined for provider: ${provider.name}` };
+    }
+    try {
+        const headers = { 'Content-Type': 'application/json' };
+        // The proxy handles adding the actual API key to the upstream request
+        // We just need to ensure the proxy itself is reachable and responds
+        // For the test, we don't need to pass the API key here, as the proxy will add it.
+        // However, if the proxy itself fails due to missing key, that's what we want to catch.
+        const res = await axios.post(proxyUrl, testPayload, {
+            headers,
+            timeout: 5000, // 5 second timeout
+            validateStatus: () => true, // Don't throw on non-2xx status codes
+        });
+        if (res.status === 200) {
+            // Basic check for a valid response structure
+            if (res.data && (res.data.candidates || res.data.choices || res.data.response)) {
+                return { ok: true };
+            }
+            else {
+                return { ok: false, message: `Unexpected response format from ${provider.name}` };
+            }
+        }
+        else if (res.status === 401 || res.status === 403) {
+            return { ok: false, message: `Authentication failed (Status: ${res.status}). Check API key.` };
+        }
+        else if (res.status === 429) {
+            return { ok: false, message: `Rate limit exceeded (Status: ${res.status}).` };
+        }
+        else if (res.status === 500 && res.data && res.data.error) {
+            // Catch specific proxy errors, e.g., "API key not set"
+            return { ok: false, message: `Proxy error: ${res.data.error}` };
+        }
+        else {
+            return { ok: false, message: `Proxy returned status ${res.status}: ${JSON.stringify(res.data)}` };
+        }
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+                return { ok: false, message: `Proxy not running or unreachable at ${proxyUrl}.` };
+            }
+            else if (error.response) {
+                return { ok: false, message: `Proxy returned status ${error.response.status}: ${JSON.stringify(error.response.data)}` };
+            }
+            return { ok: false, message: `Network error: ${error.message}` };
+        }
+        return { ok: false, message: `Unknown error during connection test: ${error.message}` };
+    }
+}
+export function generateSampleInteraction(providerName, logFilePath) {
+    const sampleInteraction = {
+        requestId: `sample-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        provider: providerName,
+        model: `${providerName}-test-model`,
+        promptTokens: 10,
+        completionTokens: 20,
+        totalTokens: 30,
+        costUSD: 0.0005,
+        taskType: 'chat',
+        userPrompt: 'Generate a sample interaction for testing.',
+        aiResponse: 'This is a sample AI response generated by the doctor command.',
+        codeQualityScore: 85,
+        effectivenessScore: 90,
+        hallucinationDetection: {
+            isLikelyHallucination: false,
+            confidence: 5,
+            severity: 'low',
+            issues: []
+        }
+    };
+    try {
+        fs.appendFileSync(logFilePath, JSON.stringify(sampleInteraction) + '\n');
+        return { ok: true, message: `Generated sample interaction for ${providerName}.` };
+    }
+    catch (error) {
+        return { ok: false, message: `Failed to write sample interaction: ${error.message}` };
+    }
+}

package/package.json

@@ -1,38 +1,71 @@
 {
   "name": "@goldensheepai/toknxr-cli",
-  "version": "0.2.0",
-  "license": "ISC",
+  "version": "0.3.0",
+  "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