@goldensheepai/toknxr-cli 0.2.0 → 0.2.2

package/lib/cli.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+const CLI = path.resolve(process.cwd(), 'toknxr-cli', 'lib', 'cli.js');
+function runCli(args, env = {}, timeoutMs = 8000) {
+    return new Promise(resolve => {
+        const child = spawn('node', [CLI, ...args], {
+            env: {
+                ...process.env,
+                SUPABASE_URL: process.env.SUPABASE_URL || 'http://localhost',
+                SUPABASE_KEY: process.env.SUPABASE_KEY || 'dummy',
+                ...env,
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', d => (stdout += String(d)));
+        child.stderr.on('data', d => (stderr += String(d)));
+        child.on('close', code => {
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+describe('TokNXR CLI smoke tests', () => {
+    it('--help renders', async () => {
+        const res = await runCli(['--help']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('Usage: toknxr');
+    });
+    it('budget --view runs', async () => {
+        const res = await runCli(['budget', '--view']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('Budget Configuration');
+    });
+    it('audit:view --help renders', async () => {
+        const res = await runCli(['audit:view', '--help']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('--to <date>');
+    });
+    it('audit:export --help renders', async () => {
+        const res = await runCli(['audit:export', '--help']);
+        expect(res.code).toBe(0);
+        expect(res.stdout).toContain('--to <date>');
+    });
+});

package/lib/code-analysis.js

@@ -1,3 +1,4 @@
+import { pluginManager } from './plugin-system.js';
 /**
  * Analyzes code quality and provides metrics
  */
@@ -41,6 +42,34 @@ export function analyzeCodeQuality(code, language) {
             metrics.syntaxValid = validatePython(code);
             metrics.estimatedReadability = calculatePythonReadability(code);
             break;
+        case 'go':
+            metrics.hasFunctions = /func\s+\w+\(/.test(code);
+            metrics.hasClasses = /type\s+\w+\s+struct/.test(code);
+            metrics.hasTests = /func\s+Test\w+/.test(code);
+            metrics.syntaxValid = validateGo(code);
+            metrics.estimatedReadability = calculateGoReadability(code);
+            break;
+        case 'rust':
+            metrics.hasFunctions = /fn\s+\w+\(/.test(code);
+            metrics.hasClasses = /(struct|enum)\s+\w+/.test(code);
+            metrics.hasTests = /#\[test\]/.test(code);
+            metrics.syntaxValid = validateRust(code);
+            metrics.estimatedReadability = calculateRustReadability(code);
+            break;
+        case 'java':
+            metrics.hasFunctions = /public\s+(\w+)\s+\w+\(/.test(code);
+            metrics.hasClasses = /public\s+class\s+\w+/.test(code);
+            metrics.hasTests = /@Test/.test(code);
+            metrics.syntaxValid = validateJava(code);
+            metrics.estimatedReadability = calculateJavaReadability(code);
+            break;
+        case 'cpp':
+            metrics.hasFunctions = /(\w+)\s+\w+\(/.test(code) && !/class\s+/.test(code);
+            metrics.hasClasses = /class\s+\w+/.test(code);
+            metrics.hasTests = /(TEST|TEST_F)/.test(code);
+            metrics.syntaxValid = validateCpp(code);
+            metrics.estimatedReadability = calculateCppReadability(code);
+            break;
         default:
             metrics.potentialIssues.push('Language not recognized for detailed analysis');
     }
@@ -51,7 +80,15 @@ export function analyzeCodeQuality(code, language) {
     if (!metrics.syntaxValid) {
         metrics.potentialIssues.push('Potential syntax errors detected');
     }
-    return metrics;
+    // Apply plugin enhancements
+    try {
+        const enhancedMetrics = pluginManager.analyzeWithPlugins(code, metrics);
+        return enhancedMetrics;
+    }
+    catch (error) {
+        console.warn('Plugin analysis failed, returning base metrics:', error);
+        return metrics;
+    }
 }
 /**
  * Calculate an effectiveness score comparing prompt to code output
@@ -81,7 +118,15 @@ export function scoreEffectiveness(userPrompt, aiResponse, extractedCode) {
         (score.codeCompleteness * 0.25) +
         (score.codeCorrectness * 0.25) +
         (score.codeEfficiency * 0.2));
-    return score;
+    // Apply plugin enhancements for effectiveness scoring
+    try {
+        const enhancedScore = pluginManager.scoreEffectivenessWithPlugins(userPrompt, aiResponse, score, extractedCode);
+        return enhancedScore;
+    }
+    catch (error) {
+        console.warn('Plugin effectiveness scoring failed, returning base score:', error);
+        return score;
+    }
 }
 /**
  * Extract code blocks from AI responses
@@ -113,12 +158,27 @@ export function extractCodeFromResponse(response) {
  */
 function detectLanguage(code) {
     if (/(?:import|export|function|const|let|var)\s+/.test(code)) {
-        return code.includes('interface') || code.includes(': string') ? 'typescript' : 'javascript';
+        return code.includes('interface') || code.includes(': string') || code.includes('<') ? 'typescript' : 'javascript';
     }
     if (/def\s+|import\s+|class\s+/.test(code) && /:/.test(code)) {
         return 'python';
     }
-    // Add more language detection as needed...
+    // Go detection
+    if (/package\s+\w+|import\s+\(|func\s+\w+\(/.test(code) && /\.\w+\(/.test(code)) {
+        return 'go';
+    }
+    // Rust detection
+    if (/fn\s+\w+|let\s+mut|println!|use\s+std::/.test(code) && /::/.test(code)) {
+        return 'rust';
+    }
+    // Java detection
+    if (/public\s+class|import\s+java\.|public\s+static\s+void\s+main/.test(code) && /System\.out\.println/.test(code)) {
+        return 'java';
+    }
+    // C++ detection
+    if (/#include\s+<|std::|cout\s+<<|int\s+main\(/.test(code) && /namespace\s+std/.test(code)) {
+        return 'cpp';
+    }
     return undefined;
 }
 /**
@@ -302,3 +362,288 @@ function estimateEfficiencyScore(code, metrics) {
     }
     return Math.max(0, Math.min(100, score));
 }
+/**
+ * Basic Go validation
+ */
+function validateGo(code) {
+    try {
+        // Basic bracket matching for Go
+        const brackets = { '(': 0, '{': 0 };
+        let inString = false;
+        let inComment = false;
+        for (let i = 0; i < code.length; i++) {
+            const char = code[i];
+            const nextChar = code[i + 1] || '';
+            // Handle strings
+            if (char === '"' && (i === 0 || code[i - 1] !== '\\')) {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            // Handle comments
+            if (char === '/' && nextChar === '/') {
+                inComment = true;
+                continue;
+            }
+            if (char === '\n') {
+                inComment = false;
+                continue;
+            }
+            if (inComment)
+                continue;
+            if (char === '(')
+                brackets['(']++;
+            if (char === ')')
+                brackets['(']--;
+            if (char === '{')
+                brackets['{']++;
+            if (char === '}')
+                brackets['{']--;
+            if (brackets['('] < 0 || brackets['{'] < 0) {
+                return false;
+            }
+        }
+        return brackets['('] === 0 && brackets['{'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Basic Rust validation
+ */
+function validateRust(code) {
+    try {
+        // Basic bracket matching for Rust
+        const brackets = { '(': 0, '[': 0, '{': 0 };
+        let inString = false;
+        let inChar = false;
+        for (let i = 0; i < code.length; i++) {
+            const char = code[i];
+            // Handle strings and characters
+            if (char === '"' && (i === 0 || code[i - 1] !== '\\')) {
+                inString = !inString;
+                continue;
+            }
+            if (char === "'" && code[i + 1] && code[i + 1] !== "\\") {
+                inChar = !inChar;
+                continue;
+            }
+            if (inString || inChar)
+                continue;
+            if (char === '(')
+                brackets['(']++;
+            if (char === ')')
+                brackets['(']--;
+            if (char === '[')
+                brackets['[']++;
+            if (char === ']')
+                brackets['[']--;
+            if (char === '{')
+                brackets['{']++;
+            if (char === '}')
+                brackets['{']--;
+            if (brackets['('] < 0 || brackets['['] < 0 || brackets['{'] < 0) {
+                return false;
+            }
+        }
+        return brackets['('] === 0 && brackets['['] === 0 && brackets['{'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Basic Java validation
+ */
+function validateJava(code) {
+    try {
+        // Basic bracket matching for Java
+        const brackets = { '(': 0, '[': 0, '{': 0 };
+        let inString = false;
+        for (let i = 0; i < code.length; i++) {
+            const char = code[i];
+            // Handle strings
+            if (char === '"' && (i === 0 || code[i - 1] !== '\\')) {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (char === '(')
+                brackets['(']++;
+            if (char === ')')
+                brackets['(']--;
+            if (char === '[')
+                brackets['[']++;
+            if (char === ']')
+                brackets['[']--;
+            if (char === '{')
+                brackets['{']++;
+            if (char === '}')
+                brackets['{']--;
+            if (brackets['('] < 0 || brackets['['] < 0 || brackets['{'] < 0) {
+                return false;
+            }
+        }
+        return brackets['('] === 0 && brackets['['] === 0 && brackets['{'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Basic C++ validation
+ */
+function validateCpp(code) {
+    try {
+        // Basic bracket matching for C++
+        const brackets = { '(': 0, '[': 0, '{': 0 };
+        let inString = false;
+        let inComment = false;
+        for (let i = 0; i < code.length; i++) {
+            const char = code[i];
+            const nextChar = code[i + 1] || '';
+            // Handle strings
+            if (char === '"' && (i === 0 || code[i - 1] !== '\\')) {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            // Handle comments
+            if (char === '/' && (nextChar === '/' || nextChar === '*')) {
+                inComment = true;
+                if (nextChar === '*') {
+                    // Multi-line comment
+                    const endComment = code.indexOf('*/', i + 2);
+                    if (endComment !== -1) {
+                        i = endComment + 1;
+                    }
+                    continue;
+                }
+            }
+            if (inComment && char === '\n') {
+                inComment = false;
+            }
+            if (inComment)
+                continue;
+            if (char === '(')
+                brackets['(']++;
+            if (char === ')')
+                brackets['(']--;
+            if (char === '[')
+                brackets['[']++;
+            if (char === ']')
+                brackets['[']--;
+            if (char === '{')
+                brackets['{']++;
+            if (char === '}')
+                brackets['{']--;
+            if (brackets['('] < 0 || brackets['['] < 0 || brackets['{'] < 0) {
+                return false;
+            }
+        }
+        return brackets['('] === 0 && brackets['['] === 0 && brackets['{'] === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Calculate readability for Go
+ */
+function calculateGoReadability(code) {
+    let score = 6; // Go is generally readable
+    // Length factors
+    if (code.length > 2000)
+        score -= 2;
+    if (code.split('\n').length > 50)
+        score -= 1;
+    // Good practices
+    if (code.includes('//'))
+        score += 1; // Has comments
+    if (/^\s*\w+\./.test(code))
+        score += 0.5; // Uses qualified names
+    if (/err\s*!=\s*nil/.test(code))
+        score += 0.5; // Error handling
+    // Poor practices
+    if (/\w+\s*:=\s*[^;]*;/.test(code))
+        score -= 1; // Short variable declarations with semicolon
+    return Math.max(1, Math.min(10, score));
+}
+/**
+ * Calculate readability for Rust
+ */
+function calculateRustReadability(code) {
+    let score = 5; // Rust can be complex but expressive
+    // Length factors
+    if (code.length > 2500)
+        score -= 2;
+    if (code.split('\n').length > 60)
+        score -= 1;
+    // Good practices
+    if (code.includes('//'))
+        score += 1; // Has comments
+    if (/let\s+/.test(code))
+        score += 0.5; // Explicit variable declarations
+    if (/->/.test(code))
+        score += 0.5; // Return type annotations
+    if (/\?/m.test(code))
+        score += 0.5; // Error propagation
+    // Code organization
+    if (/impl\s+\w+/.test(code))
+        score += 0.5; // Has implementations
+    if (/trait\s+\w+/.test(code))
+        score += 0.5; // Has traits
+    return Math.max(1, Math.min(10, score));
+}
+/**
+ * Calculate readability for Java
+ */
+function calculateJavaReadability(code) {
+    let score = 4; // Java can be verbose
+    // Length factors
+    if (code.length > 3000)
+        score -= 2;
+    if (code.split('\n').length > 70)
+        score -= 1;
+    // Good practices
+    if (code.includes('//') || code.includes('/*'))
+        score += 1; // Has comments
+    if (/public\s+class\s+\w+/.test(code))
+        score += 0.5; // Proper class declaration
+    if (/throws\s+\w+/.test(code))
+        score += 0.5; // Exception declarations
+    // Code organization
+    if (/@Override/.test(code))
+        score += 0.5; // Uses annotations properly
+    if (/import\s+java\./.test(code))
+        score += 0.5; // Proper imports
+    return Math.max(1, Math.min(10, score));
+}
+/**
+ * Calculate readability for C++
+ */
+function calculateCppReadability(code) {
+    let score = 3; // C++ can be complex
+    // Length factors
+    if (code.length > 2500)
+        score -= 2;
+    if (code.split('\n').length > 80)
+        score -= 1;
+    // Good practices
+    if (code.includes('//'))
+        score += 1; // Has comments
+    if (/std::/.test(code))
+        score += 0.5; // Uses standard library
+    if (/const\s+/.test(code))
+        score += 0.5; // Uses const
+    // Code organization
+    if (/namespace\s+\w+/.test(code))
+        score += 0.5; // Uses namespaces
+    if (/#include\s+<[\w\/]+>/.test(code))
+        score += 0.5; // Proper includes
+    return Math.max(1, Math.min(10, score));
+}

package/lib/dashboard.js

@@ -13,22 +13,7 @@ function createDashboard() {
         text: '#F8FAFC',
         textMuted: '#94A3B8'
     };
-    let stats = null;
     let lastUpdated = new Date();
-    // Create stat card HTML
-    function createStatCard(title, value, icon, color = COLORS.primary) {
-        return `
-      <div style="background: ${COLORS.surface}; border-radius: 12px; padding: 24px; border: 1px solid ${color}20; box-shadow: 0 4px 6px -1px ${color}10;">
-        <div style="display: flex; align-items: center; justify-content: space-between;">
-          <div>
-            <p style="color: ${COLORS.textMuted}; font-size: 14px; margin: 0 0 8px 0;">${title}</p>
-            <p style="font-size: 32px; font-weight: bold; margin: 0; color: ${COLORS.text};">${value}</p>
-          </div>
-          <div style="font-size: 24px; color: ${color}; opacity: 0.8;">${icon}</div>
-        </div>
-      </div>
-    `;
-    }
     // Create provider card HTML
     function createProviderChart(name, data) {
         return `
@@ -132,8 +117,8 @@ function createDashboard() {
                 const providerHTML = Object.entries(data.totals.byProvider).map(([name, providerData]) => createProviderChart(name, {
                     cost: providerData.costUSD || 0,
                     interactions: providerData.requestCount || 0,
-                    avgQuality: providerData.avgQualityScore,
-                    avgEffectiveness: providerData.avgEffectivenessScore
+                    avgQuality: providerData.avgQuality,
+                    avgEffectiveness: providerData.avgEffectiveness
                 })).join('');
                 providerContainer.innerHTML = providerHTML;
             }
@@ -265,6 +250,7 @@ function createDashboard() {
     }
 }
 // Modal for showing prompt details
+// @ts-ignore
 function showPromptDetails(provider, model, userPrompt, aiResponse, qualityScore, effectivenessScore, taskType, cost) {
     const modal = document.createElement('div');
     modal.id = 'prompt-modal';
@@ -341,6 +327,7 @@ function closePromptModal() {
     }
 }
 // Filter prompts based on search and provider filter
+// @ts-ignore
 function filterPrompts() {
     const searchTermValue = document.getElementById('prompt-search')?.value.toLowerCase() || '';
     const providerFilterValue = document.getElementById('provider-filter')?.value || '';

package/lib/fixtures/canary-interaction.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function appendFixtureInteraction() {
+    const logPath = path.resolve(process.cwd(), 'interactions.log');
+    const entry = {
+        timestamp: new Date().toISOString(),
+        provider: 'fixture',
+        model: 'fixture-model',
+        promptTokens: 5,
+        completionTokens: 10,
+        totalTokens: 15,
+        costUSD: 0,
+        taskType: 'chat',
+        userPrompt: 'Fixture entry used to validate tooling path',
+        aiResponse: 'This is a fixture interaction entry.',
+    };
+    fs.appendFileSync(logPath, JSON.stringify(entry) + '\n');
+}