@earendil-works/pi-coding-agent 0.79.0 → 0.79.2

package/dist/main.js

@@ -6,33 +6,31 @@
  */
 import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@earendil-works/pi-ai";
-import { ProcessTerminal, setKeybindings, TUI } from "@earendil-works/pi-tui";
 import chalk from "chalk";
 import { parseArgs, printHelp } from "./cli/args.js";
 import { processFileArguments } from "./cli/file-processor.js";
 import { buildInitialMessage } from "./cli/initial-message.js";
 import { listModels } from "./cli/list-models.js";
+import { createProjectTrustContext } from "./cli/project-trust.js";
 import { selectSession } from "./cli/session-picker.js";
+import { shouldRunFirstTimeSetup, showFirstTimeSetup, showStartupSelector } from "./cli/startup-ui.js";
 import { ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION } from "./config.js";
 import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
 import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
 import { formatNoModelsAvailableMessage } from "./core/auth-guidance.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
-import { emitProjectTrustEvent } from "./core/extensions/runner.js";
 import { configureHttpDispatcher } from "./core/http-dispatcher.js";
-import { KeybindingsManager } from "./core/keybindings.js";
 import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
+import { resolveProjectTrusted } from "./core/project-trust.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { printTimings, resetTimings, time } from "./core/timings.js";
-import { hasProjectTrustInputs, ProjectTrustStore } from "./core/trust-manager.js";
+import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
 import { runMigrations, showDeprecationWarnings } from "./migrations.js";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
-import { ExtensionInputComponent } from "./modes/interactive/components/extension-input.js";
-import { ExtensionSelectorComponent } from "./modes/interactive/components/extension-selector.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
 import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
