codehere 0.1.1

package/dist/session 2.js

@@ -0,0 +1,593 @@
+/**
+ * Interactive Session System
+ * Seamless REPL-like interface for natural interaction
+ */
+import * as readline from 'readline';
+import { chatWithContext } from './chat.js';
+import { searchIntelligent } from './search.js';
+import { generateAndApplyEdit } from './edit.js';
+import { reviewFile } from './review.js';
+import { planTask, formatPlan } from './planner.js';
+import { IntelligentRouter } from './application/services/intelligent-router.js';
+import { colors, success, error, warning, info, newline, formatNumber, formatPercent, createWelcomeMessage, createSessionWelcome, } from './ui.js';
+import { sessionTokenTracker } from './infrastructure/cost/session-token-tracker.js';
+import { cleanResponse } from './formatter.js';
+/**
+ * Start interactive session
+ */
+export async function startSession() {
+    // Show welcome
+    console.clear();
+    console.log(createSessionWelcome());
+    newline();
+    console.log(colors.dim('Type your questions naturally, or use /commands. Type /help for all commands, exit to quit.'));
+    newline();
+    console.log(colors.dim('Keyboard Shortcuts: ↑/↓ for history, Ctrl+C to cancel, Ctrl+D to exit, Ctrl+L to clear'));
+    newline();
+    console.log(colors.dim('────────────────────────────────────────────────────'));
+    newline();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: colors.cyan('codehere> '),
+        historySize: 100, // Enhanced: Store up to 100 commands for history navigation
+    });
+    const state = {
+        history: [],
+        context: null,
+    };
+    rl.prompt();
+    rl.on('line', async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        // Handle exit
+        if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit' || trimmed === 'q') {
+            console.log(info('Goodbye! 👋'));
+            rl.close();
+            return;
+        }
+        // Handle help
+        if (trimmed.toLowerCase() === 'help' || trimmed === '?') {
+            showHelp();
+            showKeyboardShortcuts();
+            rl.prompt();
+            return;
+        }
+        // Handle clear
+        if (trimmed.toLowerCase() === 'clear') {
+            console.clear();
+            console.log(createWelcomeMessage());
+            newline();
+            rl.prompt();
+            return;
+        }
+        // Parse and execute command
+        try {
+            await executeCommand(trimmed, state, rl);
+        }
+        catch (err) {
+            console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log(newline());
+        console.log(colors.dim('Session ended.'));
+        process.exit(0);
+    });
+}
+/**
+ * Execute command in session
+ */
+async function executeCommand(input, state, rl) {
+    const lower = input.toLowerCase().trim();
+    // SLASH COMMANDS - /command syntax for better discoverability
+    // Support both /command and command syntax
+    if (lower.startsWith('/')) {
+        await handleSlashCommand(input.substring(1), state, rl);
+        return;
+    }
+    // Detect command type (legacy syntax without slash)
+    if (lower.startsWith('explain ') || lower.startsWith('e ')) {
+        const file = input.substring(lower.startsWith('explain ') ? 8 : 2).trim();
+        await handleExplain(file, rl);
+    }
+    else if (lower.startsWith('fix ') || lower.startsWith('edit ')) {
+        const parts = input.substring(lower.startsWith('fix ') ? 4 : 5).trim().split(' ');
+        const file = parts[0];
+        const instruction = parts.slice(1).join(' ');
+        await handleFix(file, instruction, rl);
+    }
+    else if (lower.startsWith('review ')) {
+        const file = input.substring(7).trim();
+        await handleReview(file, rl);
+    }
+    else if (lower.startsWith('plan ')) {
+        const instruction = input.substring(5).trim();
+        await handlePlan(instruction, rl);
+    }
+    else {
+        // Default: use intelligent router - understands any query
+        await handleSmartQuery(input, state, rl);
+    }
+}
+/**
+ * Handle slash commands (/fix, /explain, /review, etc.)
+ */
+async function handleSlashCommand(input, state, rl) {
+    const parts = input.trim().split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1).join(' ');
+    switch (command) {
+        case 'fix':
+        case 'edit': {
+            // /fix <file> <instruction>
+            const fixParts = args.split(/\s+/);
+            if (fixParts.length < 2) {
+                console.log(warning('Usage: /fix <file> <instruction>'));
+                console.log(colors.dim('Example: /fix src/utils.ts "add error handling"'));
+                return;
+            }
+            const file = fixParts[0];
+            const instruction = fixParts.slice(1).join(' ');
+            await handleFix(file, instruction, rl);
+            break;
+        }
+        case 'explain':
+        case 'e': {
+            // /explain <file>
+            if (!args) {
+                console.log(warning('Usage: /explain <file>'));
+                console.log(colors.dim('Example: /explain src/auth.ts'));
+                return;
+            }
+            await handleExplain(args.split(/\s+/)[0], rl);
+            break;
+        }
+        case 'review':
+        case 'r': {
+            // /review <file>
+            if (!args) {
+                console.log(warning('Usage: /review <file>'));
+                console.log(colors.dim('Example: /review src/auth.ts'));
+                return;
+            }
+            await handleReview(args.split(/\s+/)[0], rl);
+            break;
+        }
+        case 'plan':
+        case 'p': {
+            // /plan <instruction>
+            if (!args) {
+                console.log(warning('Usage: /plan <instruction>'));
+                console.log(colors.dim('Example: /plan "add user authentication"'));
+                return;
+            }
+            await handlePlan(args, rl);
+            break;
+        }
+        case 'cost': {
+            // /cost - show instant session token stats (like Claude Code)
+            showSessionCostDisplay();
+            break;
+        }
+        case 'trust': {
+            // /trust - show trust dashboard
+            try {
+                const { executeTrustCommand } = await import('./presentation/cli/commands/trust-command.js');
+                await executeTrustCommand('status');
+            }
+            catch (err) {
+                console.log(error('Failed to get trust status'));
+            }
+            break;
+        }
+        case 'undo': {
+            // /undo - undo last edit
+            try {
+                const { executeUndoCommand } = await import('./presentation/cli/commands/undo-command.js');
+                await executeUndoCommand('undo');
+            }
+            catch (err) {
+                console.log(error('Failed to undo'));
+            }
+            break;
+        }
+        case 'status': {
+            // /status - show project status
+            try {
+                const { executeStatusCommand } = await import('./presentation/cli/commands/status-command.js');
+                await executeStatusCommand();
+            }
+            catch (err) {
+                console.log(error('Failed to get status'));
+            }
+            break;
+        }
+        case 'history':
+        case 'h': {
+            // /history - show command history
+            if (state.history.length === 0) {
+                console.log(colors.dim('No command history yet.'));
+            }
+            else {
+                console.log(colors.bold('Recent Commands:'));
+                state.history.slice(-10).forEach((h, i) => {
+                    console.log(colors.dim(`  ${i + 1}. ${h.command.substring(0, 60)}${h.command.length > 60 ? '...' : ''}`));
+                });
+            }
+            break;
+        }
+        case 'clear': {
+            // /clear - clear screen
+            console.clear();
+            console.log(createWelcomeMessage());
+            newline();
+            break;
+        }
+        case 'help':
+        case '?': {
+            // /help - show help
+            showSlashCommandHelp();
+            break;
+        }
+        default:
+            console.log(warning(`Unknown command: /${command}`));
+            console.log(colors.dim('Type /help to see available commands'));
+    }
+}
+/**
+ * Show instant session cost display (like Claude Code)
+ */
+function showSessionCostDisplay() {
+    newline();
+    console.log(colors.bold('Session Usage'));
+    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    newline();
+    const stats = sessionTokenTracker.getStats();
+    const formatTokens = (n) => {
+        if (n >= 1000000)
+            return `${(n / 1000000).toFixed(2)}M`;
+        if (n >= 1000)
+            return `${(n / 1000).toFixed(1)}k`;
+        return n.toLocaleString();
+    };
+    // Token display like Claude Code
+    console.log(colors.bold('  Tokens'));
+    console.log(`    Input:   ${colors.cyan('↓ ' + formatTokens(stats.inputTokens).padStart(10))}`);
+    console.log(`    Output:  ${colors.green('↑ ' + formatTokens(stats.outputTokens).padStart(10))}`);
+    if (stats.cacheReads > 0) {
+        console.log(`    Cache:   ${colors.dim('  ' + formatTokens(stats.cacheReads).padStart(10))}`);
+    }
+    newline();
+    // Cost display
+    console.log(colors.bold('  Cost'));
+    console.log(`    Session: ${colors.yellow('$' + stats.totalCost.toFixed(4))}`);
+    newline();
+    // Requests count
+    const requests = sessionTokenTracker.getRequests();
+    console.log(colors.dim(`  ${requests.length} API calls this session`));
+    newline();
+    // Quick summary line (like Claude Code)
+    console.log(colors.dim('  ─────────────────────────────'));
+    console.log(colors.bold('  ') + sessionTokenTracker.getDisplayString());
+    newline();
+}
+/**
+ * Show slash command help
+ */
+function showSlashCommandHelp() {
+    newline();
+    console.log(colors.bold('Slash Commands'));
+    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    newline();
+    const commands = [
+        ['/fix <file> <instruction>', 'Apply AI-generated edit to a file'],
+        ['/explain <file>', 'Get AI explanation of a file'],
+        ['/review <file>', 'Review code quality and get suggestions'],
+        ['/plan <instruction>', 'Create an implementation plan'],
+        ['/cost', 'Show cost tracking status'],
+        ['/trust', 'Show agent trust/reliability dashboard'],
+        ['/undo', 'Undo last edit'],
+        ['/status', 'Show project status'],
+        ['/history', 'Show command history'],
+        ['/clear', 'Clear the screen'],
+        ['/help', 'Show this help message'],
+    ];
+    commands.forEach(([cmd, desc]) => {
+        console.log(`  ${colors.cyan(cmd.padEnd(30))} ${colors.dim(desc)}`);
+    });
+    newline();
+    console.log(colors.dim('Tip: You can also just type your question naturally!'));
+    console.log(colors.dim('Example: "how does authentication work?"'));
+    newline();
+}
+/**
+ * Handle smart query (intelligent routing)
+ */
+async function handleSmartQuery(query, state, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found. Please set it in .env file.'));
+        return;
+    }
+    process.stdout.write(colors.dim('  Processing...\r'));
+    try {
+        // Use memory-aware router
+        const { container } = await import('./application/services/dependency-container.js');
+        const router = new IntelligentRouter(undefined, // Use default QueryIntentClassifier
+        container.aiService, container.memoryStreamService);
+        // Get conversation context for this session
+        const { conversationContextManager } = await import('./infrastructure/context/conversation-context.js');
+        const { sessionManager } = await import('./infrastructure/context/session-manager.js');
+        const sessionId = sessionManager.getSessionId(process.cwd());
+        const history = conversationContextManager.getHistory(sessionId, 5);
+        const result = await router.route({
+            query,
+            context: {
+                currentDirectory: process.cwd(),
+                conversationHistory: history.map(turn => ({
+                    query: turn.query,
+                    response: turn.response,
+                    timestamp: typeof turn.timestamp === 'string' ? Date.parse(turn.timestamp) : turn.timestamp,
+                })),
+                sessionId,
+            },
+        });
+        process.stdout.write(' '.repeat(50) + '\r');
+        if (result.success) {
+            newline();
+            if (result.message) {
+                const formatted = cleanResponse(result.message);
+                console.log(formatted);
+            }
+        }
+        else {
+            newline();
+            if (result.error) {
+                console.log(error(result.error));
+            }
+            else if (result.message) {
+                console.log(warning(result.message));
+            }
+        }
+        newline();
+        // Save to history
+        const response = result.message || result.error || 'Processed';
+        state.history.push({
+            command: query,
+            response,
+            timestamp: new Date().toISOString(),
+        });
+        // Update conversation context (reuse variables from above)
+        const entities = conversationContextManager.extractEntities(query);
+        conversationContextManager.addTurn(sessionId, query, response, entities, result.intent);
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Handle ask command (legacy - kept for compatibility)
+ */
+async function handleAsk(question, state, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found. Please set it in .env file.'));
+        return;
+    }
+    // Show thinking indicator
+    process.stdout.write(colors.dim('  Thinking...\r'));
+    try {
+        // NEW: Use intelligent search
+        const searchResult = await searchIntelligent(question, {
+            baseDir: process.cwd(),
+        });
+        if (searchResult.chunks.length === 0) {
+            console.log(warning('No relevant code found. Run "codehere index" first.'));
+            return;
+        }
+        // Clear thinking indicator
+        process.stdout.write(' '.repeat(50) + '\r');
+        // Show context summary
+        const retrievedFiles = [...new Set(searchResult.chunks.map(r => r.filepath))];
+        console.log(colors.dim(`  Found ${formatNumber(searchResult.chunks.length)} optimized chunks from ${formatNumber(retrievedFiles.length)} file(s)`));
+        console.log(colors.dim(`  Token reduction: ${formatPercent(searchResult.reductionPercent)}`));
+        // Generate response
+        process.stdout.write(colors.dim('  Generating response...\r'));
+        const response = await chatWithContext(question, searchResult.chunks);
+        process.stdout.write(' '.repeat(50) + '\r');
+        // Display response (formatted)
+        newline();
+        const formattedResponse = cleanResponse(response);
+        console.log(formattedResponse);
+        newline();
+        // Save to history
+        state.history.push({
+            command: question,
+            response,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Handle explain command
+ */
+async function handleExplain(file, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found.'));
+        return;
+    }
+    process.stdout.write(colors.dim('  Reading file...\r'));
+    try {
+        const { readFileSync, existsSync } = await import('fs');
+        const { join } = await import('path');
+        const fullPath = join(process.cwd(), file);
+        if (!existsSync(fullPath)) {
+            process.stdout.write(' '.repeat(50) + '\r');
+            console.error(error(`File not found: ${file}`));
+            return;
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        process.stdout.write(colors.dim('  Generating explanation...\r'));
+        const context = [{
+                filepath: file,
+                content: content,
+                score: 1.0,
+            }];
+        const question = `Explain this file: ${file}`;
+        const response = await chatWithContext(question, context);
+        process.stdout.write(' '.repeat(50) + '\r');
+        newline();
+        console.log(colors.bold(`Explanation for ${file}:`));
+        const formattedResponse = cleanResponse(response);
+        console.log(formattedResponse);
+        newline();
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Handle fix command
+ */
+async function handleFix(file, instruction, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found.'));
+        return;
+    }
+    if (!instruction) {
+        console.error(error('Please provide an instruction. Example: fix file.js "Add error handling"'));
+        return;
+    }
+    process.stdout.write(colors.dim('  Generating edit...\r'));
+    try {
+        const result = await generateAndApplyEdit(file, instruction);
+        process.stdout.write(' '.repeat(50) + '\r');
+        if (result.success) {
+            newline();
+            console.log(success('Edit applied successfully'));
+            if (result.diffStats) {
+                console.log(colors.dim(`  ${result.diffStats.linesAdded} added, ${result.diffStats.linesRemoved} removed`));
+            }
+        }
+        else {
+            newline();
+            console.log(error('Edit failed'));
+            if (result.error) {
+                console.log(colors.red(`  ${result.error}`));
+            }
+        }
+        newline();
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Handle review command
+ */
+async function handleReview(file, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found.'));
+        return;
+    }
+    process.stdout.write(colors.dim('  Reviewing code...\r'));
+    try {
+        const review = await reviewFile(file);
+        process.stdout.write(' '.repeat(50) + '\r');
+        newline();
+        console.log(colors.bold(`Review for ${file}:`));
+        console.log(`Score: ${review.score}/100`);
+        console.log(`Issues: ${review.issues.length}`);
+        if (review.issues.length > 0) {
+            newline();
+            review.issues.slice(0, 5).forEach(issue => {
+                const icon = issue.severity === 'error' ? '✗' : issue.severity === 'warning' ? '⚠' : '→';
+                console.log(`  ${icon} ${issue.message}`);
+            });
+        }
+        newline();
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Handle plan command
+ */
+async function handlePlan(instruction, rl) {
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found.'));
+        return;
+    }
+    process.stdout.write(colors.dim('  Planning...\r'));
+    try {
+        const plan = await planTask(instruction);
+        process.stdout.write(' '.repeat(50) + '\r');
+        newline();
+        console.log(colors.bold('Execution Plan:'));
+        console.log(formatPlan(plan));
+        newline();
+    }
+    catch (err) {
+        process.stdout.write(' '.repeat(50) + '\r');
+        throw err;
+    }
+}
+/**
+ * Show help
+ */
+function showHelp() {
+    newline();
+    console.log(colors.bold('Slash Commands (recommended):'));
+    newline();
+    console.log(colors.cyan('  /fix <file> <instruction>') + '  Apply AI-generated edit');
+    console.log(colors.cyan('  /explain <file>') + '            Get AI explanation');
+    console.log(colors.cyan('  /review <file>') + '             Review code quality');
+    console.log(colors.cyan('  /plan <instruction>') + '        Create implementation plan');
+    console.log(colors.cyan('  /cost') + '                      Show cost tracking');
+    console.log(colors.cyan('  /trust') + '                     Show trust dashboard');
+    console.log(colors.cyan('  /undo') + '                      Undo last edit');
+    console.log(colors.cyan('  /status') + '                    Show project status');
+    console.log(colors.cyan('  /history') + '                   Show command history');
+    console.log(colors.cyan('  /help') + '                      Show all commands');
+    newline();
+    console.log(colors.bold('Quick Commands:'));
+    newline();
+    console.log(colors.cyan('  <question>') + '                 Ask anything about your codebase');
+    console.log(colors.cyan('  clear') + '                      Clear screen');
+    console.log(colors.cyan('  exit') + '                       Exit session (or: quit, q)');
+    newline();
+    console.log(colors.dim('Examples:'));
+    console.log(colors.dim('  How does authentication work?'));
+    console.log(colors.dim('  /explain src/auth.ts'));
+    console.log(colors.dim('  /fix src/utils.js "Add error handling"'));
+    newline();
+}
+/**
+ * Show keyboard shortcuts (Task 7.5)
+ */
+function showKeyboardShortcuts() {
+    newline();
+    console.log(colors.bold('Keyboard Shortcuts:'));
+    newline();
+    console.log(colors.cyan('  ↑/↓') + '        Navigate command history');
+    console.log(colors.cyan('  Tab') + '        Autocomplete (when available)');
+    console.log(colors.cyan('  Ctrl+C') + '     Cancel current operation');
+    console.log(colors.cyan('  Ctrl+D') + '     Exit session');
+    console.log(colors.cyan('  Ctrl+L') + '     Clear screen');
+    console.log(colors.cyan('  Esc') + '        Cancel current input');
+    console.log(colors.cyan('  Enter') + '      Execute command');
+    newline();
+}
+//# sourceMappingURL=session.js.map

package/dist/session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Interactive Session System
+ * Seamless REPL-like interface for natural interaction
+ */
+export interface SessionState {
+    history: Array<{
+        command: string;
+        response: string;
+        timestamp: string;
+    }>;
+    context: any;
+}
+/**
+ * Start interactive session
+ */
+export declare function startSession(): Promise<void>;
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts 2.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgCH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzE,OAAO,EAAE,GAAG,CAAC;CACd;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAyElD"}

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgCH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzE,OAAO,EAAE,GAAG,CAAC;CACd;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAyElD"}