@goldensheepai/toknxr-cli 0.2.2 → 0.4.0

package/lib/code-review.js

@@ -1,319 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-// Comprehensive code review rules for AI-generated code
-export const DEFAULT_CODE_REVIEW_RULES = [
-    // Security Issues
-    {
-        id: 'SEC001',
-        name: 'Hardcoded Secrets',
-        description: 'Detects hardcoded API keys, passwords, or tokens',
-        severity: 'error',
-        category: 'security',
-        pattern: /(api[_-]?key|password|secret|token)\s*[=:]?\s*["'][^"']{8,}["']/gi,
-        message: 'Potential hardcoded secret detected',
-        suggestion: 'Use environment variables or secure secret management'
-    },
-    {
-        id: 'SEC002',
-        name: 'SQL Injection Risk',
-        description: 'Detects unsafe string concatenation in SQL queries',
-        severity: 'error',
-        category: 'security',
-        pattern: /(SELECT|INSERT|UPDATE|DELETE).*\+.*["'][^"']*["']/gi,
-        message: 'Potential SQL injection vulnerability',
-        suggestion: 'Use parameterized queries or prepared statements'
-    },
-    {
-        id: 'SEC003',
-        name: 'Insecure Random',
-        description: 'Detects use of Math.random() for security-sensitive operations',
-        severity: 'warning',
-        category: 'security',
-        pattern: /Math\.random\(\)/g,
-        message: 'Math.random() is not cryptographically secure',
-        suggestion: 'Use crypto.randomBytes() or crypto.getRandomValues() for security-sensitive operations'
-    },
-    // Performance Issues
-    {
-        id: 'PERF001',
-        name: 'Inefficient Loop',
-        description: 'Detects potential infinite or inefficient loops',
-        severity: 'warning',
-        category: 'performance',
-        pattern: /for\s*\(\s*let\s+\w+\s*=\s*0\s*;\s*\w+\s*<\s*\w+\.length\s*;\s*\w+\+\+\s*\)\s*{[^}]*\w+\[\w+\]/g,
-        message: 'Potential inefficient array iteration',
-        suggestion: 'Consider using modern array methods like forEach, map, or for...of'
-    },
-    {
-        id: 'PERF002',
-        name: 'Large DOM Manipulation',
-        description: 'Detects multiple DOM manipulations that could be batched',
-        severity: 'info',
-        category: 'performance',
-        pattern: /(document\.createElement|appendChild|innerHTML\s*=)[^;]+;[^;]*\1/gi,
-        message: 'Multiple DOM manipulations detected',
-        suggestion: 'Consider batching DOM operations or using DocumentFragment'
-    },
-    // Maintainability Issues
-    {
-        id: 'MAINT001',
-        name: 'Long Function',
-        description: 'Detects functions that are too long and should be broken up',
-        severity: 'warning',
-        category: 'maintainability',
-        pattern: /^(?:function|\w+\s*=>|\w+\s*\([^)]*\)\s*{[^}]*{[^}]*}[^}]*})/gm,
-        message: 'Function appears to be too long',
-        suggestion: 'Consider breaking this function into smaller, more focused functions'
-    },
-    {
-        id: 'MAINT002',
-        name: 'Missing Error Handling',
-        description: 'Detects operations that might throw errors without proper handling',
-        severity: 'warning',
-        category: 'maintainability',
-        pattern: /(fetch|axios|XMLHttpRequest)\s*\([^)]+\)\s*(?![^}]*catch|\.catch)/gi,
-        message: 'Async operation without error handling',
-        suggestion: 'Add try-catch blocks or .catch() handlers for async operations'
-    },
-    {
-        id: 'MAINT003',
-        name: 'Magic Numbers',
-        description: 'Detects hardcoded numeric values that should be constants',
-        severity: 'info',
-        category: 'maintainability',
-        pattern: /\b\d{2,}\b/g,
-        message: 'Magic number detected',
-        suggestion: 'Consider defining this as a named constant for better readability'
-    },
-    // Reliability Issues
-    {
-        id: 'REL001',
-        name: 'Unsafe Type Coercion',
-        description: 'Detects potentially unsafe type conversions',
-        severity: 'warning',
-        category: 'reliability',
-        pattern: /(==|!=)\s*null/gi,
-        message: 'Loose equality comparison with null',
-        suggestion: 'Use strict equality (===) or explicitly check for null/undefined'
-    },
-    {
-        id: 'REL002',
-        name: 'Resource Leaks',
-        description: 'Detects potential resource leaks',
-        severity: 'warning',
-        category: 'reliability',
-        pattern: /(addEventListener|setTimeout|setInterval)\s*\([^)]+\)\s*(?![^}]*removeEventListener|\.clear)/gi,
-        message: 'Event listener or timer without cleanup',
-        suggestion: 'Ensure proper cleanup of event listeners and timers'
-    }
-];
-export class CodeReviewer {
-    rules;
-    constructor(customRules = []) {
-        this.rules = [...DEFAULT_CODE_REVIEW_RULES, ...customRules];
-    }
-    async reviewFile(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf8');
-            const lines = content.split('\n');
-            const results = [];
-            let errors = 0;
-            let warnings = 0;
-            let info = 0;
-            lines.forEach((line, index) => {
-                this.rules.forEach(rule => {
-                    const matches = line.match(rule.pattern);
-                    if (matches) {
-                        matches.forEach(match => {
-                            const result = {
-                                rule,
-                                line: index + 1,
-                                context: line.trim(),
-                                severity: rule.severity,
-                                message: rule.message,
-                                suggestion: rule.suggestion
-                            };
-                            results.push(result);
-                            switch (rule.severity) {
-                                case 'error':
-                                    errors++;
-                                    break;
-                                case 'warning':
-                                    warnings++;
-                                    break;
-                                case 'info':
-                                    info++;
-                                    break;
-                            }
-                        });
-                    }
-                });
-            });
-            const totalIssues = results.length;
-            const summary = this.generateSummary(totalIssues, errors, warnings, info);
-            const recommendations = this.generateRecommendations(results);
-            return {
-                filePath,
-                totalIssues,
-                errors,
-                warnings,
-                info,
-                results,
-                summary,
-                recommendations
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to review file ${filePath}: ${error}`);
-        }
-    }
-    async reviewDirectory(dirPath) {
-        const reports = [];
-        const files = this.getCodeFiles(dirPath);
-        for (const file of files) {
-            try {
-                const report = await this.reviewFile(file);
-                reports.push(report);
-            }
-            catch (error) {
-                console.warn(chalk.yellow(`Warning: Could not review file ${file}: ${error}`));
-            }
-        }
-        return reports;
-    }
-    getCodeFiles(dirPath) {
-        const files = [];
-        const extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.cpp', '.c', '.cs'];
-        const scan = (currentPath) => {
-            const items = fs.readdirSync(currentPath);
-            for (const item of items) {
-                const fullPath = path.join(currentPath, item);
-                const stat = fs.statSync(fullPath);
-                if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
-                    scan(fullPath);
-                }
-                else if (stat.isFile() && extensions.some(ext => item.endsWith(ext))) {
-                    files.push(fullPath);
-                }
-            }
-        };
-        scan(dirPath);
-        return files;
-    }
-    generateSummary(totalIssues, errors, warnings, info) {
-        if (totalIssues === 0) {
-            return '✅ No issues found! The code looks good.';
-        }
-        let summary = `Found ${totalIssues} issue${totalIssues > 1 ? 's' : ''}: `;
-        const parts = [];
-        if (errors > 0)
-            parts.push(`${errors} error${errors > 1 ? 's' : ''}`);
-        if (warnings > 0)
-            parts.push(`${warnings} warning${warnings > 1 ? 's' : ''}`);
-        if (info > 0)
-            parts.push(`${info} info item${info > 1 ? 's' : ''}`);
-        summary += parts.join(', ');
-        if (errors > 0) {
-            summary += ' 🔴 Critical issues need immediate attention.';
-        }
-        else if (warnings > 0) {
-            summary += ' 🟡 Some issues should be addressed.';
-        }
-        else {
-            summary += ' ℹ️ Minor improvements suggested.';
-        }
-        return summary;
-    }
-    generateRecommendations(results) {
-        const recommendations = [];
-        const categories = new Set(results.map(r => r.rule.category));
-        if (categories.has('security')) {
-            recommendations.push('🔒 Review security issues first - they pose the highest risk');
-        }
-        if (categories.has('reliability')) {
-            recommendations.push('🛡️ Address reliability issues to prevent runtime errors');
-        }
-        if (categories.has('performance')) {
-            recommendations.push('⚡ Consider performance optimizations for better user experience');
-        }
-        if (categories.has('maintainability')) {
-            recommendations.push('🧹 Refactor maintainability issues for long-term code health');
-        }
-        if (recommendations.length === 0) {
-            recommendations.push('✨ Code quality looks good! Consider regular reviews to maintain standards');
-        }
-        return recommendations;
-    }
-    addCustomRule(rule) {
-        this.rules.push(rule);
-    }
-    getRules() {
-        return [...this.rules];
-    }
-}
-export function printReviewReport(report) {
-    console.log(chalk.bold.blue(`\n📋 Code Review Report for: ${path.basename(report.filePath)}`));
-    console.log(chalk.gray(`File: ${report.filePath}`));
-    console.log(chalk.cyan(report.summary));
-    console.log('');
-    if (report.results.length > 0) {
-        // Group by severity
-        const errors = report.results.filter(r => r.severity === 'error');
-        const warnings = report.results.filter(r => r.severity === 'warning');
-        const info = report.results.filter(r => r.severity === 'info');
-        if (errors.length > 0) {
-            console.log(chalk.red.bold('🔴 ERRORS:'));
-            errors.forEach(result => {
-                console.log(`  ${chalk.red(`[${result.rule.id}]`)} Line ${result.line}: ${result.message}`);
-                if (result.suggestion) {
-                    console.log(`    💡 ${chalk.gray(result.suggestion)}`);
-                }
-            });
-            console.log('');
-        }
-        if (warnings.length > 0) {
-            console.log(chalk.yellow.bold('🟡 WARNINGS:'));
-            warnings.forEach(result => {
-                console.log(`  ${chalk.yellow(`[${result.rule.id}]`)} Line ${result.line}: ${result.message}`);
-                if (result.suggestion) {
-                    console.log(`    💡 ${chalk.gray(result.suggestion)}`);
-                }
-            });
-            console.log('');
-        }
-        if (info.length > 0) {
-            console.log(chalk.blue.bold('ℹ️  INFO:'));
-            info.forEach(result => {
-                console.log(`  ${chalk.blue(`[${result.rule.id}]`)} Line ${result.line}: ${result.message}`);
-                if (result.suggestion) {
-                    console.log(`    💡 ${chalk.gray(result.suggestion)}`);
-                }
-            });
-            console.log('');
-        }
-    }
-    if (report.recommendations.length > 0) {
-        console.log(chalk.green.bold('💡 RECOMMENDATIONS:'));
-        report.recommendations.forEach(rec => {
-            console.log(`  ${rec}`);
-        });
-        console.log('');
-    }
-    console.log(chalk.gray(`Total: ${report.totalIssues} issues (${report.errors} errors, ${report.warnings} warnings, ${report.info} info)`));
-}
-export function printMultipleReports(reports) {
-    const totalIssues = reports.reduce((sum, r) => sum + r.totalIssues, 0);
-    const totalErrors = reports.reduce((sum, r) => sum + r.errors, 0);
-    const totalWarnings = reports.reduce((sum, r) => sum + r.warnings, 0);
-    const totalInfo = reports.reduce((sum, r) => sum + r.info, 0);
-    console.log(chalk.bold.blue(`\n📊 Code Review Summary`));
-    console.log(chalk.cyan(`Reviewed ${reports.length} files`));
-    console.log(chalk.gray(`Total Issues: ${totalIssues} (${totalErrors} errors, ${totalWarnings} warnings, ${totalInfo} info)`));
-    console.log('');
-    reports.forEach(report => {
-        if (report.totalIssues > 0) {
-            printReviewReport(report);
-        }
-    });
-}

package/lib/config.js

@@ -1,7 +0,0 @@
-import { createClient } from '@supabase/supabase-js';
-export const supabaseUrl = process.env.SUPABASE_URL || 'https://pkdytotoptkknghtsomn.supabase.co';
-export const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBrZHl0b3RvcHRra25naHRzb21uIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTk3MjI1OTgsImV4cCI6MjA3NTI5ODU5OH0.Y3RVJvx7w-eGD4Nv2aVv8jnkUKhmA2vpkBs7_rFzEoQ';
-export const supabase = createClient(supabaseUrl, supabaseAnonKey);
-export const setAuthToken = (token) => {
-    supabase.auth.setSession({ access_token: token, refresh_token: '' });
-};

package/lib/sync.js

@@ -1,117 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { getToken } from './auth.js';
-import { setAuthToken } from './config.js';
-import chalk from 'chalk';
-export async function syncInteractions(supabase, options) {
-    console.log(chalk.blue('Syncing local analytics with the cloud dashboard...'));
-    // Get the stored token
-    const token = await getToken();
-    if (!token) {
-        console.error(chalk.red('No authentication token found. Please login first with `toknxr login`.'));
-        process.exit(1);
-    }
-    // Set auth in Supabase
-    setAuthToken(token);
-    // 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 in current directory or toknxr-cli/. Nothing to sync.'));
-        return;
-    }
-    const fileContent = fs.readFileSync(logFilePath, 'utf8');
-    const lines = fileContent.trim().split('\n');
-    if (lines.length === 0 || (lines.length === 1 && lines[0] === '')) {
-        console.log(chalk.yellow('Log file is empty. Nothing to sync.'));
-        return;
-    }
-    const logs = [];
-    for (const line of lines) {
-        try {
-            const log = JSON.parse(line);
-            logs.push(log);
-        }
-        catch {
-            console.warn(`Skipping invalid log entry: ${line}`);
-        }
-    }
-    if (logs.length === 0) {
-        console.log('No valid interactions to sync.');
-        return;
-    }
-    // Map logs to interactions
-    const interactions = [];
-    for (const log of logs) {
-        // Find ai_service_id by provider and model
-        const { data: aiService, error: aiError } = await supabase
-            .from('ai_services')
-            .select('id')
-            .eq('provider', log.provider)
-            .eq('name', log.model)
-            .single();
-        if (aiError || !aiService) {
-            console.warn(`AI service not found for provider: ${log.provider}, model: ${log.model}`);
-            continue;
-        }
-        // Assume project_id - for now, use a default or query user's projects
-        // TODO: Add project selection or default project
-        const { data: projects, error: projError } = await supabase
-            .from('projects')
-            .select('id')
-            .limit(1);
-        if (projError || !projects || projects.length === 0) {
-            console.error('No projects found for user.');
-            continue;
-        }
-        const projectId = projects[0].id;
-        const interaction = {
-            project_id: projectId,
-            ai_service_id: aiService.id,
-            tokens_used: log.totalTokens,
-            cost_in_cents: Math.round(log.costUSD * 100),
-            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);
-    }
-    if (interactions.length === 0) {
-        console.log('No interactions to insert.');
-        return;
-    }
-    // Insert interactions
-    const { error: insertError } = await supabase
-        .from('interactions')
-        .insert(interactions);
-    if (insertError) {
-        console.error('Error syncing interactions:', insertError);
-    }
-    else {
-        console.log(`Successfully synced ${interactions.length} interactions.`);
-    }
-    if (options.clear) {
-        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.'));
-        }
-    }
-}