@saibolla/ada 0.1.2

package/dist/model/commands.js

@@ -0,0 +1,180 @@
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { writeFileSync } from "node:fs";
+import { readJson } from "../pi/settings.js";
+import { promptChoice, promptText } from "../setup/prompts.js";
+import { openUrl } from "../system/open-url.js";
+import { printInfo, printSection, printSuccess, printWarning } from "../ui/terminal.js";
+import { buildModelStatusSnapshotFromRecords, chooseRecommendedModel, getAvailableModelRecords, getSupportedModelRecords, } from "./catalog.js";
+function collectModelStatus(settingsPath, authPath) {
+    return buildModelStatusSnapshotFromRecords(getSupportedModelRecords(authPath), getAvailableModelRecords(authPath), getCurrentModelSpec(settingsPath));
+}
+function getOAuthProviders(authPath) {
+    return AuthStorage.create(authPath).getOAuthProviders();
+}
+function resolveOAuthProvider(authPath, input) {
+    const normalizedInput = input.trim().toLowerCase();
+    if (!normalizedInput) {
+        return undefined;
+    }
+    return getOAuthProviders(authPath).find((provider) => provider.id.toLowerCase() === normalizedInput);
+}
+async function selectOAuthProvider(authPath, action) {
+    const providers = getOAuthProviders(authPath);
+    if (providers.length === 0) {
+        printWarning("No Pi OAuth model providers are available.");
+        return undefined;
+    }
+    if (providers.length === 1) {
+        return providers[0];
+    }
+    const choices = providers.map((provider) => `${provider.id} — ${provider.name ?? provider.id}`);
+    choices.push("Cancel");
+    const selection = await promptChoice(`Choose an OAuth provider to ${action}:`, choices, 0);
+    if (selection >= providers.length) {
+        return undefined;
+    }
+    return providers[selection];
+}
+function resolveAvailableModelSpec(authPath, input) {
+    const normalizedInput = input.trim().toLowerCase();
+    if (!normalizedInput) {
+        return undefined;
+    }
+    const available = getAvailableModelRecords(authPath);
+    const fullSpecMatch = available.find((model) => `${model.provider}/${model.id}`.toLowerCase() === normalizedInput);
+    if (fullSpecMatch) {
+        return `${fullSpecMatch.provider}/${fullSpecMatch.id}`;
+    }
+    const exactIdMatches = available.filter((model) => model.id.toLowerCase() === normalizedInput);
+    if (exactIdMatches.length === 1) {
+        return `${exactIdMatches[0].provider}/${exactIdMatches[0].id}`;
+    }
+    return undefined;
+}
+export function getCurrentModelSpec(settingsPath) {
+    const settings = readJson(settingsPath);
+    if (typeof settings.defaultProvider === "string" && typeof settings.defaultModel === "string") {
+        return `${settings.defaultProvider}/${settings.defaultModel}`;
+    }
+    return undefined;
+}
+export function printModelList(settingsPath, authPath) {
+    const status = collectModelStatus(settingsPath, authPath);
+    if (status.availableModels.length === 0) {
+        printWarning("No authenticated Pi models are currently available.");
+        for (const line of status.guidance) {
+            printInfo(line);
+        }
+        return;
+    }
+    let lastProvider;
+    for (const spec of status.availableModels) {
+        const [provider] = spec.split("/", 1);
+        if (provider !== lastProvider) {
+            lastProvider = provider;
+            printSection(provider);
+        }
+        const markers = [
+            spec === status.current ? "current" : undefined,
+            spec === status.recommended ? "recommended" : undefined,
+        ].filter(Boolean);
+        printInfo(`${spec}${markers.length > 0 ? ` (${markers.join(", ")})` : ""}`);
+    }
+}
+export async function loginModelProvider(authPath, providerId, settingsPath) {
+    const provider = providerId ? resolveOAuthProvider(authPath, providerId) : await selectOAuthProvider(authPath, "login");
+    if (!provider) {
+        if (providerId) {
+            throw new Error(`Unknown OAuth model provider: ${providerId}`);
+        }
+        printInfo("Login cancelled.");
+        return;
+    }
+    const authStorage = AuthStorage.create(authPath);
+    const abortController = new AbortController();
+    await authStorage.login(provider.id, {
+        onAuth: (info) => {
+            printSection(`Login: ${provider.name ?? provider.id}`);
+            const opened = openUrl(info.url);
+            if (opened) {
+                printInfo("Opened the login URL in your browser.");
+            }
+            else {
+                printWarning("Couldn't open your browser automatically.");
+            }
+            printInfo(`Auth URL: ${info.url}`);
+            if (info.instructions) {
+                printInfo(info.instructions);
+            }
+        },
+        onPrompt: async (prompt) => {
+            return promptText(prompt.message, prompt.placeholder ?? "");
+        },
+        onProgress: (message) => {
+            printInfo(message);
+        },
+        onManualCodeInput: async () => {
+            return promptText("Paste redirect URL or auth code");
+        },
+        signal: abortController.signal,
+    });
+    printSuccess(`Model provider login complete: ${provider.id}`);
+    if (settingsPath) {
+        const currentSpec = getCurrentModelSpec(settingsPath);
+        const available = getAvailableModelRecords(authPath);
+        const currentValid = currentSpec
+            ? available.some((m) => `${m.provider}/${m.id}` === currentSpec)
+            : false;
+        if ((!currentSpec || !currentValid) && available.length > 0) {
+            const recommended = chooseRecommendedModel(authPath);
+            if (recommended) {
+                setDefaultModelSpec(settingsPath, authPath, recommended.spec);
+            }
+        }
+    }
+}
+export async function logoutModelProvider(authPath, providerId) {
+    const provider = providerId ? resolveOAuthProvider(authPath, providerId) : await selectOAuthProvider(authPath, "logout");
+    if (!provider) {
+        if (providerId) {
+            throw new Error(`Unknown OAuth model provider: ${providerId}`);
+        }
+        printInfo("Logout cancelled.");
+        return;
+    }
+    AuthStorage.create(authPath).logout(provider.id);
+    printSuccess(`Model provider logout complete: ${provider.id}`);
+}
+export function setDefaultModelSpec(settingsPath, authPath, spec) {
+    const resolvedSpec = resolveAvailableModelSpec(authPath, spec);
+    if (!resolvedSpec) {
+        throw new Error(`Model not available in Pi auth storage: ${spec}. Run \`ada model list\` first.`);
+    }
+    const [provider, ...rest] = resolvedSpec.split("/");
+    const modelId = rest.join("/");
+    const settings = readJson(settingsPath);
+    settings.defaultProvider = provider;
+    settings.defaultModel = modelId;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    printSuccess(`Default model set to ${resolvedSpec}`);
+}
+export async function runModelSetup(settingsPath, authPath, options) {
+    let status = collectModelStatus(settingsPath, authPath);
+    if (status.availableModels.length === 0) {
+        await loginModelProvider(authPath, undefined, settingsPath);
+        status = collectModelStatus(settingsPath, authPath);
+        if (status.availableModels.length === 0) {
+            return;
+        }
+    }
+    if (status.currentValid) {
+        if (!options?.quiet) {
+            printInfo(`Model: ${status.current}`);
+        }
+        return;
+    }
+    const recommended = status.recommended ?? status.availableModels[0];
+    if (recommended) {
+        setDefaultModelSpec(settingsPath, authPath, recommended);
+    }
+}

