codereviewerai 1.0.0

package/src/core/reviewer.ts

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import fs from 'fs';
+import path from 'path';
+// FIX: Named import for simpleGit is required in ESM/TS
+import { simpleGit, SimpleGit } from 'simple-git'; 
+import { ConfigManager } from '../config/manager.js';
+import { AIProvider } from '../ai/provider.js';
+import { ContextManager } from './context.js';
+
+export class ReviewEngine {
+    private configManager: ConfigManager;
+    private aiProvider: AIProvider;
+    private contextManager: ContextManager;
+    private git: SimpleGit;
+
+    constructor(configManager: ConfigManager) {
+        this.configManager = configManager;
+        this.aiProvider = new AIProvider(configManager);
+        this.contextManager = new ContextManager();
+        // FIX: Standard initialization call
+        this.git = simpleGit(); 
+    }
+
+    /**
+     * Reviews a specific file by reading its current content
+     */
+    async reviewFile(filePath: string): Promise<void> {
+        const spinner = ora(`Reading ${path.basename(filePath)}...`).start();
+
+        try {
+            const fullPath = path.resolve(process.cwd(), filePath);
+            if (!fs.existsSync(fullPath)) {
+                spinner.fail(chalk.red(`File not found: ${filePath}`));
+                return;
+            }
+
+            const code = fs.readFileSync(fullPath, 'utf-8');
+            
+            // Optimization: Get the actual changes to reduce AI token usage
+            const diff = await this.git.diff([filePath]); 
+
+            spinner.text = 'AI is analyzing your changes...';
+            
+            const context = await this.contextManager.getContext(filePath);
+            
+            // Logic: If there is a diff, review the diff. Otherwise, review the whole file.
+            const review = await this.aiProvider.reviewCode(diff || code, filePath, context);
+            
+            spinner.succeed(chalk.green('Review complete!'));
+            this.displayReview(filePath, review);
+
+            await this.contextManager.addToContext(filePath, code, review);
+
+        } catch (error: any) {
+            spinner.fail(chalk.red('Review failed: ' + error.message));
+        }
+    }
+
+    /**
+     * Reviews only files that are currently in the Git Staging Area
+     */
+    async reviewStaged(): Promise<void> {
+        const spinner = ora('Checking staged files...').start();
+
+        try {
+            const status = await this.git.status();
+            const stagedFiles = status.staged;
+
+            if (stagedFiles.length === 0) {
+                spinner.info(chalk.yellow('No staged files found. Use "git add" first.'));
+                return;
+            }
+
+            spinner.succeed(chalk.green(`Found ${stagedFiles.length} staged file(s)`));
+
+            for (const file of stagedFiles) {
+                console.log(chalk.cyan(`\n📄 File: ${file}`));
+                // Ensure file is a string before passing
+                await this.reviewFile(file as string); 
+            }
+        } catch (error: any) {
+            spinner.fail(chalk.red('Git Error: ' + error.message));
+        }
+    }
+
+    private displayReview(filePath: string, review: any): void {
+        // Safe check for the score to avoid crashes if the AI returns a string
+        const score = parseInt(review.score) || 0;
+        const scoreColor = score >= 8 ? chalk.green : score >= 5 ? chalk.yellow : chalk.red;
+        
+        let content = `${chalk.bold('Summary:')} ${review.summary}\n`;
+        content += `${chalk.bold('Score:')} ${scoreColor(score + '/10')}\n\n`;
+
+        if (review.issues && review.issues.length > 0) {
+            content += `${chalk.red.bold('🚀 Issues Found:')}\n`;
+            review.issues.forEach((issue: any) => {
+                content += `${chalk.yellow('•')} [Line ${issue.line || '?'}] ${issue.msg}\n`;
+                if (issue.fix) content += `   ${chalk.gray('Suggested Fix:')} ${chalk.italic(issue.fix)}\n`;
+            });
+        } else {
+            content += chalk.green('✅ No critical issues found. Great job!\n');
+        }
+
+        if (review.optimizations && Array.isArray(review.optimizations)) {
+            content += `\n${chalk.blue.bold('⚡ Optimizations:')}\n`;
+            review.optimizations.forEach((opt: string) => {
+                content += `${chalk.blue('→')} ${opt}\n`;
+            });
+        }
+
+        console.log(boxen(content, {
+            title: filePath,
+            titleAlignment: 'center',
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        }));
+    }
+
+    async clearHistory(): Promise<void> {
+        await this.contextManager.clearHistory();
+        console.log(chalk.green('✅ Local history cleared.'));
+    }
+}

