gemini-coder 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# Gemini Coder Pro
+
+Gemini Coder Pro is a TypeScript CLI agent for local code navigation, review, and surgical edits.
+
+## Install
+
+```bash
+npm install -g gemini-coder
+```
+
+## Run
+
+```bash
+gemini-coder chat
+```
+
+## Build from source
+
+```bash
+npm install
+npm run build
+npm start
+```
+
+## Authentication
+
+This tool expects a local `gemini.json` service account file in the project root when run from source. Do not publish that file with the package.
+
+## Notes
+
+- The published package includes the compiled `dist/` output only.
+- Users should run the CLI inside their own workspace because the agent reads local files and git context.

package/dist/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { SessionManager } from './core/session.js';
+import { Orchestrator } from './core/orchestrator.js';
+import { printBootScreen } from './ui/terminal.js';
+const program = new Command();
+const sessionManager = new SessionManager();
+program
+    .name('gemini')
+    .description('Gemini Coder Pro CLI - Advanced AI Coding Agent')
+    .version('0.2.0');
+program
+    .command('chat', { isDefault: true })
+    .description('Start an interactive chat session')
+    .option('-p, --prompt <query>', 'Start with an initial prompt')
+    .option('-c, --continue', 'Continue the most recent session')
+    .option('-m, --model <name>', 'Specify the model to use', 'gemini-3.1-pro-preview')
+    .action(async (options) => {
+    printBootScreen('Gemini Coder Pro', 'v0.2.0');
+    let session;
+    if (options.continue) {
+        session = await sessionManager.getLatestSession();
+        if (session) {
+            console.log(chalk.green(`✓ Resuming session: ${session.id}`));
+        }
+    }
+    if (!session) {
+        session = await sessionManager.createSession();
+    }
+    const orchestrator = new Orchestrator(session, sessionManager, options.model);
+    await orchestrator.initialize();
+    if (options.prompt) {
+        orchestrator['session'].history.push({ role: 'user', parts: [{ text: options.prompt }] });
+        await orchestrator['processTurn'](0);
+    }
+    await orchestrator.chat();
+});
+program
+    .command('list')
+    .description('List recent chat sessions')
+    .action(async () => {
+    const sessions = await sessionManager.listSessions();
+    if (sessions.length === 0) {
+        console.log(chalk.yellow('No sessions found.'));
+        return;
+    }
+    console.log(chalk.bold.blue('\n📊 Recent Sessions:'));
+    const table = new Table({
+        head: [chalk.cyan('Session ID'), chalk.cyan('Last Updated'), chalk.cyan('Tokens (Total)')],
+        style: { head: [], border: [] }
+    });
+    sessions.forEach(s => {
+        table.push([
+            s.id,
+            new Date(s.updatedAt).toLocaleString(),
+            s.tokens?.total?.toLocaleString() || '0'
+        ]);
+    });
+    console.log(table.toString());
+});
+program.parse();

package/dist/commands/commit.js

