artbot 0.1.0

package/dist/index.js

@@ -0,0 +1,892 @@
+import {
+  assessLocalSetup,
+  buildAuthCaptureCommand,
+  defaultSourceUrlForProfile,
+  loadWorkspaceEnv,
+  resolveAuthProfilesFromEnv,
+  runSetupWizard
+} from "./chunks/chunk-KKAF45ZB.js";
+
+// src/index.ts
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import Table from "cli-table3";
+import { Command, CommanderError } from "commander";
+import ora from "ora";
+import picocolors from "picocolors";
+import { ZodError } from "zod";
+
+// ../../packages/shared-types/src/query.ts
+import { z } from "zod";
+var researchQuerySchema = z.object({
+  artist: z.string().min(1),
+  title: z.string().optional(),
+  year: z.string().optional(),
+  medium: z.string().optional(),
+  dimensions: z.object({
+    heightCm: z.number().positive().optional(),
+    widthCm: z.number().positive().optional(),
+    depthCm: z.number().positive().optional(),
+    dimensionsText: z.string().optional()
+  }).optional(),
+  imagePath: z.string().optional(),
+  dateRange: z.object({
+    from: z.string().optional(),
+    to: z.string().optional()
+  }).optional(),
+  scope: z.enum(["turkey_only", "turkey_plus_international"]).default("turkey_plus_international"),
+  turkeyFirst: z.boolean().default(true),
+  analysisMode: z.enum(["comprehensive", "balanced", "fast"]).default("balanced"),
+  priceNormalization: z.enum(["legacy", "usd_dual", "usd_nominal", "usd_2026"]).default("usd_dual"),
+  authProfileId: z.string().optional(),
+  cookieFile: z.string().optional(),
+  manualLoginCheckpoint: z.boolean().default(false),
+  allowLicensed: z.boolean().default(false),
+  licensedIntegrations: z.array(z.string()).default([])
+});
+var researchArtistRequestSchema = z.object({
+  query: researchQuerySchema
+});
+var researchWorkRequestSchema = z.object({
+  query: researchQuerySchema.extend({
+    title: z.string().min(1)
+  })
+});
+
+// ../../packages/shared-types/src/record.ts
+import { z as z2 } from "zod";
+var priceRecordSchema = z2.object({
+  artist_name: z2.string(),
+  work_title: z2.string().nullable(),
+  alternate_title: z2.string().nullable(),
+  year: z2.string().nullable(),
+  medium: z2.string().nullable(),
+  support: z2.string().nullable(),
+  dimensions_text: z2.string().nullable(),
+  height_cm: z2.number().nullable(),
+  width_cm: z2.number().nullable(),
+  depth_cm: z2.number().nullable(),
+  signed: z2.boolean().nullable(),
+  dated: z2.boolean().nullable(),
+  edition_info: z2.string().nullable(),
+  is_unique_work: z2.boolean().nullable(),
+  venue_name: z2.string(),
+  venue_type: z2.enum(["auction_house", "gallery", "dealer", "marketplace", "database", "other"]),
+  city: z2.string().nullable(),
+  country: z2.string().nullable(),
+  source_name: z2.string(),
+  source_url: z2.string().url(),
+  source_page_type: z2.enum(["lot", "artist_page", "price_db", "listing", "article", "other"]),
+  sale_or_listing_date: z2.string().nullable(),
+  lot_number: z2.string().nullable(),
+  price_type: z2.enum([
+    "asking_price",
+    "estimate",
+    "hammer_price",
+    "realized_price",
+    "realized_with_buyers_premium",
+    "inquiry_only",
+    "unknown"
+  ]),
+  estimate_low: z2.number().nullable(),
+  estimate_high: z2.number().nullable(),
+  price_amount: z2.number().nullable(),
+  currency: z2.string().nullable(),
+  normalized_price_try: z2.number().nullable(),
+  normalized_price_usd: z2.number().nullable(),
+  normalized_price_usd_nominal: z2.number().nullable().optional(),
+  normalized_price_usd_2026: z2.number().nullable().optional(),
+  fx_source: z2.string().nullable().optional(),
+  fx_date_used: z2.string().nullable().optional(),
+  inflation_source: z2.string().nullable().optional(),
+  inflation_base_year: z2.number().int().nullable().optional(),
+  buyers_premium_included: z2.boolean().nullable(),
+  image_url: z2.string().url().nullable(),
+  screenshot_path: z2.string().nullable(),
+  raw_snapshot_path: z2.string().nullable(),
+  visual_match_score: z2.number().nullable(),
+  metadata_match_score: z2.number().nullable(),
+  extraction_confidence: z2.number().min(0).max(1),
+  entity_match_confidence: z2.number().min(0).max(1),
+  source_reliability_confidence: z2.number().min(0).max(1),
+  valuation_confidence: z2.number().min(0).max(1),
+  overall_confidence: z2.number().min(0).max(1),
+  accepted_for_evidence: z2.boolean(),
+  accepted_for_valuation: z2.boolean(),
+  valuation_lane: z2.enum(["realized", "estimate", "asking", "none"]),
+  acceptance_reason: z2.enum([
+    "valuation_ready",
+    "estimate_range_ready",
+    "asking_price_ready",
+    "inquiry_only_evidence",
+    "price_hidden_evidence",
+    "generic_shell_page",
+    "missing_numeric_price",
+    "missing_currency",
+    "missing_estimate_range",
+    "unknown_price_type",
+    "blocked_access"
+  ]),
+  rejection_reason: z2.string().nullable(),
+  valuation_eligibility_reason: z2.string().nullable(),
+  price_hidden: z2.boolean(),
+  source_access_status: z2.enum(["public_access", "auth_required", "licensed_access", "blocked", "price_hidden"]).default("public_access"),
+  notes: z2.array(z2.string())
+});
+
+// ../../packages/shared-types/src/evidence.ts
+import { z as z3 } from "zod";
+var sourceAttemptSchema = z3.object({
+  run_id: z3.string(),
+  source_name: z3.string(),
+  source_url: z3.string().url(),
+  canonical_url: z3.string().url().nullable(),
+  access_mode: z3.enum(["anonymous", "authorized", "licensed"]),
+  source_access_status: z3.enum([
+    "public_access",
+    "auth_required",
+    "licensed_access",
+    "blocked",
+    "price_hidden"
+  ]),
+  access_reason: z3.string().nullable(),
+  blocker_reason: z3.string().nullable(),
+  extracted_fields: z3.record(z3.unknown()).default({}),
+  discovery_provenance: z3.enum(["seed", "query_variant", "listing_expansion", "signature_expansion", "direct_lot", "web_discovery"]).optional(),
+  discovery_score: z3.number().min(0).max(1).nullable().optional(),
+  discovered_from_url: z3.string().url().nullable().optional(),
+  screenshot_path: z3.string().nullable(),
+  pre_auth_screenshot_path: z3.string().nullable().optional(),
+  post_auth_screenshot_path: z3.string().nullable().optional(),
+  raw_snapshot_path: z3.string().nullable(),
+  trace_path: z3.string().nullable().optional(),
+  har_path: z3.string().nullable().optional(),
+  fetched_at: z3.string(),
+  parser_used: z3.string(),
+  model_used: z3.string().nullable(),
+  extraction_confidence: z3.number().min(0).max(1).nullable().optional(),
+  entity_match_confidence: z3.number().min(0).max(1).nullable().optional(),
+  source_reliability_confidence: z3.number().min(0).max(1).nullable().optional(),
+  confidence_score: z3.number().min(0).max(1),
+  accepted: z3.boolean(),
+  accepted_for_evidence: z3.boolean().optional(),
+  accepted_for_valuation: z3.boolean().optional(),
+  valuation_lane: z3.enum(["realized", "estimate", "asking", "none"]).optional(),
+  acceptance_reason: z3.enum([
+    "valuation_ready",
+    "estimate_range_ready",
+    "asking_price_ready",
+    "inquiry_only_evidence",
+    "price_hidden_evidence",
+    "generic_shell_page",
+    "missing_numeric_price",
+    "missing_currency",
+    "missing_estimate_range",
+    "unknown_price_type",
+    "blocked_access"
+  ]),
+  rejection_reason: z3.string().nullable().optional(),
+  valuation_eligibility_reason: z3.string().nullable().optional()
+});
+
+// ../../packages/shared-types/src/run.ts
+import { z as z4 } from "zod";
+var runSummarySchema = z4.object({
+  run_id: z4.string(),
+  total_records: z4.number().int().nonnegative(),
+  total_attempts: z4.number().int().nonnegative().optional(),
+  evidence_records: z4.number().int().nonnegative().optional(),
+  valuation_eligible_records: z4.number().int().nonnegative().optional(),
+  accepted_records: z4.number().int().nonnegative(),
+  rejected_candidates: z4.number().int().nonnegative(),
+  discovered_candidates: z4.number().int().nonnegative(),
+  accepted_from_discovery: z4.number().int().nonnegative(),
+  priced_source_coverage_ratio: z4.number().min(0).max(1).optional(),
+  priced_crawled_source_coverage_ratio: z4.number().min(0).max(1).optional(),
+  source_candidate_breakdown: z4.record(z4.string(), z4.number().int().nonnegative()),
+  source_status_breakdown: z4.record(
+    z4.enum(["public_access", "auth_required", "licensed_access", "blocked", "price_hidden"]),
+    z4.number().int().nonnegative()
+  ),
+  auth_mode_breakdown: z4.record(z4.enum(["anonymous", "authorized", "licensed"]), z4.number().int().nonnegative()),
+  acceptance_reason_breakdown: z4.record(
+    z4.enum([
+      "valuation_ready",
+      "estimate_range_ready",
+      "asking_price_ready",
+      "inquiry_only_evidence",
+      "price_hidden_evidence",
+      "generic_shell_page",
+      "missing_numeric_price",
+      "missing_currency",
+      "missing_estimate_range",
+      "unknown_price_type",
+      "blocked_access"
+    ]),
+    z4.number().int().nonnegative()
+  ).optional(),
+  valuation_generated: z4.boolean(),
+  valuation_reason: z4.string()
+});
+
+// src/index.ts
+var EXIT_CODES = {
+  OK: 0,
+  INPUT: 2,
+  API: 3,
+  TERMINAL: 4
+};
+var require2 = createRequire(import.meta.url);
+var ApiRequestError = class extends Error {
+  constructor(status, body) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+  }
+};
+var InputValidationError = class extends Error {
+};
+var TerminalStateError = class extends Error {
+  constructor(details) {
+    super(`Run ${details.run.id} ended in a failed or blocked terminal state.`);
+    this.details = details;
+  }
+};
+function toNumber(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function toPositiveInt(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    throw new InputValidationError(`Expected a positive integer, received "${value}".`);
+  }
+  return parsed;
+}
+function parseRunStatus(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  const allowed = ["pending", "running", "completed", "failed"];
+  if (!allowed.includes(normalized)) {
+    throw new InputValidationError(`Invalid status "${value}". Allowed values: ${allowed.join(", ")}.`);
+  }
+  return normalized;
+}
+function isRunBlocked(details) {
+  const summary = details.summary;
+  if (summary.accepted_records > 0) {
+    return false;
+  }
+  return summary.total_records > 0 && (summary.source_status_breakdown.blocked ?? 0) > 0;
+}
+function isFailedOrBlocked(details) {
+  if (details.run.status === "failed") {
+    return true;
+  }
+  return details.run.status === "completed" && isRunBlocked(details);
+}
+function writeLine(writer, text) {
+  writer(`${text}
+`);
+}
+function safeJsonParse(text) {
+  if (!text) return {};
+  return JSON.parse(text);
+}
+function resolveGlobals(command) {
+  const raw = command.optsWithGlobals();
+  const globals = {
+    json: Boolean(raw.json),
+    apiBaseUrl: raw.apiBaseUrl ?? process.env.API_BASE_URL ?? "http://localhost:4000",
+    apiKey: raw.apiKey ?? process.env.ARTBOT_API_KEY,
+    verbose: Boolean(raw.verbose),
+    quiet: Boolean(raw.quiet)
+  };
+  if (globals.verbose && globals.quiet) {
+    throw new InputValidationError("Choose either --verbose or --quiet, not both.");
+  }
+  return globals;
+}
+function logInfo(globals, ctx, text) {
+  if (globals.json || globals.quiet) return;
+  writeLine(ctx.deps.stdout, text);
+}
+function logVerbose(globals, ctx, text) {
+  if (globals.json || globals.quiet || !globals.verbose) return;
+  writeLine(ctx.deps.stderr, picocolors.dim(text));
+}
+function logError(globals, ctx, text) {
+  if (globals.json) {
+    writeLine(ctx.deps.stderr, text);
+    return;
+  }
+  writeLine(ctx.deps.stderr, picocolors.red(text));
+}
+function printJson(globals, ctx, payload) {
+  if (!globals.json) return;
+  writeLine(ctx.deps.stdout, JSON.stringify(payload, null, 2));
+}
+function buildQuery(options, requireTitle) {
+  if (requireTitle && !options.title) {
+    throw new InputValidationError("Missing required --title for work research.");
+  }
+  const query = {
+    artist: options.artist,
+    title: options.title,
+    year: options.year,
+    medium: options.medium,
+    dimensions: options.heightCm || options.widthCm || options.depthCm ? {
+      heightCm: toNumber(options.heightCm),
+      widthCm: toNumber(options.widthCm),
+      depthCm: toNumber(options.depthCm)
+    } : void 0,
+    imagePath: options.imagePath,
+    dateRange: options.dateFrom || options.dateTo ? {
+      from: options.dateFrom,
+      to: options.dateTo
+    } : void 0,
+    scope: options.scope ?? "turkey_plus_international",
+    turkeyFirst: options.turkeyFirst ?? true,
+    analysisMode: options.analysisMode ?? "comprehensive",
+    priceNormalization: options.priceNormalization ?? "usd_dual",
+    authProfileId: options.authProfile,
+    cookieFile: options.cookieFile,
+    manualLoginCheckpoint: options.manualLogin ?? false,
+    allowLicensed: options.allowLicensed ?? false,
+    licensedIntegrations: options.licensedIntegrations ? options.licensedIntegrations.split(",").map((entry) => entry.trim()).filter(Boolean) : []
+  };
+  return researchQuerySchema.parse(query);
+}
+async function requestJson(ctx, globals, method, path, payload) {
+  const response = await ctx.deps.fetchImpl(`${globals.apiBaseUrl}${path}`, {
+    method,
+    headers: {
+      "content-type": "application/json",
+      ...globals.apiKey ? { "x-api-key": globals.apiKey } : {}
+    },
+    body: payload === void 0 ? void 0 : JSON.stringify(payload)
+  });
+  const text = await response.text();
+  const body = safeJsonParse(text);
+  if (!response.ok) {
+    throw new ApiRequestError(response.status, body);
+  }
+  return body;
+}
+function renderRunsTable(runs) {
+  const table = new Table({
+    head: ["Run ID", "Type", "Status", "Artist", "Created"],
+    wordWrap: true
+  });
+  for (const run of runs) {
+    table.push([
+      run.id,
+      run.runType,
+      run.status,
+      run.query.artist,
+      new Date(run.createdAt).toLocaleString("en-US")
+    ]);
+  }
+  return table.toString();
+}
+function renderRecordsTable(records, limit = 8) {
+  const table = new Table({
+    head: ["Artist", "Work", "Source", "Price Type", "Amount", "Currency"],
+    wordWrap: true
+  });
+  for (const record of records.slice(0, limit)) {
+    table.push([
+      record.artist_name,
+      record.work_title ?? "-",
+      record.source_name,
+      record.price_type,
+      record.price_amount ?? "-",
+      record.currency ?? "-"
+    ]);
+  }
+  return table.toString();
+}
+function renderSummaryTable(summary) {
+  const table = new Table({
+    head: ["Metric", "Value"]
+  });
+  const crawledCoverage = summary.priced_crawled_source_coverage_ratio ?? summary.priced_source_coverage_ratio;
+  table.push(
+    ["Accepted", summary.accepted_records],
+    ["Rejected", summary.rejected_candidates],
+    ["Discovered Candidates", summary.discovered_candidates],
+    ["Accepted from Discovery", summary.accepted_from_discovery],
+    [
+      "Priced Coverage (Crawled)",
+      crawledCoverage != null ? `${Math.round(crawledCoverage * 100)}%` : "n/a"
+    ],
+    ["Valuation Generated", summary.valuation_generated ? "yes" : "no"],
+    ["Valuation Reason", summary.valuation_reason]
+  );
+  if (summary.priced_crawled_source_coverage_ratio != null && summary.priced_source_coverage_ratio != null) {
+    table.push(["Priced Coverage (Attempted)", `${Math.round(summary.priced_source_coverage_ratio * 100)}%`]);
+  }
+  return table.toString();
+}
+function renderBreakdownTable(title, values) {
+  const table = new Table({
+    head: [title, "Count"]
+  });
+  for (const [key, value] of Object.entries(values)) {
+    table.push([key, value]);
+  }
+  return table.toString();
+}
+function renderSetupAssessment(assessment) {
+  const table = new Table({
+    head: ["Check", "Status", "Detail"]
+  });
+  table.push(
+    [
+      "LM Studio",
+      assessment.llmHealth.ok ? picocolors.green("healthy") : picocolors.red("offline"),
+      assessment.llmHealth.modelId ?? assessment.llmHealth.reason ?? assessment.llmBaseUrl
+    ],
+    [
+      "ArtBot API",
+      assessment.apiHealth.ok ? picocolors.green("healthy") : picocolors.yellow("offline"),
+      assessment.apiHealth.reason ?? assessment.apiBaseUrl
+    ],
+    [
+      "Local Backend",
+      assessment.localBackendAvailable ? picocolors.green("available") : picocolors.yellow("external only"),
+      assessment.workspaceRoot ?? "No ArtBot workspace detected"
+    ],
+    [
+      "Auth Profiles",
+      assessment.authProfilesError ? picocolors.red("invalid") : picocolors.green(String(assessment.profiles.length)),
+      assessment.authProfilesError?.message ?? `${assessment.profiles.length} configured`
+    ],
+    [
+      "Sessions",
+      assessment.sessionStates.length === 0 ? picocolors.yellow("none") : picocolors.green(String(assessment.sessionStates.length)),
+      assessment.sessionStates.map((session) => `${session.profileId}:${session.exists ? session.expired ? "expired" : "ready" : "missing"}`).join(", ") || "No relevant sessions"
+    ]
+  );
+  return table.toString();
+}
+function renderSetupIssues(assessment) {
+  if (assessment.issues.length === 0) {
+    return picocolors.green("No setup issues detected.");
+  }
+  return assessment.issues.map((issue) => {
+    const prefix = issue.severity === "error" ? picocolors.red("error") : picocolors.yellow("warning");
+    return `${prefix} ${issue.message}${issue.detail ? ` (${issue.detail})` : ""}`;
+  }).join("\n");
+}
+function renderAuthProfilesTable(assessment) {
+  const table = new Table({
+    head: ["Profile", "Mode", "Matched Sources", "Storage State"]
+  });
+  const relevantById = new Map(assessment.relevantProfiles.map((entry) => [entry.profile.id, entry.matchedSources]));
+  const sessionsById = new Map(assessment.sessionStates.map((session) => [session.profileId, session]));
+  for (const profile of assessment.profiles) {
+    const session = sessionsById.get(profile.id);
+    table.push([
+      profile.id,
+      profile.mode,
+      (relevantById.get(profile.id) ?? []).join(", ") || "\u2014",
+      session ? `${session.exists ? session.expired ? "expired" : "ready" : "missing"} \xB7 ${session.storageStatePath}` : "\u2014"
+    ]);
+  }
+  return table.toString();
+}
+function printRunDetailsHuman(globals, ctx, details) {
+  logInfo(globals, ctx, `Run ${details.run.id} (${details.run.runType})`);
+  logInfo(globals, ctx, `Status: ${details.run.status}`);
+  logInfo(globals, ctx, "");
+  logInfo(globals, ctx, renderSummaryTable(details.summary));
+  logInfo(globals, ctx, "");
+  logInfo(globals, ctx, renderBreakdownTable("Source Status", details.summary.source_status_breakdown));
+  logInfo(globals, ctx, "");
+  logInfo(globals, ctx, renderBreakdownTable("Auth Mode", details.summary.auth_mode_breakdown));
+  if (details.records.length > 0) {
+    logInfo(globals, ctx, "");
+    logInfo(globals, ctx, "Top comparable records:");
+    logInfo(globals, ctx, renderRecordsTable(details.records));
+  }
+}
+async function waitForRunTerminal(ctx, globals, runId, intervalSeconds) {
+  const spinner = globals.json || globals.quiet ? null : ctx.deps.spinnerFactory(`Waiting for run ${runId}...`).start();
+  let previousStatus = null;
+  while (true) {
+    const details = await requestJson(ctx, globals, "GET", `/runs/${runId}`);
+    const status = details.run.status;
+    if (spinner) {
+      spinner.text = `Run ${runId} status: ${status}`;
+    }
+    if (previousStatus !== status) {
+      logVerbose(globals, ctx, `Run ${runId}: ${previousStatus ?? "unknown"} -> ${status}`);
+      previousStatus = status;
+    }
+    if (status === "completed" || status === "failed") {
+      if (spinner) {
+        if (isFailedOrBlocked(details)) {
+          spinner.fail(`Run ${runId} ended in failed/blocked state`);
+        } else {
+          spinner.succeed(`Run ${runId} completed`);
+        }
+      }
+      return details;
+    }
+    await ctx.deps.sleep(intervalSeconds * 1e3);
+  }
+}
+async function handleResearch(ctx, options, command, runType) {
+  const globals = resolveGlobals(command);
+  const query = buildQuery(options, runType === "work");
+  const created = await requestJson(
+    ctx,
+    globals,
+    "POST",
+    runType === "artist" ? "/research/artist" : "/research/work",
+    { query }
+  );
+  if (!options.wait) {
+    printJson(globals, ctx, created);
+    if (!globals.json) {
+      logInfo(globals, ctx, `Run created: ${created.runId} (${created.status})`);
+      logInfo(globals, ctx, `Use "artbot runs show --run-id ${created.runId}" to inspect details.`);
+    }
+    return;
+  }
+  const waitIntervalSeconds = toPositiveInt(options.waitInterval, 2);
+  const details = await waitForRunTerminal(ctx, globals, created.runId, waitIntervalSeconds);
+  printJson(globals, ctx, details);
+  if (!globals.json) {
+    printRunDetailsHuman(globals, ctx, details);
+  }
+  if (isFailedOrBlocked(details)) {
+    throw new TerminalStateError(details);
+  }
+}
+async function handleRunsList(ctx, options, command) {
+  const globals = resolveGlobals(command);
+  const status = parseRunStatus(options.status);
+  const limit = toPositiveInt(options.limit, 20);
+  const query = new URLSearchParams();
+  if (status) query.set("status", status);
+  query.set("limit", String(limit));
+  const payload = await requestJson(ctx, globals, "GET", `/runs?${query.toString()}`);
+  printJson(globals, ctx, payload);
+  if (globals.json) {
+    return;
+  }
+  if (payload.runs.length === 0) {
+    logInfo(globals, ctx, "No runs found for the selected filters.");
+    return;
+  }
+  logInfo(globals, ctx, renderRunsTable(payload.runs));
+}
+async function handleRunsShow(ctx, options, command) {
+  const globals = resolveGlobals(command);
+  const details = await requestJson(ctx, globals, "GET", `/runs/${options.runId}`);
+  printJson(globals, ctx, details);
+  if (globals.json) {
+    return;
+  }
+  printRunDetailsHuman(globals, ctx, details);
+}
+async function handleRunsWatch(ctx, options, command) {
+  const globals = resolveGlobals(command);
+  const intervalSeconds = toPositiveInt(options.interval, 2);
+  const details = await waitForRunTerminal(ctx, globals, options.runId, intervalSeconds);
+  printJson(globals, ctx, details);
+  if (!globals.json) {
+    printRunDetailsHuman(globals, ctx, details);
+  }
+  if (isFailedOrBlocked(details)) {
+    throw new TerminalStateError(details);
+  }
+}
+async function handleSetup(ctx, command) {
+  const globals = resolveGlobals(command);
+  const result = await runSetupWizard();
+  printJson(globals, ctx, result);
+  if (!globals.json) {
+    logInfo(globals, ctx, renderSetupAssessment(result.assessment));
+    logInfo(globals, ctx, "");
+    logInfo(globals, ctx, renderSetupIssues(result.assessment));
+    if (result.backendStart) {
+      logInfo(globals, ctx, "");
+      logInfo(globals, ctx, `Started local backend. API log: ${result.backendStart.apiLogPath}`);
+      logInfo(globals, ctx, `Started local backend. Worker log: ${result.backendStart.workerLogPath}`);
+    }
+  }
+}
+async function handleDoctor(ctx, command) {
+  const globals = resolveGlobals(command);
+  const assessment = await assessLocalSetup();
+  printJson(globals, ctx, assessment);
+  if (globals.json) {
+    return;
+  }
+  logInfo(globals, ctx, renderSetupAssessment(assessment));
+  logInfo(globals, ctx, "");
+  logInfo(globals, ctx, renderSetupIssues(assessment));
+}
+async function handleAuthList(ctx, command) {
+  const globals = resolveGlobals(command);
+  const assessment = await assessLocalSetup();
+  printJson(globals, ctx, {
+    profiles: assessment.profiles,
+    relevant_profiles: assessment.relevantProfiles,
+    session_states: assessment.sessionStates,
+    auth_profiles_error: assessment.authProfilesError
+  });
+  if (globals.json) {
+    return;
+  }
+  if (assessment.authProfilesError) {
+    logError(globals, ctx, assessment.authProfilesError.message);
+    return;
+  }
+  logInfo(globals, ctx, renderAuthProfilesTable(assessment));
+}
+async function handleAuthStatus(ctx, command) {
+  const globals = resolveGlobals(command);
+  const assessment = await assessLocalSetup();
+  printJson(globals, ctx, assessment.sessionStates);
+  if (globals.json) {
+    return;
+  }
+  logInfo(globals, ctx, renderSetupAssessment(assessment));
+  logInfo(globals, ctx, "");
+  logInfo(globals, ctx, renderAuthProfilesTable(assessment));
+}
+async function handleAuthCapture(ctx, options, command) {
+  const globals = resolveGlobals(command);
+  const parsed = resolveAuthProfilesFromEnv();
+  if (parsed.error) {
+    throw new InputValidationError(parsed.error.message);
+  }
+  const profile = parsed.profiles.find((entry) => entry.id === options.profileId);
+  if (!profile) {
+    throw new InputValidationError(`Unknown auth profile "${options.profileId}".`);
+  }
+  const capture = buildAuthCaptureCommand(profile, defaultSourceUrlForProfile(profile.id));
+  printJson(globals, ctx, capture);
+  if (globals.json) {
+    return;
+  }
+  logInfo(globals, ctx, `Launching Playwright auth capture for ${profile.id}...`);
+  const playwrightCli = require2.resolve("playwright/cli");
+  const result = spawnSync(
+    process.execPath,
+    [playwrightCli, "codegen", capture.sourceUrl, `--save-storage=${capture.storageStatePath}`],
+    {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: false
+    }
+  );
+  if (result.status !== 0) {
+    throw new Error(`Auth capture exited with status ${result.status ?? 1}.`);
+  }
+}
+function addCommonResearchFlags(command, withOptionalTitle) {
+  const target = command.requiredOption("--artist <name>", "Artist name").option("--year <year>", "Year").option("--medium <medium>", "Medium").option("--height-cm <number>", "Height in cm").option("--width-cm <number>", "Width in cm").option("--depth-cm <number>", "Depth in cm").option("--scope <scope>", "turkey_only or turkey_plus_international").option("--analysis-mode <mode>", "comprehensive | balanced | fast").option("--price-normalization <mode>", "legacy | usd_dual | usd_nominal | usd_2026").option("--no-turkey-first", "Disable Turkey-first source routing").option("--date-from <date>", "YYYY-MM-DD").option("--date-to <date>", "YYYY-MM-DD").option("--image-path <path>", "Path to local image").option("--auth-profile <id>", "Auth profile id").option("--cookie-file <path>", "Cookie JSON file").option("--manual-login", "Enable manual login checkpoint").option("--allow-licensed", "Allow licensed integrations").option("--licensed-integrations <list>", "Comma-separated source names").option("--wait", "Wait until run reaches terminal state").option("--wait-interval <seconds>", "Polling interval when --wait is enabled");
+  if (withOptionalTitle) {
+    target.option("--title <title>", "Work title");
+  }
+  return target;
+}
+function registerResearchCommands(program, ctx) {
+  const researchGroup = program.command("research").description("Research commands");
+  addCommonResearchFlags(researchGroup.command("artist").description("Research artist prices"), true).action(
+    async (options, command) => {
+      await handleResearch(ctx, options, command, "artist");
+    }
+  );
+  addCommonResearchFlags(researchGroup.command("work").description("Research specific work prices"), false).requiredOption("--title <title>", "Work title").action(async (options, command) => {
+    await handleResearch(ctx, options, command, "work");
+  });
+  addCommonResearchFlags(program.command("research-artist").description("Research artist prices (legacy)"), true).action(
+    async (options, command) => {
+      await handleResearch(ctx, options, command, "artist");
+    }
+  );
+  addCommonResearchFlags(program.command("research-work").description("Research specific work prices (legacy)"), false).requiredOption("--title <title>", "Work title").action(async (options, command) => {
+    await handleResearch(ctx, options, command, "work");
+  });
+}
+function registerRunsCommands(program, ctx) {
+  const runsGroup = program.command("runs").description("Run inspection commands");
+  runsGroup.command("list").description("List recent runs").option("--status <status>", "pending|running|completed|failed").option("--limit <number>", "Maximum number of runs").action(async (options, command) => {
+    await handleRunsList(ctx, options, command);
+  });
+  runsGroup.command("show").description("Show a run details summary").requiredOption("--run-id <id>", "Run identifier").action(async (options, command) => {
+    await handleRunsShow(ctx, options, command);
+  });
+  runsGroup.command("watch").description("Watch a run until terminal state").requiredOption("--run-id <id>", "Run identifier").option("--interval <seconds>", "Polling interval in seconds", "2").action(async (options, command) => {
+    await handleRunsWatch(ctx, options, command);
+  });
+  program.command("run-status").description("Show run details summary (legacy alias)").requiredOption("--run-id <id>", "Run identifier").action(async (options, command) => {
+    await handleRunsShow(ctx, options, command);
+  });
+}
+function registerSetupCommands(program, ctx) {
+  program.command("setup").description("Guided local onboarding for LM Studio, backend services, and auth profiles").action(async (_options, command) => {
+    await handleSetup(ctx, command);
+  });
+  program.command("doctor").description("Inspect local setup and health status").action(async (_options, command) => {
+    await handleDoctor(ctx, command);
+  });
+  const authGroup = program.command("auth").description("Auth profile and session-state commands");
+  authGroup.command("list").description("List configured auth profiles and matched sources").action(async (_options, command) => {
+    await handleAuthList(ctx, command);
+  });
+  authGroup.command("status").description("Inspect saved browser session state for auth profiles").action(async (_options, command) => {
+    await handleAuthStatus(ctx, command);
+  });
+  authGroup.command("capture").description("Capture browser auth state for a profile via Playwright").argument("<profileId>", "Profile identifier").action(async (profileId, _options, command) => {
+    await handleAuthCapture(ctx, { profileId }, command);
+  });
+}
+function defaultDeps(partial = {}) {
+  return {
+    fetchImpl: partial.fetchImpl ?? fetch,
+    sleep: partial.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    spinnerFactory: partial.spinnerFactory ?? ((text) => ora(text)),
+    stdout: partial.stdout ?? ((text) => process.stdout.write(text)),
+    stderr: partial.stderr ?? ((text) => process.stderr.write(text))
+  };
+}
+function mapErrorToExitCode(error) {
+  if (error instanceof CommanderError && error.code === "commander.helpDisplayed") {
+    return EXIT_CODES.OK;
+  }
+  if (error instanceof CommanderError) {
+    return EXIT_CODES.INPUT;
+  }
+  if (error instanceof InputValidationError || error instanceof ZodError) {
+    return EXIT_CODES.INPUT;
+  }
+  if (error instanceof TerminalStateError) {
+    return EXIT_CODES.TERMINAL;
+  }
+  if (error instanceof ApiRequestError) {
+    return EXIT_CODES.API;
+  }
+  return EXIT_CODES.API;
+}
+function formatError(error) {
+  const serializeBody = (value) => {
+    try {
+      const text = JSON.stringify(value);
+      return text.length > 320 ? `${text.slice(0, 317)}...` : text;
+    } catch {
+      return String(value);
+    }
+  };
+  if (error instanceof ApiRequestError) {
+    const body = serializeBody(error.body);
+    if (error.status === 401) {
+      return `API authentication failed (401). Next: pass --api-key or set ARTBOT_API_KEY.`;
+    }
+    if (error.status === 404) {
+      return `Requested resource was not found (404). Next: verify identifiers (for example --run-id) and retry.`;
+    }
+    if (error.status >= 500) {
+      return `API server error (${error.status}). Next: inspect API logs and retry.`;
+    }
+    return `API request failed (${error.status}). Next: rerun with --verbose and confirm request payload. Body: ${body}`;
+  }
+  if (error instanceof InputValidationError) {
+    return `${error.message} Next: run command with --help to verify valid options.`;
+  }
+  if (error instanceof ZodError) {
+    return `Invalid input: ${error.issues.map((issue) => issue.message).join("; ")} Next: run command with --help to verify required flags.`;
+  }
+  if (error instanceof TerminalStateError) {
+    return `Run ${error.details.run.id} reached a failed or blocked terminal state. Next: run "artbot runs show --run-id ${error.details.run.id}" for diagnostics.`;
+  }
+  if (error instanceof TypeError && /fetch/i.test(error.message)) {
+    return `Cannot reach API endpoint. Next: start the API service or set --api-base-url to the correct host.`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function createProgram(ctx) {
+  const program = new Command();
+  program.name("artbot").description("Turkish art price research agent CLI").version("0.2.0");
+  program.showHelpAfterError().exitOverride().configureOutput({
+    writeOut: (text) => ctx.deps.stdout(text),
+    writeErr: (text) => ctx.deps.stderr(text)
+  });
+  program.option("--json", "Machine-readable JSON output").option("--api-base-url <url>", "API base URL").option("--api-key <key>", "API key override").option("--verbose", "Verbose diagnostics").option("--quiet", "Suppress non-error human output");
+  registerResearchCommands(program, ctx);
+  registerRunsCommands(program, ctx);
+  registerSetupCommands(program, ctx);
+  return program;
+}
+async function runCli(argv = process.argv, deps = {}) {
+  loadWorkspaceEnv();
+  const ctx = {
+    deps: defaultDeps(deps),
+    exitCode: EXIT_CODES.OK
+  };
+  const userArgs = argv.slice(2);
+  if (userArgs.length === 0 && process.stdout.isTTY) {
+    const { startInteractive } = await import("./chunks/interactive-DQDPPJBS.js");
+    return startInteractive();
+  }
+  const program = createProgram(ctx);
+  try {
+    await program.parseAsync(argv);
+    return ctx.exitCode;
+  } catch (error) {
+    const exitCode = mapErrorToExitCode(error);
+    if (!(error instanceof CommanderError && error.code === "commander.helpDisplayed")) {
+      const globals = (() => {
+        try {
+          return resolveGlobals(program);
+        } catch {
+          return {
+            json: false,
+            apiBaseUrl: process.env.API_BASE_URL ?? "http://localhost:4000",
+            apiKey: process.env.ARTBOT_API_KEY,
+            verbose: false,
+            quiet: false
+          };
+        }
+      })();
+      logError(globals, ctx, formatError(error));
+    }
+    return exitCode;
+  }
+}
+function isMainModule(currentImportUrl) {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) return false;
+  return pathToFileURL(scriptPath).href === currentImportUrl;
+}
+if (isMainModule(import.meta.url)) {
+  runCli(process.argv).then((code) => {
+    process.exit(code);
+  }).catch((error) => {
+    const fallbackMessage = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${fallbackMessage}
+`);
+    process.exit(EXIT_CODES.API);
+  });
+}
+export {
+  createProgram,
+  renderBreakdownTable,
+  renderRecordsTable,
+  renderRunsTable,
+  renderSummaryTable,
+  runCli
+};
+//# sourceMappingURL=index.js.map