codealmanac 0.2.3 → 0.2.5

package/dist/chunk-BGUID5BS.js

@@ -0,0 +1,766 @@
+#!/usr/bin/env node
+import {
+  AGENT_PROVIDER_IDS,
+  isAgentProviderId,
+  readConfig
+} from "./chunk-P5WGG4FJ.js";
+
+// src/agent/providers/claude/index.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/agent/providers/claude/auth.ts
+import { spawn, spawnSync } from "child_process";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+var AUTH_TIMEOUT_MS = 1e4;
+function resolveClaudeExecutable() {
+  const result = spawnSync("sh", ["-lc", "command -v claude"], {
+    encoding: "utf8"
+  });
+  if (result.status !== 0) return void 0;
+  const found = result.stdout.trim().split("\n")[0]?.trim();
+  return found !== void 0 && found.length > 0 ? found : void 0;
+}
+function resolveCliJsPath() {
+  const require2 = createRequire(import.meta.url);
+  const entry = require2.resolve("@anthropic-ai/claude-agent-sdk");
+  return join(dirname(entry), "cli.js");
+}
+var defaultSpawnCli = (args) => {
+  const command = resolveClaudeExecutable() ?? "claude";
+  const child = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return child;
+};
+var legacySdkSpawnCli = (args) => {
+  const cliPath = resolveCliJsPath();
+  const child = spawn(process.execPath, [cliPath, ...args], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return child;
+};
+async function checkClaudeAuth(spawnCli = defaultSpawnCli) {
+  if (spawnCli === defaultSpawnCli) {
+    const status = await checkClaudeAuthWith(defaultSpawnCli);
+    if (status.loggedIn) return status;
+    return await checkClaudeAuthWith(legacySdkSpawnCli);
+  }
+  return await checkClaudeAuthWith(spawnCli);
+}
+async function checkClaudeAuthWith(spawnCli) {
+  let child;
+  try {
+    child = spawnCli(["auth", "status", "--json"]);
+  } catch {
+    return { loggedIn: false };
+  }
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      settle({ loggedIn: false });
+    }, AUTH_TIMEOUT_MS);
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", () => {
+      settle({ loggedIn: false });
+    });
+    child.on("close", (code) => {
+      if (code !== 0 && stdout.trim().length === 0) {
+        void stderr;
+        settle({ loggedIn: false });
+        return;
+      }
+      try {
+        settle(parseClaudeAuthStatus(stdout.trim()));
+      } catch {
+        settle({ loggedIn: false });
+      }
+    });
+  });
+}
+function parseClaudeAuthStatus(raw) {
+  const parsed = JSON.parse(raw);
+  const loggedIn = parsed.loggedIn === true;
+  const out = { loggedIn };
+  if (typeof parsed.email === "string") out.email = parsed.email;
+  if (typeof parsed.subscriptionType === "string") {
+    out.subscriptionType = parsed.subscriptionType;
+  }
+  if (typeof parsed.authMethod === "string") {
+    out.authMethod = parsed.authMethod;
+  }
+  return out;
+}
+var UNAUTHENTICATED_MESSAGE = "not authenticated to Claude.\n\nOption 1 \u2014 use your Claude subscription (Pro/Max):\n  claude auth login --claudeai\n\nOption 2 \u2014 use a pay-per-token API key:\n  Get one at https://console.anthropic.com\n  export ANTHROPIC_API_KEY=sk-ant-...\n\nVerify with: claude auth status";
+async function assertClaudeAuth(spawnCli = defaultSpawnCli) {
+  const status = await checkClaudeAuth(spawnCli);
+  if (status.loggedIn) {
+    return status;
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey !== void 0 && apiKey.length > 0) {
+    return { loggedIn: true, authMethod: "apiKey" };
+  }
+  const err = new Error(UNAUTHENTICATED_MESSAGE);
+  err.code = "CLAUDE_AUTH_MISSING";
+  throw err;
+}
+
+// src/agent/providers/claude/index.ts
+var DEFAULT_AGENT_MODEL = "claude-sonnet-4-6";
+var metadata = {
+  id: "claude",
+  displayName: "Claude",
+  defaultModel: DEFAULT_AGENT_MODEL,
+  executable: "claude",
+  capabilities: {
+    transport: "sdk",
+    writesFiles: true,
+    supportsModelOverride: true,
+    supportsStreaming: true,
+    supportsSessionId: true,
+    supportsUsage: false,
+    supportsCost: true,
+    supportsProviderReportedTurns: true,
+    supportsProgrammaticSubagents: true,
+    supportsStrictToolAllowlist: false
+  }
+};
+var claudeProvider = {
+  metadata,
+  checkStatus,
+  assertReady,
+  run
+};
+async function run(opts) {
+  const claudeExecutable = resolveClaudeExecutable();
+  const q = query({
+    prompt: opts.prompt,
+    options: {
+      systemPrompt: opts.systemPrompt,
+      allowedTools: opts.allowedTools,
+      agents: opts.agents ?? {},
+      cwd: opts.cwd,
+      model: opts.model ?? metadata.defaultModel ?? void 0,
+      maxTurns: opts.maxTurns ?? 100,
+      ...claudeExecutable !== void 0 ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+      env: {
+        ...process.env,
+        CODEALMANAC_INTERNAL_SESSION: "1"
+      },
+      includePartialMessages: true
+    }
+  });
+  let cost = 0;
+  let turns = 0;
+  let result = "";
+  let sessionId;
+  let success = false;
+  let errorMsg;
+  try {
+    for await (const msg of q) {
+      opts.onMessage?.(msg);
+      if (sessionId === void 0 && typeof msg.session_id === "string") {
+        sessionId = msg.session_id;
+      }
+      if (msg.type === "result") {
+        cost = msg.total_cost_usd;
+        turns = msg.num_turns;
+        if (msg.subtype === "success") {
+          success = true;
+          result = msg.result;
+        } else {
+          success = false;
+          errorMsg = (msg.errors?.join("; ") ?? "") || `agent error: ${msg.subtype}`;
+        }
+      }
+    }
+  } catch (err) {
+    errorMsg = err instanceof Error ? err.message : String(err);
+    success = false;
+  }
+  return { success, cost, turns, result, sessionId, error: errorMsg };
+}
+async function checkStatus(spawnCli) {
+  let auth = { loggedIn: false };
+  try {
+    auth = await checkClaudeAuth(spawnCli);
+  } catch {
+    auth = { loggedIn: false };
+  }
+  const hasApiKey = process.env.ANTHROPIC_API_KEY !== void 0 && process.env.ANTHROPIC_API_KEY.length > 0;
+  const installed = resolveClaudeExecutable() !== void 0;
+  const authenticated = auth.loggedIn || hasApiKey;
+  const detail = authenticated ? auth.email ?? (hasApiKey ? "ANTHROPIC_API_KEY set" : "logged in") : installed ? "not logged in" : `${metadata.executable} not found on PATH`;
+  return { id: metadata.id, installed, authenticated, detail };
+}
+async function assertReady(spawnCli) {
+  await assertClaudeAuth(spawnCli);
+}
+
+// src/agent/providers/cli-status.ts
+import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
+var STATUS_TIMEOUT_MS = 3e3;
+function commandExists(command) {
+  const result = spawnSync2("sh", ["-lc", `command -v ${command}`], {
+    encoding: "utf8"
+  });
+  return result.status === 0 && result.stdout.trim().length > 0;
+}
+function runStatusCommand(command, args) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let child;
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    try {
+      child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      resolve({ ok: false, detail: msg });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (child.exitCode === null && child.signalCode === null) {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, 500).unref();
+      } catch {
+      }
+      settle({ ok: false, detail: `${command} status timed out` });
+    }, STATUS_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      settle({ ok: false, detail: err.message });
+    });
+    child.on("close", (code) => {
+      const text = `${stdout}
+${stderr}`.trim();
+      settle({
+        ok: code === 0,
+        detail: text.split("\n").find((line) => line.trim().length > 0)?.trim() ?? (code === 0 ? "ready" : `${command} exited ${code ?? 1}`)
+      });
+    });
+  });
+}
+
+// src/agent/providers/jsonl-cli.ts
+import { spawn as spawn3 } from "child_process";
+function runJsonlCli(opts) {
+  return new Promise((resolve) => {
+    const child = spawn3(opts.command, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdoutBuf = "";
+    let stderr = "";
+    let cost = 0;
+    let turns = 0;
+    let result = "";
+    let sessionId;
+    let usage;
+    let success = false;
+    let finalSeen = false;
+    let error;
+    const observe = (msg) => {
+      opts.onMessage?.(msg);
+      if (sessionId === void 0 && typeof msg.session_id === "string" && msg.session_id.length > 0) {
+        sessionId = msg.session_id;
+      }
+      if (sessionId === void 0 && typeof msg.thread_id === "string" && msg.thread_id.length > 0) {
+        sessionId = msg.thread_id;
+      }
+      const final = opts.parseFinal(msg);
+      if (final === null) return;
+      finalSeen = true;
+      if (final.cost !== void 0) cost = final.cost;
+      if (final.turns !== void 0) turns = final.turns;
+      if (final.result !== void 0) result = final.result;
+      if (final.sessionId !== void 0) sessionId = final.sessionId;
+      if (final.usage !== void 0) usage = final.usage;
+      if (final.success !== void 0) success = final.success;
+      if (final.error !== void 0) error = final.error;
+    };
+    const flushLines = () => {
+      let idx = stdoutBuf.indexOf("\n");
+      while (idx !== -1) {
+        const rawLine = stdoutBuf.slice(0, idx);
+        stdoutBuf = stdoutBuf.slice(idx + 1);
+        const line = rawLine.trim();
+        if (line.length > 0) {
+          try {
+            observe(JSON.parse(line));
+          } catch {
+          }
+        }
+        idx = stdoutBuf.indexOf("\n");
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBuf += chunk.toString("utf8");
+      flushLines();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolve({
+        success: false,
+        cost,
+        turns,
+        result,
+        sessionId,
+        usage,
+        error: err.code === "ENOENT" ? `${opts.command} not found on PATH` : err.message
+      });
+    });
+    child.on("close", (code) => {
+      flushLines();
+      if (stdoutBuf.trim().length > 0) {
+        try {
+          observe(JSON.parse(stdoutBuf.trim()));
+        } catch {
+        }
+      }
+      if (code === 0 && finalSeen && success) {
+        resolve({ success, cost, turns, result, sessionId, usage });
+        return;
+      }
+      const firstStderr = stderr.trim().split("\n")[0];
+      resolve({
+        success: false,
+        cost,
+        turns,
+        result,
+        sessionId,
+        usage,
+        error: error ?? (firstStderr !== void 0 && firstStderr.length > 0 ? firstStderr : `${opts.command} exited ${code ?? 1}`)
+      });
+    });
+  });
+}
+function parseUsage(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const obj = value;
+  return {
+    inputTokens: numberField(obj, "input_tokens") ?? numberField(obj, "inputTokens"),
+    cachedInputTokens: numberField(obj, "cached_input_tokens") ?? numberField(obj, "cachedInputTokens") ?? numberField(obj, "cacheReadTokens"),
+    outputTokens: numberField(obj, "output_tokens") ?? numberField(obj, "outputTokens"),
+    reasoningOutputTokens: numberField(obj, "reasoning_output_tokens") ?? numberField(obj, "reasoningOutputTokens")
+  };
+}
+function numberField(input, key) {
+  const value = input[key];
+  return typeof value === "number" ? value : void 0;
+}
+
+// src/agent/providers/prompt.ts
+function combinedPrompt(opts, metadata4) {
+  const reviewerFallback = buildReviewerFallback(opts, metadata4);
+  return `${opts.systemPrompt}${reviewerFallback}
+
+---
+
+${opts.prompt}`;
+}
+function buildReviewerFallback(opts, metadata4) {
+  if (metadata4.capabilities.supportsProgrammaticSubagents) return "";
+  const reviewer = opts.agents?.reviewer;
+  if (reviewer === void 0) return "";
+  return "\n\nNon-Claude provider note: this runtime does not receive Claude's nested Agent tool contract. When the writer prompt asks you to invoke the reviewer subagent, perform that review pass yourself before final wiki edits. Treat this reviewer prompt as read-only review guidance:\n\n" + reviewer.prompt;
+}
+
+// src/agent/providers/codex-cli.ts
+var metadata2 = {
+  id: "codex",
+  displayName: "Codex",
+  defaultModel: null,
+  executable: "codex",
+  capabilities: {
+    transport: "cli-jsonl",
+    writesFiles: true,
+    supportsModelOverride: true,
+    supportsStreaming: true,
+    supportsSessionId: false,
+    supportsUsage: true,
+    supportsCost: false,
+    supportsProviderReportedTurns: false,
+    supportsProgrammaticSubagents: false,
+    supportsStrictToolAllowlist: false
+  }
+};
+var codexProvider = {
+  metadata: metadata2,
+  checkStatus: checkStatus2,
+  assertReady: assertReady2,
+  run: run2
+};
+async function run2(opts) {
+  const args = [
+    "exec",
+    "--json",
+    "--sandbox",
+    "workspace-write",
+    "--skip-git-repo-check",
+    "-C",
+    opts.cwd
+  ];
+  if (opts.model !== void 0 && opts.model.length > 0) {
+    args.push("--model", opts.model);
+  }
+  args.push(combinedPrompt({ ...opts, provider: "codex" }, metadata2));
+  return await runJsonlCli({
+    command: metadata2.executable,
+    args,
+    cwd: opts.cwd,
+    env: { ...process.env, CODEALMANAC_INTERNAL_SESSION: "1" },
+    onMessage: opts.onMessage,
+    parseFinal: parseCodexFinal
+  });
+}
+async function checkStatus2() {
+  if (!commandExists(metadata2.executable)) {
+    return {
+      id: metadata2.id,
+      installed: false,
+      authenticated: false,
+      detail: `${metadata2.executable} not found on PATH`
+    };
+  }
+  const auth = await runStatusCommand(metadata2.executable, ["login", "status"]);
+  return {
+    id: metadata2.id,
+    installed: true,
+    authenticated: auth.ok,
+    detail: auth.detail
+  };
+}
+async function assertReady2() {
+  const status = await checkStatus2();
+  if (!status.installed || !status.authenticated) {
+    const err = new Error(`${status.id} not ready: ${status.detail}`);
+    err.code = "AGENT_AUTH_MISSING";
+    throw err;
+  }
+}
+function parseCodexFinal(msg) {
+  if (msg.type === "item.completed") {
+    const item = msg.item;
+    if (item !== null && typeof item === "object") {
+      const obj = item;
+      if (obj.type === "agent_message" && typeof obj.text === "string") {
+        return { result: obj.text };
+      }
+    }
+    return null;
+  }
+  if (msg.type === "turn.completed") {
+    return { success: true, turns: 1, usage: parseUsage(msg.usage) };
+  }
+  if (msg.type === "turn.failed" || msg.type === "error") {
+    return {
+      success: false,
+      error: typeof msg.message === "string" ? msg.message : typeof msg.error === "string" ? msg.error : "codex turn failed"
+    };
+  }
+  return null;
+}
+
+// src/agent/providers/cursor-cli.ts
+var metadata3 = {
+  id: "cursor",
+  displayName: "Cursor",
+  defaultModel: null,
+  executable: "cursor-agent",
+  capabilities: {
+    transport: "cli-jsonl",
+    writesFiles: true,
+    supportsModelOverride: true,
+    supportsStreaming: true,
+    supportsSessionId: true,
+    supportsUsage: true,
+    supportsCost: false,
+    supportsProviderReportedTurns: false,
+    supportsProgrammaticSubagents: false,
+    supportsStrictToolAllowlist: false
+  }
+};
+var cursorProvider = {
+  metadata: metadata3,
+  checkStatus: checkStatus3,
+  assertReady: assertReady3,
+  run: run3
+};
+async function run3(opts) {
+  const args = [
+    "--print",
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--trust",
+    "--workspace",
+    opts.cwd
+  ];
+  if (opts.model !== void 0 && opts.model.length > 0) {
+    args.push("--model", opts.model);
+  }
+  args.push(combinedPrompt({ ...opts, provider: "cursor" }, metadata3));
+  return await runJsonlCli({
+    command: metadata3.executable,
+    args,
+    cwd: opts.cwd,
+    env: { ...process.env, CODEALMANAC_INTERNAL_SESSION: "1" },
+    onMessage: opts.onMessage,
+    parseFinal: parseCursorFinal
+  });
+}
+async function checkStatus3() {
+  if (!commandExists(metadata3.executable)) {
+    return {
+      id: metadata3.id,
+      installed: false,
+      authenticated: false,
+      detail: `${metadata3.executable} not found on PATH`
+    };
+  }
+  const auth = await runStatusCommand(metadata3.executable, ["status"]);
+  return {
+    id: metadata3.id,
+    installed: true,
+    authenticated: auth.ok,
+    detail: auth.detail
+  };
+}
+async function assertReady3() {
+  const status = await checkStatus3();
+  if (!status.installed || !status.authenticated) {
+    const err = new Error(`${status.id} not ready: ${status.detail}`);
+    err.code = "AGENT_AUTH_MISSING";
+    throw err;
+  }
+}
+function parseCursorFinal(msg) {
+  if (msg.type !== "result") return null;
+  const isError = msg.is_error === true || msg.subtype !== "success";
+  return {
+    success: !isError,
+    turns: 1,
+    result: typeof msg.result === "string" ? msg.result : "",
+    sessionId: typeof msg.session_id === "string" ? msg.session_id : void 0,
+    usage: parseUsage(msg.usage),
+    error: isError ? typeof msg.result === "string" ? msg.result : `cursor result: ${String(msg.subtype ?? "error")}` : void 0
+  };
+}
+
+// src/agent/providers/status.ts
+async function assertAgentAuth(args) {
+  await getAgentProvider(args.provider).assertReady(args.spawnCli);
+}
+async function listProviderStatuses(spawnCli) {
+  const out = [];
+  for (const id of AGENT_PROVIDER_IDS) {
+    out.push(await getAgentProvider(id).checkStatus(spawnCli));
+  }
+  return out;
+}
+
+// src/agent/providers/index.ts
+var AGENT_PROVIDERS = {
+  claude: claudeProvider,
+  codex: codexProvider,
+  cursor: cursorProvider
+};
+function getAgentProvider(id) {
+  return AGENT_PROVIDERS[id];
+}
+var AGENT_PROVIDER_METADATA = {
+  claude: claudeProvider.metadata,
+  codex: codexProvider.metadata,
+  cursor: cursorProvider.metadata
+};
+
+// src/agent/provider-view.ts
+var LOGIN_FIXES = {
+  claude: "run: claude auth login --claudeai",
+  codex: "run: codex login",
+  cursor: "run: cursor-agent login"
+};
+var INSTALL_FIXES = {
+  claude: "install Claude Code, then run: claude auth login --claudeai",
+  codex: "install Codex CLI, then run: codex login",
+  cursor: "install cursor-agent, then run: cursor-agent login"
+};
+function getProviderLabel(id) {
+  return AGENT_PROVIDER_METADATA[id].displayName;
+}
+function getProviderDefaultModel(id) {
+  return AGENT_PROVIDER_METADATA[id].defaultModel;
+}
+async function buildProviderSetupView(opts = {}) {
+  const config = opts.config ?? await readConfig();
+  const statuses = opts.statuses ?? await listProviderStatuses(opts.spawnCli);
+  const statusById = new Map(statuses.map((status) => [status.id, status]));
+  const recommendedProvider = chooseRecommendedProvider(statuses);
+  const choices = AGENT_PROVIDER_IDS.map((id) => {
+    const status = statusById.get(id) ?? missingStatus(id);
+    const readiness = getReadiness(status);
+    const configuredModel = normalizeModel(config.agent.models[id]);
+    const providerDefaultModel = getProviderDefaultModel(id);
+    const effectiveModel = configuredModel ?? providerDefaultModel;
+    return {
+      id,
+      label: getProviderLabel(id),
+      selected: id === config.agent.default,
+      recommended: id === recommendedProvider,
+      readiness,
+      ready: readiness === "ready",
+      installed: status.installed,
+      authenticated: status.authenticated,
+      effectiveModel,
+      providerDefaultModel,
+      configuredModel,
+      account: status.authenticated ? accountFromDetail(status.detail) : null,
+      detail: status.detail,
+      fixCommand: fixFor(id, readiness),
+      modelChoices: buildProviderModelChoices(id, configuredModel)
+    };
+  });
+  return {
+    defaultProvider: config.agent.default,
+    recommendedProvider,
+    choices
+  };
+}
+function buildProviderModelChoices(id, configuredModel = null) {
+  const choices = [];
+  if (configuredModel !== null) {
+    choices.push({
+      value: configuredModel,
+      label: configuredModel,
+      recommended: false,
+      source: "configured"
+    });
+  }
+  const providerDefault = getProviderDefaultModel(id);
+  if (providerDefault !== null) {
+    if (!choices.some((choice) => choice.value === providerDefault)) {
+      choices.push({
+        value: providerDefault,
+        label: providerDefault,
+        recommended: true,
+        source: "provider-default"
+      });
+    } else {
+      choices[0] = { ...choices[0], recommended: true };
+    }
+  } else {
+    choices.push({
+      value: null,
+      label: "provider default",
+      recommended: true,
+      source: "provider-default"
+    });
+  }
+  choices.push({
+    value: "__custom__",
+    label: "custom model id",
+    recommended: false,
+    source: "custom"
+  });
+  return choices;
+}
+function chooseRecommendedProvider(statuses) {
+  const ready = statuses.filter((status) => status.installed && status.authenticated).map((status) => status.id);
+  if (ready.includes("claude")) return "claude";
+  for (const id of AGENT_PROVIDER_IDS) {
+    if (ready.includes(id)) return id;
+  }
+  return "claude";
+}
+function parseAgentSelection(value) {
+  const [rawProvider, ...modelParts] = value.split("/");
+  if (rawProvider === void 0 || !isAgentProviderId(rawProvider)) {
+    return { provider: null };
+  }
+  const model = modelParts.join("/");
+  return {
+    provider: rawProvider,
+    model: model.length > 0 ? model : void 0
+  };
+}
+function getReadiness(status) {
+  if (!status.installed) return "missing";
+  if (!status.authenticated) return "not-authenticated";
+  return "ready";
+}
+function fixFor(id, readiness) {
+  if (readiness === "ready") return null;
+  if (readiness === "missing") return INSTALL_FIXES[id];
+  return LOGIN_FIXES[id];
+}
+function accountFromDetail(detail) {
+  const clean = detail.trim();
+  if (clean.length === 0 || clean === "ready" || clean === "logged in" || clean === "ANTHROPIC_API_KEY set") {
+    return null;
+  }
+  return clean;
+}
+function normalizeModel(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function missingStatus(id) {
+  return {
+    id,
+    installed: false,
+    authenticated: false,
+    detail: "provider status unavailable"
+  };
+}
+
+export {
+  checkClaudeAuth,
+  DEFAULT_AGENT_MODEL,
+  assertAgentAuth,
+  getAgentProvider,
+  getProviderLabel,
+  getProviderDefaultModel,
+  buildProviderSetupView,
+  buildProviderModelChoices,
+  parseAgentSelection
+};
+//# sourceMappingURL=chunk-BGUID5BS.js.map