@@ -0,0 +1,70 @@
+import { rl } from '../core/orchestrator.js';
+import { tools } from '../core/tools.js';
+import chalk from 'chalk';
+export class CommitHandler {
+    name = 'commit';
+    description = 'Auto-generate a commit message and commit changes';
+    async execute(orchestrator) {
+        try {
+            let diffOutput = await tools.run_command({ command: 'git diff --cached' });
+            if (!diffOutput.stdout || diffOutput.stdout.trim() === '') {
+                const unstageDiff = await tools.run_command({ command: 'git diff' });
+                if (!unstageDiff.stdout || unstageDiff.stdout.trim() === '') {
+                    console.log(chalk.yellow('No changes to commit.'));
+                    return;
+                }
+                const answer = await rl.question(chalk.yellow('No staged changes. Stage all tracked changes (git add -u)? (y/n) '));
+                if (answer.toLowerCase() === 'y') {
+                    await tools.run_command({ command: 'git add -u' });
+                    diffOutput = await tools.run_command({ command: 'git diff --cached' });
+                }
+                else {
+                    console.log(chalk.yellow('Aborting.'));
+                    return;
+                }
+            }
+            console.log(chalk.cyan('● Generating commit message...'));
+            await orchestrator.injectMessage({
+                role: 'user',
+                parts: [{ text: `Generate a concise, conventional commit message for these changes:\n\n${diffOutput.stdout}\n\nFormat: <type>(<scope>): <subject>\n\n<body>` }]
+            });
+            await orchestrator.processTurn(0);
+            const lastMessage = orchestrator.session.history[orchestrator.session.history.length - 1];
+            let proposedMessage = '';
+            if (lastMessage.role === 'model' && lastMessage.parts) {
+                proposedMessage = lastMessage.parts.filter((p) => p.text).map((p) => p.text).join('').trim();
+            }
+            if (!proposedMessage) {
+                console.log(chalk.red('✗ Failed to generate message.'));
+                return;
+            }
+            console.log(chalk.bold('\nProposed Message:'));
+            console.log(chalk.green(proposedMessage));
+            const answer = await rl.question(chalk.yellow('\n[y] Commit   [e] Edit   [n] Abort: '));
+            const cmd = answer.toLowerCase().trim();
+            if (cmd === 'y') {
+                const fs = await import('fs/promises');
+                const tmpPath = '.gemini-commit-msg.tmp';
+                await fs.writeFile(tmpPath, proposedMessage);
+                const result = await tools.run_command({ command: `git commit -F ${tmpPath}` });
+                await fs.unlink(tmpPath).catch(() => { });
+                if (result.exitCode === 0) {
+                    console.log(chalk.green('✓ Commit successful'));
+                }
+                else {
+                    console.log(chalk.red('✗ Commit failed'));
+                    console.log(result.stderr || result.stdout);
+                }
+            }
+            else if (cmd === 'e') {
+                console.log(chalk.yellow('Manual commit required.'));
+            }
+            else {
+                console.log(chalk.yellow('Aborted.'));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Error: ${error.message}`));
+        }
+    }
+}

package/dist/commands/context.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+export class ContextHandler {
+    name = 'context';
+    description = 'Show which files you have read this session';
+    async execute(orchestrator) {
+        const readFiles = new Set();
+        for (const message of orchestrator.session.history) {
+            if (message.role === 'model' && message.parts) {
+                for (const part of message.parts) {
+                    if (part.functionCall && part.functionCall.name === 'read_files' && part.functionCall.args) {
+                        const paths = part.functionCall.args.paths;
+                        paths.forEach(p => readFiles.add(p));
+                    }
+                }
+            }
+        }
+        if (readFiles.size === 0) {
+            console.log(chalk.yellow('No files read this session.'));
+            return;
+        }
+        console.log(chalk.bold('\nFiles read this session:'));
+        Array.from(readFiles).sort().forEach(f => {
+            console.log(chalk.cyan(`  • ${f}`));
+        });
+    }
+}

package/dist/commands/diff.js

@@ -0,0 +1,22 @@
+import { tools } from '../core/tools.js';
+import { showInteractiveDiff } from '../core/diff.js';
+import chalk from 'chalk';
+export class DiffHandler {
+    name = 'diff';
+    description = 'Show interactive diff of all uncommitted changes';
+    async execute(orchestrator) {
+        try {
+            const cachedDiff = await tools.run_command({ command: 'git diff --cached' });
+            const unstagedDiff = await tools.run_command({ command: 'git diff' });
+            const fullDiff = (cachedDiff.stdout || '') + (unstagedDiff.stdout || '');
+            if (!fullDiff.trim()) {
+                console.log(chalk.yellow('No uncommitted changes.'));
+                return;
+            }
+            await showInteractiveDiff(fullDiff);
+        }
+        catch (error) {
+            console.error(chalk.red(`[Diff Error]: ${error.message}`));
+        }
+    }
+}

package/dist/commands/index.js

@@ -0,0 +1,22 @@
+import { CommandRegistry } from '../core/commands.js';
+import { PlanHandler } from './plan.js';
+import { DiffHandler } from './diff.js';
+import { ReviewHandler, SecurityReviewHandler } from './review.js';
+import { SimplifyHandler } from './simplify.js';
+import { UsageHandler } from './usage.js';
+import { CommitHandler } from './commit.js';
+import { TestHandler } from './test.js';
+import { UndoHandler } from './undo.js';
+import { ContextHandler } from './context.js';
+export function registerAllCommands() {
+    CommandRegistry.register(new PlanHandler());
+    CommandRegistry.register(new DiffHandler());
+    CommandRegistry.register(new ReviewHandler());
+    CommandRegistry.register(new SecurityReviewHandler());
+    CommandRegistry.register(new SimplifyHandler());
+    CommandRegistry.register(new UsageHandler());
+    CommandRegistry.register(new CommitHandler());
+    CommandRegistry.register(new TestHandler());
+    CommandRegistry.register(new UndoHandler());
+    CommandRegistry.register(new ContextHandler());
+}

package/dist/commands/plan.js

@@ -0,0 +1,17 @@
+import { OrchestratorMode } from '../core/orchestrator.js';
+import chalk from 'chalk';
+export class PlanHandler {
+    name = 'plan';
+    description = 'Enter read-only mode. Research and plan only, no edits.';
+    async execute(orchestrator) {
+        const currentMode = orchestrator.getMode();
+        const newMode = currentMode === OrchestratorMode.PLAN
+            ? OrchestratorMode.NORMAL
+            : OrchestratorMode.PLAN;
+        orchestrator.setMode(newMode);
+        console.log(chalk.blue.bold(`\n[Mode]: Switched to ${newMode}`));
+        if (newMode === OrchestratorMode.PLAN) {
+            console.log(chalk.blue('Tool calls that modify state will be intercepted. Edits will not be applied.'));
+        }
+    }
+}

package/dist/commands/review.js

@@ -0,0 +1,22 @@
+export class ReviewHandler {
+    name = 'review';
+    description = 'Deep security and code quality review. Read-only.';
+    async execute(orchestrator) {
+        await orchestrator.injectMessage({
+            role: 'user',
+            parts: [{ text: "Perform a deep read-only code review. Focus on maintainability, performance, and idiomatic TypeScript. Output an analytical report. Do not propose edits." }]
+        });
+        await orchestrator.processTurn(0);
+    }
+}
+export class SecurityReviewHandler {
+    name = 'security-review';
+    description = 'Focused security review. Read-only.';
+    async execute(orchestrator) {
+        await orchestrator.injectMessage({
+            role: 'user',
+            parts: [{ text: "Perform a focused security review. Identify vulnerabilities (injection, secrets, insecure config). Output an analytical report. Do not propose edits." }]
+        });
+        await orchestrator.processTurn(0);
+    }
+}

package/dist/commands/simplify.js

@@ -0,0 +1,11 @@
+export class SimplifyHandler {
+    name = 'simplify';
+    description = 'Analyze and simplify complex code areas';
+    async execute(orchestrator) {
+        await orchestrator.injectMessage({
+            role: 'user',
+            parts: [{ text: "Analyze recently edited files. Identify high complexity or 'code smells'. Propose simplified refactor for one area. Verify with tests." }]
+        });
+        await orchestrator.processTurn(0);
+    }
+}

package/dist/commands/test.js

@@ -0,0 +1,12 @@
+export class TestHandler {
+    name = 'test';
+    description = 'Trigger self-healing test loop until all tests pass';
+    async execute(orchestrator, args) {
+        const testCommand = args.length > 0 ? args.join(' ') : 'npm test';
+        await orchestrator.injectMessage({
+            role: 'user',
+            parts: [{ text: `Execute test command: \`${testCommand}\`. If failure occurs, diagnose error, apply surgical fixes, and retry until pass.` }]
+        });
+        await orchestrator.processTurn(0);
+    }
+}

