codeep 1.0.0

package/dist/utils/codeReview.js

@@ -0,0 +1,390 @@
+/**
+ * Code Review Mode - AI-powered code review
+ */
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, extname, relative } from 'path';
+import { getChangedFiles } from './git';
+// Common code patterns that indicate issues
+const CODE_PATTERNS = [
+    // Security issues
+    {
+        pattern: /eval\s*\(/g,
+        category: 'security',
+        severity: 'error',
+        message: 'Use of eval() is dangerous and can lead to code injection',
+        suggestion: 'Use JSON.parse() or a safer alternative',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /innerHTML\s*=/g,
+        category: 'security',
+        severity: 'warning',
+        message: 'innerHTML can lead to XSS vulnerabilities',
+        suggestion: 'Use textContent or sanitize input before using innerHTML',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /dangerouslySetInnerHTML/g,
+        category: 'security',
+        severity: 'warning',
+        message: 'dangerouslySetInnerHTML can lead to XSS if not properly sanitized',
+        suggestion: 'Ensure content is sanitized using DOMPurify or similar',
+        extensions: ['.jsx', '.tsx'],
+    },
+    {
+        pattern: /password\s*=\s*['"][^'"]+['"]/gi,
+        category: 'security',
+        severity: 'error',
+        message: 'Hardcoded password detected',
+        suggestion: 'Use environment variables for sensitive data',
+    },
+    {
+        pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/gi,
+        category: 'security',
+        severity: 'error',
+        message: 'Hardcoded API key detected',
+        suggestion: 'Use environment variables for API keys',
+    },
+    // Performance issues
+    {
+        pattern: /\.forEach\s*\([^)]*\)\s*{\s*await/g,
+        category: 'performance',
+        severity: 'warning',
+        message: 'Sequential async operations in forEach are inefficient',
+        suggestion: 'Use Promise.all() with map() for parallel execution',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /for\s*\([^)]+\)\s*{\s*await/g,
+        category: 'performance',
+        severity: 'info',
+        message: 'Consider if sequential await in loop is necessary',
+        suggestion: 'Use Promise.all() if operations can run in parallel',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /SELECT\s+\*/gi,
+        category: 'performance',
+        severity: 'warning',
+        message: 'SELECT * can be inefficient, select only needed columns',
+        suggestion: 'Specify required columns explicitly',
+    },
+    // Bug-prone patterns
+    {
+        pattern: /==\s*null|null\s*==/g,
+        category: 'bug',
+        severity: 'info',
+        message: 'Using == for null check also matches undefined',
+        suggestion: 'Use === null or == null intentionally',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /catch\s*\(\s*\w*\s*\)\s*{\s*}/g,
+        category: 'bug',
+        severity: 'warning',
+        message: 'Empty catch block swallows errors silently',
+        suggestion: 'Log the error or handle it appropriately',
+    },
+    {
+        pattern: /console\.(log|debug|info|warn|error)\s*\(/g,
+        category: 'maintainability',
+        severity: 'info',
+        message: 'Console statement found - remove before production',
+        suggestion: 'Use a proper logging library',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    {
+        pattern: /TODO|FIXME|HACK|XXX/g,
+        category: 'maintainability',
+        severity: 'info',
+        message: 'TODO/FIXME comment found',
+        suggestion: 'Address the TODO or create a ticket',
+    },
+    // Type safety
+    {
+        pattern: /:\s*any\b/g,
+        category: 'types',
+        severity: 'warning',
+        message: 'Using "any" type bypasses type checking',
+        suggestion: 'Use a more specific type or unknown',
+        extensions: ['.ts', '.tsx'],
+    },
+    {
+        pattern: /@ts-ignore/g,
+        category: 'types',
+        severity: 'warning',
+        message: '@ts-ignore suppresses TypeScript errors',
+        suggestion: 'Fix the underlying type issue instead',
+        extensions: ['.ts', '.tsx'],
+    },
+    {
+        pattern: /as\s+any\b/g,
+        category: 'types',
+        severity: 'warning',
+        message: 'Type assertion to "any" bypasses type safety',
+        suggestion: 'Use proper type assertion or fix the types',
+        extensions: ['.ts', '.tsx'],
+    },
+    // Best practices
+    {
+        pattern: /var\s+\w+/g,
+        category: 'best-practice',
+        severity: 'info',
+        message: 'Using var instead of let/const',
+        suggestion: 'Use const for constants, let for variables',
+        extensions: ['.js', '.jsx'],
+    },
+    {
+        pattern: /function\s*\(/g,
+        category: 'style',
+        severity: 'info',
+        message: 'Anonymous function expression',
+        suggestion: 'Consider using arrow functions or named functions',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+    // Documentation
+    {
+        pattern: /export\s+(default\s+)?(?:function|class|const)\s+\w+/g,
+        category: 'documentation',
+        severity: 'suggestion',
+        message: 'Exported function/class without JSDoc',
+        suggestion: 'Add JSDoc documentation for public APIs',
+        extensions: ['.js', '.ts', '.jsx', '.tsx'],
+    },
+];
+/**
+ * Analyze a single file for issues
+ */
+function analyzeFile(filePath, content, projectRoot) {
+    const issues = [];
+    const ext = extname(filePath);
+    const relativePath = relative(projectRoot, filePath);
+    const lines = content.split('\n');
+    for (const pattern of CODE_PATTERNS) {
+        // Skip if pattern doesn't apply to this file type
+        if (pattern.extensions && !pattern.extensions.includes(ext)) {
+            continue;
+        }
+        // Find all matches
+        let match;
+        const regex = new RegExp(pattern.pattern.source, pattern.pattern.flags);
+        while ((match = regex.exec(content)) !== null) {
+            // Find line number
+            const beforeMatch = content.slice(0, match.index);
+            const lineNumber = beforeMatch.split('\n').length;
+            issues.push({
+                file: relativePath,
+                line: lineNumber,
+                severity: pattern.severity,
+                category: pattern.category,
+                message: pattern.message,
+                suggestion: pattern.suggestion,
+            });
+        }
+    }
+    // Check for long files
+    if (lines.length > 500) {
+        issues.push({
+            file: relativePath,
+            severity: 'info',
+            category: 'maintainability',
+            message: `File has ${lines.length} lines - consider splitting into smaller modules`,
+        });
+    }
+    // Check for long functions (basic heuristic)
+    let braceDepth = 0;
+    let functionStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/function\s+\w+|=>\s*{|\)\s*{/.test(line)) {
+            if (braceDepth === 0) {
+                functionStart = i;
+            }
+        }
+        braceDepth += (line.match(/{/g) || []).length;
+        braceDepth -= (line.match(/}/g) || []).length;
+        if (braceDepth === 0 && functionStart !== -1) {
+            const functionLength = i - functionStart;
+            if (functionLength > 50) {
+                issues.push({
+                    file: relativePath,
+                    line: functionStart + 1,
+                    severity: 'info',
+                    category: 'maintainability',
+                    message: `Function is ${functionLength} lines long - consider breaking it down`,
+                });
+            }
+            functionStart = -1;
+        }
+    }
+    return issues;
+}
+/**
+ * Get files to review
+ */
+function getFilesToReview(projectRoot, specificFiles) {
+    if (specificFiles && specificFiles.length > 0) {
+        return specificFiles
+            .map(f => join(projectRoot, f))
+            .filter(f => existsSync(f));
+    }
+    // Get changed files from git
+    const changedFiles = getChangedFiles(projectRoot);
+    if (changedFiles.length > 0) {
+        return changedFiles.map(f => join(projectRoot, f));
+    }
+    // Otherwise, review src directory
+    const srcDir = join(projectRoot, 'src');
+    if (existsSync(srcDir)) {
+        return getAllSourceFiles(srcDir);
+    }
+    return getAllSourceFiles(projectRoot);
+}
+/**
+ * Get all source files in directory
+ */
+function getAllSourceFiles(dir, maxFiles = 50) {
+    const files = [];
+    const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', 'vendor', '__pycache__']);
+    function walk(currentDir) {
+        if (files.length >= maxFiles)
+            return;
+        try {
+            const entries = readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.length >= maxFiles)
+                    return;
+                const fullPath = join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!skipDirs.has(entry.name) && !entry.name.startsWith('.')) {
+                        walk(fullPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = extname(entry.name);
+                    if (['.ts', '.tsx', '.js', '.jsx', '.py', '.php', '.go', '.rs'].includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    walk(dir);
+    return files;
+}
+/**
+ * Perform code review
+ */
+export function performCodeReview(projectContext, specificFiles) {
+    const projectRoot = projectContext.root || process.cwd();
+    const filesToReview = getFilesToReview(projectRoot, specificFiles);
+    const allIssues = [];
+    for (const filePath of filesToReview) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const issues = analyzeFile(filePath, content, projectRoot);
+            allIssues.push(...issues);
+        }
+        catch { }
+    }
+    // Calculate summary
+    const summary = {
+        totalIssues: allIssues.length,
+        byCategory: {},
+        bySeverity: { error: 0, warning: 0, info: 0, suggestion: 0 },
+    };
+    for (const issue of allIssues) {
+        summary.byCategory[issue.category] = (summary.byCategory[issue.category] || 0) + 1;
+        summary.bySeverity[issue.severity]++;
+    }
+    // Calculate score (100 - deductions)
+    let score = 100;
+    score -= summary.bySeverity.error * 10;
+    score -= summary.bySeverity.warning * 3;
+    score -= summary.bySeverity.info * 1;
+    score = Math.max(0, Math.min(100, score));
+    return {
+        files: filesToReview.map(f => relative(projectRoot, f)),
+        issues: allIssues,
+        summary,
+        score,
+    };
+}
+/**
+ * Format review result for display
+ */
+export function formatReviewResult(result) {
+    const lines = [];
+    // Header
+    lines.push('# Code Review Report');
+    lines.push('');
+    // Score
+    const scoreEmoji = result.score >= 80 ? '✅' : result.score >= 60 ? '⚠️' : '❌';
+    lines.push(`## Score: ${result.score}/100 ${scoreEmoji}`);
+    lines.push('');
+    // Summary
+    lines.push('## Summary');
+    lines.push(`- Files reviewed: ${result.files.length}`);
+    lines.push(`- Total issues: ${result.summary.totalIssues}`);
+    lines.push(`  - Errors: ${result.summary.bySeverity.error}`);
+    lines.push(`  - Warnings: ${result.summary.bySeverity.warning}`);
+    lines.push(`  - Info: ${result.summary.bySeverity.info}`);
+    lines.push('');
+    // Issues by category
+    if (result.summary.totalIssues > 0) {
+        lines.push('## Issues by Category');
+        for (const [category, count] of Object.entries(result.summary.byCategory)) {
+            if (count > 0) {
+                lines.push(`- ${category}: ${count}`);
+            }
+        }
+        lines.push('');
+        // Detailed issues
+        lines.push('## Detailed Issues');
+        lines.push('');
+        // Group by file
+        const byFile = new Map();
+        for (const issue of result.issues) {
+            const existing = byFile.get(issue.file) || [];
+            existing.push(issue);
+            byFile.set(issue.file, existing);
+        }
+        for (const [file, issues] of byFile) {
+            lines.push(`### ${file}`);
+            for (const issue of issues.slice(0, 10)) { // Limit issues per file
+                const loc = issue.line ? `:${issue.line}` : '';
+                const icon = issue.severity === 'error' ? '❌' : issue.severity === 'warning' ? '⚠️' : 'ℹ️';
+                lines.push(`${icon} **${issue.category}**${loc}: ${issue.message}`);
+                if (issue.suggestion) {
+                    lines.push(`   → ${issue.suggestion}`);
+                }
+            }
+            if (issues.length > 10) {
+                lines.push(`   ... and ${issues.length - 10} more issues`);
+            }
+            lines.push('');
+        }
+    }
+    else {
+        lines.push('## No issues found! 🎉');
+    }
+    return lines.join('\n');
+}
+/**
+ * Get review prompt for AI-enhanced review
+ */
+export function getReviewSystemPrompt(result) {
+    return `You are a code reviewer. Analyze the following code review results and provide additional insights.
+
+## Automated Review Results
+${formatReviewResult(result)}
+
+## Your Task
+1. Identify any additional issues the automated review might have missed
+2. Prioritize the most critical issues to fix first
+3. Provide specific, actionable recommendations
+4. Highlight any positive aspects of the code
+
+Be concise and practical. Focus on issues that matter most for code quality and maintainability.`;
+}

package/dist/utils/context.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Context persistence - save and load conversation context between sessions
+ */
+import { Message } from '../config/index';
+export interface ConversationContext {
+    id: string;
+    projectPath: string;
+    projectName: string;
+    createdAt: number;
+    updatedAt: number;
+    messages: Message[];
+    summary?: string;
+}
+/**
+ * Save conversation context for a project
+ */
+export declare function saveContext(projectPath: string, messages: Message[], summary?: string): boolean;
+/**
+ * Load conversation context for a project
+ */
+export declare function loadContext(projectPath: string): ConversationContext | null;
+/**
+ * Clear context for a project
+ */
+export declare function clearContext(projectPath: string): boolean;
+/**
+ * Get all saved contexts
+ */
+export declare function getAllContexts(): ConversationContext[];
+/**
+ * Summarize messages for context persistence
+ * Keeps recent messages and summarizes older ones
+ */
+export declare function summarizeContext(messages: Message[], maxMessages?: number): {
+    messages: Message[];
+    summary?: string;
+};
+/**
+ * Merge loaded context with current conversation
+ */
+export declare function mergeContext(loaded: ConversationContext | null, currentMessages: Message[]): Message[];
+/**
+ * Format context info for display
+ */
+export declare function formatContextInfo(context: ConversationContext): string;
+/**
+ * Clear all contexts
+ */
+export declare function clearAllContexts(): number;

package/dist/utils/context.js

@@ -0,0 +1,216 @@
+/**
+ * Context persistence - save and load conversation context between sessions
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import { logger } from './logger';
+// Context storage directory
+const CONTEXT_DIR = join(homedir(), '.codeep', 'contexts');
+/**
+ * Ensure context directory exists
+ */
+function ensureContextDir() {
+    if (!existsSync(CONTEXT_DIR)) {
+        mkdirSync(CONTEXT_DIR, { recursive: true });
+    }
+}
+/**
+ * Generate context ID from project path
+ */
+function generateContextId(projectPath) {
+    // Create a stable ID from project path
+    return Buffer.from(projectPath).toString('base64url').substring(0, 32);
+}
+/**
+ * Get context file path for a project
+ */
+function getContextPath(projectPath) {
+    ensureContextDir();
+    const id = generateContextId(projectPath);
+    return join(CONTEXT_DIR, `${id}.json`);
+}
+/**
+ * Save conversation context for a project
+ */
+export function saveContext(projectPath, messages, summary) {
+    try {
+        const contextPath = getContextPath(projectPath);
+        const existing = loadContext(projectPath);
+        const context = {
+            id: generateContextId(projectPath),
+            projectPath,
+            projectName: basename(projectPath),
+            createdAt: existing?.createdAt || Date.now(),
+            updatedAt: Date.now(),
+            messages,
+            summary,
+        };
+        writeFileSync(contextPath, JSON.stringify(context, null, 2));
+        return true;
+    }
+    catch (error) {
+        logger.error('Failed to save context', error);
+        return false;
+    }
+}
+/**
+ * Load conversation context for a project
+ */
+export function loadContext(projectPath) {
+    try {
+        const contextPath = getContextPath(projectPath);
+        if (!existsSync(contextPath)) {
+            return null;
+        }
+        const content = readFileSync(contextPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        logger.error('Failed to load context', error);
+        return null;
+    }
+}
+/**
+ * Clear context for a project
+ */
+export function clearContext(projectPath) {
+    try {
+        const contextPath = getContextPath(projectPath);
+        if (existsSync(contextPath)) {
+            unlinkSync(contextPath);
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error('Failed to clear context', error);
+        return false;
+    }
+}
+/**
+ * Get all saved contexts
+ */
+export function getAllContexts() {
+    ensureContextDir();
+    try {
+        const files = readdirSync(CONTEXT_DIR)
+            .filter(f => f.endsWith('.json'));
+        const contexts = [];
+        for (const file of files) {
+            try {
+                const content = readFileSync(join(CONTEXT_DIR, file), 'utf-8');
+                const context = JSON.parse(content);
+                contexts.push(context);
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        // Sort by most recent
+        return contexts.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Summarize messages for context persistence
+ * Keeps recent messages and summarizes older ones
+ */
+export function summarizeContext(messages, maxMessages = 20) {
+    if (messages.length <= maxMessages) {
+        return { messages };
+    }
+    // Keep recent messages
+    const recentMessages = messages.slice(-maxMessages);
+    const oldMessages = messages.slice(0, -maxMessages);
+    // Create summary of old messages
+    const summary = createSummary(oldMessages);
+    return {
+        messages: recentMessages,
+        summary,
+    };
+}
+/**
+ * Create a text summary of messages
+ */
+function createSummary(messages) {
+    const lines = ['Previous conversation summary:'];
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            // Extract key actions/questions
+            const content = msg.content.slice(0, 100);
+            lines.push(`- User: ${content}${msg.content.length > 100 ? '...' : ''}`);
+        }
+        else if (msg.role === 'assistant') {
+            // Check for tool calls or key actions
+            if (msg.content.includes('created') || msg.content.includes('modified')) {
+                lines.push(`- Assistant: Made file changes`);
+            }
+            else if (msg.content.includes('executed')) {
+                lines.push(`- Assistant: Executed commands`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Merge loaded context with current conversation
+ */
+export function mergeContext(loaded, currentMessages) {
+    if (!loaded) {
+        return currentMessages;
+    }
+    // If there's a summary, add it as a system message
+    const messages = [];
+    if (loaded.summary) {
+        messages.push({
+            role: 'user',
+            content: `[Context from previous session]\n${loaded.summary}`,
+        });
+        messages.push({
+            role: 'assistant',
+            content: 'I understand the previous context. How can I help you continue?',
+        });
+    }
+    // Add loaded messages
+    messages.push(...loaded.messages);
+    // Add current messages
+    messages.push(...currentMessages);
+    return messages;
+}
+/**
+ * Format context info for display
+ */
+export function formatContextInfo(context) {
+    const date = new Date(context.updatedAt).toLocaleString();
+    const messageCount = context.messages.length;
+    return `Project: ${context.projectName}
+Path: ${context.projectPath}
+Last updated: ${date}
+Messages: ${messageCount}${context.summary ? ' (+ summary)' : ''}`;
+}
+/**
+ * Clear all contexts
+ */
+export function clearAllContexts() {
+    ensureContextDir();
+    let cleared = 0;
+    try {
+        const files = readdirSync(CONTEXT_DIR)
+            .filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            try {
+                unlinkSync(join(CONTEXT_DIR, file));
+                cleared++;
+            }
+            catch {
+                // Skip errors
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return cleared;
+}