okrapdf 0.8.0

package/dist/chunk-SBT5T6ZK.js

@@ -0,0 +1,817 @@
+// src/cli/commands/tree.ts
+async function tree(client, jobId, options = {}) {
+  const treeData = await client.request(`/document/${jobId}/verification-tree`);
+  let filteredPages = treeData.pages.map((p) => p.page);
+  if (options.status) {
+    filteredPages = treeData.pages.filter((p) => p.status === options.status).map((p) => p.page);
+  }
+  if (options.entity) {
+    const entitiesData = await client.request(`/document/${jobId}/nodes?type=${options.entity}`);
+    const pagesWithEntity = new Set(entitiesData.entities.map((e) => e.page));
+    filteredPages = filteredPages.filter((p) => pagesWithEntity.has(p));
+  }
+  return { tree: treeData, filteredPages };
+}
+function formatTreeOutput(result, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  const { tree: treeData, filteredPages } = result;
+  const lines = [];
+  if (format === "markdown") {
+    lines.push(`# Verification Tree: ${treeData.jobId}`);
+    lines.push("");
+    lines.push(`**Total Pages:** ${treeData.totalPages}`);
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("| Status | Count |");
+    lines.push("|--------|-------|");
+    lines.push(`| Complete | ${treeData.summary.complete} |`);
+    lines.push(`| Partial | ${treeData.summary.partial} |`);
+    lines.push(`| Pending | ${treeData.summary.pending} |`);
+    lines.push(`| Flagged | ${treeData.summary.flagged} |`);
+    lines.push(`| Empty | ${treeData.summary.empty} |`);
+    lines.push(`| Gap | ${treeData.summary.gap} |`);
+    lines.push("");
+    lines.push("## Pages");
+    lines.push("| Page | Status | Total | Verified | Pending | Flagged |");
+    lines.push("|------|--------|-------|----------|---------|---------|");
+    for (const page of treeData.pages) {
+      if (filteredPages.includes(page.page)) {
+        lines.push(
+          `| ${page.page} | ${page.status} | ${page.total} | ${page.verified} | ${page.pending} | ${page.flagged} |`
+        );
+      }
+    }
+  } else {
+    lines.push(`Verification Tree: ${treeData.jobId}`);
+    lines.push(`Total Pages: ${treeData.totalPages}`);
+    lines.push("");
+    lines.push("Summary:");
+    lines.push(`  Complete: ${treeData.summary.complete}`);
+    lines.push(`  Partial:  ${treeData.summary.partial}`);
+    lines.push(`  Pending:  ${treeData.summary.pending}`);
+    lines.push(`  Flagged:  ${treeData.summary.flagged}`);
+    lines.push(`  Empty:    ${treeData.summary.empty}`);
+    lines.push(`  Gap:      ${treeData.summary.gap}`);
+    lines.push("");
+    lines.push("Pages:");
+    for (const page of treeData.pages) {
+      if (filteredPages.includes(page.page)) {
+        const statusIcon = getStatusIcon(page.status);
+        const counts = `[${page.verified}/${page.total}]`;
+        const flags = page.flagged > 0 ? ` (${page.flagged} flagged)` : "";
+        const gaps = page.hasCoverageGaps ? " [GAP]" : "";
+        lines.push(`  ${statusIcon} p${page.page.toString().padStart(3)} ${counts}${flags}${gaps}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "complete":
+      return "\u2713";
+    case "partial":
+      return "\u25D0";
+    case "pending":
+      return "\u25CB";
+    case "flagged":
+      return "\u2691";
+    case "empty":
+      return "\xB7";
+    case "gap":
+      return "!";
+    case "error":
+      return "\u2717";
+    default:
+      return "?";
+  }
+}
+
+// src/cli/query-engine.ts
+function parseSelector(selector) {
+  const parts = { types: [] };
+  if (selector.includes(",") && !selector.includes("[")) {
+    const segments = selector.split(",").map((s) => s.trim());
+    for (const seg of segments) {
+      const subParts = parseSelector(seg);
+      parts.types.push(...subParts.types);
+    }
+    return parts;
+  }
+  const typeMatches = selector.match(/\.([a-zA-Z][a-zA-Z0-9_]*)/g);
+  if (typeMatches) {
+    parts.types = typeMatches.map((m) => m.slice(1));
+  }
+  const idMatch = selector.match(/#([\w-]+)/);
+  if (idMatch) {
+    parts.id = idMatch[1];
+  }
+  const pageMatch = selector.match(/:pages?\((\d+)(?:-(\d+))?\)/);
+  if (pageMatch) {
+    if (pageMatch[2]) {
+      parts.pageFilter = {
+        type: "range",
+        value: [parseInt(pageMatch[1], 10), parseInt(pageMatch[2], 10)]
+      };
+    } else {
+      parts.pageFilter = {
+        type: "single",
+        value: parseInt(pageMatch[1], 10)
+      };
+    }
+  }
+  const confMatch = selector.match(/\[confidence(>=?|<=?|>|<)(\d+\.?\d*)\]/);
+  if (confMatch) {
+    parts.confidenceFilter = {
+      op: confMatch[1],
+      value: parseFloat(confMatch[2])
+    };
+  }
+  const verifyMatch = selector.match(/\[(?:verified|status)=(\w+)\]/);
+  if (verifyMatch) {
+    const val = verifyMatch[1].toLowerCase();
+    if (val === "true") {
+      parts.verificationFilter = "verified";
+    } else if (["pending", "verified", "flagged", "rejected"].includes(val)) {
+      parts.verificationFilter = val;
+    }
+  }
+  const containsMatch = selector.match(/:contains\(([^)]+)\)/);
+  if (containsMatch) {
+    parts.textContains = containsMatch[1];
+  }
+  if (parts.types.length === 0 && selector.includes("*")) {
+    parts.types = ["table", "figure", "footnote", "summary", "signature", "paragraph"];
+  }
+  return parts;
+}
+function filterEntities(entities, parts) {
+  return entities.filter((entity) => {
+    if (parts.types.length > 0 && !parts.types.includes(entity.type)) {
+      return false;
+    }
+    if (parts.id && entity.id !== parts.id) {
+      return false;
+    }
+    if (parts.pageFilter) {
+      if (parts.pageFilter.type === "single") {
+        if (entity.page !== parts.pageFilter.value) return false;
+      } else {
+        const [start, end] = parts.pageFilter.value;
+        if (entity.page < start || entity.page > end) return false;
+      }
+    }
+    if (parts.confidenceFilter && entity.confidence !== void 0) {
+      const { op, value } = parts.confidenceFilter;
+      switch (op) {
+        case ">":
+          if (!(entity.confidence > value)) return false;
+          break;
+        case ">=":
+          if (!(entity.confidence >= value)) return false;
+          break;
+        case "<":
+          if (!(entity.confidence < value)) return false;
+          break;
+        case "<=":
+          if (!(entity.confidence <= value)) return false;
+          break;
+      }
+    }
+    if (parts.verificationFilter && entity.verificationStatus !== parts.verificationFilter) {
+      return false;
+    }
+    if (parts.textContains && entity.title) {
+      if (!entity.title.toLowerCase().includes(parts.textContains.toLowerCase())) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function executeQuery(entities, selector, options = {}) {
+  const parts = parseSelector(selector);
+  if (options.minConfidence !== void 0) {
+    parts.confidenceFilter = { op: ">=", value: options.minConfidence };
+  }
+  if (options.pageRange) {
+    parts.pageFilter = { type: "range", value: options.pageRange };
+  }
+  let results = filterEntities(entities, parts);
+  if (options.sortBy) {
+    results = [...results].sort((a, b) => {
+      switch (options.sortBy) {
+        case "confidence":
+          return (b.confidence ?? 0) - (a.confidence ?? 0);
+        case "page":
+          return a.page - b.page;
+        case "type":
+          return a.type.localeCompare(b.type);
+        default:
+          return 0;
+      }
+    });
+  }
+  const stats = calculateStats(results);
+  if (options.topK && options.topK > 0) {
+    results = results.slice(0, options.topK);
+  }
+  return {
+    entities: results,
+    total: results.length,
+    stats
+  };
+}
+function calculateStats(entities) {
+  const byType = {};
+  const byPage = {};
+  let totalConfidence = 0;
+  let minConfidence = Infinity;
+  let maxConfidence = -Infinity;
+  let confidenceCount = 0;
+  for (const entity of entities) {
+    byType[entity.type] = (byType[entity.type] || 0) + 1;
+    byPage[entity.page] = (byPage[entity.page] || 0) + 1;
+    if (entity.confidence !== void 0) {
+      totalConfidence += entity.confidence;
+      confidenceCount++;
+      if (entity.confidence < minConfidence) minConfidence = entity.confidence;
+      if (entity.confidence > maxConfidence) maxConfidence = entity.confidence;
+    }
+  }
+  return {
+    total: entities.length,
+    byType,
+    byPage,
+    avgConfidence: confidenceCount > 0 ? totalConfidence / confidenceCount : 0,
+    minConfidence: minConfidence === Infinity ? 0 : minConfidence,
+    maxConfidence: maxConfidence === -Infinity ? 0 : maxConfidence
+  };
+}
+
+// src/cli/commands/find.ts
+async function find(client, jobId, selector, options = {}) {
+  const entitiesData = await client.request(`/document/${jobId}/nodes`);
+  return executeQuery(entitiesData.entities, selector, options);
+}
+function formatFindOutput(result, format = "text", showStats = false) {
+  if (format === "json") {
+    return JSON.stringify(showStats ? result : result.entities, null, 2);
+  }
+  if (format === "ids") {
+    return result.entities.map((e) => e.id).join("\n");
+  }
+  if (format === "entities") {
+    return result.entities.map((e) => `${e.type}	${e.page}	${e.id}	${e.title || ""}`).join("\n");
+  }
+  const lines = [];
+  lines.push(`Found ${result.total} entities`);
+  lines.push("");
+  if (showStats) {
+    lines.push("Stats:");
+    lines.push(`  By Type:`);
+    for (const [type, count] of Object.entries(result.stats.byType)) {
+      lines.push(`    ${type}: ${count}`);
+    }
+    lines.push(`  Confidence: avg=${result.stats.avgConfidence.toFixed(2)}, min=${result.stats.minConfidence.toFixed(2)}, max=${result.stats.maxConfidence.toFixed(2)}`);
+    lines.push(`  Pages: ${Object.keys(result.stats.byPage).length}`);
+    lines.push("");
+  }
+  lines.push("Entities:");
+  for (const entity of result.entities) {
+    const conf = entity.confidence !== void 0 ? ` (${(entity.confidence * 100).toFixed(0)}%)` : "";
+    const title = entity.title ? ` "${entity.title.slice(0, 40)}${entity.title.length > 40 ? "..." : ""}"` : "";
+    lines.push(`  [p${entity.page}] ${entity.type}${title}${conf}`);
+  }
+  return lines.join("\n");
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push(`Total: ${stats.total}`);
+  lines.push("");
+  lines.push("By Type:");
+  for (const [type, count] of Object.entries(stats.byType)) {
+    const pct = (count / stats.total * 100).toFixed(1);
+    lines.push(`  ${type.padEnd(12)} ${count.toString().padStart(4)} (${pct}%)`);
+  }
+  lines.push("");
+  lines.push("By Page:");
+  const pageCounts = Object.entries(stats.byPage).sort((a, b) => parseInt(a[0]) - parseInt(b[0])).slice(0, 20);
+  for (const [page, count] of pageCounts) {
+    lines.push(`  p${page.padStart(3)}: ${"\u2588".repeat(Math.min(count, 40))} ${count}`);
+  }
+  if (Object.keys(stats.byPage).length > 20) {
+    lines.push(`  ... and ${Object.keys(stats.byPage).length - 20} more pages`);
+  }
+  lines.push("");
+  lines.push("Confidence:");
+  lines.push(`  Average: ${(stats.avgConfidence * 100).toFixed(1)}%`);
+  lines.push(`  Min:     ${(stats.minConfidence * 100).toFixed(1)}%`);
+  lines.push(`  Max:     ${(stats.maxConfidence * 100).toFixed(1)}%`);
+  return lines.join("\n");
+}
+
+// src/cli/commands/page.ts
+async function pageGet(client, jobId, pageNum, options = {}) {
+  if (options.version) {
+    return client.request(`/document/${jobId}/pages/${pageNum}/versions/${options.version}`);
+  }
+  return client.request(`/document/${jobId}/pages/${pageNum}`);
+}
+async function pageEdit(client, jobId, pageNum, content) {
+  const result = await client.request(
+    `/document/${jobId}/pages/${pageNum}`,
+    {
+      method: "POST",
+      body: JSON.stringify({ content }),
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+  return { success: result.success, version: result.version };
+}
+async function pageResolve(client, jobId, pageNum, options) {
+  return client.request(
+    `/document/${jobId}/pages/${pageNum}/resolve`,
+    {
+      method: "POST",
+      body: JSON.stringify(options),
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+async function pageVersions(client, jobId, pageNum) {
+  return client.request(`/document/${jobId}/pages/${pageNum}/versions`);
+}
+function formatPageOutput(content, format = "markdown") {
+  if (format === "json") {
+    return JSON.stringify(content, null, 2);
+  }
+  if (format === "markdown") {
+    return content.content;
+  }
+  const lines = [];
+  lines.push(`Page ${content.page}`);
+  if (content.version) {
+    lines.push(`Version: ${content.version}`);
+  }
+  lines.push(`Length: ${content.content.length} chars`);
+  lines.push("");
+  lines.push("---");
+  lines.push(content.content);
+  return lines.join("\n");
+}
+function formatVersionsOutput(versions, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(versions, null, 2);
+  }
+  const lines = [];
+  lines.push(`Page ${versions.page} - ${versions.versions.length} versions`);
+  lines.push(`Current: v${versions.currentVersion}`);
+  lines.push("");
+  for (const v of versions.versions) {
+    const current = v.version === versions.currentVersion ? " *" : "";
+    const date = v.createdAt ? new Date(v.createdAt).toLocaleString() : "unknown";
+    lines.push(`  v${v.version}${current} [${v.editSource}] ${date}`);
+    if (v.preview) {
+      lines.push(`    "${v.preview.slice(0, 60)}${v.preview.length > 60 ? "..." : ""}"`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/search.ts
+async function search(client, jobId, query) {
+  return client.request(`/document/${jobId}/search?q=${encodeURIComponent(query)}`);
+}
+function formatSearchOutput(result, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  const lines = [];
+  lines.push(`Search: "${result.query}"`);
+  lines.push(`Found ${result.totalMatches} matches in ${result.results.length} pages`);
+  lines.push("");
+  for (const r of result.results) {
+    const source = r.matchSource ? ` [${r.matchSource}]` : "";
+    lines.push(`p${r.page.toString().padStart(3)} (${r.matchCount} matches)${source}`);
+    if (r.snippet) {
+      lines.push(`  "${r.snippet.slice(0, 80)}${r.snippet.length > 80 ? "..." : ""}"`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/tables.ts
+async function tables(client, jobId, options = {}) {
+  const url = options.page ? `/document/${jobId}/tables?page=${options.page}` : `/document/${jobId}/tables`;
+  const result = await client.request(url);
+  if (options.status) {
+    result.tables = result.tables.filter((t) => t.verificationStatus === options.status);
+  }
+  return result;
+}
+function formatTablesOutput(result, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  if (format === "markdown") {
+    return result.tables.map((t) => {
+      return `## Table (p${t.pageNumber})
+
+${t.markdown}`;
+    }).join("\n\n---\n\n");
+  }
+  const lines = [];
+  lines.push(`Tables: ${result.tables.length}`);
+  lines.push("");
+  const byPage = /* @__PURE__ */ new Map();
+  for (const t of result.tables) {
+    const pageGroup = byPage.get(t.pageNumber) || [];
+    pageGroup.push(t);
+    byPage.set(t.pageNumber, pageGroup);
+  }
+  for (const [page, pageTables] of [...byPage.entries()].sort((a, b) => a[0] - b[0])) {
+    lines.push(`Page ${page}:`);
+    for (const t of pageTables) {
+      const status = getStatusIcon2(t.verificationStatus);
+      const conf = t.confidence !== null ? ` (${(t.confidence * 100).toFixed(0)}%)` : "";
+      const preview = t.markdown.split("\n")[0].slice(0, 50);
+      lines.push(`  ${status} ${t.id}${conf}`);
+      lines.push(`    ${preview}${t.markdown.length > 50 ? "..." : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+function getStatusIcon2(status) {
+  switch (status) {
+    case "verified":
+      return "\u2713";
+    case "pending":
+      return "\u25CB";
+    case "flagged":
+      return "\u2691";
+    case "rejected":
+      return "\u2717";
+    default:
+      return "?";
+  }
+}
+
+// src/cli/commands/history.ts
+async function history(client, jobId, options = {}) {
+  const limit = options.limit || 50;
+  return client.request(`/document/${jobId}/history?limit=${limit}`);
+}
+function formatHistoryOutput(result, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  const lines = [];
+  lines.push(`History: ${result.history.length} entries`);
+  lines.push("");
+  for (const entry of result.history) {
+    const date = new Date(entry.createdAt).toLocaleString();
+    const page = entry.pageNum !== null ? ` p${entry.pageNum}` : "";
+    const transition = entry.transitionName || `${entry.previousState || "?"} -> ${entry.state}`;
+    const by = entry.triggeredByName || entry.triggeredBy || "system";
+    lines.push(`[${date}] ${entry.entityType}${page}`);
+    lines.push(`  ${transition} by ${by}`);
+    if (entry.reason) {
+      lines.push(`  Reason: ${entry.reason}`);
+    }
+    if (entry.resolution) {
+      lines.push(`  Resolution: ${entry.resolution}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/toc.ts
+import WebSocket from "ws";
+async function toc(client, jobId, options = {}) {
+  const params = options.maxDepth ? `?maxDepth=${options.maxDepth}` : "";
+  const result = await client.request(`/document/${jobId}/toc${params}`);
+  if (options.watch && result._replay) {
+    console.log(`
+\u{1F4FC} Watching live events for session ${result._replay.sessionId}...
+`);
+    await watchLiveEvents(result._replay.replayUrl);
+  }
+  return result;
+}
+async function watchLiveEvents(wsUrl) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    let hasSeenEvents = false;
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ type: "JOIN_SESSION" }));
+    });
+    ws.on("message", (data) => {
+      try {
+        const event = JSON.parse(data.toString());
+        if (event.type === "EVENTS_BATCH") {
+          for (const evt of event.events) {
+            printEvent(evt);
+            hasSeenEvents = true;
+          }
+        } else if (event.type && event.type.startsWith("TOC_")) {
+          printEvent(event);
+          hasSeenEvents = true;
+        } else if (event.type === "TOC_RESPONSE_READY") {
+          printEvent(event);
+          hasSeenEvents = true;
+          setTimeout(() => {
+            ws.close();
+            resolve();
+          }, 500);
+        }
+      } catch (err) {
+        console.error("Failed to parse event:", err);
+      }
+    });
+    ws.on("error", (error) => {
+      console.error("WebSocket error:", error.message);
+      reject(error);
+    });
+    ws.on("close", () => {
+      if (!hasSeenEvents) {
+        console.log("No events received (session may have completed).");
+      }
+      resolve();
+    });
+    setTimeout(() => {
+      ws.close();
+      resolve();
+    }, 1e4);
+  });
+}
+function printEvent(event) {
+  const timestamp = event.eventTimestamp ? new Date(event.eventTimestamp).toISOString().slice(11, 23) : "";
+  const duration = event.cost?.duration_ms ? ` (${event.cost.duration_ms}ms)` : "";
+  const eventType = event.type.replace("TOC_", "").replace(/_/g, " ").toLowerCase();
+  console.log(`[${timestamp}] ${eventType}${duration}`);
+  if (event.data && Object.keys(event.data).length > 0) {
+    const dataStr = formatEventData(event.data);
+    if (dataStr) {
+      console.log(`  ${dataStr}`);
+    }
+  }
+}
+function formatEventData(data) {
+  const relevant = [];
+  if (data.fileName) relevant.push(`file: ${data.fileName}`);
+  if (data.gcsPath) relevant.push(`path: ${data.gcsPath}`);
+  if (data.sizeBytes) relevant.push(`size: ${(data.sizeBytes / 1024 / 1024).toFixed(2)}MB`);
+  if (data.sandboxId) relevant.push(`sandbox: ${data.sandboxId.slice(0, 12)}...`);
+  if (data.template) relevant.push(`template: ${data.template}`);
+  if (data.strategy) relevant.push(`strategy: ${data.strategy}`);
+  if (data.totalEntries !== void 0) relevant.push(`entries: ${data.totalEntries}`);
+  if (data.exitCode !== void 0) relevant.push(`exit: ${data.exitCode}`);
+  if (data.totalElapsedMs) relevant.push(`total: ${data.totalElapsedMs}ms`);
+  return relevant.join(", ");
+}
+function formatTocOutput(result, format = "text") {
+  if (format === "json") {
+    return JSON.stringify(result, null, 2);
+  }
+  if (format === "markdown") {
+    const lines2 = [];
+    lines2.push(`# Table of Contents
+`);
+    lines2.push(`_${result.file_name}_
+`);
+    lines2.push(`Strategy: ${result.strategy} | Pages: ${result.total_pages} | Entries: ${result.total_entries}
+`);
+    for (const entry of result.toc) {
+      const hashes = "#".repeat(entry.level + 1);
+      lines2.push(`${hashes} ${entry.title} (p. ${entry.page})`);
+    }
+    return lines2.join("\n");
+  }
+  const lines = [];
+  lines.push(`File: ${result.file_name}`);
+  lines.push(`Strategy: ${result.strategy}`);
+  lines.push(`Entries: ${result.total_entries}`);
+  lines.push(`Pages: ${result.total_pages}`);
+  lines.push(`Elapsed: ${result.elapsed_ms}ms (total: ${result.total_elapsed_ms}ms)`);
+  lines.push("");
+  if (result.total_entries === 0) {
+    lines.push("No table of contents found.");
+    if (result.strategy === "none") {
+      lines.push("This PDF may not have bookmarks or a printed TOC page.");
+    }
+  } else {
+    lines.push("Table of Contents:");
+    lines.push("");
+    for (const entry of result.toc) {
+      const indent = "  ".repeat(entry.level - 1);
+      const dots = ".".repeat(Math.max(1, 60 - indent.length - entry.title.length));
+      lines.push(`${indent}${entry.title} ${dots} ${entry.page}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getGlobalConfigDir() {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) {
+    return join(xdgConfigHome, "okra");
+  }
+  return join(homedir(), ".okra");
+}
+function getGlobalConfigPath() {
+  return join(getGlobalConfigDir(), "config.json");
+}
+function readGlobalConfig() {
+  try {
+    const configPath = getGlobalConfigPath();
+    if (!existsSync(configPath)) {
+      return null;
+    }
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+function writeGlobalConfig(config) {
+  const configDir = getGlobalConfigDir();
+  const configPath = getGlobalConfigPath();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function readProjectConfig() {
+  const projectFiles = [".okrarc", ".okra.json"];
+  for (const filename of projectFiles) {
+    try {
+      const path = join(process.cwd(), filename);
+      if (existsSync(path)) {
+        const content = readFileSync(path, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  return null;
+}
+function getApiKey() {
+  if (process.env.OKRA_API_KEY) {
+    return process.env.OKRA_API_KEY;
+  }
+  const projectConfig = readProjectConfig();
+  if (projectConfig?.apiKey) {
+    return projectConfig.apiKey;
+  }
+  const globalConfig = readGlobalConfig();
+  if (globalConfig?.apiKey) {
+    return globalConfig.apiKey;
+  }
+  return void 0;
+}
+function getBaseUrl() {
+  if (process.env.OKRA_BASE_URL) {
+    return process.env.OKRA_BASE_URL;
+  }
+  const projectConfig = readProjectConfig();
+  if (projectConfig?.baseUrl) {
+    return projectConfig.baseUrl;
+  }
+  const globalConfig = readGlobalConfig();
+  if (globalConfig?.baseUrl) {
+    return globalConfig.baseUrl;
+  }
+  return "https://app.okrapdf.com";
+}
+function getApiKeySource() {
+  if (process.env.OKRA_API_KEY) {
+    return "environment variable (OKRA_API_KEY)";
+  }
+  const projectConfig = readProjectConfig();
+  if (projectConfig?.apiKey) {
+    const files = [".okrarc", ".okra.json"];
+    for (const f of files) {
+      if (existsSync(join(process.cwd(), f))) {
+        return `project config (${f})`;
+      }
+    }
+  }
+  const globalConfig = readGlobalConfig();
+  if (globalConfig?.apiKey) {
+    return `global config (${getGlobalConfigPath()})`;
+  }
+  return "not found";
+}
+
+// src/cli/commands/auth.ts
+import * as readline from "readline";
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function authLogin() {
+  console.log("okra CLI Authentication");
+  console.log("");
+  console.log("Get your API key from: https://app.okrapdf.com/settings/api");
+  console.log("");
+  const apiKey = await prompt("Enter your API key: ");
+  if (!apiKey) {
+    console.error("Error: API key cannot be empty");
+    process.exit(1);
+  }
+  if (!apiKey.startsWith("okra_")) {
+    console.warn('Warning: API key should start with "okra_"');
+  }
+  const config = readGlobalConfig() || {};
+  config.apiKey = apiKey;
+  writeGlobalConfig(config);
+  console.log("");
+  console.log(`\u2713 API key saved to ${getGlobalConfigPath()}`);
+  console.log("");
+  console.log("You can now use okra commands without setting OKRA_API_KEY");
+}
+async function authStatus() {
+  const apiKey = getApiKey();
+  const source = getApiKeySource();
+  console.log("okra CLI Authentication Status");
+  console.log("");
+  if (apiKey) {
+    const maskedKey = apiKey.slice(0, 10) + "..." + apiKey.slice(-4);
+    console.log(`\u2713 Authenticated: ${maskedKey}`);
+    console.log(`  Source: ${source}`);
+  } else {
+    console.log("\u2717 Not authenticated");
+    console.log("");
+    console.log("Set API key via:");
+    console.log("  okra auth login");
+    console.log('  export OKRA_API_KEY="okra_xxx"');
+  }
+  console.log("");
+}
+async function authLogout() {
+  const config = readGlobalConfig();
+  if (!config || !config.apiKey) {
+    console.log("No API key found in global config");
+    return;
+  }
+  delete config.apiKey;
+  writeGlobalConfig(config);
+  console.log(`\u2713 API key removed from ${getGlobalConfigPath()}`);
+  console.log("");
+  console.log("Note: Environment variables and project configs are not affected");
+}
+
+export {
+  tree,
+  formatTreeOutput,
+  parseSelector,
+  filterEntities,
+  executeQuery,
+  calculateStats,
+  find,
+  formatFindOutput,
+  formatStats,
+  pageGet,
+  pageEdit,
+  pageResolve,
+  pageVersions,
+  formatPageOutput,
+  formatVersionsOutput,
+  search,
+  formatSearchOutput,
+  tables,
+  formatTablesOutput,
+  history,
+  formatHistoryOutput,
+  toc,
+  formatTocOutput,
+  getGlobalConfigDir,
+  getGlobalConfigPath,
+  readGlobalConfig,
+  writeGlobalConfig,
+  readProjectConfig,
+  getApiKey,
+  getBaseUrl,
+  getApiKeySource,
+  authLogin,
+  authStatus,
+  authLogout
+};
+//# sourceMappingURL=chunk-SBT5T6ZK.js.map