package/dist/commands/undo.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import fs from 'fs/promises';
+export class UndoHandler {
+    name = 'undo';
+    description = 'Revert last applied edit';
+    async execute(orchestrator) {
+        const lastEdit = orchestrator.appliedEdits.pop();
+        if (!lastEdit) {
+            console.log(chalk.yellow('No edits to undo.'));
+            return;
+        }
+        try {
+            await fs.writeFile(lastEdit.path, lastEdit.originalContent, 'utf8');
+            console.log(chalk.green(`\n✓ Reverted change to ${lastEdit.path}`));
+        }
+        catch (error) {
+            console.error(chalk.red(`\n✗ Failed to undo: ${error.message}`));
+            // Put it back if it failed?
+            orchestrator.appliedEdits.push(lastEdit);
+        }
+    }
+}

package/dist/commands/usage.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+export class UsageHandler {
+    name = 'usage';
+    description = 'Show token usage and estimated cost for the current session';
+    async execute(orchestrator) {
+        const tokens = orchestrator.session.tokens || { prompt: 0, candidates: 0, total: 0 };
+        // Cost estimation based on standard Gemini 1.5 Pro/Flash pricing (rough estimate)
+        // Adjust logic as needed. Assume $3.50 per 1M prompt, $10.50 per 1M candidates for Pro
+        const costPerMillionPrompt = 3.50;
+        const costPerMillionCandidates = 10.50;
+        const promptCost = (tokens.prompt / 1_000_000) * costPerMillionPrompt;
+        const candidatesCost = (tokens.candidates / 1_000_000) * costPerMillionCandidates;
+        const totalCost = promptCost + candidatesCost;
+        console.log(chalk.bold('\nTOKEN USAGE'));
+        console.log(chalk.cyan(`• Input:  ${tokens.prompt.toLocaleString()}`));
+        console.log(chalk.cyan(`• Output: ${tokens.candidates.toLocaleString()}`));
+        console.log(chalk.cyan(`• Total:  ${tokens.total.toLocaleString()}`));
+        console.log(chalk.green(`• Cost:   $${totalCost.toFixed(4)}\n`));
+    }
+}

package/dist/core/ai.js

@@ -0,0 +1,33 @@
+import { GoogleGenAI } from '@google/genai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+function findProjectRoot(startPath) {
+    let currentPath = startPath;
+    while (currentPath !== path.parse(currentPath).root) {
+        if (fs.existsSync(path.join(currentPath, 'package.json'))) {
+            return currentPath;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    throw new Error('Could not find project root containing package.json');
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = findProjectRoot(__dirname);
+const credentialsPath = path.join(projectRoot, 'gemini.json');
+if (!fs.existsSync(credentialsPath)) {
+    console.error(`Error: gemini.json not found at expected path: ${credentialsPath}`);
+    process.exit(1);
+}
+const config = JSON.parse(fs.readFileSync(credentialsPath, 'utf8'));
+const location = config.location ?? process.env.GOOGLE_CLOUD_LOCATION ?? 'global';
+export const client = new GoogleGenAI({
+    project: config.project_id,
+    location,
+    vertexai: true,
+    googleAuthOptions: {
+        keyFile: credentialsPath,
+        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+    }
+});

package/dist/core/commands.js

@@ -0,0 +1,12 @@
+export class CommandRegistry {
+    static commands = new Map();
+    static register(handler) {
+        this.commands.set(handler.name, handler);
+    }
+    static get(name) {
+        return this.commands.get(name);
+    }
+    static getAll() {
+        return Array.from(this.commands.values());
+    }
+}

package/dist/core/context.js

@@ -0,0 +1,47 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+import { glob } from 'glob';
+const execAsync = promisify(exec);
+async function getSignature(filePath) {
+    const keyExtensions = ['.ts', '.js', '.json', '.md'];
+    if (!keyExtensions.some(ext => filePath.endsWith(ext))) {
+        return null;
+    }
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const lines = content.split('\n').slice(0, 10);
+        return lines.join('\n');
+    }
+    catch (e) {
+        return null;
+    }
+}
+export async function getContextMap() {
+    let files = [];
+    try {
+        const { stdout } = await execAsync('git ls-files --cached --others --exclude-standard');
+        files = stdout.split('\n').filter(f => f.trim().length > 0);
+    }
+    catch (e) {
+        // Fallback to glob if not a git repository
+        files = await glob('**/*', {
+            ignore: ['node_modules/**', 'dist/**', '.git/**', 'package-lock.json'],
+            nodir: true
+        });
+    }
+    const results = [];
+    const batchSize = 50;
+    for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        const batchResults = await Promise.all(batch.map(async (file) => {
+            const signature = await getSignature(file);
+            if (signature) {
+                return `${file}:\n[Signature]\n${signature}\n---`;
+            }
+            return file;
+        }));
+        results.push(...batchResults);
+    }
+    return results.join('\n');
+}

