@companion-ai/feynman 0.2.0

package/dist/model/catalog.js

@@ -0,0 +1,238 @@
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+const PROVIDER_LABELS = {
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    "openai-codex": "OpenAI Codex",
+    openrouter: "OpenRouter",
+    google: "Google",
+    "google-gemini-cli": "Google Gemini CLI",
+    zai: "Z.AI / GLM",
+    minimax: "MiniMax",
+    "minimax-cn": "MiniMax (China)",
+    "github-copilot": "GitHub Copilot",
+    "vercel-ai-gateway": "Vercel AI Gateway",
+    opencode: "OpenCode",
+    "opencode-go": "OpenCode Go",
+    "kimi-coding": "Kimi / Moonshot",
+    xai: "xAI",
+    groq: "Groq",
+    mistral: "Mistral",
+    cerebras: "Cerebras",
+    huggingface: "Hugging Face",
+    "amazon-bedrock": "Amazon Bedrock",
+    "azure-openai-responses": "Azure OpenAI Responses",
+};
+const RESEARCH_MODEL_PREFERENCES = [
+    {
+        spec: "anthropic/claude-opus-4-6",
+        reason: "strong long-context reasoning for source-heavy research work",
+    },
+    {
+        spec: "anthropic/claude-opus-4-5",
+        reason: "strong long-context reasoning for source-heavy research work",
+    },
+    {
+        spec: "anthropic/claude-sonnet-4-6",
+        reason: "balanced reasoning and speed for iterative research sessions",
+    },
+    {
+        spec: "anthropic/claude-sonnet-4-5",
+        reason: "balanced reasoning and speed for iterative research sessions",
+    },
+    {
+        spec: "openai/gpt-5.4",
+        reason: "strong general reasoning and drafting quality for research tasks",
+    },
+    {
+        spec: "openai/gpt-5",
+        reason: "strong general reasoning and drafting quality for research tasks",
+    },
+    {
+        spec: "openai-codex/gpt-5.4",
+        reason: "strong research + coding balance when Pi exposes Codex directly",
+    },
+    {
+        spec: "google/gemini-3-pro-preview",
+        reason: "good fallback for broad web-and-doc research work",
+    },
+    {
+        spec: "google/gemini-2.5-pro",
+        reason: "good fallback for broad web-and-doc research work",
+    },
+    {
+        spec: "openrouter/openai/gpt-5.1-codex",
+        reason: "good routed fallback when only OpenRouter is configured",
+    },
+    {
+        spec: "zai/glm-5",
+        reason: "good fallback when GLM is the available research model",
+    },
+    {
+        spec: "kimi-coding/kimi-k2-thinking",
+        reason: "good fallback when Kimi is the available research model",
+    },
+];
+const PROVIDER_SORT_ORDER = [
+    "anthropic",
+    "openai",
+    "openai-codex",
+    "google",
+    "openrouter",
+    "zai",
+    "kimi-coding",
+    "minimax",
+    "minimax-cn",
+    "github-copilot",
+    "vercel-ai-gateway",
+];
+function formatProviderLabel(provider) {
+    return PROVIDER_LABELS[provider] ?? provider;
+}
+function modelSpec(model) {
+    return `${model.provider}/${model.id}`;
+}
+function compareByResearchPreference(left, right) {
+    const leftSpec = modelSpec(left);
+    const rightSpec = modelSpec(right);
+    const leftIndex = RESEARCH_MODEL_PREFERENCES.findIndex((entry) => entry.spec === leftSpec);
+    const rightIndex = RESEARCH_MODEL_PREFERENCES.findIndex((entry) => entry.spec === rightSpec);
+    if (leftIndex !== -1 || rightIndex !== -1) {
+        if (leftIndex === -1)
+            return 1;
+        if (rightIndex === -1)
+            return -1;
+        return leftIndex - rightIndex;
+    }
+    const leftProviderIndex = PROVIDER_SORT_ORDER.indexOf(left.provider);
+    const rightProviderIndex = PROVIDER_SORT_ORDER.indexOf(right.provider);
+    if (leftProviderIndex !== -1 || rightProviderIndex !== -1) {
+        if (leftProviderIndex === -1)
+            return 1;
+        if (rightProviderIndex === -1)
+            return -1;
+        return leftProviderIndex - rightProviderIndex;
+    }
+    return modelSpec(left).localeCompare(modelSpec(right));
+}
+function sortProviders(left, right) {
+    if (left.configured !== right.configured) {
+        return left.configured ? -1 : 1;
+    }
+    if (left.current !== right.current) {
+        return left.current ? -1 : 1;
+    }
+    if (left.recommended !== right.recommended) {
+        return left.recommended ? -1 : 1;
+    }
+    const leftIndex = PROVIDER_SORT_ORDER.indexOf(left.id);
+    const rightIndex = PROVIDER_SORT_ORDER.indexOf(right.id);
+    if (leftIndex !== -1 || rightIndex !== -1) {
+        if (leftIndex === -1)
+            return 1;
+        if (rightIndex === -1)
+            return -1;
+        return leftIndex - rightIndex;
+    }
+    return left.label.localeCompare(right.label);
+}
+function createModelRegistry(authPath) {
+    return new ModelRegistry(AuthStorage.create(authPath));
+}
+export function getAvailableModelRecords(authPath) {
+    return createModelRegistry(authPath)
+        .getAvailable()
+        .map((model) => ({ provider: model.provider, id: model.id, name: model.name }));
+}
+export function getSupportedModelRecords(authPath) {
+    return createModelRegistry(authPath)
+        .getAll()
+        .map((model) => ({ provider: model.provider, id: model.id, name: model.name }));
+}
+export function chooseRecommendedModel(authPath) {
+    const available = getAvailableModelRecords(authPath).sort(compareByResearchPreference);
+    if (available.length === 0) {
+        return undefined;
+    }
+    const matchedPreference = RESEARCH_MODEL_PREFERENCES.find((entry) => entry.spec === modelSpec(available[0]));
+    if (matchedPreference) {
+        return matchedPreference;
+    }
+    return {
+        spec: modelSpec(available[0]),
+        reason: "best currently authenticated fallback for research work",
+    };
+}
+export function buildModelStatusSnapshotFromRecords(supported, available, current) {
+    const availableSpecs = available
+        .slice()
+        .sort(compareByResearchPreference)
+        .map((model) => modelSpec(model));
+    const recommended = available.length > 0
+        ? (() => {
+            const preferred = available.slice().sort(compareByResearchPreference)[0];
+            const matched = RESEARCH_MODEL_PREFERENCES.find((entry) => entry.spec === modelSpec(preferred));
+            return {
+                spec: modelSpec(preferred),
+                reason: matched?.reason ?? "best currently authenticated fallback for research work",
+            };
+        })()
+        : undefined;
+    const currentValid = current ? availableSpecs.includes(current) : false;
+    const providerMap = new Map();
+    for (const model of supported) {
+        const provider = providerMap.get(model.provider) ?? {
+            id: model.provider,
+            label: formatProviderLabel(model.provider),
+            supportedModels: 0,
+            availableModels: 0,
+            configured: false,
+            current: false,
+            recommended: false,
+        };
+        provider.supportedModels += 1;
+        provider.current ||= current?.startsWith(`${model.provider}/`) ?? false;
+        provider.recommended ||= recommended?.spec.startsWith(`${model.provider}/`) ?? false;
+        providerMap.set(model.provider, provider);
+    }
+    for (const model of available) {
+        const provider = providerMap.get(model.provider) ?? {
+            id: model.provider,
+            label: formatProviderLabel(model.provider),
+            supportedModels: 0,
+            availableModels: 0,
+            configured: false,
+            current: false,
+            recommended: false,
+        };
+        provider.availableModels += 1;
+        provider.configured = true;
+        provider.current ||= current?.startsWith(`${model.provider}/`) ?? false;
+        provider.recommended ||= recommended?.spec.startsWith(`${model.provider}/`) ?? false;
+        providerMap.set(model.provider, provider);
+    }
+    const guidance = [];
+    if (available.length === 0) {
+        guidance.push("No authenticated Pi models are available yet.");
+        guidance.push("Run `feynman model login <provider>` or add provider credentials that Pi can see.");
+        guidance.push("After auth is in place, rerun `feynman model list` or `feynman setup model`.");
+    }
+    else if (!current) {
+        guidance.push(`No default research model is set. Recommended: ${recommended?.spec}.`);
+        guidance.push("Run `feynman model set <provider/model>` or `feynman setup model`.");
+    }
+    else if (!currentValid) {
+        guidance.push(`Configured default model is unavailable: ${current}.`);
+        if (recommended) {
+            guidance.push(`Switch to the current research recommendation: ${recommended.spec}.`);
+        }
+    }
+    return {
+        current,
+        currentValid,
+        recommended: recommended?.spec,
+        recommendationReason: recommended?.reason,
+        availableModels: availableSpecs,
+        providers: Array.from(providerMap.values()).sort(sortProviders),
+        guidance,
+    };
+}

