artbot 0.1.0

package/dist/chunks/interactive-DQDPPJBS.js

@@ -0,0 +1,994 @@
+import {
+  assessLocalSetup,
+  pathExists,
+  runSetupWizard
+} from "./chunk-KKAF45ZB.js";
+
+// src/interactive-app.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box as Box2, Text as Text2, render, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+
+// src/tui/helpers.ts
+function text(text2, tone = "neutral", weight = "normal") {
+  return { kind: "text", text: text2, tone, weight };
+}
+function spacer(size = 1) {
+  return { kind: "spacer", size };
+}
+function divider(label, tone = "muted") {
+  return { kind: "divider", label, tone };
+}
+function panel(title, children, options = {}) {
+  return {
+    kind: "panel",
+    title,
+    subtitle: options.subtitle,
+    accent: options.accent,
+    width: options.width,
+    children
+  };
+}
+function stack(direction, children, gap = 1) {
+  return {
+    kind: "stack",
+    direction,
+    gap,
+    children
+  };
+}
+function commandHint(command, description, tone = "accent") {
+  return { command, description, tone };
+}
+function table(columns, rows) {
+  return { kind: "table", columns, rows };
+}
+function progressBar(value, tone = "accent", label, width) {
+  return { kind: "progress-bar", value: Math.min(1, Math.max(0, value)), tone, label, width };
+}
+function formatElapsed(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+
+// src/tui/status-rail.ts
+function statusDot(state) {
+  switch (state) {
+    case "healthy":
+      return { symbol: "\u25CF", tone: "success" };
+    case "degraded":
+      return { symbol: "\u25CF", tone: "warning" };
+    case "offline":
+      return { symbol: "\u25CF", tone: "danger" };
+    default:
+      return { symbol: "\u25CB", tone: "muted" };
+  }
+}
+function statusEntry(name, status) {
+  const dot = statusDot(status.state);
+  const detail = status.detail ? `: ${status.detail}` : "";
+  return text(`${dot.symbol} ${name}${detail}`, dot.tone);
+}
+var StatusRail = (props) => stack("column", [
+  stack("row", [statusEntry("LM Studio", props.llm), statusEntry("API", props.api), statusEntry("Worker", props.worker)], 3),
+  stack("row", [statusEntry("Auth", props.auth), statusEntry("Licensed", props.licensed)], 3)
+]);
+StatusRail.displayName = "StatusRail";
+
+// src/tui/command-bar.ts
+var CommandBar = ({ command }) => text(
+  command.mode === "running" ? "Running pipeline..." : command.mode === "setup" ? "Setup mode \u2014 run /setup to configure" : "Type /research <artist> or artist name. /help for all commands.",
+  command.mode === "running" ? "accent" : "muted",
+  "dim"
+);
+CommandBar.displayName = "CommandBar";
+function buildDefaultCommandHints() {
+  return [
+    commandHint("/research <artist>", "Start artist price research"),
+    commandHint("/work <artist> --title <title>", "Start work-specific research"),
+    commandHint("/setup", "Verify LM Studio, API, worker, and auth"),
+    commandHint("/auth", "Inspect or capture browser session state"),
+    commandHint("/doctor", "Run a local environment health check"),
+    commandHint("/runs", "Inspect recent or active runs")
+  ];
+}
+
+// src/tui/run-progress-view.ts
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function stageIcon(state, tick) {
+  switch (state) {
+    case "done":
+      return { symbol: "\u2713", tone: "success" };
+    case "running":
+      return { symbol: SPINNER[tick % SPINNER.length], tone: "accent" };
+    case "blocked":
+      return { symbol: "!", tone: "warning" };
+    case "failed":
+      return { symbol: "\u2717", tone: "danger" };
+    default:
+      return { symbol: "\u25CB", tone: "muted" };
+  }
+}
+var RunProgressView = ({ progress }) => {
+  const tick = progress.tick ?? 0;
+  if (progress.status === "idle") {
+    return text("  No active research. Type /research <artist> to begin.", "muted", "dim");
+  }
+  const isActive = progress.status === "running" || progress.status === "queued";
+  const stateTone = progress.status === "running" ? "accent" : progress.status === "completed" ? "success" : progress.status === "failed" ? "danger" : "muted";
+  const statusIcon = progress.status === "completed" ? "\u2713" : progress.status === "failed" ? "\u2717" : isActive ? SPINNER[tick % SPINNER.length] : "\u25B6";
+  const headerParts = [
+    text(`${statusIcon} ${progress.artistName ?? "n/a"}`, stateTone, "strong"),
+    text(progress.status.toUpperCase(), stateTone, "strong")
+  ];
+  if (progress.elapsed != null) {
+    headerParts.push(text(formatElapsed(progress.elapsed), "muted", "dim"));
+  }
+  const lines = [
+    stack("row", headerParts, 2),
+    text(`  ${progress.runId ?? "n/a"}`, "muted", "dim")
+  ];
+  const doneCount = progress.stages.filter((s) => s.state === "done").length;
+  const total = progress.stages.length;
+  const ratio = total > 0 ? doneCount / total : 0;
+  const barLabel = isActive && progress.elapsed != null ? formatElapsed(progress.elapsed) + " elapsed" : void 0;
+  lines.push(spacer(1));
+  lines.push(
+    progressBar(
+      progress.status === "completed" ? 1 : progress.status === "failed" ? ratio : ratio,
+      progress.status === "completed" ? "success" : progress.status === "failed" ? "danger" : "accent",
+      barLabel
+    )
+  );
+  lines.push(spacer(1));
+  if (isActive) {
+    for (const stage of progress.stages) {
+      const icon = stageIcon(stage.state, tick);
+      const stateLabel = stage.state === "running" ? "running..." : stage.state;
+      lines.push(stack("row", [text(`  ${icon.symbol} ${stage.label}`, icon.tone), text(stateLabel, icon.tone, "dim")], 1));
+    }
+  } else {
+    const stages = [];
+    for (let i = 0; i < progress.stages.length; i++) {
+      const stage = progress.stages[i];
+      const icon = stageIcon(stage.state, tick);
+      stages.push(text(`${icon.symbol} ${stage.label}`, icon.tone));
+      if (i < progress.stages.length - 1) {
+        stages.push(text("\u2192", "muted", "dim"));
+      }
+    }
+    lines.push(stack("row", stages, 1));
+  }
+  if (progress.summaryLines.length > 0) {
+    lines.push(spacer(1));
+    lines.push(text(`  ${progress.summaryLines.join("  \xB7  ")}`, "muted"));
+  }
+  if (progress.blockerSummary) {
+    lines.push(text(`  \u26A0 ${progress.blockerSummary}`, "warning"));
+  }
+  return stack("column", lines, 0);
+};
+RunProgressView.displayName = "RunProgressView";
+
+// src/tui/report-workspace.ts
+function recordTone(priceType) {
+  switch (priceType) {
+    case "hammer_price":
+    case "realized_price":
+    case "realized_with_buyers_premium":
+      return "success";
+    case "asking_price":
+      return "accent";
+    case "estimate":
+      return "warning";
+    default:
+      return "muted";
+  }
+}
+var ReportWorkspace = ({ report }) => {
+  const lines = [];
+  const coverageText = report.sourceCoverage.map((e) => `${e.label}: ${e.value}`).join("  \xB7  ");
+  lines.push(text(`  Sources   ${coverageText}`, "muted"));
+  const valuationText = report.valuation.map((e) => `${e.label}: ${e.value}`).join("  \xB7  ");
+  lines.push(text(`  Values    ${valuationText}`, "muted"));
+  if (report.acceptedRecords.length > 0) {
+    lines.push(spacer(1));
+    const columns = [
+      { key: "price", label: "Price", width: 14, tone: "neutral" },
+      { key: "title", label: "Title", width: 34, tone: "neutral" },
+      { key: "source", label: "Source", width: 22, tone: "muted" },
+      { key: "detail", label: "Date / Info", width: 20, tone: "muted" }
+    ];
+    const rows = report.acceptedRecords.map((record) => ({
+      price: { text: record.price, tone: recordTone(record.priceType) },
+      title: { text: record.workTitle, tone: "neutral" },
+      source: { text: record.sourceName, tone: "muted" },
+      detail: { text: record.detail ?? "", tone: "muted" }
+    }));
+    lines.push(table(columns, rows));
+  }
+  if (lines.length === 0) {
+    return text("  No results yet.", "muted", "dim");
+  }
+  return stack("column", lines, 0);
+};
+ReportWorkspace.displayName = "ReportWorkspace";
+
+// src/tui/side-detail-pane.ts
+var SideDetailPane = ({ detail }) => {
+  const lines = [];
+  for (const blocker of detail.blockers) {
+    if (blocker && blocker !== "No blockers recorded.") {
+      lines.push(text(`\u26A0 ${blocker}`, "warning"));
+    }
+  }
+  for (const url of detail.evidence) {
+    lines.push(text(url, "muted", "dim"));
+  }
+  if (lines.length === 0) {
+    return text("No evidence collected yet.", "muted", "dim");
+  }
+  return stack("column", lines, 0);
+};
+SideDetailPane.displayName = "SideDetailPane";
+
+// src/tui/shell.ts
+var ArtbotTuiShell = ({ model }) => {
+  const children = [];
+  children.push(StatusRail(model.status));
+  children.push(divider("Pipeline"));
+  children.push(RunProgressView({ progress: model.progress }));
+  const hasRun = model.progress.status !== "idle";
+  if (hasRun) {
+    children.push(divider("Results"));
+    children.push(ReportWorkspace({ report: model.report }));
+  }
+  if (model.detail.evidence.length > 0) {
+    children.push(divider("Evidence"));
+    for (const url of model.detail.evidence) {
+      children.push(text(`  ${url}`, "muted", "dim"));
+    }
+  }
+  for (const section of model.report.diagnostics) {
+    const skip = /* @__PURE__ */ new Set(["No detail available.", "No additional diagnostics.", "Slash command ready."]);
+    const meaningful = section.lines.filter((l) => !skip.has(l));
+    if (meaningful.length > 0) {
+      children.push(divider(section.title));
+      for (const line of meaningful) {
+        const tone = section.tone === "warning" ? "warning" : "muted";
+        children.push(text(`  ${line}`, tone));
+      }
+    }
+  }
+  children.push(spacer(1));
+  children.push(CommandBar({ command: model.command }));
+  return panel(model.title, children, { accent: "accent", subtitle: model.subtitle });
+};
+ArtbotTuiShell.displayName = "ArtbotTuiShell";
+
+// src/tui/ink-renderer.tsx
+import { Fragment } from "react";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function toneColor(tone) {
+  switch (tone) {
+    case "accent":
+      return "cyan";
+    case "success":
+      return "green";
+    case "warning":
+      return "yellow";
+    case "danger":
+      return "red";
+    case "muted":
+      return "gray";
+    case "inverse":
+      return "black";
+    default:
+      return "white";
+  }
+}
+function renderText(node, key) {
+  return /* @__PURE__ */ jsx(Text, { color: toneColor(node.tone), dimColor: node.weight === "dim", bold: node.weight === "strong", children: node.text }, key);
+}
+function renderSpacer(node, key) {
+  return /* @__PURE__ */ jsx(Text, { children: "\n".repeat(Math.max(1, node.size)) }, key);
+}
+function renderDivider(node, key) {
+  return /* @__PURE__ */ jsx(Text, { color: toneColor(node.tone), dimColor: true, children: node.label ? `\u2500\u2500 ${node.label} ${"\u2500".repeat(Math.max(8, 28 - node.label.length))}` : "\u2500".repeat(32) }, key);
+}
+function renderMetric(node, key) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: toneColor(node.tone), paddingX: 1, marginRight: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: node.label }),
+    /* @__PURE__ */ jsx(Text, { color: toneColor(node.tone), bold: true, children: node.value }),
+    node.hint ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: node.hint }) : null
+  ] }, key);
+}
+function renderList(node, key) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginRight: 1, children: [
+    node.title ? /* @__PURE__ */ jsx(Text, { color: "gray", bold: true, children: node.title }) : null,
+    node.items.map((item, index) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: item.detail ? 1 : 0, children: [
+      /* @__PURE__ */ jsxs(Text, { color: toneColor(item.tone), children: [
+        item.label,
+        item.value ? /* @__PURE__ */ jsxs(Text, { color: "white", children: [
+          ": ",
+          item.value
+        ] }) : null
+      ] }),
+      item.detail ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: item.detail }) : null
+    ] }, `${key}-item-${index}`))
+  ] }, key);
+}
+function renderStack(node, key) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: node.direction, children: node.children.map((child, index) => /* @__PURE__ */ jsx(
+    Box,
+    {
+      marginRight: node.direction === "row" && index < node.children.length - 1 ? node.gap ?? 1 : 0,
+      marginBottom: node.direction === "column" && index < node.children.length - 1 ? node.gap ?? 1 : 0,
+      children: /* @__PURE__ */ jsx(RenderTuiNode, { node: child })
+    },
+    `${key}-child-${index}`
+  )) }, key);
+}
+function renderSplit(node, key) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: node.direction, children: node.children.map((child, index) => /* @__PURE__ */ jsx(Box, { flexGrow: node.ratios?.[index] ?? 1, marginRight: node.direction === "row" && index === 0 ? 1 : 0, children: /* @__PURE__ */ jsx(RenderTuiNode, { node: child }) }, `${key}-split-${index}`)) }, key);
+}
+function renderPanel(node, key) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: toneColor(node.accent), paddingX: 1, paddingY: 0, width: node.width, children: [
+    node.title ? /* @__PURE__ */ jsx(Text, { color: toneColor(node.accent), bold: true, children: node.title }) : null,
+    node.subtitle ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: node.subtitle }) : null,
+    node.children.map((child, index) => /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(RenderTuiNode, { node: child }) }, `${key}-panel-${index}`))
+  ] }, key);
+}
+function renderTable(node, key) {
+  if (node.rows.length === 0) return null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box, { children: node.columns.map((col, i) => /* @__PURE__ */ jsx(Box, { width: col.width, marginRight: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", bold: true, children: col.label }) }, `${key}-hdr-${i}`)) }),
+    /* @__PURE__ */ jsx(Box, { children: node.columns.map((col, i) => /* @__PURE__ */ jsx(Box, { width: col.width, marginRight: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "\u2500".repeat(Math.min(col.width, col.label.length + 2)) }) }, `${key}-sep-${i}`)) }),
+    node.rows.map((row, ri) => /* @__PURE__ */ jsx(Box, { children: node.columns.map((col, ci) => {
+      const cell = row[col.key];
+      return /* @__PURE__ */ jsx(Box, { width: col.width, marginRight: 1, children: /* @__PURE__ */ jsx(Text, { color: toneColor(cell?.tone ?? col.tone), wrap: "truncate", children: cell?.text ?? "" }) }, `${key}-cell-${ri}-${ci}`);
+    }) }, `${key}-row-${ri}`))
+  ] }, key);
+}
+function renderProgressBar(node, key) {
+  const width = node.width ?? 24;
+  const filled = Math.round(node.value * width);
+  const empty = width - filled;
+  const pct = Math.round(node.value * 100);
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: toneColor(node.tone), children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      " ",
+      pct,
+      "%"
+    ] }),
+    node.label ? /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  ",
+      node.label
+    ] }) : null
+  ] }, key);
+}
+function renderKeyHint(node, key) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "row", gap: 2, children: node.keys.map((k, i) => /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsxs(Text, { color: toneColor(k.tone ?? "accent"), bold: true, children: [
+      "[",
+      k.key,
+      "]"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      " ",
+      k.label
+    ] })
+  ] }, `${key}-kh-${i}`)) }, key);
+}
+function RenderTuiNode({ node }) {
+  switch (node.kind) {
+    case "text":
+      return renderText(node, "text");
+    case "spacer":
+      return renderSpacer(node, "spacer");
+    case "divider":
+      return renderDivider(node, "divider");
+    case "metric":
+      return renderMetric(node, "metric");
+    case "list":
+      return renderList(node, "list");
+    case "stack":
+      return renderStack(node, "stack");
+    case "split":
+      return renderSplit(node, "split");
+    case "panel":
+      return renderPanel(node, "panel");
+    case "table":
+      return renderTable(node, "table");
+    case "progress-bar":
+      return renderProgressBar(node, "progress-bar");
+    case "key-hint":
+      return renderKeyHint(node, "key-hint");
+    default:
+      return null;
+  }
+}
+
+// src/interactive-app.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function fmtCurrency(amount, currency) {
+  try {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency,
+      maximumFractionDigits: 0
+    }).format(amount);
+  } catch {
+    return `${amount.toLocaleString("en-US")} ${currency}`;
+  }
+}
+function asRuntimeStatus(label, ok, detail, tone) {
+  return {
+    label,
+    state: ok ? "healthy" : "offline",
+    detail,
+    tone: tone ?? (ok ? "success" : "danger")
+  };
+}
+function blockerSummary(details) {
+  if (!details?.summary?.acceptance_reason_breakdown) return void 0;
+  const entries = Object.entries(details.summary.acceptance_reason_breakdown).filter(([, count]) => count > 0).sort((a, b) => b[1] - a[1]);
+  if (entries.length === 0) return void 0;
+  return `Top issue: ${entries[0][0]} (${entries[0][1]})`;
+}
+function priceLabel(record) {
+  if (typeof record.normalized_price_usd_nominal === "number") return fmtCurrency(record.normalized_price_usd_nominal, "USD");
+  if (typeof record.normalized_price_usd === "number") return fmtCurrency(record.normalized_price_usd, "USD");
+  if (typeof record.price_amount === "number") return fmtCurrency(record.price_amount, record.currency ?? "TRY");
+  if (typeof record.estimate_low === "number" && typeof record.estimate_high === "number") {
+    return `${fmtCurrency(record.estimate_low, record.currency ?? "TRY")}\u2013${fmtCurrency(record.estimate_high, record.currency ?? "TRY")}`;
+  }
+  if (record.price_type === "inquiry_only" || record.price_hidden) return "Inquiry only";
+  return "n/a";
+}
+function rangeLabel(range) {
+  if (!range) return "n/a";
+  return `${fmtCurrency(range.low, "TRY")} \u2013 ${fmtCurrency(range.high, "TRY")}`;
+}
+function buildModel(params) {
+  const { assessment, details, recentRuns, activeArtist, input, history, detailMode, busy, message, context, tick, runStartedAt } = params;
+  const summary = details?.summary;
+  const records = details?.records ?? [];
+  const runId = details?.run?.id ?? "n/a";
+  const valuation = details?.valuation;
+  const issueLines = assessment?.issues.map((issue) => `${issue.severity}: ${issue.message}${issue.detail ? ` (${issue.detail})` : ""}`) ?? [];
+  const recentRunLines = recentRuns.slice(0, 5).map((run) => `${run.id} \xB7 ${run.status} \xB7 ${run.query.artist}`);
+  const authLines = assessment?.sessionStates.map((session) => `${session.profileId}: ${session.exists ? session.expired ? "expired" : "ready" : "missing"}`) ?? [];
+  const diagnosticsLines = detailMode === "runs" ? recentRunLines : detailMode === "auth" ? authLines : detailMode === "setup" ? issueLines : [message || "No additional diagnostics."];
+  return {
+    title: "ArtBot",
+    subtitle: "Market operations console",
+    command: {
+      mode: busy ? "running" : detailMode === "setup" ? "setup" : "idle",
+      input,
+      placeholder: "Type /research <artist> or plain artist text. /help for commands.",
+      hints: buildDefaultCommandHints(),
+      history
+    },
+    status: {
+      llm: assessment ? asRuntimeStatus("LM Studio", assessment.llmHealth.ok, assessment.llmHealth.modelId ?? assessment.llmHealth.reason) : asRuntimeStatus("LM Studio", false, "checking"),
+      api: assessment ? asRuntimeStatus("ArtBot API", assessment.apiHealth.ok, assessment.apiHealth.reason ?? assessment.apiBaseUrl) : asRuntimeStatus("ArtBot API", false, "checking"),
+      worker: assessment && assessment.apiHealth.ok ? { label: "Worker", state: "healthy", detail: "assumed with local backend", tone: "success" } : { label: "Worker", state: "unknown", detail: "verify with /doctor", tone: "muted" },
+      auth: assessment ? {
+        label: "Auth",
+        state: assessment.authProfilesError ? "offline" : assessment.sessionStates.some((session) => session.exists && !session.expired) ? "healthy" : "degraded",
+        detail: assessment.authProfilesError?.message ?? `${assessment.profiles.length} profiles`,
+        tone: assessment.authProfilesError ? "danger" : assessment.sessionStates.some((session) => session.exists && !session.expired) ? "success" : "warning"
+      } : { label: "Auth", state: "unknown", detail: "checking", tone: "muted" },
+      licensed: {
+        label: "Licensed",
+        state: context.defaults.allowLicensed ? "healthy" : "degraded",
+        detail: context.defaults.licensedIntegrations.length > 0 ? context.defaults.licensedIntegrations.join(", ") : "none",
+        tone: context.defaults.allowLicensed ? "success" : "warning"
+      },
+      model: assessment?.llmHealth.modelId,
+      apiBaseUrl: context.apiBaseUrl,
+      llmBaseUrl: assessment?.llmBaseUrl
+    },
+    progress: {
+      runId,
+      artistName: activeArtist || "n/a",
+      status: details?.run?.status === "completed" ? "completed" : details?.run?.status === "failed" ? "failed" : details?.run?.status === "running" ? "running" : details?.run?.status === "pending" ? "queued" : "idle",
+      stages: [
+        {
+          id: "queue",
+          label: "Queue",
+          state: details?.run?.status ? details.run.status === "pending" ? "running" : "done" : "pending"
+        },
+        {
+          id: "scan",
+          label: "Scan sources",
+          state: details?.run?.status === "running" ? "running" : summary ? "done" : "pending"
+        },
+        {
+          id: "analyze",
+          label: "Analyze",
+          state: summary ? details?.run?.status === "completed" ? "done" : "running" : "pending"
+        },
+        {
+          id: "report",
+          label: "Report",
+          state: details?.run?.status === "completed" ? "done" : details?.run?.status === "failed" ? "failed" : "pending"
+        }
+      ],
+      summaryLines: [
+        summary ? `Accepted: ${summary.accepted_records}` : "Accepted: n/a",
+        summary ? `Valuation eligible: ${summary.valuation_eligible_records ?? 0}` : "Valuation eligible: n/a",
+        summary ? `Priced coverage: ${Math.round((summary.priced_crawled_source_coverage_ratio ?? summary.priced_source_coverage_ratio ?? 0) * 100)}%` : "Priced coverage: n/a"
+      ],
+      blockerSummary: blockerSummary(details),
+      tick,
+      elapsed: runStartedAt ? Math.floor((Date.now() - runStartedAt) / 1e3) : void 0
+    },
+    report: {
+      artistName: activeArtist || "No active research",
+      runId,
+      overview: [
+        { label: "Accepted", value: String(summary?.accepted_records ?? 0), tone: "success" },
+        { label: "URLs Crawled", value: String(summary?.total_attempts ?? 0), tone: "muted" },
+        {
+          label: "Coverage",
+          value: `${Math.round((summary?.priced_crawled_source_coverage_ratio ?? summary?.priced_source_coverage_ratio ?? 0) * 100)}%`,
+          tone: (summary?.priced_crawled_source_coverage_ratio ?? 0) >= 0.7 ? "success" : "warning"
+        }
+      ],
+      sourceCoverage: [
+        { label: "Platforms", value: String(Object.keys(summary?.source_candidate_breakdown ?? {}).length), tone: "accent" },
+        { label: "Public", value: String(summary?.source_status_breakdown?.public_access ?? 0), tone: "success" },
+        { label: "Blocked", value: String(summary?.source_status_breakdown?.blocked ?? 0), tone: "danger" }
+      ],
+      valuation: [
+        { label: "Blended", value: rangeLabel(valuation?.blendedRange), tone: valuation?.generated ? "success" : "warning" },
+        { label: "Turkey", value: rangeLabel(valuation?.turkeyRange), tone: "accent" },
+        { label: "Intl", value: rangeLabel(valuation?.internationalRange), tone: "muted" }
+      ],
+      acceptedRecords: records.slice(0, 8).map((record) => ({
+        price: priceLabel(record),
+        priceType: record.price_type,
+        workTitle: record.work_title ?? "Untitled",
+        sourceName: record.source_name,
+        detail: [record.sale_or_listing_date, record.dimensions_text, record.year].filter(Boolean).join(" \xB7 ")
+      })),
+      diagnostics: [
+        {
+          title: detailMode === "help" ? "Commands" : detailMode === "setup" ? "Setup Issues" : detailMode === "auth" ? "Auth State" : detailMode === "runs" ? "Recent Runs" : "Run Notes",
+          tone: detailMode === "setup" ? "warning" : "muted",
+          lines: detailMode === "help" ? [
+            "/research <artist>",
+            "/work <artist> --title <title>",
+            "/setup",
+            "/auth",
+            "/doctor",
+            "/status",
+            "/runs",
+            "/help",
+            "/exit"
+          ] : diagnosticsLines.length > 0 ? diagnosticsLines : ["No detail available."]
+        }
+      ]
+    },
+    detail: {
+      title: detailMode === "auth" ? "Auth" : detailMode === "runs" ? "Runs" : detailMode === "setup" ? "Setup" : detailMode === "help" ? "Help" : "Context",
+      subtitle: detailMode === "setup" ? "Run `artbot setup` for the guided wizard and `artbot auth capture <profile>` for login capture." : message,
+      status: [
+        assessment ? asRuntimeStatus("LM Studio", assessment.llmHealth.ok, assessment.llmHealth.modelId ?? assessment.llmHealth.reason) : asRuntimeStatus("LM Studio", false, "checking"),
+        assessment ? asRuntimeStatus("ArtBot API", assessment.apiHealth.ok, assessment.apiHealth.reason ?? assessment.apiBaseUrl) : asRuntimeStatus("ArtBot API", false, "checking")
+      ],
+      details: detailMode === "auth" ? assessment?.sessionStates.map((session) => ({
+        label: session.profileId,
+        value: session.exists ? session.expired ? "expired" : "ready" : "missing",
+        tone: session.exists ? session.expired ? "warning" : "success" : "danger",
+        detail: session.storageStatePath
+      })) ?? [] : detailMode === "runs" ? recentRuns.slice(0, 6).map((run) => ({
+        label: run.id,
+        value: run.status,
+        tone: run.status === "completed" ? "success" : run.status === "failed" ? "danger" : "accent",
+        detail: run.query.artist
+      })) : [
+        {
+          label: "Mode",
+          value: detailMode,
+          tone: detailMode === "setup" ? "warning" : "accent"
+        },
+        {
+          label: "Artist",
+          value: activeArtist || "n/a",
+          tone: "neutral"
+        }
+      ],
+      blockers: detailMode === "setup" ? issueLines : [blockerSummary(details) ?? "No blockers recorded."],
+      evidence: details?.attempts?.slice(0, 4).map((attempt) => attempt.source_url) ?? []
+    }
+  };
+}
+function parseWorkCommand(value) {
+  const match = value.match(/^\/work\s+(.+?)\s+--title\s+(.+)$/i);
+  if (!match) return null;
+  return {
+    artist: match[1].trim(),
+    title: match[2].trim()
+  };
+}
+function runInteractiveTui(props) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const instance = render(
+      /* @__PURE__ */ jsx2(
+        InteractiveApp,
+        {
+          ...props,
+          onExit: (code) => {
+            if (settled) return;
+            settled = true;
+            instance.unmount();
+            resolve(code);
+          }
+        }
+      )
+    );
+  });
+}
+function InteractiveApp({ context, initialAssessment, onExit }) {
+  const { exit } = useApp();
+  const [assessment, setAssessment] = useState(initialAssessment);
+  const [details, setDetails] = useState(null);
+  const [recentRuns, setRecentRuns] = useState([]);
+  const [input, setInput] = useState("");
+  const [history, setHistory] = useState([]);
+  const [detailMode, setDetailMode] = useState(initialAssessment?.issues.length ? "setup" : "help");
+  const [busy, setBusy] = useState(false);
+  const [activeArtist, setActiveArtist] = useState("");
+  const [message, setMessage] = useState("Slash command ready.");
+  const [tick, setTick] = useState(0);
+  const [runStartedAt, setRunStartedAt] = useState(null);
+  const cancelPollingRef = useRef(false);
+  useInput((_input, key) => {
+    if (key.ctrl && _input === "c") {
+      exit();
+      onExit(0);
+    }
+  });
+  useEffect(() => {
+    if (!busy) return;
+    const interval = setInterval(() => setTick((t) => t + 1), 150);
+    return () => clearInterval(interval);
+  }, [busy]);
+  const refreshAssessment = useCallback(async () => {
+    const next = await assessLocalSetup();
+    setAssessment(next);
+    return next;
+  }, []);
+  const fetchRecentRuns = useCallback(async () => {
+    const headers = {};
+    if (context.apiKey) headers["x-api-key"] = context.apiKey;
+    const response = await fetch(`${context.apiBaseUrl}/runs?limit=8`, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to load runs (${response.status})`);
+    }
+    const payload = await response.json();
+    setRecentRuns(payload.runs);
+  }, [context.apiBaseUrl, context.apiKey]);
+  useEffect(() => {
+    void (async () => {
+      try {
+        await refreshAssessment();
+        await fetchRecentRuns();
+      } catch (error) {
+        setMessage(error instanceof Error ? error.message : String(error));
+      }
+    })();
+  }, [fetchRecentRuns, refreshAssessment]);
+  const startResearch = useCallback(
+    async (kind, artist, title) => {
+      setBusy(true);
+      setDetailMode("report");
+      setActiveArtist(artist);
+      setMessage(`Launching ${kind} research for ${artist}...`);
+      setRunStartedAt(Date.now());
+      cancelPollingRef.current = false;
+      try {
+        const nextAssessment = await refreshAssessment();
+        if (!nextAssessment.apiHealth.ok) {
+          setDetailMode("setup");
+          setMessage(`ArtBot API offline at ${nextAssessment.apiBaseUrl}. Run /setup or artbot setup.`);
+          return;
+        }
+        const headers = {
+          "content-type": "application/json"
+        };
+        if (context.apiKey) headers["x-api-key"] = context.apiKey;
+        const response = await fetch(`${context.apiBaseUrl}/research/${kind}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            query: {
+              artist,
+              title,
+              scope: "turkey_plus_international",
+              turkeyFirst: true,
+              analysisMode: context.defaults.analysisMode,
+              priceNormalization: context.defaults.priceNormalization,
+              authProfileId: context.defaults.authProfileId,
+              manualLoginCheckpoint: false,
+              allowLicensed: context.defaults.allowLicensed,
+              licensedIntegrations: context.defaults.licensedIntegrations
+            }
+          })
+        });
+        if (!response.ok) {
+          const text2 = await response.text();
+          throw new Error(`Research request failed (${response.status}): ${text2.slice(0, 200)}`);
+        }
+        const created = await response.json();
+        setDetails({
+          run: {
+            id: created.runId,
+            status: created.status
+          }
+        });
+        setMessage(`Run created: ${created.runId}`);
+        while (!cancelPollingRef.current) {
+          const detailResponse = await fetch(`${context.apiBaseUrl}/runs/${created.runId}`, {
+            headers: context.apiKey ? { "x-api-key": context.apiKey } : void 0
+          });
+          if (!detailResponse.ok) {
+            throw new Error(`Failed to poll run ${created.runId} (${detailResponse.status})`);
+          }
+          const nextDetails = await detailResponse.json();
+          setDetails(nextDetails);
+          const status = nextDetails.run?.status;
+          if (status === "completed" || status === "failed") {
+            if (status === "completed") {
+              const s = nextDetails.summary;
+              const accepted = s?.accepted_records ?? 0;
+              const coverage = Math.round((s?.priced_crawled_source_coverage_ratio ?? s?.priced_source_coverage_ratio ?? 0) * 100);
+              setMessage(`\u2713 Run completed \u2014 ${accepted} accepted, ${coverage}% coverage`);
+            } else {
+              setMessage(`\u2717 Run failed: ${created.runId}`);
+            }
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+        await fetchRecentRuns();
+      } finally {
+        setBusy(false);
+      }
+    },
+    [context.apiBaseUrl, context.apiKey, context.defaults, fetchRecentRuns, refreshAssessment]
+  );
+  const handleSubmit = useCallback(
+    async (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) return;
+      setHistory((current) => [trimmed, ...current].slice(0, 8));
+      setInput("");
+      try {
+        if (!trimmed.startsWith("/")) {
+          await startResearch("artist", trimmed);
+          return;
+        }
+        if (trimmed === "/exit") {
+          cancelPollingRef.current = true;
+          exit();
+          onExit(0);
+          return;
+        }
+        if (trimmed === "/help") {
+          setDetailMode("help");
+          setMessage("Command reference loaded.");
+          return;
+        }
+        if (trimmed === "/status" || trimmed === "/doctor") {
+          setDetailMode(trimmed === "/status" ? "status" : "setup");
+          await refreshAssessment();
+          setMessage("Environment status refreshed.");
+          return;
+        }
+        if (trimmed === "/setup") {
+          setDetailMode("setup");
+          await refreshAssessment();
+          setMessage("Setup diagnostics loaded. Run `artbot setup` for the guided wizard.");
+          return;
+        }
+        if (trimmed === "/auth") {
+          setDetailMode("auth");
+          await refreshAssessment();
+          setMessage("Auth profile status loaded.");
+          return;
+        }
+        if (trimmed === "/runs") {
+          setDetailMode("runs");
+          await fetchRecentRuns();
+          setMessage("Recent runs loaded.");
+          return;
+        }
+        if (trimmed.startsWith("/research ")) {
+          await startResearch("artist", trimmed.slice("/research ".length).trim());
+          return;
+        }
+        const workCommand = parseWorkCommand(trimmed);
+        if (workCommand) {
+          await startResearch("work", workCommand.artist, workCommand.title);
+          return;
+        }
+        setMessage(`Unknown command: ${trimmed}`);
+      } catch (error) {
+        setMessage(error instanceof Error ? error.message : String(error));
+      }
+    },
+    [exit, fetchRecentRuns, onExit, refreshAssessment, startResearch]
+  );
+  const model = useMemo(
+    () => buildModel({
+      assessment,
+      details,
+      recentRuns,
+      activeArtist,
+      input,
+      history,
+      detailMode,
+      busy,
+      message,
+      context,
+      tick,
+      runStartedAt
+    }),
+    [activeArtist, assessment, busy, context, detailMode, details, history, input, message, recentRuns, tick, runStartedAt]
+  );
+  const messageColor = message.startsWith("\u2717") || message.startsWith("Failed") || message.includes("error") ? "red" : message.startsWith("\u2713") ? "green" : "gray";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(RenderTuiNode, { node: ArtbotTuiShell({ model }) }),
+    /* @__PURE__ */ jsxs2(Box2, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "\u276F" }),
+      /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, flexGrow: 1, children: /* @__PURE__ */ jsx2(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: "/research <artist>" }) })
+    ] }),
+    /* @__PURE__ */ jsxs2(Box2, { justifyContent: "space-between", children: [
+      message && message !== "Slash command ready." ? /* @__PURE__ */ jsx2(Text2, { color: messageColor, dimColor: true, children: message }) : /* @__PURE__ */ jsx2(Text2, { children: " " }),
+      /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "[/r]" }),
+          /* @__PURE__ */ jsx2(Text2, { color: "gray", children: " research" })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "[/s]" }),
+          /* @__PURE__ */ jsx2(Text2, { color: "gray", children: " setup" })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "[/h]" }),
+          /* @__PURE__ */ jsx2(Text2, { color: "gray", children: " help" })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "[^c]" }),
+          /* @__PURE__ */ jsx2(Text2, { color: "gray", children: " quit" })
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/interactive.ts
+function resolveContext() {
+  return {
+    apiBaseUrl: process.env.API_BASE_URL ?? "http://localhost:4000",
+    apiKey: process.env.ARTBOT_API_KEY
+  };
+}
+function toPositiveInt(value, fallback) {
+  const parsed = Number(value ?? fallback);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+}
+function parseBoolean(value, fallback) {
+  if (value === void 0) return fallback;
+  return value.trim().toLowerCase() === "true";
+}
+function resolvePipelineDefaultsFromEnv() {
+  const rawLicensed = process.env.DEFAULT_LICENSED_INTEGRATIONS ?? "";
+  const licensedIntegrations = rawLicensed.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return {
+    analysisMode: process.env.DEFAULT_ANALYSIS_MODE ?? "comprehensive",
+    priceNormalization: process.env.DEFAULT_PRICE_NORMALIZATION ?? "usd_dual",
+    authProfileId: process.env.DEFAULT_AUTH_PROFILE?.trim() || void 0,
+    allowLicensed: parseBoolean(process.env.ENABLE_LICENSED_INTEGRATIONS, false),
+    licensedIntegrations,
+    transportMaxAttempts: toPositiveInt(process.env.TRANSPORT_MAX_ATTEMPTS, 3),
+    transportRequestTimeoutMs: toPositiveInt(process.env.TRANSPORT_REQUEST_TIMEOUT_MS, 15e3),
+    transportCurlFallback: parseBoolean(process.env.TRANSPORT_CURL_FALLBACK, true),
+    pipelineConcurrency: {
+      healthy: toPositiveInt(process.env.PIPELINE_MAX_CONCURRENCY, 6),
+      degraded: toPositiveInt(process.env.PIPELINE_DEGRADED_CONCURRENCY, 3),
+      suspected: toPositiveInt(process.env.PIPELINE_SUSPECTED_CONCURRENCY, 1)
+    },
+    pipelineCandidateTimeoutMs: toPositiveInt(process.env.PIPELINE_CANDIDATE_TIMEOUT_MS, 45e3)
+  };
+}
+function hostFromUrl(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function classifyBlocker(attempt) {
+  const blocker = (attempt.blocker_reason ?? "").toLowerCase();
+  const transport = attempt.extracted_fields?.transport;
+  const transportKind = transport?.kind?.toUpperCase();
+  if (blocker.includes("target_unreachable") || blocker.includes("transport:dns_failed") || blocker.includes("transport:tcp_timeout") || blocker.includes("transport:tcp_refused") || blocker.includes("transport:tls_failed") || blocker.includes("transport:unknown_network")) {
+    return "transport_outage";
+  }
+  if (transportKind === "RATE_LIMITED") return "rate_limited";
+  if (transportKind === "AUTH_INVALID" || attempt.source_access_status === "auth_required") return "auth_required";
+  if (transportKind === "LEGAL_BLOCK") return "legal_block";
+  if (transportKind === "WAF_BLOCK") return "waf_block";
+  if (attempt.source_access_status === "price_hidden") return "price_hidden";
+  if (attempt.source_access_status === "blocked") return "blocked";
+  return "other";
+}
+function summarizeAttemptBlockers(attempts) {
+  if (!attempts || attempts.length === 0) return null;
+  const counters = /* @__PURE__ */ new Map();
+  for (const attempt of attempts) {
+    const category = classifyBlocker(attempt);
+    const host = hostFromUrl(attempt.source_url) ?? "unknown-host";
+    const current = counters.get(category) ?? { count: 0, hosts: /* @__PURE__ */ new Map() };
+    current.count += 1;
+    current.hosts.set(host, (current.hosts.get(host) ?? 0) + 1);
+    counters.set(category, current);
+  }
+  const top = [...counters.entries()].sort((a, b) => b[1].count - a[1].count)[0];
+  if (!top) return null;
+  const topHosts = [...top[1].hosts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([host]) => host);
+  return {
+    category: top[0],
+    count: top[1].count,
+    hosts: topHosts
+  };
+}
+function shouldRunSetupWizard(assessment) {
+  return !pathExists(assessment.envPath) || Boolean(assessment.authProfilesError);
+}
+async function startInteractive() {
+  let initialAssessment = await assessLocalSetup();
+  if (shouldRunSetupWizard(initialAssessment)) {
+    try {
+      const setup = await runSetupWizard();
+      initialAssessment = setup.assessment;
+    } catch {
+      return 0;
+    }
+  }
+  const ctx = resolveContext();
+  const pipelineDefaults = resolvePipelineDefaultsFromEnv();
+  return runInteractiveTui({
+    context: {
+      apiBaseUrl: ctx.apiBaseUrl,
+      apiKey: ctx.apiKey,
+      defaults: {
+        analysisMode: pipelineDefaults.analysisMode,
+        priceNormalization: pipelineDefaults.priceNormalization,
+        authProfileId: pipelineDefaults.authProfileId,
+        allowLicensed: pipelineDefaults.allowLicensed,
+        licensedIntegrations: pipelineDefaults.licensedIntegrations
+      }
+    },
+    initialAssessment
+  });
+}
+export {
+  resolvePipelineDefaultsFromEnv,
+  startInteractive,
+  summarizeAttemptBlockers
+};
+//# sourceMappingURL=interactive-DQDPPJBS.js.map