package/dist/pi/launch.js

@@ -0,0 +1,33 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { buildPiArgs, buildPiEnv, resolvePiPaths } from "./runtime.js";
+import { ensureSupportedNodeVersion } from "../system/node-version.js";
+export async function launchPiChat(options) {
+    ensureSupportedNodeVersion();
+    const { piCliPath, promisePolyfillPath } = resolvePiPaths(options.appRoot);
+    if (!existsSync(piCliPath)) {
+        throw new Error(`Pi CLI not found: ${piCliPath}`);
+    }
+    if (!existsSync(promisePolyfillPath)) {
+        throw new Error(`Promise polyfill not found: ${promisePolyfillPath}`);
+    }
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    }
+    const child = spawn(process.execPath, ["--import", promisePolyfillPath, piCliPath, ...buildPiArgs(options)], {
+        cwd: options.workingDir,
+        stdio: "inherit",
+        env: buildPiEnv(options),
+    });
+    await new Promise((resolvePromise, reject) => {
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            process.exitCode = code ?? 0;
+            resolvePromise();
+        });
+    });
+}

package/dist/pi/package-presets.js

@@ -0,0 +1,55 @@
+export const CORE_PACKAGE_SOURCES = [
+    "npm:pi-subagents",
+    "npm:pi-btw",
+    "npm:pi-docparser",
+    "npm:pi-web-access",
+    "npm:pi-markdown-preview",
+    "npm:@walterra/pi-charts",
+    "npm:pi-mermaid",
+    "npm:@aliou/pi-processes",
+    "npm:pi-zotero",
+    "npm:@kaiserlich-dev/pi-session-search",
+    "npm:pi-schedule-prompt",
+    "npm:@tmustier/pi-ralph-wiggum",
+];
+export const OPTIONAL_PACKAGE_PRESETS = {
+    "generative-ui": {
+        description: "Interactive Glimpse UI widgets.",
+        sources: ["npm:pi-generative-ui"],
+    },
+};
+const LEGACY_DEFAULT_PACKAGE_SOURCES = [
+    ...CORE_PACKAGE_SOURCES,
+    "npm:pi-generative-ui",
+];
+function arraysMatchAsSets(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const rightSet = new Set(right);
+    return left.every((entry) => rightSet.has(entry));
+}
+export function shouldPruneLegacyDefaultPackages(packages) {
+    if (!Array.isArray(packages)) {
+        return false;
+    }
+    if (packages.some((entry) => typeof entry !== "string")) {
+        return false;
+    }
+    return arraysMatchAsSets(packages, LEGACY_DEFAULT_PACKAGE_SOURCES);
+}
+export function getOptionalPackagePresetSources(name) {
+    const normalized = name.trim().toLowerCase();
+    if (normalized === "ui") {
+        return [...OPTIONAL_PACKAGE_PRESETS["generative-ui"].sources];
+    }
+    const preset = OPTIONAL_PACKAGE_PRESETS[normalized];
+    return preset ? [...preset.sources] : undefined;
+}
+export function listOptionalPackagePresets() {
+    return Object.entries(OPTIONAL_PACKAGE_PRESETS).map(([name, preset]) => ({
+        name: name,
+        description: preset.description,
+        sources: [...preset.sources],
+    }));
+}