package/src/core/watcher.ts

@@ -0,0 +1,86 @@
+import { watch, FSWatcher } from 'chokidar'; // Fixed import
+import chalk from 'chalk';
+import path from 'path';
+import { ConfigManager } from '../config/manager.js';
+import { ReviewEngine } from './reviewer.js';
+
+export class FileWatcher {
+    // Fixed: Using the explicitly imported FSWatcher type
+    private watcher: FSWatcher | null = null;
+    private reviewer: ReviewEngine;
+    private configManager: ConfigManager;
+
+    constructor(configManager: ConfigManager) {
+        this.configManager = configManager;
+        this.reviewer = new ReviewEngine(configManager);
+    }
+
+    /**
+     * Starts the background process to watch for file changes
+     */
+    async start(): Promise<void> {
+        // Clear terminal for a clean "Watch Mode" UI
+        console.clear();
+        console.log(chalk.bold.green('👀 codereviewer.ai is now watching your code...'));
+        console.log(chalk.gray('Press Ctrl+C to stop the watcher.\n'));
+
+        // Fixed: Use the watch() function directly
+        this.watcher = watch(process.cwd(), {
+            ignored: [
+                /(^|[\/\\])\../, // ignore dotfiles (.git, .awesomediagns)
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/package-lock.json'
+            ],
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 100
+            }
+        });
+
+        // Event listener for saved changes
+        this.watcher.on('change', async (filePath: string) => {
+            const fileName = path.basename(filePath);
+            const ext = path.extname(filePath);
+
+            const supportedExtensions = ['.ts', '.js', '.py', '.go', '.cpp', '.java', '.tsx', '.jsx'];
+            
+            if (supportedExtensions.includes(ext)) {
+                console.log(chalk.cyan(`\n💾 Change detected in: ${fileName}`));
+                
+                // Trigger the review engine
+                try {
+                    await this.reviewer.reviewFile(filePath);
+                } catch (error) {
+                    console.error(chalk.red('Review failed during auto-watch.'));
+                }
+                
+                console.log(chalk.gray('\nWaiting for next change...'));
+            }
+        });
+
+        this.watcher.on('error', (error: unknown) => {
+            console.error(chalk.red(`Watcher error: ${(error as Error).message}`));
+        });
+
+        // Handle process termination to clean up the watcher
+        process.on('SIGINT', () => {
+            this.stop();
+            // Give the close() promise a moment to resolve before exiting
+            setTimeout(() => process.exit(0), 100);
+        });
+    }
+
+    /**
+     * Stops the watcher safely
+     */
+    stop(): void {
+        if (this.watcher) {
+            this.watcher.close().then(() => {
+                console.log(chalk.yellow('\n🛑 Watcher stopped. Goodbye!'));
+            });
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { homePage } from './ui/home.js'; // Note the .js extension for ESM
+import { ConfigWizard } from './config/wizard.js';
+import { ConfigManager } from './config/manager.js';
+import { ReviewEngine } from './core/reviewer.js';
+import { FileWatcher } from './core/watcher.js';
+import { ChatInterface } from './ui/chat.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Fix for __dirname in ESM
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'));
+
+const program = new Command();
+const configManager = new ConfigManager();
+const configWizard = new ConfigWizard();
+
+program
+  .name('awd')
+  .description('codereviewer.ai - AI-powered code review for developers')
+  .version(packageJson.version)
+  .alias('awesomediagns');
+
+// --- 1. Home / Help ---
+program
+  .command('home')
+  .description('Display the AwesomeDiagns home screen')
+  .action(async () => {
+    await homePage.displayWelcome();
+    homePage.displayQuickHelp();
+  });
+
+// --- 2. Configuration ---
+program
+  .command('init')
+  .description('Initialize your AI provider and API keys')
+  .action(async () => {
+    await configWizard.runSetup();
+  });
+
+program
+  .command('config')
+  .description('View or update current configuration')
+  .option('-s, --show', 'Show current config')
+  .option('-r, --reset', 'Clear all settings')
+  .action(async (options) => {
+    if (options.show) {
+      configManager.displayConfig();
+    } else if (options.reset) {
+      configManager.clearConfig();
+    } else {
+      await configWizard.runSetup();
+    }
+  });
+
+// --- 3. Code Review ---
+program
+  .command('review [file]')
+  .description('Review staged changes or a specific file')
+  .option('-s, --staged', 'Review only files in git staging area', true)
+  .action(async (file, options) => {
+    if (!configManager.isConfigured()) {
+      console.log(chalk.red('\n❌ Not configured! Run: ') + chalk.white('awd init'));
+      return;
+    }
+    const reviewer = new ReviewEngine(configManager);
+    if (file) {
+      await reviewer.reviewFile(file);
+    } else {
+      await reviewer.reviewStaged();
+    }
+  });
+
+// --- 4. Auto-Mode (Watcher) ---
+program
+  .command('watch')
+  .description('Start real-time auto-review mode (on save)')
+  .action(async () => {
+    if (!configManager.isConfigured()) return;
+    const watcher = new FileWatcher(configManager);
+    await watcher.start();
+  });
+
+// --- 5. Interactive Chat ---
+program
+  .command('chat')
+  .description('Start a conversation with the AI about your code')
+  .action(async () => {
+    const chat = new ChatInterface(configManager);
+    await chat.start();
+  });
+
+// --- Default Action ---
+// If the user just types 'awd', show the home page
+program.action(async () => {
+  await homePage.displayWelcome();
+  homePage.displayQuickHelp();
+});
+
+// Handle unknown commands
+program.on('command:*', () => {
+  console.error(chalk.red('\nInvalid command: %s\nSee --help for a list of available commands.'), program.args.join(' '));
+  process.exit(1);
+});
+
+program.parse(process.argv);

package/src/ui/chat.ts

@@ -0,0 +1,111 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfigManager } from '../config/manager.js';
+import { AIProvider } from '../ai/provider.js';
+import { ContextManager } from '../core/context.js';
+// Note: We import ChatMessage as a type if your TS version requires it
+import type { ChatMessage } from '../core/context.js';
+
+export class ChatInterface {
+    private configManager: ConfigManager;
+    private aiProvider: AIProvider;
+    private contextManager: ContextManager;
+    private conversationHistory: ChatMessage[] = [];
+
+    constructor(configManager: ConfigManager) {
+        this.configManager = configManager;
+        this.aiProvider = new AIProvider(configManager);
+        this.contextManager = new ContextManager();
+    }
+
+    async start(): Promise<void> {
+        console.clear();
+        console.log(chalk.cyan.bold('╔════════════════════════════════════════════╗'));
+        console.log(chalk.cyan.bold('║') + chalk.bold.white('       💬 codereviewer.ai Chat Mode        ') + chalk.cyan.bold('║'));
+        console.log(chalk.cyan.bold('╚════════════════════════════════════════════╝\n'));
+        
+        console.log(chalk.gray('Type your questions about the code or reviews.'));
+        console.log(chalk.gray('Commands: "exit" to quit, "clear" to reset history.\n'));
+
+        // Load existing history
+        this.conversationHistory = await this.contextManager.getChatHistory();
+        
+        if (this.conversationHistory.length > 0) {
+            console.log(chalk.yellow(`📖 Loaded ${this.conversationHistory.length} previous messages.\n`));
+            this.displayLastExchange();
+        }
+
+        await this.chatLoop();
+    }
+
+    private async chatLoop(): Promise<void> {
+        while (true) {
+            // Fix: Inquirer v9+ requires this specific handling for async loops
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'userInput',
+                    message: chalk.green('You:'),
+                    validate: (input: string) => input.trim().length > 0 || 'Please enter a message.'
+                }
+            ]);
+
+            const userInput = answers.userInput;
+            const command = userInput.trim().toLowerCase();
+
+            if (command === 'exit' || command === 'quit') {
+                await this.contextManager.saveChatHistory(this.conversationHistory);
+                console.log(chalk.yellow('\n👋 Chat session saved. Goodbye!'));
+                break;
+            }
+
+            if (command === 'clear') {
+                this.conversationHistory = [];
+                await this.contextManager.saveChatHistory([]);
+                console.log(chalk.red('🗑️  Chat history cleared.\n'));
+                continue;
+            }
+
+            await this.handleResponse(userInput);
+        }
+    }
+
+    private async handleResponse(message: string): Promise<void> {
+        const spinner = ora('AI is thinking...').start();
+
+        try {
+            this.conversationHistory.push({ role: 'user', content: message });
+
+            // Ensure your AIProvider.ts actually has the .chat() method!
+            const response = await this.aiProvider.chat(message, this.conversationHistory);
+
+            spinner.stop();
+
+            console.log(`\n${chalk.cyan.bold('AI:')} ${chalk.white(response)}\n`);
+
+            this.conversationHistory.push({ role: 'assistant', content: response });
+
+            // Keep context window manageable (e.g., last 20 messages)
+            if (this.conversationHistory.length > 20) {
+                this.conversationHistory = this.conversationHistory.slice(-20);
+            }
+
+            await this.contextManager.saveChatHistory(this.conversationHistory);
+
+        } catch (error: any) {
+            spinner.fail(chalk.red('Error: ' + (error.message || 'Unknown AI error')));
+        }
+    }
+
+    private displayLastExchange(): void {
+        const lastTwo = this.conversationHistory.slice(-2);
+        lastTwo.forEach(msg => {
+            const label = msg.role === 'user' ? chalk.green('You:') : chalk.cyan.bold('AI:');
+            // Clean display of previous chat content
+            const preview = msg.content.length > 100 ? msg.content.substring(0, 100) + '...' : msg.content;
+            console.log(`${label} ${chalk.gray(preview)}`);
+        });
+        console.log(chalk.gray('————————————————————————————————─────────────\n'));
+    }
+}

