@mariozechner/pi-coding-agent 0.8.5 → 0.9.0

package/dist/main.js

@@ -18,16 +18,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
 const VERSION = packageJson.version;
-const envApiKeyMap = {
-    google: ["GEMINI_API_KEY"],
-    openai: ["OPENAI_API_KEY"],
-    anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
-    xai: ["XAI_API_KEY"],
-    groq: ["GROQ_API_KEY"],
-    cerebras: ["CEREBRAS_API_KEY"],
-    openrouter: ["OPENROUTER_API_KEY"],
-    zai: ["ZAI_API_KEY"],
-};
 const defaultModelPerProvider = {
     anthropic: "claude-sonnet-4-5",
     openai: "gpt-5.1-codex",
@@ -80,6 +70,18 @@ function parseArgs(args) {
         else if (arg === "--models" && i + 1 < args.length) {
             result.models = args[++i].split(",").map((s) => s.trim());
         }
+        else if (arg === "--thinking" && i + 1 < args.length) {
+            const level = args[++i];
+            if (level === "off" || level === "minimal" || level === "low" || level === "medium" || level === "high") {
+                result.thinking = level;
+            }
+            else {
+                console.error(chalk.yellow(`Warning: Invalid thinking level "${level}". Valid values: off, minimal, low, medium, high`));
+            }
+        }
+        else if (arg === "--print" || arg === "-p") {
+            result.print = true;
+        }
         else if (!arg.startsWith("-")) {
             result.messages.push(arg);
         }
@@ -98,21 +100,26 @@ ${chalk.bold("Options:")}
   --api-key <key>         API key (defaults to env vars)
   --system-prompt <text>  System prompt (default: coding assistant prompt)
   --mode <mode>           Output mode: text (default), json, or rpc
+  --print, -p             Non-interactive mode: process prompt and exit
   --continue, -c          Continue previous session
   --resume, -r            Select a session to resume
   --session <path>        Use specific session file
   --no-session            Don't save session (ephemeral)
   --models <patterns>     Comma-separated model patterns for quick cycling with Ctrl+P
+  --thinking <level>      Set thinking level: off, minimal, low, medium, high
   --help, -h              Show this help
 
 ${chalk.bold("Examples:")}
-  # Interactive mode (no messages = interactive TUI)
+  # Interactive mode
   pi
 
-  # Single message
+  # Interactive mode with initial prompt
   pi "List all .ts files in src/"
 
-  # Multiple messages
+  # Non-interactive mode (process and exit)
+  pi -p "List all .ts files in src/"
+
+  # Multiple messages (interactive)
   pi "Read package.json" "What dependencies do we have?"
 
   # Continue previous session
@@ -124,6 +131,12 @@ ${chalk.bold("Examples:")}
   # Limit model cycling to specific models
   pi --models claude-sonnet,claude-haiku,gpt-4o
 
+  # Cycle models with fixed thinking levels
+  pi --models sonnet:high,haiku:low
+
+  # Start with a specific thinking level
+  pi --thinking high "Solve this complex problem"
+
 ${chalk.bold("Environment Variables:")}
   ANTHROPIC_API_KEY       - Anthropic Claude API key
   ANTHROPIC_OAUTH_TOKEN   - Anthropic OAuth token (alternative to API key)
@@ -307,7 +320,8 @@ async function checkForNewVersion(currentVersion) {
     }
 }
 /**
- * Resolve model patterns to actual Model objects
+ * Resolve model patterns to actual Model objects with optional thinking levels
+ * Format: "pattern:level" where :level is optional
  * For each pattern, finds all matching models and picks the best version:
  * 1. Prefer alias (e.g., claude-sonnet-4-5) over dated versions (claude-sonnet-4-5-20250929)
  * 2. If no alias, pick the latest dated version
@@ -320,10 +334,47 @@ async function resolveModelScope(patterns) {
     }
     const scopedModels = [];
     for (const pattern of patterns) {
-        // Find all models matching this pattern (case-insensitive partial match)
-        const matches = availableModels.filter((m) => m.id.toLowerCase().includes(pattern.toLowerCase()) || m.name?.toLowerCase().includes(pattern.toLowerCase()));
+        // Parse pattern:level format
+        const parts = pattern.split(":");
+        const modelPattern = parts[0];
+        let thinkingLevel = "off";
+        if (parts.length > 1) {
+            const level = parts[1];
+            if (level === "off" || level === "minimal" || level === "low" || level === "medium" || level === "high") {
+                thinkingLevel = level;
+            }
+            else {
+                console.warn(chalk.yellow(`Warning: Invalid thinking level "${level}" in pattern "${pattern}". Using "off" instead.`));
+            }
+        }
+        // Check for provider/modelId format (provider is everything before the first /)
+        const slashIndex = modelPattern.indexOf("/");
+        if (slashIndex !== -1) {
+            const provider = modelPattern.substring(0, slashIndex);
+            const modelId = modelPattern.substring(slashIndex + 1);
+            const providerMatch = availableModels.find((m) => m.provider.toLowerCase() === provider.toLowerCase() && m.id.toLowerCase() === modelId.toLowerCase());
+            if (providerMatch) {
+                if (!scopedModels.find((sm) => sm.model.id === providerMatch.id && sm.model.provider === providerMatch.provider)) {
+                    scopedModels.push({ model: providerMatch, thinkingLevel });
+                }
+                continue;
+            }
+            // No exact provider/model match - fall through to other matching
+        }
+        // Check for exact ID match (case-insensitive)
+        const exactMatch = availableModels.find((m) => m.id.toLowerCase() === modelPattern.toLowerCase());
+        if (exactMatch) {
+            // Exact match found - use it directly
+            if (!scopedModels.find((sm) => sm.model.id === exactMatch.id && sm.model.provider === exactMatch.provider)) {
+                scopedModels.push({ model: exactMatch, thinkingLevel });
+            }
+            continue;
+        }
+        // No exact match - fall back to partial matching
+        const matches = availableModels.filter((m) => m.id.toLowerCase().includes(modelPattern.toLowerCase()) ||
+            m.name?.toLowerCase().includes(modelPattern.toLowerCase()));
         if (matches.length === 0) {
-            console.warn(chalk.yellow(`Warning: No models match pattern "${pattern}"`));
+            console.warn(chalk.yellow(`Warning: No models match pattern "${modelPattern}"`));
             continue;
         }
         // Helper to check if a model ID looks like an alias (no date suffix)
@@ -351,8 +402,8 @@ async function resolveModelScope(patterns) {
             bestMatch = datedVersions[0];
         }
         // Avoid duplicates
-        if (!scopedModels.find((m) => m.id === bestMatch.id && m.provider === bestMatch.provider)) {
-            scopedModels.push(bestMatch);
+        if (!scopedModels.find((sm) => sm.model.id === bestMatch.id && sm.model.provider === bestMatch.provider)) {
+            scopedModels.push({ model: bestMatch, thinkingLevel });
         }
     }
     return scopedModels;
@@ -379,25 +430,26 @@ async function selectSession(sessionManager) {
         ui.start();
     });
 }
-async function runInteractiveMode(agent, sessionManager, settingsManager, version, changelogMarkdown = null, modelFallbackMessage = null, newVersion = null, scopedModels = []) {
+async function runInteractiveMode(agent, sessionManager, settingsManager, version, changelogMarkdown = null, modelFallbackMessage = null, newVersion = null, scopedModels = [], initialMessages = []) {
     const renderer = new TuiRenderer(agent, sessionManager, settingsManager, version, changelogMarkdown, newVersion, scopedModels);
-    // Initialize TUI
+    // Initialize TUI (subscribes to agent events internally)
     await renderer.init();
-    // Set interrupt callback
-    renderer.setInterruptCallback(() => {
-        agent.abort();
-    });
     // Render any existing messages (from --continue mode)
     renderer.renderInitialMessages(agent.state);
     // Show model fallback warning at the end of the chat if applicable
     if (modelFallbackMessage) {
         renderer.showWarning(modelFallbackMessage);
     }
-    // Subscribe to agent events
-    agent.subscribe(async (event) => {
-        // Pass all events to the renderer
-        await renderer.handleEvent(event, agent.state);
-    });
+    // Process initial messages if provided (from CLI args)
+    for (const message of initialMessages) {
+        try {
+            await agent.prompt(message);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            renderer.showError(errorMessage);
+        }
+    }
     // Interactive loop
     while (true) {
         const userInput = await renderer.getUserInput();
@@ -407,7 +459,8 @@ async function runInteractiveMode(agent, sessionManager, settingsManager, versio
         }
         catch (error) {
             // Display error in the TUI by adding an error message to the chat
-            renderer.showError(error.message || "Unknown error occurred");
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            renderer.showError(errorMessage);
         }
     }
 }
@@ -491,13 +544,20 @@ export async function main(args) {
         // Set the selected session as the active session
         sessionManager.setSessionFile(selectedSession);
     }
+    // Resolve model scope early if provided (needed for initial model selection)
+    let scopedModels = [];
+    if (parsed.models && parsed.models.length > 0) {
+        scopedModels = await resolveModelScope(parsed.models);
+    }
     // Determine initial model using priority system:
     // 1. CLI args (--provider and --model)
-    // 2. Restored from session (if --continue or --resume)
-    // 3. Saved default from settings.json
-    // 4. First available model with valid API key
-    // 5. null (allowed in interactive mode)
+    // 2. First model from --models scope
+    // 3. Restored from session (if --continue or --resume)
+    // 4. Saved default from settings.json
+    // 5. First available model with valid API key
+    // 6. null (allowed in interactive mode)
     let initialModel = null;
+    let initialThinking = "off";
     if (parsed.provider && parsed.model) {
         // 1. CLI args take priority
         const { model, error } = findModel(parsed.provider, parsed.model);
@@ -511,8 +571,13 @@ export async function main(args) {
         }
         initialModel = model;
     }
+    else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+        // 2. Use first model from --models scope (skip if continuing/resuming session)
+        initialModel = scopedModels[0].model;
+        initialThinking = scopedModels[0].thinkingLevel;
+    }
     else if (parsed.continue || parsed.resume) {
-        // 2. Restore from session (will be handled below after loading session)
+        // 3. Restore from session (will be handled below after loading session)
         // Leave initialModel as null for now
     }
     if (!initialModel) {
@@ -526,6 +591,11 @@ export async function main(args) {
                 process.exit(1);
             }
             initialModel = model;
+            // Also load saved thinking level if we're using saved model
+            const savedThinking = settingsManager.getDefaultThinkingLevel();
+            if (savedThinking) {
+                initialThinking = savedThinking;
+            }
         }
     }
     if (!initialModel) {
@@ -553,7 +623,9 @@ export async function main(args) {
         }
     }
     // Determine mode early to know if we should print messages and fail early
-    const isInteractive = parsed.messages.length === 0 && parsed.mode === undefined;
+    // Interactive mode: no --print flag and no --mode flag
+    // Having initial messages doesn't make it non-interactive anymore
+    const isInteractive = !parsed.print && parsed.mode === undefined;
     const mode = parsed.mode || "text";
     const shouldPrintMessages = isInteractive || mode === "text";
     // Non-interactive mode: fail early if no model available
@@ -576,10 +648,6 @@ export async function main(args) {
     // Load previous messages if continuing or resuming
     // This may update initialModel if restoring from session
     if (parsed.continue || parsed.resume) {
-        const messages = sessionManager.loadMessages();
-        if (messages.length > 0 && shouldPrintMessages) {
-            console.log(chalk.dim(`Loaded ${messages.length} messages from previous session`));
-        }
         // Load and restore model (overrides initialModel if found and has API key)
         const savedModel = sessionManager.loadModel();
         if (savedModel) {
@@ -644,12 +712,16 @@ export async function main(args) {
             }
         }
     }
+    // CLI --thinking flag takes highest priority
+    if (parsed.thinking) {
+        initialThinking = parsed.thinking;
+    }
     // Create agent (initialModel can be null in interactive mode)
     const agent = new Agent({
         initialState: {
             systemPrompt,
             model: initialModel, // Can be null
-            thinkingLevel: "off",
+            thinkingLevel: initialThinking,
             tools: codingTools,
         },
         queueMode: settingsManager.getQueueMode(),
@@ -673,6 +745,10 @@ export async function main(args) {
             },
         }),
     });
+    // If initial thinking was requested but model doesn't support it, silently reset to off
+    if (initialThinking !== "off" && initialModel && !initialModel.reasoning) {
+        agent.setThinkingLevel("off");
+    }
     // Track if we had to fall back from saved model (to show in chat later)
     let modelFallbackMessage = null;
     // Load previous messages if continuing or resuming
@@ -706,8 +782,6 @@ export async function main(args) {
             }
         }
     }
-    // Note: Session will be started lazily after first user+assistant message exchange
-    // (unless continuing/resuming, in which case it's already initialized)
     // Log loaded context files (they're already in the system prompt)
     if (shouldPrintMessages && !parsed.continue && !parsed.resume) {
         const contextFiles = loadProjectContextFiles();
@@ -718,17 +792,6 @@ export async function main(args) {
             }
         }
     }
-    // Subscribe to agent events to save messages
-    agent.subscribe((event) => {
-        // Save messages on completion
-        if (event.type === "message_end") {
-            sessionManager.saveMessage(event.message);
-            // Check if we should initialize session now (after first user+assistant exchange)
-            if (sessionManager.shouldInitializeSession(agent.state.messages)) {
-                sessionManager.startSession(agent.state);
-            }
-        }
-    });
     // Route to appropriate mode
     if (mode === "rpc") {
         // RPC mode - headless operation
@@ -762,8 +825,6 @@ export async function main(args) {
             }
             else {
                 // Parse current and last versions
-                const currentParts = VERSION.split(".").map(Number);
-                const current = { major: currentParts[0] || 0, minor: currentParts[1] || 0, patch: currentParts[2] || 0 };
                 const changelogPath = getChangelogPath();
                 const entries = parseChangelog(changelogPath);
                 const newEntries = getNewEntries(entries, lastVersion);
@@ -773,19 +834,21 @@ export async function main(args) {
                 }
             }
         }
-        // Resolve model scope if provided
-        let scopedModels = [];
-        if (parsed.models && parsed.models.length > 0) {
-            scopedModels = await resolveModelScope(parsed.models);
-            if (scopedModels.length > 0) {
-                console.log(chalk.dim(`Model scope: ${scopedModels.map((m) => m.id).join(", ")} ${chalk.gray("(Ctrl+P to cycle)")}`));
-            }
-        }
-        // No messages and not RPC - use TUI
-        await runInteractiveMode(agent, sessionManager, settingsManager, VERSION, changelogMarkdown, modelFallbackMessage, newVersion, scopedModels);
+        // Show model scope if provided
+        if (scopedModels.length > 0) {
+            const modelList = scopedModels
+                .map((sm) => {
+                const thinkingStr = sm.thinkingLevel !== "off" ? `:${sm.thinkingLevel}` : "";
+                return `${sm.model.id}${thinkingStr}`;
+            })
+                .join(", ");
+            console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
+        }
+        // Interactive mode - use TUI (may have initial messages from CLI args)
+        await runInteractiveMode(agent, sessionManager, settingsManager, VERSION, changelogMarkdown, modelFallbackMessage, newVersion, scopedModels, parsed.messages);
     }
     else {
-        // CLI mode with messages
+        // Non-interactive mode (--print flag or --mode flag)
         await runSingleShotMode(agent, sessionManager, parsed.messages, mode);
     }
 }