package/dist/model/commands.js

@@ -0,0 +1,165 @@
+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 { printInfo, printSection, printSuccess, printWarning } from "../ui/terminal.js";
+import { buildModelStatusSnapshotFromRecords, 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) {
+    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}`);
+            printInfo(`Open this 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}`);
+}
+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 \`feynman 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) {
+    const status = collectModelStatus(settingsPath, authPath);
+    if (status.availableModels.length === 0) {
+        printWarning("No Pi models are currently authenticated for Feynman.");
+        for (const line of status.guidance) {
+            printInfo(line);
+        }
+        printInfo("Tip: run `feynman model login <provider>` if your provider supports Pi OAuth login.");
+        return;
+    }
+    const choices = status.availableModels.map((spec) => {
+        const markers = [
+            spec === status.recommended ? "recommended" : undefined,
+            spec === status.current ? "current" : undefined,
+        ].filter(Boolean);
+        return `${spec}${markers.length > 0 ? ` (${markers.join(", ")})` : ""}`;
+    });
+    choices.push(`Keep current (${status.current ?? "unset"})`);
+    const defaultIndex = status.current ? Math.max(0, status.availableModels.indexOf(status.current)) : 0;
+    const selection = await promptChoice("Select your default research model:", choices, defaultIndex >= 0 ? defaultIndex : 0);
+    if (selection >= status.availableModels.length) {
+        printInfo("Skipped (keeping current model)");
+        return;
+    }
+    setDefaultModelSpec(settingsPath, authPath, status.availableModels[selection]);
+}

package/dist/pi/launch.js

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { buildPiArgs, buildPiEnv, resolvePiPaths } from "./runtime.js";
+export async function launchPiChat(options) {
+    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/runtime.js

@@ -0,0 +1,70 @@
+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, ".feynman", "SYSTEM.md"),
+        piWorkspaceNodeModulesPath: resolve(appRoot, ".feynman", "npm", "node_modules"),
+    };
+}
+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);
+    return {
+        ...process.env,
+        FEYNMAN_VERSION: options.feynmanVersion,
+        FEYNMAN_SESSION_DIR: options.sessionDir,
+        FEYNMAN_MEMORY_DIR: resolve(dirname(options.feynmanAgentDir), "memory"),
+        FEYNMAN_NODE_EXECUTABLE: process.execPath,
+        FEYNMAN_BIN_PATH: resolve(options.appRoot, "bin", "feynman.js"),
+        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),
+    };
+}

package/dist/pi/settings.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+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 normalizeFeynmanSettings(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 = "feynman";
+    settings.quietStartup = true;
+    settings.collapseChangelog = true;
+    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, ".feynman", "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}`,
+    ];
+}