@goldensheepai/toknxr-cli 0.2.0

package/lib/code-review.js

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

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