codebot-ai 1.0.0

package/dist/cli.js

@@ -0,0 +1,518 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const readline = __importStar(require("readline"));
+const agent_1 = require("./agent");
+const openai_1 = require("./providers/openai");
+const anthropic_1 = require("./providers/anthropic");
+const registry_1 = require("./providers/registry");
+const history_1 = require("./history");
+const setup_1 = require("./setup");
+const banner_1 = require("./banner");
+const VERSION = '1.0.0';
+const C = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+function c(text, style) {
+    return `${C[style]}${text}${C.reset}`;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        showHelp();
+        return;
+    }
+    if (args.version) {
+        console.log(`codebot v${VERSION}`);
+        return;
+    }
+    // Setup wizard
+    if (args.setup) {
+        await (0, setup_1.runSetup)();
+        return;
+    }
+    // First run: auto-launch setup if nothing is configured
+    if ((0, setup_1.isFirstRun)() && process.stdin.isTTY && !args.message) {
+        console.log(c('Welcome! No configuration found — launching setup...', 'cyan'));
+        await (0, setup_1.runSetup)();
+        // If setup saved a config, continue to main flow
+        // Otherwise exit
+        if ((0, setup_1.isFirstRun)())
+            return;
+    }
+    const config = await resolveConfig(args);
+    const provider = createProvider(config);
+    // Session management
+    let resumeId;
+    if (args.continue) {
+        resumeId = history_1.SessionManager.latest();
+        if (!resumeId) {
+            console.log(c('No previous session found.', 'yellow'));
+        }
+    }
+    else if (typeof args.resume === 'string') {
+        resumeId = args.resume;
+    }
+    const session = new history_1.SessionManager(config.model, resumeId);
+    const sessionShort = session.getId().substring(0, 8);
+    console.log((0, banner_1.banner)(VERSION, config.model, `${config.provider} @ ${config.baseUrl}`, `${sessionShort}...`, !!config.autoApprove));
+    if (resumeId) {
+        console.log(c(`   Resuming session...`, 'green'));
+    }
+    console.log(c(`   ${(0, banner_1.randomGreeting)()}\n`, 'dim'));
+    const agent = new agent_1.Agent({
+        provider,
+        model: config.model,
+        maxIterations: config.maxIterations,
+        autoApprove: config.autoApprove,
+        onMessage: (msg) => session.save(msg),
+    });
+    // Resume: load previous messages
+    if (resumeId) {
+        const messages = session.load();
+        if (messages.length > 0) {
+            agent.loadMessages(messages);
+            console.log(c(`   Loaded ${messages.length} messages from previous session.`, 'dim'));
+        }
+    }
+    // Non-interactive: single message from CLI args
+    if (typeof args.message === 'string') {
+        await runOnce(agent, args.message);
+        return;
+    }
+    // Non-interactive: piped stdin
+    if (!process.stdin.isTTY) {
+        const input = await readStdin();
+        if (input.trim()) {
+            await runOnce(agent, input.trim());
+        }
+        return;
+    }
+    // Interactive REPL
+    await repl(agent, config, session);
+}
+function createProvider(config) {
+    if (config.provider === 'anthropic') {
+        return new anthropic_1.AnthropicProvider({
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
+            model: config.model,
+        });
+    }
+    // All other providers use OpenAI-compatible format
+    return new openai_1.OpenAIProvider({
+        baseUrl: config.baseUrl,
+        apiKey: config.apiKey,
+        model: config.model,
+    });
+}
+async function repl(agent, config, session) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: c('> ', 'cyan'),
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input.startsWith('/')) {
+            handleSlashCommand(input, agent, config);
+            rl.prompt();
+            return;
+        }
+        try {
+            for await (const event of agent.run(input)) {
+                renderEvent(event);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(c(`\nError: ${msg}`, 'red'));
+        }
+        console.log();
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log(c('\nBye!', 'dim'));
+        process.exit(0);
+    });
+}
+async function runOnce(agent, message) {
+    for await (const event of agent.run(message)) {
+        renderEvent(event);
+    }
+    console.log();
+}
+let isThinking = false;
+function renderEvent(event) {
+    switch (event.type) {
+        case 'thinking':
+            if (!isThinking) {
+                process.stdout.write(c('\n💭 ', 'dim'));
+                isThinking = true;
+            }
+            process.stdout.write(c(event.text || '', 'dim'));
+            break;
+        case 'text':
+            if (isThinking) {
+                process.stdout.write('\n');
+                isThinking = false;
+            }
+            process.stdout.write(event.text || '');
+            break;
+        case 'tool_call':
+            if (isThinking) {
+                process.stdout.write('\n');
+                isThinking = false;
+            }
+            console.log(c(`\n⚡ ${event.toolCall?.name}`, 'yellow') +
+                c(`(${formatArgs(event.toolCall?.args)})`, 'dim'));
+            break;
+        case 'tool_result':
+            if (event.toolResult?.is_error) {
+                console.log(c(`  ✗ ${truncate(event.toolResult.result, 200)}`, 'red'));
+            }
+            else {
+                const result = event.toolResult?.result || '';
+                const lines = result.split('\n');
+                if (lines.length > 10) {
+                    console.log(c(`  ✓ (${lines.length} lines)`, 'green'));
+                }
+                else {
+                    console.log(c(`  ✓ ${truncate(result, 200)}`, 'green'));
+                }
+            }
+            break;
+        case 'usage':
+            if (event.usage) {
+                const parts = [];
+                if (event.usage.inputTokens)
+                    parts.push(`in: ${event.usage.inputTokens}`);
+                if (event.usage.outputTokens)
+                    parts.push(`out: ${event.usage.outputTokens}`);
+                if (parts.length > 0) {
+                    console.log(c(`  [${parts.join(', ')} tokens]`, 'dim'));
+                }
+            }
+            break;
+        case 'compaction':
+            console.log(c(`\n📦 ${event.text}`, 'dim'));
+            break;
+        case 'error':
+            console.error(c(`\n✗ ${event.error}`, 'red'));
+            break;
+        case 'done':
+            if (isThinking) {
+                process.stdout.write('\n');
+                isThinking = false;
+            }
+            break;
+    }
+}
+function formatArgs(args) {
+    if (!args)
+        return '';
+    return Object.entries(args)
+        .map(([k, v]) => {
+        const val = typeof v === 'string' ? truncate(v, 60) : JSON.stringify(v);
+        return `${k}: ${val}`;
+    })
+        .join(', ');
+}
+function truncate(s, max) {
+    return s.length <= max ? s : s.substring(0, max) + '...';
+}
+function handleSlashCommand(input, agent, config) {
+    const [cmd, ...rest] = input.split(/\s+/);
+    switch (cmd) {
+        case '/help':
+            console.log(`${c('Commands:', 'bold')}
+  /help      Show this help
+  /model     Show or change model (/model <name>)
+  /models    List all supported models
+  /sessions  List saved sessions
+  /clear     Clear conversation history
+  /compact   Force context compaction
+  /auto      Toggle autonomous mode
+  /config    Show current config
+  /quit      Exit`);
+            break;
+        case '/model':
+            if (rest.length > 0) {
+                config.model = rest.join(' ');
+                const detected = (0, registry_1.detectProvider)(config.model);
+                if (detected) {
+                    config.provider = detected;
+                    console.log(c(`Model: ${config.model} (provider: ${detected})`, 'green'));
+                }
+                else {
+                    console.log(c(`Model: ${config.model} (local/ollama)`, 'green'));
+                }
+            }
+            else {
+                console.log(`Current model: ${config.model} (${config.provider})`);
+            }
+            break;
+        case '/models':
+            showModels();
+            break;
+        case '/clear':
+            agent.clearHistory();
+            console.log(c('Conversation cleared.', 'dim'));
+            break;
+        case '/compact': {
+            const stats = agent.forceCompact();
+            console.log(c(`Context compacted: ${stats.before} → ${stats.after} messages.`, 'dim'));
+            break;
+        }
+        case '/auto':
+            config.autoApprove = !config.autoApprove;
+            console.log(c(`Autonomous mode: ${config.autoApprove ? 'ON' : 'OFF'}`, config.autoApprove ? 'yellow' : 'green'));
+            break;
+        case '/sessions': {
+            const sessions = history_1.SessionManager.list();
+            if (sessions.length === 0) {
+                console.log(c('No saved sessions.', 'dim'));
+            }
+            else {
+                console.log(c('\nSaved sessions:', 'bold'));
+                for (const s of sessions) {
+                    const date = s.updated ? new Date(s.updated).toLocaleString() : 'unknown';
+                    console.log(`  ${c(s.id.substring(0, 8), 'cyan')}  ${date}  ${s.messageCount} msgs  ${c(s.preview || '(empty)', 'dim')}`);
+                }
+                console.log(c(`\nResume with: codebot --resume <id>`, 'dim'));
+            }
+            break;
+        }
+        case '/config':
+            console.log(JSON.stringify({ ...config, apiKey: config.apiKey ? '***' : undefined }, null, 2));
+            break;
+        case '/quit':
+        case '/exit':
+            process.exit(0);
+        default:
+            console.log(c(`Unknown command: ${cmd}. Type /help`, 'yellow'));
+    }
+}
+function showModels() {
+    const { MODEL_REGISTRY } = require('./providers/registry');
+    const byProvider = {};
+    for (const [name, info] of Object.entries(MODEL_REGISTRY)) {
+        const p = info.provider || 'local/ollama';
+        if (!byProvider[p])
+            byProvider[p] = [];
+        byProvider[p].push(name);
+    }
+    for (const [provider, models] of Object.entries(byProvider).sort()) {
+        console.log(c(`\n${provider}:`, 'bold'));
+        for (const m of models) {
+            console.log(`  ${m}`);
+        }
+    }
+}
+async function resolveConfig(args) {
+    // Load saved config (CLI args override saved config)
+    const saved = (0, setup_1.loadConfig)();
+    const model = args.model || process.env.CODEBOT_MODEL || saved.model || 'qwen2.5-coder:32b';
+    const detected = (0, registry_1.detectProvider)(model);
+    const config = {
+        provider: args.provider || process.env.CODEBOT_PROVIDER || saved.provider || detected || 'openai',
+        model,
+        baseUrl: args['base-url'] || process.env.CODEBOT_BASE_URL || saved.baseUrl || '',
+        apiKey: args['api-key'] || '',
+        maxIterations: parseInt(args['max-iterations'] || String(saved.maxIterations || 50), 10),
+        autoApprove: !!args['auto-approve'] || !!args.autonomous || !!args.auto || !!saved.autoApprove,
+    };
+    // Auto-resolve base URL and API key from provider
+    if (!config.baseUrl || !config.apiKey) {
+        const defaults = registry_1.PROVIDER_DEFAULTS[config.provider];
+        if (defaults) {
+            if (!config.baseUrl)
+                config.baseUrl = defaults.baseUrl;
+            if (!config.apiKey)
+                config.apiKey = process.env[defaults.envKey] || process.env.CODEBOT_API_KEY || '';
+        }
+    }
+    // Fallback: try generic env vars
+    if (!config.apiKey) {
+        config.apiKey = process.env.CODEBOT_API_KEY || process.env.OPENAI_API_KEY || '';
+    }
+    // If still no base URL, auto-detect local provider
+    if (!config.baseUrl) {
+        config.baseUrl = await autoDetectProvider();
+    }
+    return config;
+}
+async function autoDetectProvider() {
+    const candidates = [
+        { url: 'http://localhost:11434', name: 'Ollama' },
+        { url: 'http://localhost:1234', name: 'LM Studio' },
+        { url: 'http://localhost:8000', name: 'vLLM' },
+    ];
+    for (const { url, name } of candidates) {
+        try {
+            const res = await fetch(`${url}/v1/models`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            if (res.ok) {
+                console.log(c(`  ✓ ${name} detected on ${url}`, 'green'));
+                return url;
+            }
+        }
+        catch {
+            // not running
+        }
+    }
+    console.log(c('  ⚠ No local LLM detected. Start Ollama or set --base-url', 'yellow'));
+    return 'http://localhost:11434';
+}
+function parseArgs(argv) {
+    const result = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            result.help = true;
+            continue;
+        }
+        if (arg === '--version' || arg === '-v') {
+            result.version = true;
+            continue;
+        }
+        if (arg === '--auto-approve' || arg === '--autonomous' || arg === '--auto') {
+            result['auto-approve'] = true;
+            result.autonomous = true;
+            result.auto = true;
+            continue;
+        }
+        if (arg === '--continue' || arg === '-c') {
+            result.continue = true;
+            continue;
+        }
+        if (arg === '--setup' || arg === '--init') {
+            result.setup = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                result[key] = next;
+                i++;
+            }
+            else {
+                result[key] = true;
+            }
+            continue;
+        }
+        positional.push(arg);
+    }
+    if (positional.length > 0) {
+        result.message = positional.join(' ');
+    }
+    return result;
+}
+function readStdin() {
+    return new Promise(resolve => {
+        let data = '';
+        process.stdin.on('data', (chunk) => (data += chunk.toString()));
+        process.stdin.on('end', () => resolve(data));
+    });
+}
+function showHelp() {
+    console.log(`${c('CodeBot AI', 'bold')} - Local-first AI coding assistant
+
+${c('Quick Start:', 'bold')}
+  codebot --setup                  Run interactive setup wizard
+  codebot                          Start interactive mode
+  codebot "fix the bug in app.ts"  Single message mode
+  echo "explain this" | codebot    Pipe mode
+
+${c('Options:', 'bold')}
+  --setup              Run the setup wizard (auto-runs on first use)
+  --model <name>       Model to use (default: qwen2.5-coder:32b)
+  --provider <name>    Provider: openai, anthropic, gemini, deepseek, groq, mistral, xai
+  --base-url <url>     LLM API base URL (auto-detects Ollama/LM Studio/vLLM + cloud)
+  --api-key <key>      API key (or set provider-specific env var)
+  --autonomous         Skip ALL permission prompts — full auto mode
+  --auto-approve       Same as --autonomous
+  --resume <id>        Resume a previous session by ID
+  --continue, -c       Resume the most recent session
+  --max-iterations <n> Max agent loop iterations (default: 50)
+  -h, --help           Show this help
+  -v, --version        Show version
+
+${c('Supported Providers:', 'bold')}
+  Local:      Ollama, LM Studio, vLLM (auto-detected)
+  Anthropic:  Claude Opus/Sonnet/Haiku (ANTHROPIC_API_KEY)
+  OpenAI:     GPT-4o, GPT-4.1, o1/o3/o4 (OPENAI_API_KEY)
+  Google:     Gemini 2.5/2.0/1.5 (GEMINI_API_KEY)
+  DeepSeek:   deepseek-chat, deepseek-reasoner (DEEPSEEK_API_KEY)
+  Groq:       Llama, Mixtral on Groq (GROQ_API_KEY)
+  Mistral:    mistral-large, codestral (MISTRAL_API_KEY)
+  xAI:        Grok-3 (XAI_API_KEY)
+
+${c('Examples:', 'bold')}
+  codebot --model claude-opus-4-6          Uses Anthropic API
+  codebot --model gpt-4o                   Uses OpenAI API
+  codebot --model gemini-2.5-pro           Uses Gemini API
+  codebot --model deepseek-chat            Uses DeepSeek API
+  codebot --model qwen2.5-coder:32b        Uses local Ollama
+  codebot --autonomous "refactor src/"     Full auto, no prompts
+
+${c('Interactive Commands:', 'bold')}
+  /help      Show commands
+  /model     Show or change model
+  /models    List all supported models
+  /sessions  List saved sessions
+  /auto      Toggle autonomous mode
+  /clear     Clear conversation
+  /compact   Force context compaction
+  /config    Show configuration
+  /quit      Exit`);
+}
+//# sourceMappingURL=cli.js.map