package/dist/pi/runtime.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { BROWSER_FALLBACK_PATHS, MERMAID_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveExecutable, } from "../system/executables.js";
+export function resolvePiPaths(appRoot) {
+    return {
+        piPackageRoot: resolve(appRoot, "node_modules", "@mariozechner", "pi-coding-agent"),
+        piCliPath: resolve(appRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "cli.js"),
+        promisePolyfillPath: resolve(appRoot, "dist", "system", "promise-polyfill.js"),
+        researchToolsPath: resolve(appRoot, "extensions", "research-tools.ts"),
+        promptTemplatePath: resolve(appRoot, "prompts"),
+        systemPromptPath: resolve(appRoot, ".ada", "SYSTEM.md"),
+        piWorkspaceNodeModulesPath: resolve(appRoot, ".ada", "npm", "node_modules"),
+        nodeModulesBinPath: resolve(appRoot, "node_modules", ".bin"),
+    };
+}
+export function validatePiInstallation(appRoot) {
+    const paths = resolvePiPaths(appRoot);
+    const missing = [];
+    if (!existsSync(paths.piCliPath))
+        missing.push(paths.piCliPath);
+    if (!existsSync(paths.promisePolyfillPath))
+        missing.push(paths.promisePolyfillPath);
+    if (!existsSync(paths.researchToolsPath))
+        missing.push(paths.researchToolsPath);
+    if (!existsSync(paths.promptTemplatePath))
+        missing.push(paths.promptTemplatePath);
+    return missing;
+}
+export function buildPiArgs(options) {
+    const paths = resolvePiPaths(options.appRoot);
+    const args = [
+        "--session-dir",
+        options.sessionDir,
+        "--extension",
+        paths.researchToolsPath,
+        "--prompt-template",
+        paths.promptTemplatePath,
+    ];
+    if (existsSync(paths.systemPromptPath)) {
+        args.push("--system-prompt", readFileSync(paths.systemPromptPath, "utf8"));
+    }
+    if (options.explicitModelSpec) {
+        args.push("--model", options.explicitModelSpec);
+    }
+    if (options.thinkingLevel) {
+        args.push("--thinking", options.thinkingLevel);
+    }
+    if (options.oneShotPrompt) {
+        args.push("-p", options.oneShotPrompt);
+    }
+    else if (options.initialPrompt) {
+        args.push(options.initialPrompt);
+    }
+    return args;
+}
+export function buildPiEnv(options) {
+    const paths = resolvePiPaths(options.appRoot);
+    const adaHome = dirname(options.adaAgentDir);
+    const adaNpmPrefixPath = resolve(adaHome, "npm-global");
+    const adaNpmBinPath = resolve(adaNpmPrefixPath, "bin");
+    const currentPath = process.env.PATH ?? "";
+    const binEntries = [paths.nodeModulesBinPath, resolve(paths.piWorkspaceNodeModulesPath, ".bin"), adaNpmBinPath];
+    const binPath = binEntries.join(":");
+    return {
+        ...process.env,
+        PATH: `${binPath}:${currentPath}`,
+        ADA_VERSION: options.adaVersion,
+        ADA_SESSION_DIR: options.sessionDir,
+        ADA_MEMORY_DIR: resolve(dirname(options.adaAgentDir), "memory"),
+        ADA_NODE_EXECUTABLE: process.execPath,
+        ADA_BIN_PATH: resolve(options.appRoot, "bin", "ada.js"),
+        ADA_NPM_PREFIX: adaNpmPrefixPath,
+        PANDOC_PATH: process.env.PANDOC_PATH ?? resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS),
+        PI_HARDWARE_CURSOR: process.env.PI_HARDWARE_CURSOR ?? "1",
+        PI_SKIP_VERSION_CHECK: process.env.PI_SKIP_VERSION_CHECK ?? "1",
+        MERMAID_CLI_PATH: process.env.MERMAID_CLI_PATH ?? resolveExecutable("mmdc", MERMAID_FALLBACK_PATHS),
+        PUPPETEER_EXECUTABLE_PATH: process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS),
+        NPM_CONFIG_PREFIX: process.env.NPM_CONFIG_PREFIX ?? adaNpmPrefixPath,
+        npm_config_prefix: process.env.npm_config_prefix ?? adaNpmPrefixPath,
+    };
+}