package/dist/core/diff.js

@@ -0,0 +1,113 @@
+import fs from 'fs/promises';
+import * as diff from 'diff';
+import chalk from 'chalk';
+import { rl } from './orchestrator.js';
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function flexibleSearch(content, search) {
+    const exactIndex = content.indexOf(search);
+    if (exactIndex !== -1) {
+        return { start: exactIndex, end: exactIndex + search.length };
+    }
+    const tokens = search.trim().split(/\s+/);
+    if (tokens.length === 0)
+        return null;
+    const pattern = tokens.map(escapeRegExp).join('\\s+');
+    const regex = new RegExp(pattern);
+    const match = content.match(regex);
+    if (match && match.index !== undefined) {
+        return { start: match.index, end: match.index + match[0].length };
+    }
+    return null;
+}
+export async function showDiff(path, search, replace, action = 'Replace content', reason = 'Requested change') {
+    try {
+        const content = await fs.readFile(path, 'utf8');
+        const match = flexibleSearch(content, search);
+        if (!match) {
+            console.log(chalk.red(`\n[Diff Error]: Search block not found in ${path}`));
+            return { success: false };
+        }
+        const newContent = content.slice(0, match.start) + replace + content.slice(match.end);
+        while (true) {
+            // ... same boxed UI code ...
+            const boxWidth = 50;
+            const border = chalk.cyan('┌' + '─'.repeat(boxWidth - 2) + '┐');
+            const divider = chalk.cyan('├' + '─'.repeat(boxWidth - 2) + '┤');
+            const bottom = chalk.cyan('└' + '─'.repeat(boxWidth - 2) + '┘');
+            const pipe = chalk.cyan('│');
+            const padLine = (label, value) => {
+                const line = `  ${label}: ${value}`;
+                const remaining = boxWidth - 3 - line.length;
+                return pipe + line + (remaining > 0 ? ' '.repeat(remaining) : '') + pipe;
+            };
+            console.log('\n' + border);
+            console.log(pipe + chalk.bold('  PROPOSED EDIT'.padEnd(boxWidth - 3)) + pipe);
+            console.log(padLine('File', path));
+            console.log(padLine('Action', action));
+            console.log(padLine('Reason', reason));
+            console.log(divider);
+            console.log(pipe + chalk.yellow('  [y] Apply   [n] Skip   [d] Diff'.padEnd(boxWidth - 3)) + pipe);
+            console.log(bottom);
+            const answer = await rl.question(chalk.yellow('Choice: '));
+            const cmd = answer.toLowerCase().trim();
+            if (cmd === 'y') {
+                await fs.writeFile(path, newContent, 'utf8');
+                return { success: true, originalContent: content };
+            }
+            else if (cmd === 'n') {
+                return { success: false };
+            }
+            else if (cmd === 'd') {
+                // ... same diff code ...
+                const patch = diff.createPatch(path, content, newContent);
+                console.log(chalk.bold(`\n${chalk.cyan(path)}`));
+                const lines = patch.split('\n');
+                for (const line of lines) {
+                    if (line.startsWith('---') || line.startsWith('+++') || line.startsWith('Index:')) {
+                        continue;
+                    }
+                    if (line.startsWith('+')) {
+                        process.stdout.write(chalk.green(line + '\n'));
+                    }
+                    else if (line.startsWith('-')) {
+                        process.stdout.write(chalk.red(line + '\n'));
+                    }
+                    else if (line.startsWith('@@')) {
+                        process.stdout.write(chalk.cyan(line + '\n'));
+                    }
+                    else {
+                        process.stdout.write(line + '\n');
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`\n[Diff Error]: ${error.message}`));
+        return { success: false };
+    }
+}
+export async function showInteractiveDiff(gitDiffOutput) {
+    if (!gitDiffOutput)
+        return;
+    const lines = gitDiffOutput.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('---') || line.startsWith('+++') || line.startsWith('Index:') || line.startsWith('diff --git')) {
+            process.stdout.write(chalk.bold(line + '\n'));
+        }
+        else if (line.startsWith('+')) {
+            process.stdout.write(chalk.green(line + '\n'));
+        }
+        else if (line.startsWith('-')) {
+            process.stdout.write(chalk.red(line + '\n'));
+        }
+        else if (line.startsWith('@@')) {
+            process.stdout.write(chalk.cyan(line + '\n'));
+        }
+        else {
+            process.stdout.write(line + '\n');
+        }
+    }
+}

package/dist/core/orchestrator.js