package/dist/context/manager.d.ts

@@ -0,0 +1,27 @@
+import { Message, LLMProvider } from '../types';
+export declare class ContextManager {
+    private contextWindow;
+    private reservedForOutput;
+    private reservedForSystem;
+    private reservedForTools;
+    private provider?;
+    constructor(model: string, provider?: LLMProvider);
+    /** Set the provider (for LLM-powered compaction) */
+    setProvider(provider: LLMProvider): void;
+    /** Conservative token estimate: ~3.5 chars per token */
+    estimateTokens(text: string): number;
+    /** Tokens available for conversation messages */
+    availableTokens(): number;
+    /** Check if messages fit within budget */
+    fitsInBudget(messages: Message[]): boolean;
+    /** Compact conversation by dropping old messages and inserting a summary placeholder */
+    compact(messages: Message[], force?: boolean): Message[];
+    /** Smart compaction: use LLM to summarize dropped messages instead of just discarding */
+    compactWithSummary(messages: Message[]): Promise<{
+        messages: Message[];
+        summary: string;
+    }>;
+    private summarizeMessages;
+    getContextWindow(): number;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/context/manager.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+const registry_1 = require("../providers/registry");
+class ContextManager {
+    contextWindow;
+    reservedForOutput = 2048;
+    reservedForSystem = 1500;
+    reservedForTools = 2000;
+    provider;
+    constructor(model, provider) {
+        this.contextWindow = (0, registry_1.getModelInfo)(model).contextWindow;
+        this.provider = provider;
+    }
+    /** Set the provider (for LLM-powered compaction) */
+    setProvider(provider) {
+        this.provider = provider;
+    }
+    /** Conservative token estimate: ~3.5 chars per token */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 3.5);
+    }
+    /** Tokens available for conversation messages */
+    availableTokens() {
+        return this.contextWindow - this.reservedForOutput - this.reservedForSystem - this.reservedForTools;
+    }
+    /** Check if messages fit within budget */
+    fitsInBudget(messages) {
+        const total = messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+        return total <= this.availableTokens();
+    }
+    /** Compact conversation by dropping old messages and inserting a summary placeholder */
+    compact(messages, force = false) {
+        if (!force && this.fitsInBudget(messages))
+            return messages;
+        const system = messages[0]?.role === 'system' ? messages[0] : null;
+        const rest = system ? messages.slice(1) : [...messages];
+        // Keep recent messages that fit within 80% of budget
+        const kept = [];
+        let tokenCount = 0;
+        const budget = this.availableTokens();
+        for (let i = rest.length - 1; i >= 0; i--) {
+            const msgTokens = this.estimateTokens(rest[i].content);
+            if (tokenCount + msgTokens > budget * 0.8)
+                break;
+            kept.unshift(rest[i]);
+            tokenCount += msgTokens;
+        }
+        const dropped = rest.length - kept.length;
+        if (dropped > 0) {
+            kept.unshift({
+                role: 'system',
+                content: `[${dropped} earlier messages compacted. The conversation has been ongoing — continue from the recent messages below.]`,
+            });
+        }
+        if (system)
+            kept.unshift(system);
+        return kept;
+    }
+    /** Smart compaction: use LLM to summarize dropped messages instead of just discarding */
+    async compactWithSummary(messages) {
+        const system = messages[0]?.role === 'system' ? messages[0] : null;
+        const rest = system ? messages.slice(1) : [...messages];
+        // Determine which messages to keep vs summarize
+        const kept = [];
+        let tokenCount = 0;
+        const budget = this.availableTokens();
+        for (let i = rest.length - 1; i >= 0; i--) {
+            const msgTokens = this.estimateTokens(rest[i].content);
+            if (tokenCount + msgTokens > budget * 0.8)
+                break;
+            kept.unshift(rest[i]);
+            tokenCount += msgTokens;
+        }
+        const droppedCount = rest.length - kept.length;
+        if (droppedCount === 0) {
+            return { messages, summary: '' };
+        }
+        const dropped = rest.slice(0, droppedCount);
+        let summary = `[${droppedCount} earlier messages compacted.]`;
+        // Try LLM summarization
+        if (this.provider) {
+            try {
+                summary = await this.summarizeMessages(dropped);
+            }
+            catch {
+                // Fall back to simple compaction
+            }
+        }
+        kept.unshift({ role: 'system', content: summary });
+        if (system)
+            kept.unshift(system);
+        return { messages: kept, summary };
+    }
+    async summarizeMessages(messages) {
+        if (!this.provider) {
+            throw new Error('No provider for summarization');
+        }
+        // Build a condensed version of the conversation for summarization
+        const convoText = messages
+            .filter(m => m.role !== 'system')
+            .map(m => {
+            if (m.role === 'tool') {
+                const result = m.content.length > 200 ? m.content.substring(0, 200) + '...' : m.content;
+                return `[Tool result]: ${result}`;
+            }
+            if (m.role === 'assistant' && m.tool_calls?.length) {
+                const tools = m.tool_calls.map(tc => tc.function.name).join(', ');
+                const text = m.content ? m.content.substring(0, 200) : '';
+                return `Assistant: ${text}\n[Used tools: ${tools}]`;
+            }
+            return `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content.substring(0, 500)}`;
+        })
+            .join('\n');
+        // Keep summary request short to minimize cost
+        const summaryPrompt = [
+            {
+                role: 'system',
+                content: 'Summarize this conversation excerpt in 2-4 sentences. Focus on: what was discussed, what actions were taken, what was decided, and any important context for continuing the conversation. Be specific about file names, functions, and technical details.',
+            },
+            { role: 'user', content: convoText },
+        ];
+        let summaryText = '';
+        for await (const event of this.provider.chat(summaryPrompt)) {
+            if (event.type === 'text' && event.text) {
+                summaryText += event.text;
+            }
+        }
+        if (!summaryText.trim()) {
+            return `[${messages.length} earlier messages compacted.]`;
+        }
+        return `[Conversation summary: ${summaryText.trim()}]`;
+    }
+    getContextWindow() {
+        return this.contextWindow;
+    }
+}
+exports.ContextManager = ContextManager;
+//# sourceMappingURL=manager.js.map

package/dist/context/repo-map.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build a lightweight repo map (~200-500 tokens) to give the model project awareness.
+ */
+export declare function buildRepoMap(rootDir: string): string;
+//# sourceMappingURL=repo-map.d.ts.map