package/dist/pi/settings.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { CORE_PACKAGE_SOURCES, shouldPruneLegacyDefaultPackages } from "./package-presets.js";
+export function parseModelSpec(spec, modelRegistry) {
+    const trimmed = spec.trim();
+    const separator = trimmed.includes(":") ? ":" : trimmed.includes("/") ? "/" : null;
+    if (!separator) {
+        return undefined;
+    }
+    const [provider, ...rest] = trimmed.split(separator);
+    const id = rest.join(separator);
+    if (!provider || !id) {
+        return undefined;
+    }
+    return modelRegistry.find(provider, id);
+}
+export function normalizeThinkingLevel(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "off" ||
+        normalized === "minimal" ||
+        normalized === "low" ||
+        normalized === "medium" ||
+        normalized === "high" ||
+        normalized === "xhigh") {
+        return normalized;
+    }
+    return undefined;
+}
+function choosePreferredModel(availableModels) {
+    const preferences = [
+        { provider: "anthropic", id: "claude-opus-4-6" },
+        { provider: "anthropic", id: "claude-opus-4-5" },
+        { provider: "anthropic", id: "claude-sonnet-4-5" },
+        { provider: "openai", id: "gpt-5.4" },
+        { provider: "openai", id: "gpt-5" },
+    ];
+    for (const preferred of preferences) {
+        const match = availableModels.find((model) => model.provider === preferred.provider && model.id === preferred.id);
+        if (match) {
+            return match;
+        }
+    }
+    return availableModels[0];
+}
+export function readJson(path) {
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function normalizeAdaSettings(settingsPath, bundledSettingsPath, defaultThinkingLevel, authPath) {
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    else if (existsSync(bundledSettingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(bundledSettingsPath, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    if (!settings.defaultThinkingLevel) {
+        settings.defaultThinkingLevel = defaultThinkingLevel;
+    }
+    if (settings.editorPaddingX === undefined) {
+        settings.editorPaddingX = 1;
+    }
+    settings.theme = "ada";
+    settings.quietStartup = true;
+    settings.collapseChangelog = true;
+    if (!Array.isArray(settings.packages) || settings.packages.length === 0) {
+        settings.packages = [...CORE_PACKAGE_SOURCES];
+    }
+    else if (shouldPruneLegacyDefaultPackages(settings.packages)) {
+        settings.packages = [...CORE_PACKAGE_SOURCES];
+    }
+    const authStorage = AuthStorage.create(authPath);
+    const modelRegistry = new ModelRegistry(authStorage);
+    const availableModels = modelRegistry.getAvailable().map((model) => ({
+        provider: model.provider,
+        id: model.id,
+    }));
+    if ((!settings.defaultProvider || !settings.defaultModel) && availableModels.length > 0) {
+        const preferredModel = choosePreferredModel(availableModels);
+        if (preferredModel) {
+            settings.defaultProvider = preferredModel.provider;
+            settings.defaultModel = preferredModel.id;
+        }
+    }
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}

package/dist/pi/web-access.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export function getPiWebSearchConfigPath(home = process.env.HOME ?? homedir()) {
+    return resolve(home, ".ada", "web-search.json");
+}
+function normalizeProvider(value) {
+    return value === "auto" || value === "perplexity" || value === "gemini" ? value : undefined;
+}
+function normalizeNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function loadPiWebAccessConfig(configPath = getPiWebSearchConfigPath()) {
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function formatRouteLabel(provider) {
+    switch (provider) {
+        case "perplexity":
+            return "Perplexity";
+        case "gemini":
+            return "Gemini";
+        default:
+            return "Auto";
+    }
+}
+function formatRouteNote(provider) {
+    switch (provider) {
+        case "perplexity":
+            return "Pi web-access will use Perplexity for search.";
+        case "gemini":
+            return "Pi web-access will use Gemini API or Gemini Browser.";
+        default:
+            return "Pi web-access will try Perplexity, then Gemini API, then Gemini Browser.";
+    }
+}
+export function getPiWebAccessStatus(config = loadPiWebAccessConfig(), configPath = getPiWebSearchConfigPath()) {
+    const searchProvider = normalizeProvider(config.searchProvider) ?? "auto";
+    const requestProvider = normalizeProvider(config.provider) ?? searchProvider;
+    const perplexityConfigured = Boolean(normalizeNonEmptyString(config.perplexityApiKey));
+    const geminiApiConfigured = Boolean(normalizeNonEmptyString(config.geminiApiKey));
+    const chromeProfile = normalizeNonEmptyString(config.chromeProfile);
+    const effectiveProvider = searchProvider;
+    return {
+        configPath,
+        searchProvider,
+        requestProvider,
+        perplexityConfigured,
+        geminiApiConfigured,
+        chromeProfile,
+        routeLabel: formatRouteLabel(effectiveProvider),
+        note: formatRouteNote(effectiveProvider),
+    };
+}
+export function formatPiWebAccessDoctorLines(status = getPiWebAccessStatus()) {
+    return [
+        "web access: pi-web-access",
+        `  search route: ${status.routeLabel}`,
+        `  request route: ${status.requestProvider}`,
+        `  perplexity api: ${status.perplexityConfigured ? "configured" : "not configured"}`,
+        `  gemini api: ${status.geminiApiConfigured ? "configured" : "not configured"}`,
+        `  browser profile: ${status.chromeProfile ?? "default Chromium profile"}`,
+        `  config path: ${status.configPath}`,
+        `  note: ${status.note}`,
+    ];
+}

package/dist/search/commands.js

@@ -0,0 +1,12 @@
+import { getPiWebAccessStatus } from "../pi/web-access.js";
+import { printInfo } from "../ui/terminal.js";
+export function printSearchStatus() {
+    const status = getPiWebAccessStatus();
+    printInfo("Managed by: pi-web-access");
+    printInfo(`Search route: ${status.routeLabel}`);
+    printInfo(`Request route: ${status.requestProvider}`);
+    printInfo(`Perplexity API configured: ${status.perplexityConfigured ? "yes" : "no"}`);
+    printInfo(`Gemini API configured: ${status.geminiApiConfigured ? "yes" : "no"}`);
+    printInfo(`Browser profile: ${status.chromeProfile ?? "default Chromium profile"}`);
+    printInfo(`Config path: ${status.configPath}`);
+}

package/dist/setup/doctor.js

@@ -0,0 +1,126 @@
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { getUserName as getAlphaUserName, isLoggedIn as isAlphaLoggedIn } from "@ada/alpha-hub/lib";
+import { formatPiWebAccessDoctorLines, getPiWebAccessStatus } from "../pi/web-access.js";
+import { BROWSER_FALLBACK_PATHS, PANDOC_FALLBACK_PATHS, resolveExecutable } from "../system/executables.js";
+import { readJson } from "../pi/settings.js";
+import { validatePiInstallation } from "../pi/runtime.js";
+import { printInfo, printPanel, printSection } from "../ui/terminal.js";
+import { getCurrentModelSpec } from "../model/commands.js";
+import { buildModelStatusSnapshotFromRecords, getAvailableModelRecords, getSupportedModelRecords } from "../model/catalog.js";
+export function collectStatusSnapshot(options) {
+    const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
+    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
+    const missingPiBits = validatePiInstallation(options.appRoot);
+    const webStatus = getPiWebAccessStatus();
+    const modelStatus = buildModelStatusSnapshotFromRecords(getSupportedModelRecords(options.authPath), getAvailableModelRecords(options.authPath), getCurrentModelSpec(options.settingsPath));
+    return {
+        model: modelStatus.current,
+        modelValid: modelStatus.currentValid,
+        recommendedModel: modelStatus.recommended,
+        recommendedModelReason: modelStatus.recommendationReason,
+        authenticatedModelCount: modelStatus.availableModels.length,
+        authenticatedProviderCount: modelStatus.providers.filter((provider) => provider.configured).length,
+        modelGuidance: modelStatus.guidance,
+        alphaLoggedIn: isAlphaLoggedIn(),
+        alphaUser: isAlphaLoggedIn() ? getAlphaUserName() ?? undefined : undefined,
+        webRouteLabel: webStatus.routeLabel,
+        previewConfigured: Boolean(pandocPath),
+        sessionDir: options.sessionDir,
+        pandocReady: Boolean(pandocPath),
+        browserReady: Boolean(browserPath),
+        piReady: missingPiBits.length === 0,
+        missingPiBits,
+    };
+}
+export function runStatus(options) {
+    const snapshot = collectStatusSnapshot(options);
+    printPanel("Ada Status", [
+        "Current setup summary for the research shell.",
+    ]);
+    printSection("Core");
+    printInfo(`Model: ${snapshot.model ?? "not configured"}`);
+    printInfo(`Model valid: ${snapshot.modelValid ? "yes" : "no"}`);
+    printInfo(`Authenticated models: ${snapshot.authenticatedModelCount}`);
+    printInfo(`Authenticated providers: ${snapshot.authenticatedProviderCount}`);
+    printInfo(`Recommended model: ${snapshot.recommendedModel ?? "not available"}`);
+    printInfo(`alphaXiv: ${snapshot.alphaLoggedIn ? snapshot.alphaUser ?? "configured" : "not configured"}`);
+    printInfo(`Web access: pi-web-access (${snapshot.webRouteLabel})`);
+    printInfo(`Preview: ${snapshot.previewConfigured ? "configured" : "not configured"}`);
+    printSection("Paths");
+    printInfo(`Sessions: ${snapshot.sessionDir}`);
+    printSection("Runtime");
+    printInfo(`Pi runtime: ${snapshot.piReady ? "ready" : "missing files"}`);
+    printInfo(`Pandoc: ${snapshot.pandocReady ? "ready" : "missing"}`);
+    printInfo(`Browser preview: ${snapshot.browserReady ? "ready" : "missing"}`);
+    if (snapshot.missingPiBits.length > 0) {
+        for (const entry of snapshot.missingPiBits) {
+            printInfo(`  missing: ${entry}`);
+        }
+    }
+    if (snapshot.modelGuidance.length > 0) {
+        printSection("Next Steps");
+        for (const line of snapshot.modelGuidance) {
+            printInfo(line);
+        }
+    }
+}
+export function runDoctor(options) {
+    const settings = readJson(options.settingsPath);
+    const modelRegistry = new ModelRegistry(AuthStorage.create(options.authPath));
+    const availableModels = modelRegistry.getAvailable();
+    const pandocPath = resolveExecutable("pandoc", PANDOC_FALLBACK_PATHS);
+    const browserPath = process.env.PUPPETEER_EXECUTABLE_PATH ?? resolveExecutable("google-chrome", BROWSER_FALLBACK_PATHS);
+    const missingPiBits = validatePiInstallation(options.appRoot);
+    printPanel("Ada Doctor", [
+        "Checks config, auth, runtime wiring, and preview dependencies.",
+    ]);
+    console.log(`working dir: ${options.workingDir}`);
+    console.log(`session dir: ${options.sessionDir}`);
+    console.log("");
+    console.log(`alphaXiv auth: ${isAlphaLoggedIn() ? "ok" : "missing"}`);
+    if (isAlphaLoggedIn()) {
+        const name = getAlphaUserName();
+        if (name) {
+            console.log(`  user: ${name}`);
+        }
+    }
+    console.log(`models available: ${availableModels.length}`);
+    if (availableModels.length > 0) {
+        const sample = availableModels
+            .slice(0, 6)
+            .map((model) => `${model.provider}/${model.id}`)
+            .join(", ");
+        console.log(`  sample: ${sample}`);
+    }
+    console.log(`default model: ${typeof settings.defaultProvider === "string" && typeof settings.defaultModel === "string"
+        ? `${settings.defaultProvider}/${settings.defaultModel}`
+        : "not set"}`);
+    const modelStatus = collectStatusSnapshot(options);
+    console.log(`default model valid: ${modelStatus.modelValid ? "yes" : "no"}`);
+    console.log(`authenticated providers: ${modelStatus.authenticatedProviderCount}`);
+    console.log(`authenticated models: ${modelStatus.authenticatedModelCount}`);
+    console.log(`recommended model: ${modelStatus.recommendedModel ?? "not available"}`);
+    if (modelStatus.recommendedModelReason) {
+        console.log(`  why: ${modelStatus.recommendedModelReason}`);
+    }
+    console.log(`pandoc: ${pandocPath ?? "missing"}`);
+    console.log(`browser preview runtime: ${browserPath ?? "missing"}`);
+    for (const line of formatPiWebAccessDoctorLines()) {
+        console.log(line);
+    }
+    console.log(`quiet startup: ${settings.quietStartup === true ? "enabled" : "disabled"}`);
+    console.log(`theme: ${typeof settings.theme === "string" ? settings.theme : "not set"}`);
+    if (missingPiBits.length > 0) {
+        console.log("pi runtime: missing files");
+        for (const entry of missingPiBits) {
+            console.log(`  ${entry}`);
+        }
+    }
+    else {
+        console.log("pi runtime: ok");
+    }
+    for (const line of modelStatus.modelGuidance) {
+        console.log(`next step: ${line}`);
+    }
+    console.log("setup hint: ada setup");
+}