@goldensheepai/toknxr-cli 0.2.2 → 0.4.0

package/lib/ui.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import readline from 'readline';
+import inquirer from 'inquirer';
 export const createStatsOverview = (cost, requests, waste, hallucinations) => `
   ${chalk.bold.blue('📊 TokNXR Analytics Overview')}
   ${chalk.gray('------------------------------------')}
@@ -45,19 +45,16 @@ export const createOperationProgress = (title, steps) => {
     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 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;
@@ -99,11 +96,20 @@ export const createFilterInterface = (currentFilters) => {
         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 const createSearchInterface = async (fields) => {
+    const { selectedFields } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFields',
+        message: 'Which fields would you like to search in?',
+        choices: fields.map(field => ({ name: field, value: field, checked: true })),
+        validate: (answer) => {
+            if (!answer || answer.length < 1) {
+                return 'You must choose at least one field.';
+            }
+            return true;
+        }
     });
+    return { query: '', fields: selectedFields };
 };
 export class InteractiveDataExplorer {
     constructor(data) {
@@ -127,6 +133,64 @@ export class CliStateManager {
         return { budgets: {} };
     }
 }
-export const filterAndSearchInteractions = (interactions, _filters, _search) => {
-    return interactions;
+export const filterAndSearchInteractions = (interactions, _filters, search) => {
+    if (!search.query || search.query.trim().length === 0) {
+        return interactions;
+    }
+    const query = search.query.toLowerCase();
+    return interactions.filter(interaction => {
+        return search.fields.some(field => {
+            const value = interaction[field];
+            if (typeof value === 'string') {
+                return value.toLowerCase().includes(query);
+            }
+            return false;
+        });
+    });
+};
+// Helper functions for search results
+export const calcRelevanceScore = (interaction, query, fields) => {
+    const queryLower = query.toLowerCase();
+    let totalScore = 0;
+    let matchingFields = 0;
+    fields.forEach(field => {
+        const value = interaction[field];
+        if (typeof value === 'string') {
+            const valueLower = value.toLowerCase();
+            if (valueLower.includes(queryLower)) {
+                matchingFields++;
+                // Exact match gets highest score
+                if (valueLower === queryLower) {
+                    totalScore += 1.0;
+                }
+                else if (valueLower.startsWith(queryLower)) {
+                    totalScore += 0.8;
+                }
+                else if (valueLower.endsWith(queryLower)) {
+                    totalScore += 0.7;
+                }
+                else {
+                    // Partial match - score based on how much of the string matches
+                    const matchRatio = queryLower.length / valueLower.length;
+                    totalScore += 0.3 + (matchRatio * 0.3);
+                }
+            }
+        }
+    });
+    // Calculate final score
+    if (matchingFields === 0)
+        return 0;
+    const baseScore = totalScore / matchingFields;
+    const multiFieldBonus = matchingFields > 1 ? 0.2 : 0;
+    // Ensure exact matches get high scores
+    const finalScore = Math.min(1.0, baseScore + multiFieldBonus);
+    // Debug: log the score calculation for troubleshooting
+    // console.log(`Debug: query="${query}", baseScore=${baseScore}, finalScore=${finalScore}`);
+    return finalScore;
+};
+export const highlightMatch = (text, query) => {
+    if (!text || !query)
+        return text;
+    const regex = new RegExp(`(${query})`, 'gi');
+    return text.replace(regex, chalk.yellow.bold('$1'));
 };

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,6 +1,6 @@
 {
   "name": "@goldensheepai/toknxr-cli",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "CLI-powered AI effectiveness & code quality analysis tool - 100% Local",
   "license": "MIT",
   "type": "module",

package/lib/auth.js

@@ -1,73 +0,0 @@
-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 };

package/lib/cli.test.js

@@ -1,49 +0,0 @@
-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>');
-    });
-});