@@ -0,0 +1,398 @@
+import { client as aiClient } from './ai.js';
+import { getContextMap } from './context.js';
+import { tools } from './tools.js';
+import { showDiff } from './diff.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { Type } from '@google/genai';
+import * as readline from 'readline/promises';
+import { CommandRegistry } from './commands.js';
+import { registerAllCommands } from '../commands/index.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import inquirer from 'inquirer';
+import { getPromptText, printAssistantResponse, printHelp, printModeChange, printBox } from '../ui/terminal.js';
+// Configure marked to use terminal rendering
+marked.use(markedTerminal());
+export const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+export var OrchestratorMode;
+(function (OrchestratorMode) {
+    OrchestratorMode["NORMAL"] = "NORMAL";
+    OrchestratorMode["PLAN"] = "PLAN";
+})(OrchestratorMode || (OrchestratorMode = {}));
+const functionDeclarations = [
+    {
+        name: 'read_files',
+        description: 'Read the contents of one or more files.',
+        parameters: {
+            type: Type.OBJECT,
+            properties: {
+                paths: {
+                    type: Type.ARRAY,
+                    items: { type: Type.STRING },
+                    description: 'The paths of the files to read.',
+                },
+            },
+            required: ['paths'],
+        },
+    },
+    {
+        name: 'run_command',
+        description: 'Execute a shell command in the local terminal.',
+        parameters: {
+            type: Type.OBJECT,
+            properties: {
+                command: {
+                    type: Type.STRING,
+                    description: 'The shell command to execute.',
+                },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'grep_search',
+        description: 'Search for a pattern across the codebase (grep).',
+        parameters: {
+            type: Type.OBJECT,
+            properties: {
+                pattern: { type: Type.STRING, description: 'The regex pattern to search for.' },
+                include: { type: Type.STRING, description: 'Optional glob for files to include (e.g. "*.ts").' },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'list_directory',
+        description: 'List the contents of a specific directory.',
+        parameters: {
+            type: Type.OBJECT,
+            properties: {
+                path: { type: Type.STRING, description: 'The directory path (default ".").' },
+            },
+        },
+    },
+    {
+        name: 'propose_edits',
+        description: 'Propose surgical edits to files using search/replace blocks.',
+        parameters: {
+            type: Type.OBJECT,
+            properties: {
+                edits: {
+                    type: Type.ARRAY,
+                    items: {
+                        type: Type.OBJECT,
+                        properties: {
+                            path: { type: Type.STRING },
+                            search: { type: Type.STRING, description: 'The EXACT literal text to find.' },
+                            replace: { type: Type.STRING, description: 'The text to replace it with.' },
+                            action: { type: Type.STRING, description: 'Brief description of the action (e.g. "Replace lines 10-15").' },
+                            reason: { type: Type.STRING, description: 'Technical reason for this change.' },
+                        },
+                        required: ['path', 'search', 'replace', 'action', 'reason'],
+                    },
+                },
+            },
+            required: ['edits'],
+        },
+    },
+];
+const MAX_TURNS = 50;
+const MAX_RETRIES = 3;
+export class Orchestrator {
+    session;
+    sessionManager;
+    mode = OrchestratorMode.NORMAL;
+    model;
+    appliedEdits = [];
+    constructor(session, sessionManager, model = 'gemini-3.1-pro-preview') {
+        this.session = session;
+        this.sessionManager = sessionManager;
+        this.model = model;
+    }
+    async initialize() {
+        // Register all slash commands
+        registerAllCommands();
+        // Initialize system prompt if new session
+        if (this.session.history.length === 0) {
+            const systemPrompt = await this.loadSystemPrompt();
+            this.session.history.push({
+                role: 'user',
+                parts: [{
+                        text: systemPrompt
+                    }]
+            });
+            this.session.history.push({
+                role: 'model',
+                parts: [{ text: "Gemini Coder Pro initialized. Precision coding agent active. Objective?" }]
+            });
+        }
+    }
+    async loadSystemPrompt() {
+        try {
+            const promptPath = path.join(process.cwd(), '.gemini-coder', 'system-prompt.md');
+            return await fs.readFile(promptPath, 'utf8');
+        }
+        catch (error) {
+            return `You are Gemini Coder Pro, an autonomous engineering agent.`;
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+        printModeChange(mode);
+    }
+    injectMessage(message) {
+        this.session.history.push(message);
+    }
+    async withRetry(fn, retries = MAX_RETRIES) {
+        let delay = 2000;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                const errorMsg = String(error.message || error);
+                const isRateLimit = errorMsg.includes('429') || error.status === 429;
+                if (isRateLimit && i < retries - 1) {
+                    console.log(chalk.yellow(`\n[System]: Rate limit hit (429). Retrying in ${delay / 1000}s... (Attempt ${i + 1}/${retries})`));
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    delay *= 2;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error('Max retries reached');
+    }
+    async chat() {
+        while (true) {
+            const userInput = await rl.question(getPromptText(this.mode));
+            if (userInput.trim() === '')
+                continue;
+            if (userInput.toLowerCase() === 'exit')
+                break;
+            if (userInput.startsWith('/')) {
+                await this.handleSlashCommand(userInput);
+                continue;
+            }
+            this.session.history.push({ role: 'user', parts: [{ text: userInput }] });
+            await this.processTurn(0);
+            // Save session after every exchange
+            this.session.updatedAt = new Date().toISOString();
+            await this.sessionManager.saveSession(this.session);
+        }
+    }
+    async handleSlashCommand(command) {
+        const [cmd, ...args] = command.slice(1).split(' ');
+        // Check registry first
+        const handler = CommandRegistry.get(cmd);
+        if (handler) {
+            await handler.execute(this, args);
+            return;
+        }
+        switch (cmd) {
+            case 'clear':
+            case 'new':
+                console.log(chalk.yellow('Starting new session...'));
+                this.session = await this.sessionManager.createSession();
+                break;
+            case 'help':
+                printHelp(CommandRegistry.getAll());
+                break;
+            case 'actions': {
+                printBox('Actions', ['Choose an interactive command.'], 'blue');
+                const answer = await inquirer.prompt([{
+                        type: 'expand',
+                        name: 'command',
+                        message: 'Action',
+                        choices: [
+                            { key: 'p', name: 'Plan', value: '/plan' },
+                            { key: 'd', name: 'Diff', value: '/diff' },
+                            { key: 'r', name: 'Review', value: '/review' },
+                            { key: 's', name: 'Simplify', value: '/simplify' },
+                            { key: 't', name: 'Test', value: '/test' },
+                            { key: 'c', name: 'Cancel', value: null },
+                        ],
+                    }]);
+                if (answer.command) {
+                    await this.handleSlashCommand(answer.command);
+                }
+                break;
+            }
+            default:
+                console.log(chalk.red(`Unknown command: /${cmd}`));
+        }
+    }
+    async processTurn(turnCount) {
+        if (turnCount >= MAX_TURNS) {
+            console.log(chalk.red(`\n[System]: Max turns (${MAX_TURNS}) reached. Stopping this loop.`));
+            return;
+        }
+        try {
+            const contextMap = await getContextMap();
+            const contents = this.session.history.map(item => ({
+                role: item.role,
+                parts: item.parts
+            }));
+            // Inject context map into last user message
+            for (let i = contents.length - 1; i >= 0; i--) {
+                if (contents[i].role === 'user') {
+                    const parts = contents[i].parts;
+                    if (parts && parts.length > 0 && 'text' in parts[0]) {
+                        parts[0].text = `CONTEXT_MAP:\n${contextMap}\n\nUSER_REQUEST: ${parts[0].text}`;
+                    }
+                    break;
+                }
+            }
+            const spinner = ora(chalk.cyan('Thinking...')).start();
+            let responseStream;
+            try {
+                responseStream = await this.withRetry(async () => await aiClient.models.generateContentStream({
+                    model: this.model,
+                    contents,
+                    config: {
+                        tools: [{ functionDeclarations }],
+                    }
+                }));
+            }
+            catch (err) {
+                spinner.fail(chalk.red('API Error'));
+                console.error(chalk.red(`\n[API Error]: ${err.message || err}`));
+                return;
+            }
+            let responseParts = [];
+            let finalUsageMetadata = null;
+            let isFirstChunk = true;
+            const functionCallsByKey = new Map();
+            let assistantText = '';
+            for await (const chunk of responseStream) {
+                if (isFirstChunk) {
+                    spinner.stop();
+                    isFirstChunk = false;
+                }
+                const candidate = chunk.candidates?.[0];
+                const parts = candidate?.content?.parts ?? [];
+                if (parts.length > 0) {
+                    responseParts.push(...parts);
+                    const textParts = parts
+                        .map(part => ('text' in part ? part.text : undefined))
+                        .filter((text) => typeof text === 'string' && text.length > 0)
+                        .join('');
+                    if (textParts) {
+                        assistantText += textParts;
+                    }
+                }
+                if (chunk.functionCalls) {
+                    for (const call of chunk.functionCalls) {
+                        const key = call.id ?? `${call.name ?? 'unknown'}:${JSON.stringify(call.args ?? call.partialArgs ?? {})}`;
+                        functionCallsByKey.set(key, call);
+                    }
+                }
+                if (chunk.usageMetadata) {
+                    finalUsageMetadata = chunk.usageMetadata;
+                }
+            }
+            if (!isFirstChunk && assistantText.trim()) {
+                const formattedText = marked.parse(assistantText);
+                printAssistantResponse(formattedText.trim());
+            }
+            else {
+                spinner.stop();
+            }
+            if (responseParts.length === 0)
+                return;
+            // Update token tracking
+            if (finalUsageMetadata) {
+                if (!this.session.tokens) {
+                    this.session.tokens = { prompt: 0, candidates: 0, total: 0 };
+                }
+                this.session.tokens.prompt += (finalUsageMetadata.promptTokenCount || 0);
+                this.session.tokens.candidates += (finalUsageMetadata.candidatesTokenCount || 0);
+                this.session.tokens.total += (finalUsageMetadata.totalTokenCount || 0);
+            }
+            this.session.history.push({ role: 'model', parts: responseParts });
+            const functionCalls = Array.from(functionCallsByKey.values());
+            if (functionCalls.length > 0) {
+                const toolResponses = new Array(functionCalls.length);
+                const executeCall = async (call, index) => {
+                    const { name, args } = call;
+                    const progressLabel = chalk.blue(`● Executing ${name}...`);
+                    process.stdout.write(progressLabel);
+                    let functionResponse;
+                    try {
+                        // Centralized Plan Mode interception
+                        if (this.mode === OrchestratorMode.PLAN && ['run_command', 'propose_edits'].includes(name)) {
+                            functionResponse = { error: `Plan Mode: ${name} is intercepted and not applied.` };
+                        }
+                        // Specialized interactive tool
+                        else if (name === 'propose_edits') {
+                            const { edits } = args;
+                            const results = [];
+                            for (const edit of edits || []) {
+                                const { success, originalContent } = await showDiff(edit.path, edit.search, edit.replace, edit.action, edit.reason);
+                                if (success && originalContent) {
+                                    this.appliedEdits.push({ path: edit.path, originalContent });
+                                }
+                                results.push({ path: edit.path, applied: success });
+                            }
+                            functionResponse = { results };
+                        }
+                        // Dynamic routing for all other registered tools
+                        else if (name in tools) {
+                            functionResponse = await tools[name](args || {});
+                        }
+                        else {
+                            functionResponse = { error: `Unknown tool: ${name}` };
+                        }
+                        // Clear progress line and show success
+                        process.stdout.clearLine(0);
+                        process.stdout.cursorTo(0);
+                        console.log(chalk.green(`✓ ${name} complete`));
+                    }
+                    catch (error) {
+                        process.stdout.clearLine(0);
+                        process.stdout.cursorTo(0);
+                        console.log(chalk.red(`✗ ${name} failed`));
+                        functionResponse = { error: error.message || String(error) };
+                    }
+                    toolResponses[index] = {
+                        functionResponse: {
+                            name: name,
+                            response: { result: functionResponse }
+                        }
+                    };
+                };
+                const parallelPromises = [];
+                for (let i = 0; i < functionCalls.length; i++) {
+                    const call = functionCalls[i];
+                    if (['read_files', 'list_directory', 'grep_search'].includes(call.name || '')) {
+                        parallelPromises.push(executeCall(call, i));
+                    }
+                }
+                await Promise.all(parallelPromises);
+                for (let i = 0; i < functionCalls.length; i++) {
+                    const call = functionCalls[i];
+                    if (!['read_files', 'list_directory', 'grep_search'].includes(call.name || '')) {
+                        await executeCall(call, i);
+                    }
+                }
+                this.session.history.push({
+                    role: 'user',
+                    parts: toolResponses
+                });
+                await this.processTurn(turnCount + 1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`\n[Error]: ${error.message || error}`));
+        }
+    }
+}

package/dist/core/session.js

@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import path from 'path';
+const SESSIONS_DIR = path.join(process.cwd(), '.gemini-coder', 'sessions');
+export class SessionManager {
+    currentSessionId = null;
+    constructor() {
+        this.ensureDirectory();
+    }
+    async ensureDirectory() {
+        try {
+            await fs.mkdir(SESSIONS_DIR, { recursive: true });
+        }
+        catch (e) {
+            console.warn(`\n[System Warning]: Failed to ensure sessions directory at ${SESSIONS_DIR}. Error: ${e.message}`);
+        }
+    }
+    async createSession(name = 'default') {
+        const id = Date.now().toString();
+        const session = {
+            id,
+            name,
+            history: [],
+            updatedAt: new Date().toISOString(),
+            tokens: { prompt: 0, candidates: 0, total: 0 }
+        };
+        await this.saveSession(session);
+        this.currentSessionId = id;
+        return session;
+    }
+    async saveSession(session) {
+        const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(session, null, 2));
+    }
+    async loadSession(id) {
+        try {
+            const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+            const data = await fs.readFile(filePath, 'utf8');
+            const session = JSON.parse(data);
+            this.currentSessionId = id;
+            return session;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async getLatestSession() {
+        const files = await fs.readdir(SESSIONS_DIR);
+        if (files.length === 0)
+            return null;
+        const sessions = await Promise.all(files.filter(f => f.endsWith('.json')).map(async (f) => {
+            const data = await fs.readFile(path.join(SESSIONS_DIR, f), 'utf8');
+            return JSON.parse(data);
+        }));
+        return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
+    }
+    async listSessions() {
+        try {
+            const files = await fs.readdir(SESSIONS_DIR);
+            const sessions = await Promise.all(files.filter(f => f.endsWith('.json')).map(async (f) => {
+                const data = await fs.readFile(path.join(SESSIONS_DIR, f), 'utf8');
+                return JSON.parse(data);
+            }));
+            return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        }
+        catch (e) {
+            return [];
+        }
+    }
+}

package/dist/core/tools.js

@@ -0,0 +1,71 @@
+import fs from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export const tools = {
+    read_files: async ({ paths }) => {
+        const contents = await Promise.all(paths.map(async (p) => {
+            try {
+                return {
+                    path: p,
+                    content: await fs.readFile(p, 'utf8')
+                };
+            }
+            catch (error) {
+                return {
+                    path: p,
+                    error: error.message || String(error)
+                };
+            }
+        }));
+        return contents;
+    },
+    propose_edits: async ({ edits }) => {
+        // This will be handled by the orchestrator for the approval gate
+        return { status: "pending_approval", edits };
+    },
+    run_command: async ({ command }) => {
+        try {
+            // 5MB buffer to prevent ERR_CHILD_PROCESS_STDIO_MAXBUFFER
+            const { stdout, stderr } = await execAsync(command, { timeout: 60000, maxBuffer: 1024 * 1024 * 5 });
+            // Truncate massive outputs so they don't blow out the LLM context window
+            return {
+                stdout: stdout ? stdout.slice(0, 50000) : '',
+                stderr: stderr ? stderr.slice(0, 50000) : '',
+                exitCode: 0
+            };
+        }
+        catch (error) {
+            return {
+                stdout: error.stdout ? error.stdout.slice(0, 50000) : '',
+                stderr: (error.stderr || error.message).slice(0, 50000),
+                exitCode: error.code || 1
+            };
+        }
+    },
+    grep_search: async ({ pattern, include }) => {
+        try {
+            // Use grep -rnIE (recursive, line numbers, ignore binary, extended regex)
+            const includeFlag = include ? `--include="${include}"` : '';
+            const command = `grep -rnIE "${pattern}" . ${includeFlag} --exclude-dir={node_modules,dist,.git}`;
+            const { stdout, stderr } = await execAsync(command, { timeout: 30000 });
+            return { results: stdout, stderr };
+        }
+        catch (error) {
+            // grep returns exit code 1 if no matches found
+            if (error.code === 1)
+                return { results: '', message: 'No matches found.' };
+            return { results: '', error: error.message };
+        }
+    },
+    list_directory: async ({ path = '.' }) => {
+        try {
+            const entries = await fs.readdir(path, { withFileTypes: true });
+            const results = entries.map(e => `${e.isDirectory() ? 'DIR ' : 'FILE'} ${e.name}`).join('\n');
+            return { path, results };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    }
+};

package/dist/test/test-diff-command.js

@@ -0,0 +1,7 @@
+import { DiffHandler } from '../commands/diff.js';
+async function test() {
+    const handler = new DiffHandler();
+    // @ts-ignore
+    await handler.execute({});
+}
+test().catch(console.error);

package/dist/ui/terminal.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import { OrchestratorMode } from '../core/orchestrator.js';
+export const QUICK_ACTIONS = [
+    { label: 'Plan', command: '/plan' },
+    { label: 'Diff', command: '/diff' },
+    { label: 'Review', command: '/review' },
+    { label: 'Simplify', command: '/simplify' },
+    { label: 'Test', command: '/test' },
+];
+function getBoxWidth() {
+    return Math.max(60, Math.min(process.stdout.columns || 80, 96));
+}
+function boxLine(content, width) {
+    const innerWidth = width - 2;
+    const text = content.length > innerWidth ? content.slice(0, innerWidth) : content;
+    const padding = ' '.repeat(Math.max(0, innerWidth - text.length));
+    return `│${text}${padding}│`;
+}
+export function printBox(title, lines, accent = 'blue') {
+    const width = getBoxWidth();
+    const borderColor = accent === 'green' ? chalk.green : accent === 'magenta' ? chalk.magenta : chalk.blue;
+    const titleText = ` ${title} `;
+    const titlePad = Math.max(0, width - 2 - titleText.length);
+    const left = '─'.repeat(Math.floor(titlePad / 2));
+    const right = '─'.repeat(titlePad - left.length);
+    console.log(borderColor(`┌${left}${titleText}${right}┐`));
+    for (const line of lines) {
+        console.log(borderColor(boxLine(` ${line}`, width)));
+    }
+    console.log(borderColor(`└${'─'.repeat(width - 2)}┘`));
+}
+export function printBootScreen(appName, version) {
+    console.clear();
+    printBox(`${appName} ${version}`, [
+        'Initializing autonomous engineering agent...',
+        'Type "exit" to quit, "/" for commands.',
+        '',
+        'Quick actions:',
+        QUICK_ACTIONS.map(action => `[${action.command}]`).join('   '),
+        'Type /actions for the interactive menu.',
+    ], 'blue');
+}
+export function getPromptText(mode) {
+    const promptColor = mode === OrchestratorMode.PLAN ? chalk.magenta : chalk.green;
+    return chalk.bold(`${promptColor('>')} `);
+}
+export function printAssistantResponse(text) {
+    const lines = text.split(/\r?\n/);
+    printBox('Gemini', lines.length > 0 ? lines : [''], 'blue');
+}
+export function printModeChange(mode) {
+    const label = mode === OrchestratorMode.PLAN ? chalk.magenta('Plan mode') : chalk.green('Normal mode');
+    printBox('Mode', [`${label}`], mode === OrchestratorMode.PLAN ? 'magenta' : 'green');
+}
+export function printHelp(commands) {
+    printBox('Commands', [
+        ...commands.map(command => `/${command.name} - ${command.description}`),
+        '/clear - Start a new conversation',
+        '/help - Show this help',
+        '/exit - Exit the CLI',
+    ], 'blue');
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "gemini-coder",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "gemini-coder": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts chat",
+    "start": "node dist/cli.js chat",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@google/genai": "^2.6.0",
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.0.0",
+    "diff": "^5.2.0",
+    "glob": "^10.3.12",
+    "google-auth-library": "^10.6.2",
+    "highlight.js": "^11.11.1",
+    "inquirer": "^13.4.3",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.4.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/inquirer": "^9.0.9",
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^20.12.7",
+    "esm": "^3.2.25",
+    "tsx": "^4.7.2",
+    "typescript": "^5.4.5"
+  }
+}