package/src/ui/home.ts

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+
+export const homePage = {
+    /**
+     * Displays the high-tech matrix-style header
+     */
+    displayWelcome: async () => {
+        // Ensure the terminal is clear for the professional 'splash' effect
+        console.clear();
+        
+        // Fix: Store the color in a constant for cleaner reuse
+        const matrixGreen = chalk.hex('#00FF41');
+        
+        // Your specific ASCII Art - Wrapped in a raw string to protect backslashes
+        console.log(matrixGreen.bold(`
+    ██████╗ ██████╗ ██████╗ ███████╗██████╗ ███████╗██╗   ██╗██╗███████╗██╗    ██╗███████╗██████╗ 
+    ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗██╔════╝██║   ██║██║██╔════╝██║    ██║██╔════╝██╔══██╗
+    ██║     ██║   ██║██║  ██║█████╗  ██████╔╝█████╗  ██║   ██║██║█████╗  ██║ █╗ ██║█████╗  ██████╔╝
+    ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗██╔══╝  ╚██╗ ██╔╝██║██╔══╝  ██║███╗██║██╔══╝  ██╔══██╗
+    ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║███████╗ ╚████╔╝ ██║███████╗╚███╔███╔╝███████╗██║  ██║
+     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚══════╝  ╚═══╝  ╚═╝╚══════╝ ╚══╝╚══╝ ╚══════╝╚═╝  ╚═╝.ai
+        `));
+
+        // Adding a subtle subtitle using gradient
+        try {
+            const subHeader = figlet.textSync('CODEREVIEWER', {
+                font: 'Small',
+                horizontalLayout: 'default',
+                verticalLayout: 'default',
+            });
+            console.log(gradient(['#00FF41', '#008F11']).multiline(subHeader));
+        } catch (err) {
+            // Fallback if figlet fails
+            console.log(matrixGreen.bold('      --- CODEREVIEWER.AI ---      '));
+        }
+        
+        console.log(chalk.gray('————————————————————————————————————————————————————————————————————'));
+        console.log(chalk.white('  Advanced AI Analysis • Performance Optimization • Security Audit'));
+        console.log(chalk.gray('————————————————————————————————————————————————————————————————————\n'));
+    },
+
+    /**
+     * Shows a clean list of available commands
+     */
+    displayQuickHelp: () => {
+        console.log(chalk.bold.white('📂 GETTING STARTED'));
+        console.log(`  ${chalk.green('awd init')}        ${chalk.gray('→ Setup your API keys and provider')}`);
+        console.log(`  ${chalk.green('awd review')}      ${chalk.gray('→ Review staged changes in Git')}`);
+        console.log(`  ${chalk.green('awd watch')}       ${chalk.gray('→ Enable real-time auto-review mode')}`);
+        console.log(`  ${chalk.green('awd chat')}        ${chalk.gray('→ Discuss results with the AI assistant')}\n`);
+
+        console.log(chalk.bold.white('⚙️  SYSTEM'));
+        console.log(`  ${chalk.green('awd status')}      ${chalk.gray('→ Show current configuration')}`);
+        console.log(`  ${chalk.green('awd history')}     ${chalk.gray('→ View previous review scores')}\n`);
+        
+        console.log(chalk.hex('#00FF41')('Ready for input...'));
+    }
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "declaration": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}