@@ -76,14 +74,14 @@ function isTruthyEnvFlag(value) {
         return false;
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
-function resolveAppMode(parsed, stdinIsTTY) {
+function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
     if (parsed.mode === "rpc") {
         return "rpc";
     }
     if (parsed.mode === "json") {
         return "json";
     }
-    if (parsed.print || !stdinIsTTY) {
+    if (parsed.print || !stdinIsTTY || !stdoutIsTTY) {
         return "print";
     }
     return "interactive";
@@ -91,6 +89,9 @@ function resolveAppMode(parsed, stdinIsTTY) {
 function toPrintOutputMode(appMode) {
     return appMode === "json" ? "json" : "text";
 }
+function isPlainRuntimeMetadataCommand(parsed) {
+    return !parsed.print && parsed.mode === undefined && (parsed.help === true || parsed.listModels !== undefined);
+}
 async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
     if (parsed.fileArgs.length === 0) {
         return buildInitialMessage({ parsed, stdinContent });
@@ -270,6 +271,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
         const resolved = resolveCliModel({
             cliProvider: parsed.provider,
             cliModel: parsed.model,
+            cliThinking: parsed.thinking,
             modelRegistry,
         });
         if (resolved.warning) {
@@ -342,172 +344,12 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
 function resolveCliPaths(cwd, paths) {
     return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
 }
-function createStartupTui(settingsManager) {
-    initTheme(settingsManager.getTheme());
-    setKeybindings(KeybindingsManager.create());
-    const ui = new TUI(new ProcessTerminal(), settingsManager.getShowHardwareCursor());
-    ui.setClearOnShrink(settingsManager.getClearOnShrink());
-    return ui;
-}
-async function clearStartupTui(ui) {
-    ui.clear();
-    ui.requestRender();
-    await new Promise((resolve) => setTimeout(resolve, 25));
-}
-async function showStartupSelector(settingsManager, title, options) {
-    return new Promise((resolve) => {
-        const ui = createStartupTui(settingsManager);
-        let settled = false;
-        const finish = async (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            await clearStartupTui(ui);
-            ui.stop();
-            resolve(result);
-        };
-        const selector = new ExtensionSelectorComponent(title, options.map((option) => option.label), (option) => void finish(options.find((entry) => entry.label === option)?.value), () => void finish(undefined), { tui: ui });
-        ui.addChild(selector);
-        ui.setFocus(selector);
-        ui.start();
-    });
-}
-async function showStartupInput(settingsManager, title, placeholder) {
-    return new Promise((resolve) => {
-        const ui = createStartupTui(settingsManager);
-        let settled = false;
-        const finish = async (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            input.dispose();
-            await clearStartupTui(ui);
-            ui.stop();
-            resolve(result);
-        };
-        const input = new ExtensionInputComponent(title, placeholder, (value) => void finish(value), () => void finish(undefined), {
-            tui: ui,
-        });
-        ui.addChild(input);
-        ui.setFocus(input);
-        ui.start();
-    });
-}
 async function promptForMissingSessionCwd(issue, settingsManager) {
     return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
         { label: "Continue", value: issue.fallbackCwd },
         { label: "Cancel", value: undefined },
     ]);
 }
-const PROJECT_TRUST_PROMPT_OPTIONS = [
-    { label: "Trust", value: { trusted: true, remember: true } },
-    { label: "Trust (this session only)", value: { trusted: true, remember: false } },
-    { label: "Do not trust", value: { trusted: false, remember: true } },
-    { label: "Do not trust (this session only)", value: { trusted: false, remember: false } },
-];
-function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows pi to read project instructions (AGENTS.md/CLAUDE.md), load .pi settings and resources, install missing project packages, and execute project extensions.`;
-}
-async function promptForProjectTrust(cwd, settingsManager) {
-    return showStartupSelector(settingsManager, formatProjectTrustPrompt(cwd), PROJECT_TRUST_PROMPT_OPTIONS);
-}
-async function promptForProjectTrustWithContext(cwd, ctx) {
-    const selected = await ctx.ui.select(formatProjectTrustPrompt(cwd), PROJECT_TRUST_PROMPT_OPTIONS.map((option) => option.label));
-    return PROJECT_TRUST_PROMPT_OPTIONS.find((option) => option.label === selected)?.value;
-}
-function createProjectTrustContext(options) {
-    return {
-        cwd: options.cwd,
-        mode: options.mode === "interactive" ? "tui" : options.mode,
-        hasUI: options.hasUI,
-        ui: {
-            select: async (title, selectOptions) => {
-                if (!options.hasUI) {
-                    return undefined;
-                }
-                if (options.mode !== "interactive") {
-                    return undefined;
-                }
-                return showStartupSelector(options.settingsManager, title, selectOptions.map((option) => ({ label: option, value: option })));
-            },
-            confirm: async (title, message) => {
-                if (!options.hasUI) {
-                    return false;
-                }
-                if (options.mode !== "interactive") {
-                    return false;
-                }
-                return ((await showStartupSelector(options.settingsManager, `${title}\n${message}`, [
-                    { label: "Yes", value: true },
-                    { label: "No", value: false },
-                ])) ?? false);
-            },
-            input: async (title, placeholder) => {
-                if (!options.hasUI) {
-                    return undefined;
-                }
-                if (options.mode !== "interactive") {
-                    return undefined;
-                }
-                return showStartupInput(options.settingsManager, title, placeholder);
-            },
-            notify: (message, type = "info") => {
-                if (options.mode !== "interactive") {
-                    const color = type === "error" ? chalk.red : type === "warning" ? chalk.yellow : chalk.cyan;
-                    console.error(color(message));
-                }
-            },
-        },
-    };
-}
-async function resolveProjectTrusted(options) {
-    if (options.trustOverride !== undefined) {
-        return options.trustOverride;
-    }
-    if (!hasProjectTrustInputs(options.cwd)) {
-        return true;
-    }
-    if (options.extensionsResult && options.projectTrustContext) {
-        const { result, errors } = await emitProjectTrustEvent(options.extensionsResult, { type: "project_trust", cwd: options.cwd }, options.projectTrustContext);
-        for (const error of errors) {
-            options.onExtensionError?.(`Extension "${error.extensionPath}" project_trust error: ${error.error}`);
-        }
-        if (result) {
-            const trusted = result.trusted === "yes";
-            if (result.remember === true) {
-                options.trustStore.set(options.cwd, trusted);
-            }
-            return trusted;
-        }
-    }
-    const decision = options.trustStore.get(options.cwd);
-    if (decision !== null) {
-        return decision;
-    }
-    if (options.projectTrustContext?.hasUI) {
-        const selected = await promptForProjectTrustWithContext(options.cwd, options.projectTrustContext);
-        if (selected !== undefined) {
-            if (selected.remember) {
-                options.trustStore.set(options.cwd, selected.trusted);
-            }
-            return selected.trusted;
-        }
-        return false;
-    }
-    if (options.appMode !== "interactive") {
-        return false;
-    }
-    const selected = await promptForProjectTrust(options.cwd, options.settingsManagerForPrompt);
-    if (selected !== undefined) {
-        if (selected.remember) {
-            options.trustStore.set(options.cwd, selected.trusted);
-        }
-        return selected.trusted;
-    }
-    return false;
-}
 export async function main(args, options) {
     resetTimings();
     const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
@@ -518,10 +360,10 @@ export async function main(args, options) {
     if (process.platform === "win32") {
         cleanupWindowsSelfUpdateQuarantine(getPackageDir());
     }
-    if (await handlePackageCommand(args)) {
+    if (await handlePackageCommand(args, { extensionFactories: options?.extensionFactories })) {
         return;
     }
-    if (await handleConfigCommand(args)) {
+    if (await handleConfigCommand(args, { extensionFactories: options?.extensionFactories })) {
         return;
     }
     const parsed = parseArgs(args);
@@ -535,11 +377,6 @@ export async function main(args, options) {
         }
     }
     time("parseArgs");
-    let appMode = resolveAppMode(parsed, process.stdin.isTTY);
-    const shouldTakeOverStdout = appMode !== "interactive";
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
     if (parsed.version) {
         console.log(VERSION);
         process.exit(0);
@@ -558,6 +395,11 @@ export async function main(args, options) {
         console.log(`Exported to: ${result}`);
         process.exit(0);
     }
+    let appMode = resolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY);
+    const shouldTakeOverStdout = appMode !== "interactive" && !isPlainRuntimeMetadataCommand(parsed);
+    if (shouldTakeOverStdout) {
+        takeOverStdout();
+    }
     if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
         console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
         process.exit(1);
@@ -571,6 +413,12 @@ export async function main(args, options) {
     const agentDir = getAgentDir();
     const startupSettingsManager = SettingsManager.create(cwd, agentDir);
     reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
+    // Experimental first-time setup: theme choice and analytics opt-in.
+    // Runs before any runtime services are created so the chosen settings apply everywhere.
+    if (appMode === "interactive" && !parsed.help && parsed.listModels === undefined && shouldRunFirstTimeSetup()) {
+        await showFirstTimeSetup(startupSettingsManager);
+        time("firstTimeSetup");
+    }
     // Decide the final runtime cwd before creating cwd-bound runtime services.
     // --session and --resume may select a session from another project, so project-local
     // settings, resources, provider registrations, and models must be resolved only after
@@ -606,7 +454,9 @@ export async function main(args, options) {
     time("createSessionManager");
     const trustStore = new ProjectTrustStore(agentDir);
     const sessionCwd = sessionManager.getCwd();
-    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !hasProjectTrustInputs(sessionCwd) ? sessionCwd : undefined;
+    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !hasTrustRequiringProjectResources(sessionCwd)
+        ? sessionCwd
+        : undefined;
     const trustPromptMode = parsed.help || parsed.listModels !== undefined ? "print" : appMode;
     const projectTrustByCwd = new Map();
     const resolvedExtensionPaths = resolveCliPaths(cwd, parsed.extensions);
@@ -618,11 +468,13 @@ export async function main(args, options) {
         const isInitialRuntime = sessionStartEvent === undefined;
         const projectTrustDiagnostics = [];
         const cachedProjectTrust = projectTrustByCwd.get(cwd);
-        const hasTrustInputs = hasProjectTrustInputs(cwd);
-        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustInputs;
+        const hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd);
+        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustRequiringResources;
         const projectTrusted = shouldResolveProjectTrust
             ? false
-            : (cachedProjectTrust ?? parsed.projectTrustOverride ?? (!hasTrustInputs || trustStore.get(cwd) === true));
+            : (cachedProjectTrust ??
+                parsed.projectTrustOverride ??
+                (!hasTrustRequiringResources || trustStore.get(cwd) === true));
         const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
         const services = await createAgentSessionServices({
             cwd,
@@ -637,8 +489,7 @@ export async function main(args, options) {
                             cwd,
                             trustStore,
                             trustOverride: parsed.projectTrustOverride,
-                            appMode: isInitialRuntime ? trustPromptMode : "print",
-                            settingsManagerForPrompt: startupSettingsManager,
+                            defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
                             extensionsResult,
                             projectTrustContext: projectTrustContext ??
                                 createProjectTrustContext({