meetsoma 0.3.2 → 0.3.3

package/dist/main.js

@@ -1,806 +0,0 @@
-/**
- * Main entry point for the coding agent CLI.
- *
- * This file handles CLI argument parsing and translates them into
- * createAgentSession() options. The SDK does the heavy lifting.
- */
-import { resolve } from "node:path";
-import { modelsAreEqual, supportsXhigh } from "@mariozechner/pi-ai";
-import chalk from "chalk";
-import { createInterface } from "readline";
-import { parseArgs, printHelp } from "./cli/args.js";
-import { selectConfig } from "./cli/config-selector.js";
-import { processFileArguments } from "./cli/file-processor.js";
-import { buildInitialMessage } from "./cli/initial-message.js";
-import { listModels } from "./cli/list-models.js";
-import { selectSession } from "./cli/session-picker.js";
-import { APP_NAME, getAgentDir, getModelsPath, VERSION } from "./config.js";
-import { AgentSessionRuntimeHost, createAgentSessionRuntime, } from "./core/agent-session-runtime.js";
-import { AuthStorage } from "./core/auth-storage.js";
-import { exportFromFile } from "./core/export-html/index.js";
-import { migrateKeybindingsConfigFile } from "./core/keybindings.js";
-import { ModelRegistry } from "./core/model-registry.js";
-import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
-import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
-import { DefaultPackageManager } from "./core/package-manager.js";
-import { DefaultResourceLoader } from "./core/resource-loader.js";
-import { SessionManager } from "./core/session-manager.js";
-import { SettingsManager } from "./core/settings-manager.js";
-import { printTimings, resetTimings, time } from "./core/timings.js";
-import { allTools } from "./core/tools/index.js";
-import { runMigrations, showDeprecationWarnings } from "./migrations.js";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
-import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
-/**
- * Read all content from piped stdin.
- * Returns undefined if stdin is a TTY (interactive terminal).
- */
-async function readPipedStdin() {
-    // If stdin is a TTY, we're running interactively - don't read stdin
-    if (process.stdin.isTTY) {
-        return undefined;
-    }
-    return new Promise((resolve) => {
-        let data = "";
-        process.stdin.setEncoding("utf8");
-        process.stdin.on("data", (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on("end", () => {
-            resolve(data.trim() || undefined);
-        });
-        process.stdin.resume();
-    });
-}
-function reportSettingsErrors(settingsManager, context) {
-    const errors = settingsManager.drainErrors();
-    for (const { scope, error } of errors) {
-        console.error(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`));
-        if (error.stack) {
-            console.error(chalk.dim(error.stack));
-        }
-    }
-}
-function isTruthyEnvFlag(value) {
-    if (!value)
-        return false;
-    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
-}
-function getPackageCommandUsage(command) {
-    switch (command) {
-        case "install":
-            return `${APP_NAME} install <source> [-l]`;
-        case "remove":
-            return `${APP_NAME} remove <source> [-l]`;
-        case "update":
-            return `${APP_NAME} update [source]`;
-        case "list":
-            return `${APP_NAME} list`;
-    }
-}
-function printPackageCommandHelp(command) {
-    switch (command) {
-        case "install":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("install")}
-
-Install a package and add it to settings.
-
-Options:
-  -l, --local    Install project-locally (.pi/settings.json)
-
-Examples:
-  ${APP_NAME} install npm:@foo/bar
-  ${APP_NAME} install git:github.com/user/repo
-  ${APP_NAME} install git:git@github.com:user/repo
-  ${APP_NAME} install https://github.com/user/repo
-  ${APP_NAME} install ssh://git@github.com/user/repo
-  ${APP_NAME} install ./local/path
-`);
-            return;
-        case "remove":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("remove")}
-
-Remove a package and its source from settings.
-Alias: ${APP_NAME} uninstall <source> [-l]
-
-Options:
-  -l, --local    Remove from project settings (.pi/settings.json)
-
-Examples:
-  ${APP_NAME} remove npm:@foo/bar
-  ${APP_NAME} uninstall npm:@foo/bar
-`);
-            return;
-        case "update":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("update")}
-
-Update installed packages.
-If <source> is provided, only that package is updated.
-`);
-            return;
-        case "list":
-            console.log(`${chalk.bold("Usage:")}
-  ${getPackageCommandUsage("list")}
-
-List installed packages from user and project settings.
-`);
-            return;
-    }
-}
-function parsePackageCommand(args) {
-    const [rawCommand, ...rest] = args;
-    let command;
-    if (rawCommand === "uninstall") {
-        command = "remove";
-    }
-    else if (rawCommand === "install" || rawCommand === "remove" || rawCommand === "update" || rawCommand === "list") {
-        command = rawCommand;
-    }
-    if (!command) {
-        return undefined;
-    }
-    let local = false;
-    let help = false;
-    let invalidOption;
-    let source;
-    for (const arg of rest) {
-        if (arg === "-h" || arg === "--help") {
-            help = true;
-            continue;
-        }
-        if (arg === "-l" || arg === "--local") {
-            if (command === "install" || command === "remove") {
-                local = true;
-            }
-            else {
-                invalidOption = invalidOption ?? arg;
-            }
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            invalidOption = invalidOption ?? arg;
-            continue;
-        }
-        if (!source) {
-            source = arg;
-        }
-    }
-    return { command, source, local, help, invalidOption };
-}
-async function handlePackageCommand(args) {
-    const options = parsePackageCommand(args);
-    if (!options) {
-        return false;
-    }
-    if (options.help) {
-        printPackageCommandHelp(options.command);
-        return true;
-    }
-    if (options.invalidOption) {
-        console.error(chalk.red(`Unknown option ${options.invalidOption} for "${options.command}".`));
-        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getPackageCommandUsage(options.command)}".`));
-        process.exitCode = 1;
-        return true;
-    }
-    const source = options.source;
-    if ((options.command === "install" || options.command === "remove") && !source) {
-        console.error(chalk.red(`Missing ${options.command} source.`));
-        console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`));
-        process.exitCode = 1;
-        return true;
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "package command");
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    packageManager.setProgressCallback((event) => {
-        if (event.type === "start") {
-            process.stdout.write(chalk.dim(`${event.message}\n`));
-        }
-    });
-    try {
-        switch (options.command) {
-            case "install":
-                await packageManager.install(source, { local: options.local });
-                packageManager.addSourceToSettings(source, { local: options.local });
-                console.log(chalk.green(`Installed ${source}`));
-                return true;
-            case "remove": {
-                await packageManager.remove(source, { local: options.local });
-                const removed = packageManager.removeSourceFromSettings(source, { local: options.local });
-                if (!removed) {
-                    console.error(chalk.red(`No matching package found for ${source}`));
-                    process.exitCode = 1;
-                    return true;
-                }
-                console.log(chalk.green(`Removed ${source}`));
-                return true;
-            }
-            case "list": {
-                const globalSettings = settingsManager.getGlobalSettings();
-                const projectSettings = settingsManager.getProjectSettings();
-                const globalPackages = globalSettings.packages ?? [];
-                const projectPackages = projectSettings.packages ?? [];
-                if (globalPackages.length === 0 && projectPackages.length === 0) {
-                    console.log(chalk.dim("No packages installed."));
-                    return true;
-                }
-                const formatPackage = (pkg, scope) => {
-                    const source = typeof pkg === "string" ? pkg : pkg.source;
-                    const filtered = typeof pkg === "object";
-                    const display = filtered ? `${source} (filtered)` : source;
-                    console.log(`  ${display}`);
-                    const path = packageManager.getInstalledPath(source, scope);
-                    if (path) {
-                        console.log(chalk.dim(`    ${path}`));
-                    }
-                };
-                if (globalPackages.length > 0) {
-                    console.log(chalk.bold("User packages:"));
-                    for (const pkg of globalPackages) {
-                        formatPackage(pkg, "user");
-                    }
-                }
-                if (projectPackages.length > 0) {
-                    if (globalPackages.length > 0)
-                        console.log();
-                    console.log(chalk.bold("Project packages:"));
-                    for (const pkg of projectPackages) {
-                        formatPackage(pkg, "project");
-                    }
-                }
-                return true;
-            }
-            case "update":
-                await packageManager.update(source);
-                if (source) {
-                    console.log(chalk.green(`Updated ${source}`));
-                }
-                else {
-                    console.log(chalk.green("Updated packages"));
-                }
-                return true;
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown package command error";
-        console.error(chalk.red(`Error: ${message}`));
-        process.exitCode = 1;
-        return true;
-    }
-}
-async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
-    if (parsed.fileArgs.length === 0) {
-        return buildInitialMessage({ parsed, stdinContent });
-    }
-    const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
-    return buildInitialMessage({
-        parsed,
-        fileText: text,
-        fileImages: images,
-        stdinContent,
-    });
-}
-/**
- * Resolve a session argument to a file path.
- * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
- */
-async function resolveSessionPath(sessionArg, cwd, sessionDir) {
-    // If it looks like a file path, use as-is
-    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-        return { type: "path", path: sessionArg };
-    }
-    // Try to match as session ID in current project first
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatches = localSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (localMatches.length >= 1) {
-        return { type: "local", path: localMatches[0].path };
-    }
-    // Try global search across all projects
-    const allSessions = await SessionManager.listAll();
-    const globalMatches = allSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (globalMatches.length >= 1) {
-        const match = globalMatches[0];
-        return { type: "global", path: match.path, cwd: match.cwd };
-    }
-    // Not found anywhere
-    return { type: "not_found", arg: sessionArg };
-}
-/** Prompt user for yes/no confirmation */
-async function promptConfirm(message) {
-    return new Promise((resolve) => {
-        const rl = createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`${message} [y/N] `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-        });
-    });
-}
-/** Helper to call CLI-only session_directory handlers before the initial session manager is created */
-async function callSessionDirectoryHook(extensions, cwd) {
-    let customSessionDir;
-    for (const ext of extensions.extensions) {
-        const handlers = ext.handlers.get("session_directory");
-        if (!handlers || handlers.length === 0)
-            continue;
-        for (const handler of handlers) {
-            try {
-                const event = { type: "session_directory", cwd };
-                const result = (await handler(event));
-                if (result?.sessionDir) {
-                    customSessionDir = result.sessionDir;
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(chalk.red(`Extension "${ext.path}" session_directory handler failed: ${message}`));
-            }
-        }
-    }
-    return customSessionDir;
-}
-function validateForkFlags(parsed) {
-    if (!parsed.fork)
-        return;
-    const conflictingFlags = [
-        parsed.session ? "--session" : undefined,
-        parsed.continue ? "--continue" : undefined,
-        parsed.resume ? "--resume" : undefined,
-        parsed.noSession ? "--no-session" : undefined,
-    ].filter((flag) => flag !== undefined);
-    if (conflictingFlags.length > 0) {
-        console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
-        process.exit(1);
-    }
-}
-function forkSessionOrExit(sourcePath, cwd, sessionDir) {
-    try {
-        return SessionManager.forkFrom(sourcePath, cwd, sessionDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        process.exit(1);
-    }
-}
-async function createSessionManager(parsed, cwd, extensions, settingsManager) {
-    if (parsed.noSession) {
-        return SessionManager.inMemory();
-    }
-    // Priority: CLI flag > settings.json > extension hook
-    const effectiveSessionDir = parsed.sessionDir ?? settingsManager.getSessionDir() ?? (await callSessionDirectoryHook(extensions, cwd));
-    if (parsed.fork) {
-        const resolved = await resolveSessionPath(parsed.fork, cwd, effectiveSessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-            case "global":
-                return forkSessionOrExit(resolved.path, cwd, effectiveSessionDir);
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.session) {
-        const resolved = await resolveSessionPath(parsed.session, cwd, effectiveSessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-                return SessionManager.open(resolved.path, effectiveSessionDir);
-            case "global": {
-                // Session found in different project - ask user if they want to fork
-                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
-                const shouldFork = await promptConfirm("Fork this session into current directory?");
-                if (!shouldFork) {
-                    console.log(chalk.dim("Aborted."));
-                    process.exit(0);
-                }
-                return forkSessionOrExit(resolved.path, cwd, effectiveSessionDir);
-            }
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, effectiveSessionDir);
-    }
-    // --resume is handled separately (needs picker UI)
-    // If effective session dir is set, create new session there
-    if (effectiveSessionDir) {
-        return SessionManager.create(cwd, effectiveSessionDir);
-    }
-    // Default case (new session) returns undefined, SDK will create one
-    return undefined;
-}
-function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager) {
-    const options = {};
-    let cliThinkingFromModel = false;
-    if (sessionManager) {
-        options.sessionManager = sessionManager;
-    }
-    // Model from CLI
-    // - supports --provider <name> --model <pattern>
-    // - supports --model <provider>/<pattern>
-    if (parsed.model) {
-        const resolved = resolveCliModel({
-            cliProvider: parsed.provider,
-            cliModel: parsed.model,
-            modelRegistry,
-        });
-        if (resolved.warning) {
-            console.warn(chalk.yellow(`Warning: ${resolved.warning}`));
-        }
-        if (resolved.error) {
-            console.error(chalk.red(resolved.error));
-            process.exit(1);
-        }
-        if (resolved.model) {
-            options.model = resolved.model;
-            // Allow "--model <pattern>:<thinking>" as a shorthand.
-            // Explicit --thinking still takes precedence (applied later).
-            if (!parsed.thinking && resolved.thinkingLevel) {
-                options.thinkingLevel = resolved.thinkingLevel;
-                cliThinkingFromModel = true;
-            }
-        }
-    }
-    if (!options.model && scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
-        // Check if saved default is in scoped models - use it if so, otherwise first scoped model
-        const savedProvider = settingsManager.getDefaultProvider();
-        const savedModelId = settingsManager.getDefaultModel();
-        const savedModel = savedProvider && savedModelId ? modelRegistry.find(savedProvider, savedModelId) : undefined;
-        const savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : undefined;
-        if (savedInScope) {
-            options.model = savedInScope.model;
-            // Use thinking level from scoped model config if explicitly set
-            if (!parsed.thinking && savedInScope.thinkingLevel) {
-                options.thinkingLevel = savedInScope.thinkingLevel;
-            }
-        }
-        else {
-            options.model = scopedModels[0].model;
-            // Use thinking level from first scoped model if explicitly set
-            if (!parsed.thinking && scopedModels[0].thinkingLevel) {
-                options.thinkingLevel = scopedModels[0].thinkingLevel;
-            }
-        }
-    }
-    // Thinking level from CLI (takes precedence over scoped model thinking levels set above)
-    if (parsed.thinking) {
-        options.thinkingLevel = parsed.thinking;
-    }
-    // Scoped models for Ctrl+P cycling
-    // Keep thinking level undefined when not explicitly set in the model pattern.
-    // Undefined means "inherit current session thinking level" during cycling.
-    if (scopedModels.length > 0) {
-        options.scopedModels = scopedModels.map((sm) => ({
-            model: sm.model,
-            thinkingLevel: sm.thinkingLevel,
-        }));
-    }
-    // API key from CLI - set in authStorage
-    // (handled by caller before createAgentSession)
-    // Tools
-    if (parsed.noTools) {
-        // --no-tools: start with no built-in tools
-        // --tools can still add specific ones back
-        if (parsed.tools && parsed.tools.length > 0) {
-            options.tools = parsed.tools.map((name) => allTools[name]);
-        }
-        else {
-            options.tools = [];
-        }
-    }
-    else if (parsed.tools) {
-        options.tools = parsed.tools.map((name) => allTools[name]);
-    }
-    return { options, cliThinkingFromModel };
-}
-function resolveCliPaths(cwd, paths) {
-    return paths?.map((value) => resolve(cwd, value));
-}
-function buildRuntimeBootstrap(parsed, cwd, agentDir, authStorage, sessionOptions) {
-    return {
-        agentDir,
-        authStorage,
-        model: sessionOptions.model,
-        thinkingLevel: sessionOptions.thinkingLevel,
-        scopedModels: sessionOptions.scopedModels,
-        tools: sessionOptions.tools,
-        customTools: sessionOptions.customTools,
-        resourceLoader: {
-            additionalExtensionPaths: resolveCliPaths(cwd, parsed.extensions),
-            additionalSkillPaths: resolveCliPaths(cwd, parsed.skills),
-            additionalPromptTemplatePaths: resolveCliPaths(cwd, parsed.promptTemplates),
-            additionalThemePaths: resolveCliPaths(cwd, parsed.themes),
-            noExtensions: parsed.noExtensions,
-            noSkills: parsed.noSkills,
-            noPromptTemplates: parsed.noPromptTemplates,
-            noThemes: parsed.noThemes,
-            systemPrompt: parsed.systemPrompt,
-            appendSystemPrompt: parsed.appendSystemPrompt,
-        },
-    };
-}
-async function handleConfigCommand(args) {
-    if (args[0] !== "config") {
-        return false;
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "config command");
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    const resolvedPaths = await packageManager.resolve();
-    await selectConfig({
-        resolvedPaths,
-        settingsManager,
-        cwd,
-        agentDir,
-    });
-    process.exit(0);
-}
-export async function main(args) {
-    resetTimings();
-    const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
-    if (offlineMode) {
-        process.env.PI_OFFLINE = "1";
-        process.env.PI_SKIP_VERSION_CHECK = "1";
-    }
-    if (await handlePackageCommand(args)) {
-        return;
-    }
-    if (await handleConfigCommand(args)) {
-        return;
-    }
-    // First pass: parse args to get --extension paths
-    const firstPass = parseArgs(args);
-    time("parseArgs.firstPass");
-    const shouldTakeOverStdout = firstPass.mode !== undefined || firstPass.print || !process.stdin.isTTY;
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
-    // Run migrations (pass cwd for project-local migrations)
-    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
-    time("runMigrations");
-    // Early load extensions to discover their CLI flags
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    reportSettingsErrors(settingsManager, "startup");
-    const authStorage = AuthStorage.create();
-    const modelRegistry = ModelRegistry.create(authStorage, getModelsPath());
-    const resourceLoader = new DefaultResourceLoader({
-        cwd,
-        agentDir,
-        settingsManager,
-        additionalExtensionPaths: firstPass.extensions,
-        additionalSkillPaths: firstPass.skills,
-        additionalPromptTemplatePaths: firstPass.promptTemplates,
-        additionalThemePaths: firstPass.themes,
-        noExtensions: firstPass.noExtensions,
-        noSkills: firstPass.noSkills,
-        noPromptTemplates: firstPass.noPromptTemplates,
-        noThemes: firstPass.noThemes,
-        systemPrompt: firstPass.systemPrompt,
-        appendSystemPrompt: firstPass.appendSystemPrompt,
-    });
-    time("createResourceLoader");
-    await resourceLoader.reload();
-    time("resourceLoader.reload");
-    const extensionsResult = resourceLoader.getExtensions();
-    for (const { path, error } of extensionsResult.errors) {
-        console.error(chalk.red(`Failed to load extension "${path}": ${error}`));
-    }
-    // Apply pending provider registrations from extensions immediately
-    // so they're available for model resolution before AgentSession is created
-    for (const { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
-        try {
-            modelRegistry.registerProvider(name, config);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(chalk.red(`Extension "${extensionPath}" error: ${message}`));
-        }
-    }
-    extensionsResult.runtime.pendingProviderRegistrations = [];
-    const extensionFlags = new Map();
-    for (const ext of extensionsResult.extensions) {
-        for (const [name, flag] of ext.flags) {
-            extensionFlags.set(name, { type: flag.type });
-        }
-    }
-    // Second pass: parse args with extension flags
-    const parsed = parseArgs(args, extensionFlags);
-    time("parseArgs.secondPass");
-    // Pass flag values to extensions via runtime
-    for (const [name, value] of parsed.unknownFlags) {
-        extensionsResult.runtime.flagValues.set(name, value);
-    }
-    if (parsed.version) {
-        console.log(VERSION);
-        process.exit(0);
-    }
-    if (parsed.help) {
-        printHelp();
-        process.exit(0);
-    }
-    if (parsed.listModels !== undefined) {
-        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRegistry, searchPattern);
-        process.exit(0);
-    }
-    // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
-    let stdinContent;
-    if (parsed.mode !== "rpc") {
-        stdinContent = await readPipedStdin();
-        if (stdinContent !== undefined) {
-            // Force print mode since interactive mode requires a TTY for keyboard input
-            parsed.print = true;
-        }
-    }
-    time("readPipedStdin");
-    if (parsed.export) {
-        let result;
-        try {
-            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
-            result = await exportFromFile(parsed.export, outputPath);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to export session";
-            console.error(chalk.red(`Error: ${message}`));
-            process.exit(1);
-        }
-        console.log(`Exported to: ${result}`);
-        process.exit(0);
-    }
-    migrateKeybindingsConfigFile(agentDir);
-    time("migrateKeybindingsConfigFile");
-    if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
-        console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
-        process.exit(1);
-    }
-    validateForkFlags(parsed);
-    const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize(), stdinContent);
-    time("prepareInitialMessage");
-    const isInteractive = !parsed.print && parsed.mode === undefined;
-    const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
-    if (startupBenchmark && !isInteractive) {
-        console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
-        process.exit(1);
-    }
-    const mode = parsed.mode || "text";
-    initTheme(settingsManager.getTheme(), isInteractive);
-    time("initTheme");
-    // Show deprecation warnings in interactive mode
-    if (isInteractive && deprecationWarnings.length > 0) {
-        await showDeprecationWarnings(deprecationWarnings);
-    }
-    let scopedModels = [];
-    const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-    if (modelPatterns && modelPatterns.length > 0) {
-        scopedModels = await resolveModelScope(modelPatterns, modelRegistry);
-    }
-    time("resolveModelScope");
-    // Create session manager based on CLI flags
-    let sessionManager = await createSessionManager(parsed, cwd, extensionsResult, settingsManager);
-    time("createSessionManager");
-    // Handle --resume: show session picker
-    if (parsed.resume) {
-        // Compute effective session dir for resume (same logic as createSessionManager)
-        const effectiveSessionDir = parsed.sessionDir ??
-            settingsManager.getSessionDir() ??
-            (await callSessionDirectoryHook(extensionsResult, cwd));
-        const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, effectiveSessionDir, onProgress), SessionManager.listAll);
-        if (!selectedPath) {
-            console.log(chalk.dim("No session selected"));
-            stopThemeWatcher();
-            process.exit(0);
-        }
-        sessionManager = SessionManager.open(selectedPath, effectiveSessionDir);
-    }
-    const { options: sessionOptions, cliThinkingFromModel } = buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager);
-    if (parsed.apiKey) {
-        if (!sessionOptions.model) {
-            console.error(chalk.red("--api-key requires a model to be specified via --model, --provider/--model, or --models"));
-            process.exit(1);
-        }
-        authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
-    }
-    const runtimeBootstrap = buildRuntimeBootstrap(parsed, cwd, agentDir, authStorage, sessionOptions);
-    const runtime = await createAgentSessionRuntime(runtimeBootstrap, {
-        cwd: sessionManager?.getCwd() ?? cwd,
-        sessionManager,
-    });
-    if (process.cwd() !== runtime.cwd) {
-        process.chdir(runtime.cwd);
-    }
-    const runtimeHost = new AgentSessionRuntimeHost(runtimeBootstrap, runtime);
-    const { session, modelFallbackMessage } = runtime;
-    time("createAgentSession");
-    if (!isInteractive && !session.model) {
-        console.error(chalk.red("No models available."));
-        console.error(chalk.yellow("\nSet an API key environment variable:"));
-        console.error("  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.");
-        console.error(chalk.yellow(`\nOr create ${getModelsPath()}`));
-        process.exit(1);
-    }
-    // Clamp thinking level to model capabilities for CLI-provided thinking levels.
-    // This covers both --thinking <level> and --model <pattern>:<thinking>.
-    const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
-    if (session.model && cliThinkingOverride) {
-        let effectiveThinking = session.thinkingLevel;
-        if (!session.model.reasoning) {
-            effectiveThinking = "off";
-        }
-        else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
-            effectiveThinking = "high";
-        }
-        if (effectiveThinking !== session.thinkingLevel) {
-            session.setThinkingLevel(effectiveThinking);
-        }
-    }
-    if (mode === "rpc") {
-        printTimings();
-        await runRpcMode(runtimeHost);
-    }
-    else if (isInteractive) {
-        if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const modelList = scopedModels
-                .map((sm) => {
-                const thinkingStr = sm.thinkingLevel ? `:${sm.thinkingLevel}` : "";
-                return `${sm.model.id}${thinkingStr}`;
-            })
-                .join(", ");
-            console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
-        }
-        const interactiveMode = new InteractiveMode(runtimeHost, {
-            migratedProviders,
-            modelFallbackMessage,
-            initialMessage,
-            initialImages,
-            initialMessages: parsed.messages,
-            verbose: parsed.verbose,
-        });
-        if (startupBenchmark) {
-            await interactiveMode.init();
-            time("interactiveMode.init");
-            printTimings();
-            interactiveMode.stop();
-            stopThemeWatcher();
-            if (process.stdout.writableLength > 0) {
-                await new Promise((resolve) => process.stdout.once("drain", resolve));
-            }
-            if (process.stderr.writableLength > 0) {
-                await new Promise((resolve) => process.stderr.once("drain", resolve));
-            }
-            return;
-        }
-        printTimings();
-        await interactiveMode.run();
-    }
-    else {
-        printTimings();
-        const exitCode = await runPrintMode(runtimeHost, {
-            mode,
-            messages: parsed.messages,
-            initialMessage,
-            initialImages,
-        });
-        stopThemeWatcher();
-        restoreStdout();
-        if (exitCode !== 0) {
-            process.exitCode = exitCode;
-        }
-        return;
-    }
-}
-//# sourceMappingURL=main.js.map