notsleep 1.0.0

package/dist/index.js

@@ -0,0 +1,882 @@
+#!/usr/bin/env node
+"use strict";
+// ============================================================
+// NotSleep - CLI Entry Point
+// ============================================================
+//
+// Two modes:
+//   notsleep                 → Interactive REPL (like OpenCode)
+//   notsleep "Build an API"  → One-shot autonomous agent
+//
+// ============================================================
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./config");
+const agent_1 = require("./agent");
+const logger_1 = require("./logger");
+const dashboard_1 = require("./dashboard");
+const context_1 = require("./context");
+const checkpoint_1 = require("./checkpoint");
+const provider_1 = require("./provider");
+const types_1 = require("./types");
+const init_1 = require("./init");
+const fileconfig_1 = require("./fileconfig");
+const parallel_1 = require("./parallel");
+const registry_1 = require("./registry");
+const modelsdev_1 = require("./modelsdev");
+const schema_1 = require("./schema");
+const path = __importStar(require("path"));
+const VERSION = '1.0.0';
+const BANNER = `
+${chalk_1.default.bold.cyan('╔══════════════════════════════════════════════════════════╗')}
+${chalk_1.default.bold.cyan('║')}  ${chalk_1.default.bold.white('NotSleep')} - Long Horizon Autonomous AI Agent           ${chalk_1.default.bold.cyan('║')}
+${chalk_1.default.bold.cyan('║')}  ${chalk_1.default.dim('"Do not stop until I woke up"')}                          ${chalk_1.default.bold.cyan('║')}
+${chalk_1.default.bold.cyan('║')}  ${chalk_1.default.dim(`v${VERSION} | OpenAI + Anthropic Compatible`)}                ${chalk_1.default.bold.cyan('║')}
+${chalk_1.default.bold.cyan('╚══════════════════════════════════════════════════════════╝')}
+`;
+const HELP_TEXT = `
+${chalk_1.default.bold('Commands:')}
+  ${chalk_1.default.cyan('/help')}          Show this help
+  ${chalk_1.default.cyan('/run <task>')}    Run agent on a task (autonomous, long-horizon)
+  ${chalk_1.default.cyan('/status')}        Show agent status & stats
+  ${chalk_1.default.cyan('/context')}       Show detected project context
+  ${chalk_1.default.cyan('/config')}        Show resolved configuration & sources
+  ${chalk_1.default.cyan('/checkpoints')}   List saved checkpoints you can resume from
+  ${chalk_1.default.cyan('/resume [task]')} Resume the latest checkpoint (autonomous)
+  ${chalk_1.default.cyan('/clear')}         Clear conversation history
+  ${chalk_1.default.cyan('/model')}         Show current model info
+  ${chalk_1.default.cyan('/exit')}          Exit NotSleep
+
+${chalk_1.default.dim('Or just type normally to chat with the AI.')}
+${chalk_1.default.dim('The AI can see your project files and run commands.')}
+`;
+async function main() {
+    const program = new commander_1.Command();
+    // ── Subcommand: init ──
+    program
+        .command('init')
+        .description('Create a notsleep.json config file (interactive wizard)')
+        .option('-g, --global', 'Write to the global config (~/.notsleep/config.json)', false)
+        .option('-y, --yes', 'Skip prompts and write defaults', false)
+        .action(async (opts) => {
+        console.log(BANNER);
+        await (0, init_1.runInit)({ global: opts.global, yes: opts.yes });
+        process.exit(0);
+    });
+    // ── Subcommand: config ──
+    program
+        .command('config')
+        .description('Show the resolved configuration and where it came from')
+        .action(async () => {
+        console.log(BANNER);
+        // Refresh live model metadata so the shown context limit is accurate.
+        await (0, modelsdev_1.ensureModelCatalog)({ log: (m) => console.log(chalk_1.default.dim(`  ${m}`)) });
+        await showConfig();
+        process.exit(0);
+    });
+    program
+        .command('schema')
+        .description('Write the notsleep.json JSON Schema to disk (for IDE autocomplete)')
+        .option('-o, --out <path>', 'Output path', schema_1.DEFAULT_SCHEMA_FILENAME)
+        .action(async (options) => {
+        const written = (0, schema_1.writeSchemaFile)(options.out);
+        console.log(chalk_1.default.green(`  JSON Schema written to ${written}`));
+        console.log(chalk_1.default.dim(`  Reference it in notsleep.json:  "$schema": "./${schema_1.DEFAULT_SCHEMA_FILENAME}"`));
+        process.exit(0);
+    });
+    program
+        .name('notsleep')
+        .version(VERSION)
+        .description('Long-horizon autonomous AI agent. Interactive REPL or one-shot mode.')
+        .argument('[task...]', 'Task description. If omitted, starts interactive mode.')
+        .option('-p, --provider <provider>', 'LLM provider: openai or anthropic (default: openai, or from config)')
+        .option('-m, --model <model>', 'Model to use (overrides .env). Accepts provider/model, e.g. groq/llama-3.3-70b')
+        .option('--small-model <model>', 'Cheaper model for internal calls (summarize, task-gen). provider/model or a bare id')
+        .option('--resume', 'Resume from the latest checkpoint', false)
+        .option('--task-file <path>', 'Read the task description from a file')
+        .option('--max-iterations <n>', 'Maximum iterations (default: 1000; use 0 for unlimited)')
+        .option('--unlimited', 'Run with no iteration cap (same as --max-iterations 0)', false)
+        .option('--max-iterations-per-task <n>', 'Auto-advance to the next queued task after N iterations on one task (0 = no cap)')
+        .option('--context-limit <n>', 'Context window token limit (default: 120000, or from config)')
+        .option('--verbose', 'Enable verbose/debug logging', false)
+        .option('--openai-key <key>', 'OpenAI API key (overrides .env)')
+        .option('--anthropic-key <key>', 'Anthropic API key (overrides .env)')
+        .option('--base-url <url>', 'Custom API base URL')
+        .option('--system-prompt <prompt>', 'Custom system prompt')
+        .option('--system-prompt-file <path>', 'Read system prompt from a file')
+        .option('-c, --continuous', 'Continuous mode: keep picking up new tasks', false)
+        .option('--stop-file <path>', 'File path that signals the agent to stop')
+        .option('--max-cost <usd>', 'Stop when estimated cost exceeds this USD budget (e.g. 5.00)')
+        .option('--auto-commit', 'Create a local git commit after each completed task (never pushes)', false)
+        .option('--parallel <n>', 'Run tasks concurrently (n at a time), each in an isolated git worktree/branch')
+        .option('--tasks-file <path>', 'File with one task per line (used with --parallel)')
+        .option('--merge', 'After --parallel, merge each successful task branch back into the current branch', false)
+        .option('--no-cleanup', 'Keep task worktree directories after a --parallel run (for debugging)')
+        .option('--ui', 'Enable web dashboard UI', false)
+        .option('--port <port>', 'Dashboard port')
+        .option('--host <host>', 'Dashboard bind address (default 127.0.0.1; use 0.0.0.0 to expose to your network)')
+        .action(async (taskArgs, options) => {
+        console.log(BANNER);
+        // Sync live model metadata (context window + pricing) from models.dev
+        // BEFORE building config, so the context-window limit is auto-detected
+        // from the real model window rather than the static fallback table.
+        await (0, modelsdev_1.ensureModelCatalog)({
+            log: options.verbose ? (m) => console.log(chalk_1.default.dim(`  ${m}`)) : undefined,
+        });
+        // Build config
+        const config = buildConfig(options);
+        // Layer 2: if the catalog didn't know this model (static fallback), ask
+        // the provider's own /models endpoint for the real context window.
+        await refineContextLimitFromEndpoint(config, options.verbose);
+        // Determine mode
+        let taskDescription = '';
+        if (options.taskFile) {
+            try {
+                taskDescription = fs.readFileSync(options.taskFile, 'utf-8').trim();
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(`Error reading task file: ${err.message}`));
+                process.exit(1);
+            }
+        }
+        else if (taskArgs.length > 0) {
+            taskDescription = taskArgs.join(' ');
+        }
+        if (options.parallel) {
+            // ─── Parallel Mode ──────────────────────────────
+            await runParallel(config, options);
+        }
+        else if (taskDescription || options.resume) {
+            // ─── One-Shot Mode ──────────────────────────────
+            await runOneShot(config, taskDescription, options);
+        }
+        else {
+            // ─── Interactive REPL Mode ──────────────────────
+            await runInteractive(config, options);
+        }
+    });
+    await program.parseAsync(process.argv);
+}
+// ─────────────────────────────────────────────────────────────
+// Config Builder
+// ─────────────────────────────────────────────────────────────
+function buildConfig(options) {
+    const overrides = {};
+    if (options.provider)
+        overrides.provider = options.provider;
+    if (options.openaiKey)
+        overrides.openai = { apiKey: options.openaiKey };
+    if (options.anthropicKey)
+        overrides.anthropic = { apiKey: options.anthropicKey };
+    // Resolve the EFFECTIVE provider so --model / --base-url land on the right
+    // block. Priority mirrors config.ts: CLI flag > file config > env > default.
+    // We must NOT assume 'openai' here — that would misroute overrides when the
+    // active provider comes from notsleep.json or the environment.
+    const { config: fileCfg } = (0, fileconfig_1.loadFileConfig)();
+    const effectiveProvider = (options.provider ||
+        fileCfg.provider ||
+        process.env.NOTSLEEP_PROVIDER ||
+        'openai');
+    if (options.model) {
+        if ((0, registry_1.isModelRef)(options.model)) {
+            // Unified "provider/model" registry selector (e.g. groq/llama-3.3-70b).
+            // Resolved against the provider registry in loadConfig().
+            overrides.model = options.model;
+        }
+        else if (effectiveProvider === 'anthropic') {
+            overrides.anthropic = { ...overrides.anthropic, model: options.model };
+        }
+        else {
+            overrides.openai = { ...overrides.openai, model: options.model };
+        }
+    }
+    // Small model ref (provider/model or bare id) — resolved in loadConfig().
+    if (options.smallModel)
+        overrides.smallModelRef = options.smallModel;
+    if (options.baseUrl) {
+        if (effectiveProvider === 'anthropic') {
+            overrides.anthropic = { ...overrides.anthropic, baseURL: options.baseUrl };
+        }
+        else {
+            overrides.openai = { ...overrides.openai, baseURL: options.baseUrl };
+        }
+    }
+    if (options.unlimited) {
+        overrides.maxIterations = 0; // 0 = unlimited
+    }
+    else if (options.maxIterations !== undefined) {
+        overrides.maxIterations = parseInt(options.maxIterations, 10);
+    }
+    if (options.maxIterationsPerTask !== undefined) {
+        overrides.maxIterationsPerTask = parseInt(options.maxIterationsPerTask, 10);
+    }
+    if (options.contextLimit)
+        overrides.contextWindowLimit = parseInt(options.contextLimit, 10);
+    if (options.systemPromptFile) {
+        try {
+            overrides.systemPrompt = fs.readFileSync(options.systemPromptFile, 'utf-8').trim();
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`Error reading system prompt file: ${err.message}`));
+            process.exit(1);
+        }
+    }
+    else if (options.systemPrompt) {
+        overrides.systemPrompt = options.systemPrompt;
+    }
+    if (options.continuous)
+        overrides.continuous = true;
+    if (options.stopFile)
+        overrides.stopFile = options.stopFile;
+    if (options.autoCommit)
+        overrides.autoCommit = true;
+    if (options.maxCost) {
+        const c = parseFloat(options.maxCost);
+        if (!isNaN(c) && c > 0)
+            overrides.maxCostUsd = c;
+    }
+    try {
+        return (0, config_1.loadConfig)(overrides);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`Configuration error: ${err.message}`));
+        process.exit(1);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// One-Shot Mode (autonomous agent, like before)
+// ─────────────────────────────────────────────────────────────
+async function runOneShot(config, taskDescription, options) {
+    const logLevel = options.verbose ? logger_1.LogLevel.DEBUG : logger_1.LogLevel.INFO;
+    const logger = new logger_1.Logger(config.logDir, logLevel);
+    printConfigWarnings();
+    // Detect project context
+    const ctx = (0, context_1.detectProjectContext)();
+    logger.info(`Project: ${chalk_1.default.bold(ctx.language)} / ${chalk_1.default.bold(ctx.framework)}`);
+    logger.info(`Provider: ${chalk_1.default.bold(getProviderLabel(config))} | Model: ${chalk_1.default.bold(getModelName(config))}`);
+    logger.info(`Mode: ${chalk_1.default.bold(config.continuous ? 'CONTINUOUS' : 'SINGLE TASK')}`);
+    if (ctx.gitBranch) {
+        logger.info(`Git: ${chalk_1.default.bold(ctx.gitBranch)}${ctx.gitDirty ? chalk_1.default.yellow(' (dirty)') : chalk_1.default.green(' (clean)')}`);
+    }
+    // Inject project context into system prompt
+    config.systemPrompt += `\n\nPROJECT CONTEXT:\n${ctx.summary}`;
+    // Create agent
+    const agent = new agent_1.Agent(config, logger);
+    // Start dashboard if --ui flag OR enabled in config
+    let dashboard = null;
+    if (options.ui || config.dashboard.enabled) {
+        const port = options.port ? parseInt(options.port, 10) : config.dashboard.port;
+        dashboard = new dashboard_1.DashboardServer(port, logger, options.host || '127.0.0.1');
+        agent.setDashboard(dashboard);
+        try {
+            await dashboard.start();
+            logger.separator();
+            console.log(chalk_1.default.bold.green(`  Dashboard: http://localhost:${port}`));
+            logger.separator();
+        }
+        catch (err) {
+            logger.error(`Failed to start dashboard: ${err.message}`);
+        }
+    }
+    // Run
+    const result = await agent.run(taskDescription, options.resume);
+    if (dashboard)
+        await dashboard.stop();
+    if (result.success) {
+        console.log(chalk_1.default.green.bold(`\n  Task completed! (${result.stats.tasksCompleted} task(s))`));
+        console.log(chalk_1.default.white(result.summary));
+        process.exit(0);
+    }
+    else {
+        console.log(chalk_1.default.yellow.bold('\n  Task did not complete.'));
+        console.log(chalk_1.default.white(result.summary));
+        console.log(chalk_1.default.dim('  Use --resume to continue from the last checkpoint.'));
+        process.exit(1);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Parallel Mode (multiple tasks concurrently, isolated worktrees)
+// ─────────────────────────────────────────────────────────────
+async function runParallel(config, options) {
+    const logLevel = options.verbose ? logger_1.LogLevel.DEBUG : logger_1.LogLevel.INFO;
+    const logger = new logger_1.Logger(config.logDir, logLevel);
+    printConfigWarnings();
+    const concurrency = parseInt(options.parallel, 10);
+    if (!Number.isFinite(concurrency) || concurrency < 1) {
+        console.error(chalk_1.default.red('--parallel needs a positive integer (e.g. --parallel 3).'));
+        process.exit(1);
+    }
+    // Gather tasks: one per line from --tasks-file.
+    let tasks = [];
+    if (options.tasksFile) {
+        let raw = '';
+        try {
+            raw = fs.readFileSync(options.tasksFile, 'utf-8');
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`Error reading tasks file: ${err.message}`));
+            process.exit(1);
+        }
+        tasks = raw
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith('#'))
+            .map((description, i) => ({ id: `task-${i + 1}`, description }));
+    }
+    if (tasks.length === 0) {
+        console.error(chalk_1.default.red('No tasks found. Provide --tasks-file <path> with one task per line.'));
+        process.exit(1);
+    }
+    logger.info(`Loaded ${tasks.length} task(s) for parallel execution.`);
+    const runner = new parallel_1.ParallelRunner(process.cwd(), logger);
+    // Each task runs the built one-shot CLI as a child process, in its worktree.
+    // Forward the safety/limit flags so child agents behave like this invocation.
+    const cliEntry = path.resolve(__dirname, 'index.js');
+    const forwarded = [];
+    if (options.maxIterations !== undefined)
+        forwarded.push('--max-iterations', String(options.maxIterations));
+    if (options.unlimited)
+        forwarded.push('--unlimited');
+    if (options.maxCost !== undefined)
+        forwarded.push('--max-cost', String(options.maxCost));
+    if (options.autoCommit)
+        forwarded.push('--auto-commit');
+    if (options.provider)
+        forwarded.push('--provider', String(options.provider));
+    if (options.model)
+        forwarded.push('--model', String(options.model));
+    if (options.smallModel)
+        forwarded.push('--small-model', String(options.smallModel));
+    const taskRunner = (0, parallel_1.spawnAgentInWorktree)(process.execPath, cliEntry, forwarded, logger);
+    let outcomes;
+    try {
+        outcomes = await runner.run(tasks, taskRunner, {
+            concurrency,
+            merge: options.merge === true,
+            cleanup: options.cleanup !== false, // commander sets cleanup=false for --no-cleanup
+        });
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`Parallel run could not start: ${err.message}`));
+        process.exit(1);
+    }
+    // Summary
+    console.log('');
+    logger.separator();
+    console.log(chalk_1.default.bold('  Parallel run summary:'));
+    for (const o of outcomes) {
+        const status = o.ok ? chalk_1.default.green('ok') : chalk_1.default.red('failed');
+        const mergeNote = o.merged ? chalk_1.default.green(' merged') : o.conflict ? chalk_1.default.yellow(' conflict (kept branch)') : '';
+        console.log(`    [${status}] ${o.task.id}  ->  ${o.branch}${mergeNote}`);
+        if (o.error)
+            console.log(chalk_1.default.dim(`         ${o.error}`));
+    }
+    logger.separator();
+    const failed = outcomes.filter((o) => !o.ok).length;
+    process.exit(failed > 0 ? 1 : 0);
+}
+// ─────────────────────────────────────────────────────────────
+// Interactive REPL Mode (like OpenCode)
+// ─────────────────────────────────────────────────────────────
+async function runInteractive(config, options) {
+    const logLevel = options.verbose ? logger_1.LogLevel.DEBUG : logger_1.LogLevel.INFO;
+    const logger = new logger_1.Logger(config.logDir, logLevel);
+    // Detect project context
+    const ctx = (0, context_1.detectProjectContext)();
+    printConfigWarnings();
+    // Show project info
+    console.log(chalk_1.default.dim('  Scanning project...'));
+    console.log(`  ${chalk_1.default.bold('Project:')}   ${ctx.language} / ${ctx.framework}`);
+    console.log(`  ${chalk_1.default.bold('Provider:')}  ${getProviderLabel(config)} / ${getModelName(config)}`);
+    if (ctx.gitBranch) {
+        console.log(`  ${chalk_1.default.bold('Git:')}       ${ctx.gitBranch}${ctx.gitDirty ? chalk_1.default.yellow(' (dirty)') : chalk_1.default.green(' (clean)')}`);
+    }
+    console.log(`  ${chalk_1.default.bold('CWD:')}       ${ctx.cwd}`);
+    console.log('');
+    console.log(chalk_1.default.dim('  Type a message to chat, /run <task> for autonomous mode, /help for commands.'));
+    console.log('');
+    // Build provider for direct chat
+    const provider = new provider_1.LLMProvider(config, logger);
+    // Inject project context into system prompt
+    const systemPrompt = config.systemPrompt +
+        `\n\nPROJECT CONTEXT:\n${ctx.summary}` +
+        `\n\nYou are in INTERACTIVE mode. The user is chatting with you directly. ` +
+        `You can use tools to help them. Be concise but helpful. ` +
+        `If they ask you to do something complex, use tools step by step.`;
+    // Conversation history
+    const messages = [
+        { role: 'system', content: systemPrompt },
+    ];
+    // Tools (from the agent's built-in tools + any user-defined custom tools)
+    const { createBuiltinTools, createCustomTools } = require('./tools');
+    const taskQueue = [];
+    const tools = createBuiltinTools(logger, config.toolTimeoutMs, taskQueue, process.cwd());
+    const customTools = createCustomTools(config.customTools, logger, config.toolTimeoutMs);
+    if (customTools.length > 0)
+        tools.push(...customTools);
+    // Remove task_complete from interactive mode - not needed
+    const interactiveTools = tools.filter((t) => t.name !== 'task_complete');
+    // Real prompt-token count from the API's last reply (0 until the first call),
+    // so /status reports the true context size instead of a chars/4 guess.
+    let lastPromptTokens = 0;
+    const chatTracked = async (msgs, toolsArg) => {
+        const r = await provider.chat(msgs, toolsArg);
+        if (r.usage && r.usage.prompt_tokens > 0)
+            lastPromptTokens = r.usage.prompt_tokens;
+        return r;
+    };
+    // Readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk_1.default.cyan('you > '),
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        // ── Slash Commands ──
+        if (input.startsWith('/')) {
+            const [cmd, ...args] = input.split(' ');
+            switch (cmd) {
+                case '/help':
+                    console.log(HELP_TEXT);
+                    break;
+                case '/exit':
+                case '/quit':
+                    console.log(chalk_1.default.dim('  Goodbye!'));
+                    process.exit(0);
+                    break; // unreachable (process.exit), but makes the fallthrough explicit
+                case '/clear':
+                    messages.length = 0;
+                    messages.push({ role: 'system', content: systemPrompt });
+                    console.log(chalk_1.default.dim('  Conversation cleared.'));
+                    break;
+                case '/context':
+                    console.log(chalk_1.default.dim('─'.repeat(60)));
+                    console.log(ctx.summary);
+                    console.log(chalk_1.default.dim('─'.repeat(60)));
+                    break;
+                case '/model':
+                    console.log(`  Provider: ${chalk_1.default.bold(config.provider)}`);
+                    console.log(`  Model:    ${chalk_1.default.bold(getModelName(config))}`);
+                    console.log(`  Context:  ${chalk_1.default.bold(config.contextWindowLimit.toLocaleString())} tokens`);
+                    break;
+                case '/config':
+                    await showConfig();
+                    break;
+                case '/status':
+                    console.log(`  Messages in context: ${chalk_1.default.bold(String(messages.length))}`);
+                    if (lastPromptTokens > 0) {
+                        console.log(`  Context tokens:      ${chalk_1.default.bold(lastPromptTokens.toLocaleString())} ${chalk_1.default.dim('(from API)')}`);
+                    }
+                    else {
+                        const estimatedTokens = Math.round(messages.reduce((sum, m) => sum + (m.content?.length || 0), 0) / 4);
+                        console.log(`  Context tokens:      ${chalk_1.default.bold('~' + estimatedTokens.toLocaleString())} ${chalk_1.default.dim('(estimated, no API call yet)')}`);
+                    }
+                    console.log(`  Tasks in queue:      ${chalk_1.default.bold(String(taskQueue.length))}`);
+                    break;
+                case '/run': {
+                    const task = args.join(' ');
+                    if (!task) {
+                        console.log(chalk_1.default.red('  Usage: /run <task description>'));
+                        break;
+                    }
+                    console.log(chalk_1.default.dim(`  Starting autonomous agent for: "${task}"...`));
+                    console.log(chalk_1.default.dim('  Press Ctrl+C to interrupt.\n'));
+                    // Run as autonomous agent
+                    const agentConfig = { ...config };
+                    agentConfig.systemPrompt += `\n\nPROJECT CONTEXT:\n${ctx.summary}`;
+                    const agentLogger = new logger_1.Logger(config.logDir, logLevel);
+                    const agent = new agent_1.Agent(agentConfig, agentLogger);
+                    // Start dashboard if --ui flag OR enabled in config
+                    let dashboard = null;
+                    if (options.ui || config.dashboard.enabled) {
+                        const port = options.port ? parseInt(options.port, 10) : config.dashboard.port;
+                        dashboard = new dashboard_1.DashboardServer(port, agentLogger, options.host || '127.0.0.1');
+                        agent.setDashboard(dashboard);
+                        try {
+                            await dashboard.start();
+                            console.log(chalk_1.default.bold.green(`  Dashboard: http://localhost:${port}\n`));
+                        }
+                        catch { /* ignore */ }
+                    }
+                    const result = await agent.run(task, false);
+                    if (dashboard)
+                        await dashboard.stop();
+                    if (result.success) {
+                        console.log(chalk_1.default.green.bold(`\n  Task completed! (${result.stats.tasksCompleted} task(s))`));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow.bold('\n  Task did not complete.'));
+                    }
+                    console.log(chalk_1.default.white('  ' + result.summary.substring(0, 300)));
+                    console.log('');
+                    break;
+                }
+                case '/checkpoints': {
+                    const mgr = new checkpoint_1.CheckpointManager(config.checkpointDir, new logger_1.Logger(config.logDir, logger_1.LogLevel.ERROR));
+                    const list = mgr.list();
+                    if (list.length === 0) {
+                        console.log(chalk_1.default.dim('  No checkpoints found. They are created automatically while an agent runs.'));
+                    }
+                    else {
+                        console.log(chalk_1.default.bold(`  ${list.length} checkpoint(s) (newest first):`));
+                        for (const cp of list) {
+                            console.log(`    ${chalk_1.default.cyan(cp.timestamp)}  iteration ${chalk_1.default.bold(String(cp.iteration))}`);
+                        }
+                        console.log(chalk_1.default.dim('  Use /resume to continue from the latest checkpoint.'));
+                    }
+                    break;
+                }
+                case '/resume': {
+                    const mgr = new checkpoint_1.CheckpointManager(config.checkpointDir, new logger_1.Logger(config.logDir, logger_1.LogLevel.ERROR));
+                    const latest = mgr.loadLatest();
+                    if (!latest) {
+                        console.log(chalk_1.default.yellow('  No checkpoint to resume from.'));
+                        break;
+                    }
+                    const task = args.join(' ') || latest.taskDescription;
+                    console.log(chalk_1.default.dim(`  Resuming from checkpoint at iteration ${latest.iteration}...`));
+                    console.log(chalk_1.default.dim(`  Task: ${task.substring(0, 100)}`));
+                    console.log(chalk_1.default.dim('  Press Ctrl+C to interrupt.\n'));
+                    const agentConfig = { ...config };
+                    agentConfig.systemPrompt += `\n\nPROJECT CONTEXT:\n${ctx.summary}`;
+                    const agentLogger = new logger_1.Logger(config.logDir, logLevel);
+                    const agent = new agent_1.Agent(agentConfig, agentLogger);
+                    let dashboard = null;
+                    if (options.ui || config.dashboard.enabled) {
+                        const port = options.port ? parseInt(options.port, 10) : config.dashboard.port;
+                        dashboard = new dashboard_1.DashboardServer(port, agentLogger, options.host || '127.0.0.1');
+                        agent.setDashboard(dashboard);
+                        try {
+                            await dashboard.start();
+                            console.log(chalk_1.default.bold.green(`  Dashboard: http://localhost:${port}\n`));
+                        }
+                        catch { /* ignore */ }
+                    }
+                    const result = await agent.run(task, true); // resume=true
+                    if (dashboard)
+                        await dashboard.stop();
+                    if (result.success) {
+                        console.log(chalk_1.default.green.bold(`\n  Task completed! (${result.stats.tasksCompleted} task(s))`));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow.bold('\n  Task did not complete.'));
+                    }
+                    console.log(chalk_1.default.white('  ' + result.summary.substring(0, 300)));
+                    console.log('');
+                    break;
+                }
+                default:
+                    console.log(chalk_1.default.red(`  Unknown command: ${cmd}. Type /help for available commands.`));
+            }
+            rl.prompt();
+            return;
+        }
+        // ── Normal Chat ──
+        messages.push({ role: 'user', content: input });
+        // Show thinking indicator
+        process.stdout.write(chalk_1.default.dim('  thinking...'));
+        try {
+            // Call LLM
+            const response = await chatTracked(messages, interactiveTools);
+            // Clear thinking indicator
+            process.stdout.write('\r' + ' '.repeat(30) + '\r');
+            // Handle tool calls
+            if (response.tool_calls.length > 0) {
+                // Add assistant message with tool calls
+                messages.push({
+                    role: 'assistant',
+                    content: response.content || '',
+                    tool_calls: response.tool_calls,
+                });
+                if (response.content) {
+                    console.log(chalk_1.default.green('  ai > ') + response.content);
+                }
+                // Execute tools
+                for (const tc of response.tool_calls) {
+                    const tool = interactiveTools.find((t) => t.name === tc.function.name);
+                    if (!tool) {
+                        console.log(chalk_1.default.red(`  Unknown tool: ${tc.function.name}`));
+                        messages.push({ role: 'tool', tool_call_id: tc.id, content: 'Unknown tool' });
+                        continue;
+                    }
+                    let args;
+                    try {
+                        args = JSON.parse(tc.function.arguments);
+                    }
+                    catch {
+                        messages.push({ role: 'tool', tool_call_id: tc.id, content: 'Invalid JSON arguments' });
+                        continue;
+                    }
+                    console.log(chalk_1.default.magenta(`  [${tc.function.name}]`) + chalk_1.default.dim(` ${JSON.stringify(args).substring(0, 100)}`));
+                    try {
+                        const result = await tool.execute(args);
+                        messages.push({ role: 'tool', tool_call_id: tc.id, content: result });
+                        // Show truncated result
+                        const displayResult = result.length > 500 ? result.substring(0, 500) + '...' : result;
+                        console.log(chalk_1.default.dim('  ' + displayResult.split('\n').join('\n  ')));
+                    }
+                    catch (err) {
+                        messages.push({ role: 'tool', tool_call_id: tc.id, content: `Error: ${err.message}` });
+                        console.log(chalk_1.default.red(`  Error: ${err.message}`));
+                    }
+                }
+                // Get follow-up response after tool results
+                const followUp = await chatTracked(messages, interactiveTools);
+                // Always show the follow-up text, but only push a content-only
+                // assistant message when there are NO tool calls. If tool_calls are
+                // present, the loop below pushes the assistant message together with
+                // its tool_calls — pushing here too would duplicate the turn and
+                // orphan the text from its tool calls, corrupting the history.
+                if (followUp.content) {
+                    console.log('');
+                    console.log(chalk_1.default.green('  ai > ') + followUp.content);
+                    if (followUp.tool_calls.length === 0) {
+                        messages.push({ role: 'assistant', content: followUp.content });
+                    }
+                }
+                // Handle nested tool calls (up to 5 rounds)
+                let depth = 0;
+                let currentResponse = followUp;
+                while (currentResponse.tool_calls.length > 0 && depth < 5) {
+                    depth++;
+                    messages.push({
+                        role: 'assistant',
+                        content: currentResponse.content || '',
+                        tool_calls: currentResponse.tool_calls,
+                    });
+                    for (const tc of currentResponse.tool_calls) {
+                        const tool = interactiveTools.find((t) => t.name === tc.function.name);
+                        if (!tool) {
+                            messages.push({ role: 'tool', tool_call_id: tc.id, content: 'Unknown tool' });
+                            continue;
+                        }
+                        let args;
+                        try {
+                            args = JSON.parse(tc.function.arguments);
+                        }
+                        catch {
+                            args = {};
+                        }
+                        console.log(chalk_1.default.magenta(`  [${tc.function.name}]`) + chalk_1.default.dim(` ${JSON.stringify(args).substring(0, 100)}`));
+                        try {
+                            const result = await tool.execute(args);
+                            messages.push({ role: 'tool', tool_call_id: tc.id, content: result });
+                            const displayResult = result.length > 500 ? result.substring(0, 500) + '...' : result;
+                            console.log(chalk_1.default.dim('  ' + displayResult.split('\n').join('\n  ')));
+                        }
+                        catch (err) {
+                            messages.push({ role: 'tool', tool_call_id: tc.id, content: `Error: ${err.message}` });
+                        }
+                    }
+                    currentResponse = await chatTracked(messages, interactiveTools);
+                    // Same rule as above: only push content-only here. If this response
+                    // has tool_calls, the next loop iteration pushes it with them.
+                    if (currentResponse.content) {
+                        console.log('');
+                        console.log(chalk_1.default.green('  ai > ') + currentResponse.content);
+                        if (currentResponse.tool_calls.length === 0) {
+                            messages.push({ role: 'assistant', content: currentResponse.content });
+                        }
+                    }
+                }
+            }
+            else {
+                // Simple text response
+                messages.push({ role: 'assistant', content: response.content || '' });
+                console.log(chalk_1.default.green('  ai > ') + (response.content || ''));
+            }
+        }
+        catch (err) {
+            process.stdout.write('\r' + ' '.repeat(30) + '\r');
+            console.log(chalk_1.default.red(`  Error: ${err.message}`));
+        }
+        console.log('');
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log(chalk_1.default.dim('\n  Goodbye!'));
+        process.exit(0);
+    });
+}
+// ─────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────
+function getModelName(config) {
+    // When a unified "provider/model" selector is in use, show it verbatim
+    // (e.g. "groq/llama-3.3-70b-versatile") — that's what the user typed.
+    if ((0, registry_1.isModelRef)(config.model))
+        return config.model;
+    if (config.provider === 'openai')
+        return config.openai?.model || 'gpt-4o';
+    return config.anthropic?.model || 'claude-sonnet-4-20250514';
+}
+/** Display label for the active provider: registry name if set, else protocol. */
+function getProviderLabel(config) {
+    if ((0, registry_1.isModelRef)(config.model))
+        return config.model.slice(0, config.model.indexOf('/'));
+    return config.provider;
+}
+/**
+ * Layer 2 of the context-window sync: when the model wasn't found in the
+ * models.dev catalog (contextLimitSource === 'static') and the user didn't pin
+ * a limit, ask the provider's own OpenAI-style /models endpoint for the real
+ * context window. Useful for custom proxies (e.g. LimitRouter) and models the
+ * catalog doesn't list. Best-effort and quiet: any failure leaves the static
+ * fallback untouched. Skips native Anthropic (no baseURL / no /models).
+ */
+async function refineContextLimitFromEndpoint(config, verbose) {
+    if ((0, config_1.getConfigSources)().contextLimitSource !== 'static')
+        return;
+    const baseURL = config.provider === 'openai' ? config.openai?.baseURL : config.anthropic?.baseURL;
+    const apiKey = config.provider === 'openai' ? config.openai?.apiKey : config.anthropic?.apiKey;
+    const modelId = config.provider === 'openai' ? config.openai?.model : config.anthropic?.model;
+    if (!baseURL || !modelId)
+        return;
+    const live = await (0, modelsdev_1.fetchEndpointContextLimit)(baseURL, apiKey, modelId);
+    if (live && live > 0) {
+        config.contextWindowLimit = Math.floor(live * 0.9);
+        (0, config_1.markContextLimitSource)('endpoint');
+        if (verbose) {
+            console.log(chalk_1.default.dim(`  Context window ${live.toLocaleString()} tokens from ${baseURL}/models`));
+        }
+    }
+}
+/** Print any config warnings collected during loadConfig(). */
+function printConfigWarnings() {
+    const { warnings } = (0, config_1.getConfigSources)();
+    if (warnings.length > 0) {
+        console.log(chalk_1.default.yellow.bold('  Config warnings:'));
+        for (const w of warnings) {
+            console.log(chalk_1.default.yellow(`  ! ${w}`));
+        }
+        console.log('');
+    }
+}
+/** Mask a secret, showing only the last 4 chars. */
+function maskSecret(secret) {
+    if (!secret)
+        return chalk_1.default.red('(not set)');
+    if (secret.length <= 4)
+        return '****';
+    return '****' + secret.slice(-4);
+}
+/** Print the resolved config and its sources (for `notsleep config`). */
+async function showConfig() {
+    // Show config file locations first (before validation can throw).
+    const globalPath = (0, fileconfig_1.getGlobalConfigPath)();
+    const projectPath = (0, fileconfig_1.findProjectConfig)();
+    console.log(chalk_1.default.bold('  Config files:'));
+    console.log(`    Global:  ${fs.existsSync(globalPath) ? globalPath : chalk_1.default.dim(globalPath + ' (none)')}`);
+    console.log(`    Project: ${projectPath ? projectPath : chalk_1.default.dim('(none found)')}`);
+    console.log('');
+    let config;
+    try {
+        config = (0, config_1.loadConfig)();
+    }
+    catch (err) {
+        // loadConfig() ran far enough to populate (filtered) warnings — show them.
+        printConfigWarnings();
+        // Still show what we can even if validation fails.
+        console.log(chalk_1.default.yellow(`  Warning: ${err.message}`));
+        const { config: file } = (0, fileconfig_1.loadFileConfig)();
+        console.log('');
+        console.log(chalk_1.default.bold('  Partial config (from files/env):'));
+        console.log('    ' + JSON.stringify(file, null, 2).split('\n').join('\n    '));
+        return;
+    }
+    // Layer 2 endpoint fallback, same as a real run, so the shown limit matches.
+    await refineContextLimitFromEndpoint(config, false);
+    // Surface filtered config warnings (malformed env refs, missing active-provider vars).
+    printConfigWarnings();
+    const sources = (0, config_1.getConfigSources)();
+    const limitSourceLabel = sources.contextLimitSource === 'catalog' ? chalk_1.default.dim(' (models.dev)')
+        : sources.contextLimitSource === 'endpoint' ? chalk_1.default.dim(' (/models endpoint)')
+            : sources.contextLimitSource === 'explicit' ? chalk_1.default.dim(' (set)')
+                : chalk_1.default.dim(' (static table)');
+    const key = config.provider === 'openai' ? config.openai?.apiKey : config.anthropic?.apiKey;
+    console.log(chalk_1.default.bold('  Resolved configuration:'));
+    console.log(`    Provider:          ${chalk_1.default.cyan(getProviderLabel(config))}`);
+    console.log(`    Model:             ${chalk_1.default.cyan(getModelName(config))}`);
+    if (config.smallModel) {
+        console.log(`    Small model:       ${chalk_1.default.cyan(config.smallModel.model)} ${chalk_1.default.dim('(summarize / task-gen)')}`);
+    }
+    console.log(`    API key:           ${maskSecret(key || '')}`);
+    const baseURL = config.provider === 'openai' ? config.openai?.baseURL : config.anthropic?.baseURL;
+    if (baseURL)
+        console.log(`    Base URL:          ${baseURL}`);
+    console.log(`    Max iterations:    ${(0, types_1.isUnlimitedIterations)(config.maxIterations) ? 'unlimited' : config.maxIterations}`);
+    console.log(`    Max iter/task:     ${config.maxIterationsPerTask > 0 ? config.maxIterationsPerTask : 'no cap'}`);
+    console.log(`    Context limit:     ${config.contextWindowLimit.toLocaleString()} tokens${limitSourceLabel}`);
+    console.log(`    Summarize at:      ${Math.round(config.summarizeThreshold * 100)}%`);
+    console.log(`    Max retries:       ${config.maxRetries}`);
+    console.log(`    Tool timeout:      ${config.toolTimeoutMs}ms`);
+    console.log(`    Continuous mode:   ${config.continuous ? chalk_1.default.green('on') : chalk_1.default.dim('off')}`);
+    console.log(`    Max cost (USD):    ${config.maxCostUsd ? chalk_1.default.cyan('$' + config.maxCostUsd) : chalk_1.default.dim('no limit')}`);
+    console.log(`    Auto-commit:       ${config.autoCommit ? chalk_1.default.green('on (local commits per task)') : chalk_1.default.dim('off')}`);
+    console.log(`    Dashboard:         ${config.dashboard.enabled ? chalk_1.default.green(`on (port ${config.dashboard.port})`) : chalk_1.default.dim('off')}`);
+    console.log(`    Checkpoint dir:    ${config.checkpointDir}`);
+    console.log(`    Log dir:           ${config.logDir}`);
+    console.log(`    Stop file:         ${config.stopFile}`);
+    if (sources.instructionFiles.length > 0) {
+        console.log(`    Instructions:      ${chalk_1.default.cyan(sources.instructionFiles.join(', '))}`);
+    }
+    console.log('');
+    console.log(chalk_1.default.dim(`    .env loaded:       ${sources.envLoaded ? 'yes' : 'no'}`));
+    if (sources.fileConfigSources.length > 0) {
+        console.log(chalk_1.default.dim(`    Config sources:    ${sources.fileConfigSources.join(', ')}`));
+    }
+    console.log('');
+    console.log(chalk_1.default.dim('  Run "notsleep init" to create or update your config file.'));
+}
+// Run
+main().catch((err) => {
+    console.error(chalk_1.default.red(`Fatal error: ${err.message}`));
+    console.error(err.stack);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map