@mariozechner/pi-coding-agent 0.25.4 → 0.26.1

package/dist/main.js

@@ -1,58 +1,27 @@
 /**
- * Main entry point for the coding agent
+ * 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 { Agent, ProviderTransport } from "@mariozechner/pi-agent-core";
-import { setOAuthStorage, supportsXhigh } from "@mariozechner/pi-ai";
+import { supportsXhigh } from "@mariozechner/pi-ai";
 import chalk from "chalk";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname } from "path";
 import { parseArgs, printHelp } from "./cli/args.js";
 import { processFileArguments } from "./cli/file-processor.js";
 import { listModels } from "./cli/list-models.js";
 import { selectSession } from "./cli/session-picker.js";
-import { getModelsPath, getOAuthPath, VERSION } from "./config.js";
-import { AgentSession } from "./core/agent-session.js";
-import { discoverAndLoadCustomTools } from "./core/custom-tools/index.js";
+import { getModelsPath, VERSION } from "./config.js";
 import { exportFromFile } from "./core/export-html.js";
-import { discoverAndLoadHooks, HookRunner, wrapToolsWithHooks } from "./core/hooks/index.js";
-import { messageTransformer } from "./core/messages.js";
-import { findModel, getApiKeyForModel, getAvailableModels } from "./core/model-config.js";
-import { resolveModelScope, restoreModelFromSession } from "./core/model-resolver.js";
+import { findModel } from "./core/model-config.js";
+import { resolveModelScope } from "./core/model-resolver.js";
+import { configureOAuthStorage, createAgentSession } from "./core/sdk.js";
 import { SessionManager } from "./core/session-manager.js";
 import { SettingsManager } from "./core/settings-manager.js";
-import { loadSlashCommands } from "./core/slash-commands.js";
-import { buildSystemPrompt } from "./core/system-prompt.js";
-import { allTools, codingTools } from "./core/tools/index.js";
+import { allTools } from "./core/tools/index.js";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog.js";
 import { ensureTool } from "./utils/tools-manager.js";
-/** Configure OAuth storage to use the coding-agent's configurable path */
-function configureOAuthStorage() {
-    const oauthPath = getOAuthPath();
-    setOAuthStorage({
-        load: () => {
-            if (!existsSync(oauthPath)) {
-                return {};
-            }
-            try {
-                return JSON.parse(readFileSync(oauthPath, "utf-8"));
-            }
-            catch {
-                return {};
-            }
-        },
-        save: (storage) => {
-            const dir = dirname(oauthPath);
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true, mode: 0o700 });
-            }
-            writeFileSync(oauthPath, JSON.stringify(storage, null, 2), "utf-8");
-            chmodSync(oauthPath, 0o600);
-        },
-    });
-}
-/** Check npm registry for new version (non-blocking) */
 async function checkForNewVersion(currentVersion) {
     try {
         const response = await fetch("https://registry.npmjs.org/@mariozechner/pi-coding-agent/latest");
@@ -66,28 +35,21 @@ async function checkForNewVersion(currentVersion) {
         return null;
     }
     catch {
-        // Silently fail - don't disrupt the user experience
         return null;
     }
 }
-/** Run interactive mode with TUI */
 async function runInteractiveMode(session, version, changelogMarkdown, modelFallbackMessage, versionCheckPromise, initialMessages, customTools, setToolUIContext, initialMessage, initialAttachments, fdPath = null) {
     const mode = new InteractiveMode(session, version, changelogMarkdown, customTools, setToolUIContext, fdPath);
-    // Initialize TUI (subscribes to agent events internally)
     await mode.init();
-    // Handle version check result when it completes (don't block)
     versionCheckPromise.then((newVersion) => {
         if (newVersion) {
             mode.showNewVersionNotification(newVersion);
         }
     });
-    // Render any existing messages (from --continue mode)
     mode.renderInitialMessages(session.state);
-    // Show model fallback warning at the end of the chat if applicable
     if (modelFallbackMessage) {
         mode.showWarning(modelFallbackMessage);
     }
-    // Process initial message with attachments if provided (from @file args)
     if (initialMessage) {
         try {
             await session.prompt(initialMessage, { attachments: initialAttachments });
@@ -97,7 +59,6 @@ async function runInteractiveMode(session, version, changelogMarkdown, modelFall
             mode.showError(errorMessage);
         }
     }
-    // Process remaining initial messages if provided (from CLI args)
     for (const message of initialMessages) {
         try {
             await session.prompt(message);
@@ -107,10 +68,8 @@ async function runInteractiveMode(session, version, changelogMarkdown, modelFall
             mode.showError(errorMessage);
         }
     }
-    // Interactive loop
     while (true) {
         const userInput = await mode.getUserInput();
-        // Process the message
         try {
             await session.prompt(userInput);
         }
@@ -120,17 +79,15 @@ async function runInteractiveMode(session, version, changelogMarkdown, modelFall
         }
     }
 }
-/** Prepare initial message from @file arguments */
 async function prepareInitialMessage(parsed) {
     if (parsed.fileArgs.length === 0) {
         return {};
     }
     const { textContent, imageAttachments } = await processFileArguments(parsed.fileArgs);
-    // Combine file content with first plain text message (if any)
     let initialMessage;
     if (parsed.messages.length > 0) {
         initialMessage = textContent + parsed.messages[0];
-        parsed.messages.shift(); // Remove first message as it's been combined
+        parsed.messages.shift();
     }
     else {
         initialMessage = textContent;
@@ -140,9 +97,107 @@ async function prepareInitialMessage(parsed) {
         initialAttachments: imageAttachments.length > 0 ? imageAttachments : undefined,
     };
 }
+function getChangelogForDisplay(parsed, settingsManager) {
+    if (parsed.continue || parsed.resume) {
+        return null;
+    }
+    const lastVersion = settingsManager.getLastChangelogVersion();
+    const changelogPath = getChangelogPath();
+    const entries = parseChangelog(changelogPath);
+    if (!lastVersion) {
+        if (entries.length > 0) {
+            settingsManager.setLastChangelogVersion(VERSION);
+            return entries.map((e) => e.content).join("\n\n");
+        }
+    }
+    else {
+        const newEntries = getNewEntries(entries, lastVersion);
+        if (newEntries.length > 0) {
+            settingsManager.setLastChangelogVersion(VERSION);
+            return newEntries.map((e) => e.content).join("\n\n");
+        }
+    }
+    return null;
+}
+function createSessionManager(parsed, cwd) {
+    if (parsed.noSession) {
+        return SessionManager.inMemory();
+    }
+    if (parsed.session) {
+        return SessionManager.open(parsed.session);
+    }
+    if (parsed.continue) {
+        return SessionManager.continueRecent(cwd);
+    }
+    // --resume is handled separately (needs picker UI)
+    // Default case (new session) returns null, SDK will create one
+    return null;
+}
+function buildSessionOptions(parsed, scopedModels, sessionManager) {
+    const options = {};
+    if (sessionManager) {
+        options.sessionManager = sessionManager;
+    }
+    // Model from CLI
+    if (parsed.provider && parsed.model) {
+        const { model, error } = findModel(parsed.provider, parsed.model);
+        if (error) {
+            console.error(chalk.red(error));
+            process.exit(1);
+        }
+        if (!model) {
+            console.error(chalk.red(`Model ${parsed.provider}/${parsed.model} not found`));
+            process.exit(1);
+        }
+        options.model = model;
+    }
+    else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+        options.model = scopedModels[0].model;
+    }
+    // Thinking level
+    if (parsed.thinking) {
+        options.thinkingLevel = parsed.thinking;
+    }
+    else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+        options.thinkingLevel = scopedModels[0].thinkingLevel;
+    }
+    // Scoped models for Ctrl+P cycling
+    if (scopedModels.length > 0) {
+        options.scopedModels = scopedModels;
+    }
+    // API key from CLI
+    if (parsed.apiKey) {
+        options.getApiKey = async () => parsed.apiKey;
+    }
+    // System prompt
+    if (parsed.systemPrompt && parsed.appendSystemPrompt) {
+        options.systemPrompt = `${parsed.systemPrompt}\n\n${parsed.appendSystemPrompt}`;
+    }
+    else if (parsed.systemPrompt) {
+        options.systemPrompt = parsed.systemPrompt;
+    }
+    else if (parsed.appendSystemPrompt) {
+        options.systemPrompt = (defaultPrompt) => `${defaultPrompt}\n\n${parsed.appendSystemPrompt}`;
+    }
+    // Tools
+    if (parsed.tools) {
+        options.tools = parsed.tools.map((name) => allTools[name]);
+    }
+    // Skills
+    if (parsed.noSkills) {
+        options.skills = [];
+    }
+    // Additional hook paths from CLI
+    if (parsed.hooks && parsed.hooks.length > 0) {
+        options.additionalHookPaths = parsed.hooks;
+    }
+    // Additional custom tool paths from CLI
+    if (parsed.customTools && parsed.customTools.length > 0) {
+        options.additionalCustomToolPaths = parsed.customTools;
+    }
+    return options;
+}
 export async function main(args) {
-    // Configure OAuth storage to use the coding-agent's configurable path
-    // This must happen before any OAuth operations
     configureOAuthStorage();
     const parsed = parseArgs(args);
     if (parsed.version) {
@@ -153,13 +208,11 @@ export async function main(args) {
         printHelp();
         return;
     }
-    // Handle --list-models flag: list available models and exit
     if (parsed.listModels !== undefined) {
         const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
         await listModels(searchPattern);
         return;
     }
-    // Handle --export flag: convert session file to HTML and exit
     if (parsed.export) {
         try {
             const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
@@ -173,215 +226,64 @@ export async function main(args) {
             process.exit(1);
         }
     }
-    // Validate: RPC mode doesn't support @file arguments
     if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
         console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
         process.exit(1);
     }
-    // Process @file arguments
+    const cwd = process.cwd();
     const { initialMessage, initialAttachments } = await prepareInitialMessage(parsed);
-    // Determine if we're in interactive mode (needed for theme watcher)
     const isInteractive = !parsed.print && parsed.mode === undefined;
-    // Initialize theme (before any TUI rendering)
-    const settingsManager = new SettingsManager();
-    const themeName = settingsManager.getTheme();
-    initTheme(themeName, isInteractive);
-    // Setup session manager
-    const sessionManager = new SessionManager(parsed.continue && !parsed.resume, parsed.session);
-    if (parsed.noSession) {
-        sessionManager.disable();
-    }
-    // Handle --resume flag: show session selector
-    if (parsed.resume) {
-        const selectedSession = await selectSession(sessionManager);
-        if (!selectedSession) {
-            console.log(chalk.dim("No session selected"));
-            return;
-        }
-        sessionManager.setSessionFile(selectedSession);
-    }
-    // Resolve model scope early if provided
+    const mode = parsed.mode || "text";
+    const settingsManager = SettingsManager.create(cwd);
+    initTheme(settingsManager.getTheme(), isInteractive);
     let scopedModels = [];
     if (parsed.models && parsed.models.length > 0) {
         scopedModels = await resolveModelScope(parsed.models);
     }
-    // Determine mode and output behavior
-    const mode = parsed.mode || "text";
-    const shouldPrintMessages = isInteractive;
-    // Find initial model
-    let initialModel = await findInitialModelForSession(parsed, scopedModels, settingsManager);
-    let initialThinking = "off";
-    // Get thinking level from scoped models if applicable
-    if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
-        initialThinking = scopedModels[0].thinkingLevel;
-    }
-    else {
-        // Try saved thinking level
-        const savedThinking = settingsManager.getDefaultThinkingLevel();
-        if (savedThinking) {
-            initialThinking = savedThinking;
+    // Create session manager based on CLI flags
+    let sessionManager = createSessionManager(parsed, cwd);
+    // Handle --resume: show session picker
+    if (parsed.resume) {
+        const sessions = SessionManager.list(cwd);
+        if (sessions.length === 0) {
+            console.log(chalk.dim("No sessions found"));
+            return;
         }
+        const selectedPath = await selectSession(sessions);
+        if (!selectedPath) {
+            console.log(chalk.dim("No session selected"));
+            return;
+        }
+        sessionManager = SessionManager.open(selectedPath);
     }
-    // Non-interactive mode: fail early if no model available
-    if (!isInteractive && !initialModel) {
+    const sessionOptions = buildSessionOptions(parsed, scopedModels, sessionManager);
+    const { session, customToolsResult, modelFallbackMessage } = await createAgentSession(sessionOptions);
+    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);
     }
-    // Non-interactive mode: validate API key exists
-    if (!isInteractive && initialModel) {
-        const apiKey = parsed.apiKey || (await getApiKeyForModel(initialModel));
-        if (!apiKey) {
-            console.error(chalk.red(`No API key found for ${initialModel.provider}`));
-            process.exit(1);
-        }
-    }
-    // Build system prompt
-    const skillsSettings = settingsManager.getSkillsSettings();
-    if (parsed.noSkills) {
-        skillsSettings.enabled = false;
-    }
-    if (parsed.skills && parsed.skills.length > 0) {
-        skillsSettings.includeSkills = parsed.skills;
-    }
-    const systemPrompt = buildSystemPrompt({
-        customPrompt: parsed.systemPrompt,
-        selectedTools: parsed.tools,
-        appendSystemPrompt: parsed.appendSystemPrompt,
-        skillsSettings,
-    });
-    // Handle session restoration
-    let modelFallbackMessage = null;
-    if (parsed.continue || parsed.resume || parsed.session) {
-        const savedModel = sessionManager.loadModel();
-        if (savedModel) {
-            const result = await restoreModelFromSession(savedModel.provider, savedModel.modelId, initialModel, shouldPrintMessages);
-            if (result.model) {
-                initialModel = result.model;
-            }
-            modelFallbackMessage = result.fallbackMessage;
-        }
-        // Load and restore thinking level
-        const thinkingLevel = sessionManager.loadThinkingLevel();
-        if (thinkingLevel) {
-            initialThinking = thinkingLevel;
-            if (shouldPrintMessages) {
-                console.log(chalk.dim(`Restored thinking level: ${thinkingLevel}`));
-            }
-        }
-    }
-    // CLI --thinking flag takes highest priority
-    if (parsed.thinking) {
-        initialThinking = parsed.thinking;
-    }
-    // Clamp thinking level to model capabilities
-    if (initialModel) {
-        if (!initialModel.reasoning) {
-            initialThinking = "off";
+    // Clamp thinking level to model capabilities (for CLI override case)
+    if (session.model && parsed.thinking) {
+        let effectiveThinking = parsed.thinking;
+        if (!session.model.reasoning) {
+            effectiveThinking = "off";
         }
-        else if (initialThinking === "xhigh" && !supportsXhigh(initialModel)) {
-            initialThinking = "high";
+        else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
+            effectiveThinking = "high";
         }
-    }
-    // Determine which tools to use
-    let selectedTools = parsed.tools ? parsed.tools.map((name) => allTools[name]) : codingTools;
-    // Discover and load hooks from:
-    // 1. ~/.pi/agent/hooks/*.ts (global)
-    // 2. cwd/.pi/hooks/*.ts (project-local)
-    // 3. Explicit paths in settings.json
-    // 4. CLI --hook flags
-    let hookRunner = null;
-    const cwd = process.cwd();
-    const configuredHookPaths = [...settingsManager.getHookPaths(), ...(parsed.hooks ?? [])];
-    const { hooks, errors } = await discoverAndLoadHooks(configuredHookPaths, cwd);
-    // Report hook loading errors
-    for (const { path, error } of errors) {
-        console.error(chalk.red(`Failed to load hook "${path}": ${error}`));
-    }
-    if (hooks.length > 0) {
-        const timeout = settingsManager.getHookTimeout();
-        hookRunner = new HookRunner(hooks, cwd, timeout);
-    }
-    // Discover and load custom tools from:
-    // 1. ~/.pi/agent/tools/*.ts (global)
-    // 2. cwd/.pi/tools/*.ts (project-local)
-    // 3. Explicit paths in settings.json
-    // 4. CLI --tool flags
-    const configuredToolPaths = [...settingsManager.getCustomToolPaths(), ...(parsed.customTools ?? [])];
-    const builtInToolNames = Object.keys(allTools);
-    const { tools: loadedCustomTools, errors: toolErrors, setUIContext: setToolUIContext, } = await discoverAndLoadCustomTools(configuredToolPaths, cwd, builtInToolNames);
-    // Report custom tool loading errors
-    for (const { path, error } of toolErrors) {
-        console.error(chalk.red(`Failed to load custom tool "${path}": ${error}`));
-    }
-    // Add custom tools to selected tools
-    if (loadedCustomTools.length > 0) {
-        const customToolInstances = loadedCustomTools.map((lt) => lt.tool);
-        selectedTools = [...selectedTools, ...customToolInstances];
-    }
-    // Wrap tools with hook callbacks (built-in and custom)
-    if (hookRunner) {
-        selectedTools = wrapToolsWithHooks(selectedTools, hookRunner);
-    }
-    // Create agent
-    const agent = new Agent({
-        initialState: {
-            systemPrompt,
-            model: initialModel, // Can be null in interactive mode
-            thinkingLevel: initialThinking,
-            tools: selectedTools,
-        },
-        messageTransformer,
-        queueMode: settingsManager.getQueueMode(),
-        transport: new ProviderTransport({
-            getApiKey: async () => {
-                const currentModel = agent.state.model;
-                if (!currentModel) {
-                    throw new Error("No model selected");
-                }
-                if (parsed.apiKey) {
-                    return parsed.apiKey;
-                }
-                const key = await getApiKeyForModel(currentModel);
-                if (!key) {
-                    throw new Error(`No API key found for provider "${currentModel.provider}". Please set the appropriate environment variable or update ${getModelsPath()}`);
-                }
-                return key;
-            },
-        }),
-    });
-    // Load previous messages if continuing, resuming, or using --session
-    if (parsed.continue || parsed.resume || parsed.session) {
-        const messages = sessionManager.loadMessages();
-        if (messages.length > 0) {
-            agent.replaceMessages(messages);
+        if (effectiveThinking !== session.thinkingLevel) {
+            session.setThinkingLevel(effectiveThinking);
         }
     }
-    // Load file commands for slash command expansion
-    const fileCommands = loadSlashCommands();
-    // Create session
-    const session = new AgentSession({
-        agent,
-        sessionManager,
-        settingsManager,
-        scopedModels,
-        fileCommands,
-        hookRunner,
-        customTools: loadedCustomTools,
-        skillsSettings,
-    });
-    // Route to appropriate mode
     if (mode === "rpc") {
         await runRpcMode(session);
     }
     else if (isInteractive) {
-        // Check for new version in the background
         const versionCheckPromise = checkForNewVersion(VERSION).catch(() => null);
-        // Check if we should show changelog
         const changelogMarkdown = getChangelogForDisplay(parsed, settingsManager);
-        // Show model scope if provided
         if (scopedModels.length > 0) {
             const modelList = scopedModels
                 .map((sm) => {
@@ -391,88 +293,16 @@ export async function main(args) {
                 .join(", ");
             console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
         }
-        // Ensure fd tool is available for file autocomplete
         const fdPath = await ensureTool("fd");
-        await runInteractiveMode(session, VERSION, changelogMarkdown, modelFallbackMessage, versionCheckPromise, parsed.messages, loadedCustomTools, setToolUIContext, initialMessage, initialAttachments, fdPath);
+        await runInteractiveMode(session, VERSION, changelogMarkdown, modelFallbackMessage, versionCheckPromise, parsed.messages, customToolsResult.tools, customToolsResult.setUIContext, initialMessage, initialAttachments, fdPath);
     }
     else {
-        // Non-interactive mode (--print flag or --mode flag)
         await runPrintMode(session, mode, parsed.messages, initialMessage, initialAttachments);
-        // Clean up and exit (file watchers keep process alive)
         stopThemeWatcher();
-        // Wait for stdout to fully flush before exiting
         if (process.stdout.writableLength > 0) {
             await new Promise((resolve) => process.stdout.once("drain", resolve));
         }
         process.exit(0);
     }
 }
-/** Find initial model based on CLI args, scoped models, settings, or available models */
-async function findInitialModelForSession(parsed, scopedModels, settingsManager) {
-    // 1. CLI args take priority
-    if (parsed.provider && parsed.model) {
-        const { model, error } = findModel(parsed.provider, parsed.model);
-        if (error) {
-            console.error(chalk.red(error));
-            process.exit(1);
-        }
-        if (!model) {
-            console.error(chalk.red(`Model ${parsed.provider}/${parsed.model} not found`));
-            process.exit(1);
-        }
-        return model;
-    }
-    // 2. Use first model from scoped models (skip if continuing/resuming)
-    if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
-        return scopedModels[0].model;
-    }
-    // 3. Try saved default from settings
-    const defaultProvider = settingsManager.getDefaultProvider();
-    const defaultModelId = settingsManager.getDefaultModel();
-    if (defaultProvider && defaultModelId) {
-        const { model, error } = findModel(defaultProvider, defaultModelId);
-        if (error) {
-            console.error(chalk.red(error));
-            process.exit(1);
-        }
-        if (model) {
-            return model;
-        }
-    }
-    // 4. Try first available model with valid API key
-    const { models: availableModels, error } = await getAvailableModels();
-    if (error) {
-        console.error(chalk.red(error));
-        process.exit(1);
-    }
-    if (availableModels.length > 0) {
-        return availableModels[0];
-    }
-    return null;
-}
-/** Get changelog markdown to display (only for new sessions with updates) */
-function getChangelogForDisplay(parsed, settingsManager) {
-    if (parsed.continue || parsed.resume) {
-        return null;
-    }
-    const lastVersion = settingsManager.getLastChangelogVersion();
-    const changelogPath = getChangelogPath();
-    const entries = parseChangelog(changelogPath);
-    if (!lastVersion) {
-        // First run - show all entries
-        if (entries.length > 0) {
-            settingsManager.setLastChangelogVersion(VERSION);
-            return entries.map((e) => e.content).join("\n\n");
-        }
-    }
-    else {
-        // Check for new entries since last version
-        const newEntries = getNewEntries(entries, lastVersion);
-        if (newEntries.length > 0) {
-            settingsManager.setLastChangelogVersion(VERSION);
-            return newEntries.map((e) => e.content).join("\n\n");
-        }
-    }
-    return null;
-}
 //# sourceMappingURL=main.js.map