cograph 0.1.14 → 0.1.16

package/dist/{shell-2QXHLD4W.js → shell-VPPIRJSS.js}

@@ -2,7 +2,7 @@
 import {
   Client,
   CographError
-} from "./chunk-IHKVOXYV.js";
+} from "./chunk-K7B4PPX2.js";
 import "./chunk-7VVBEUZQ.js";
 
 // src/shell.ts
@@ -59,6 +59,11 @@ function showCommands() {
     ["/kg delete <name>", "Delete a KG (irreversible)"],
     ["/types [query]", "List types in the current KG (with entity counts)"],
     ["/type <name>", "Drill into one type \u2014 attributes, relationships, samples"],
+    ["/type <name> --system", "\u2026also include auto-attached system attributes"],
+    ["/enrich <Type> <attr> ...", "Plan + run an enrichment job (interactive)"],
+    ["/enrich watch <job_id>", "Live progress for a running job"],
+    ["/enrich jobs", "List recent enrichment jobs"],
+    ["/enrich review <job_id>", "Walk through conflicts and accept/reject"],
     ["/login", "Re-authenticate (browser)"],
     ["/status", "Show graph stats"],
     ["/reset", "Clear the current KG"],
@@ -376,17 +381,21 @@ async function resolveTypeName(client, kg, rl, input) {
   return null;
 }
 async function cmdType(client, kg, rl, input) {
-  if (!input.trim()) {
-    stdout.write(`  ${YELLOW}Usage:${RESET} /type <name>
+  const tokens = splitArgs(input.trim());
+  const includeSystem = tokens.includes("--system");
+  const nameTokens = tokens.filter((t) => t !== "--system");
+  const nameInput = nameTokens.join(" ").trim();
+  if (!nameInput) {
+    stdout.write(`  ${YELLOW}Usage:${RESET} /type <name> [--system]
 `);
     return;
   }
-  const name = await resolveTypeName(client, kg, rl, input);
+  const name = await resolveTypeName(client, kg, rl, nameInput);
   if (!name) return;
   const sp = startSpinner(`Loading ${name}...`);
   let usage;
   try {
-    usage = await client.typeUsage(kg, name);
+    usage = await client.typeUsage(kg, name, { includeSystem });
   } catch (err) {
     sp.stop();
     if (err instanceof CographError) printError(err.message);
@@ -396,6 +405,9 @@ async function cmdType(client, kg, rl, input) {
   sp.stop();
   const total = usage.entity_count;
   const pct = (n) => total > 0 ? `${Math.round(n / total * 100).toString().padStart(3)}%` : "  \u2014";
+  const relNames = new Set(usage.relationships.map((r) => r.name));
+  const attrLitByName = new Map(usage.attributes.map((a) => [a.name, a]));
+  const litOnlyAttrs = usage.attributes.filter((a) => !relNames.has(a.name));
   stdout.write("\n");
   stdout.write(
     `  ${BOLD}${usage.name}${RESET}  ${DIM}${fmtNum(total)} entities${RESET}
@@ -409,25 +421,25 @@ async function cmdType(client, kg, rl, input) {
     stdout.write(`  ${DIM}subClassOf  ${usage.parent_type}${RESET}
 `);
   }
-  if (usage.attributes.length > 0) {
+  if (litOnlyAttrs.length > 0) {
     stdout.write(
       `
-  ${BOLD}Attributes (${usage.attributes.length})${RESET}
+  ${BOLD}Attributes (${litOnlyAttrs.length})${RESET}
 `
     );
     const nameW = Math.max(
-      ...usage.attributes.map((a) => a.name.length + 1),
+      ...litOnlyAttrs.map((a) => a.name.length + 1),
       8
     );
     const typeW = Math.max(
-      ...usage.attributes.map((a) => a.datatype.length),
+      ...litOnlyAttrs.map((a) => a.datatype.length),
       8
     );
     const cntW = Math.max(
-      ...usage.attributes.map((a) => fmtNum(a.count).length),
+      ...litOnlyAttrs.map((a) => fmtNum(a.count).length),
       4
     );
-    for (const a of usage.attributes) {
+    for (const a of litOnlyAttrs) {
       const dotName = `.${a.name}`;
       stdout.write(
         `    ${CYAN}${dotName.padEnd(nameW)}${RESET}  ${DIM}${a.datatype.padEnd(typeW)}${RESET}  ${fmtNum(a.count).padStart(cntW)}  ${DIM}(${pct(a.count)})${RESET}
@@ -452,8 +464,10 @@ async function cmdType(client, kg, rl, input) {
     for (const r of usage.relationships) {
       const dotName = `.${r.name}`;
       const tgt = r.target_type ?? "?";
+      const lit = attrLitByName.get(r.name);
+      const litNote = lit ? ` ${DIM}(+${fmtNum(lit.count)} ${lit.datatype})${RESET}` : "";
       stdout.write(
-        `    ${CYAN}${dotName.padEnd(nameW)}${RESET}  ${DIM}\u2192${RESET} ${BOLD}${tgt.padEnd(tgtW)}${RESET}  ${fmtNum(r.count).padStart(6)}  ${DIM}(${pct(r.count)})${RESET}
+        `    ${CYAN}${dotName.padEnd(nameW)}${RESET}  ${DIM}\u2192${RESET} ${BOLD}${tgt.padEnd(tgtW)}${RESET}  ${fmtNum(r.count).padStart(6)}  ${DIM}(${pct(r.count)})${RESET}${litNote}
 `
       );
     }
@@ -477,12 +491,321 @@ async function cmdType(client, kg, rl, input) {
   }
   stdout.write("\n");
 }
-function makePrompt(kg, triples) {
+function lastUriSegment(uri) {
+  if (!uri) return uri;
+  const hash = uri.lastIndexOf("#");
+  if (hash >= 0 && hash < uri.length - 1) return uri.slice(hash + 1);
+  const slash = uri.lastIndexOf("/");
+  if (slash >= 0 && slash < uri.length - 1) return uri.slice(slash + 1);
+  return uri;
+}
+function relativeTime(iso) {
+  if (!iso) return "\u2014";
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return "\u2014";
+  const diffMs = Date.now() - t;
+  const s = Math.max(0, Math.floor(diffMs / 1e3));
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  return `${d}d ago`;
+}
+function progressBar(processed, total, width = 20) {
+  if (!total || total <= 0) return "[" + " ".repeat(width) + "]";
+  const ratio = Math.max(0, Math.min(1, processed / total));
+  const filled = Math.round(ratio * width);
+  return "[" + "\u2588".repeat(filled) + "\u2591".repeat(width - filled) + "]";
+}
+function statusColor(status) {
+  switch (status) {
+    case "applied":
+      return GREEN;
+    case "failed":
+      return RED;
+    case "review":
+      return YELLOW;
+    case "cancelled":
+      return DIM;
+    default:
+      return CYAN;
+  }
+}
+async function cmdEnrichRun(client, kg, rl, args) {
+  if (args.length < 2) {
+    stdout.write(
+      `  ${YELLOW}Usage:${RESET} /enrich <Type> <attr1> [<attr2> ...]
+`
+    );
+    return;
+  }
+  const typeInput = args[0];
+  const attrs = args.slice(1).map((a) => a.replace(/^\./, ""));
+  const typeName = await resolveTypeName(client, kg, rl, typeInput);
+  if (!typeName) return;
+  const tier = "lite";
+  const policy = "stage";
+  stdout.write(
+    `
+  ${BOLD}Plan:${RESET} enrich ${CYAN}${typeName}${RESET}.${attrs.map((a) => `${CYAN}${a}${RESET}`).join(`, .`)} in ${BOLD}${kg}${RESET}  ${DIM}\xB7${RESET} tier: ${tier}  ${DIM}\xB7${RESET} policy: ${policy}
+
+`
+  );
+  const sp = startSpinner(`Queueing enrichment for ${typeName}...`);
+  let created;
+  try {
+    created = await client.enrichRun({
+      type_name: typeName,
+      attributes: attrs,
+      tier,
+      kg_name: kg,
+      conflict_policy: policy
+    });
+  } catch (err) {
+    sp.stop();
+    if (err instanceof CographError) printError(err.message);
+    else printError(err instanceof Error ? err.message : String(err));
+    return;
+  }
+  sp.stop();
+  const cost = (created.estimated_cost_usd ?? 0).toFixed(4);
+  stdout.write(
+    `  ${GREEN}\u2713${RESET} Job queued: ${CYAN_BOLD}${created.job_id}${RESET} ${DIM}\xB7${RESET} estimated cost ${BOLD}$${cost}${RESET} ${DIM}\xB7${RESET} ${fmtNum(created.total_entities ?? 0)} entities
+`
+  );
+  const watch = (await ask(rl, `  Watch progress? [Y/n]: `)).trim().toLowerCase();
+  if (watch === "" || watch === "y" || watch === "yes") {
+    await watchJob(client, created.job_id);
+  } else {
+    stdout.write(
+      `  ${DIM}Tip: /enrich watch ${created.job_id} to follow it.${RESET}
+`
+    );
+  }
+}
+async function watchJob(client, jobId) {
+  const startedAt = Date.now();
+  let lastJob = null;
+  const draw = (job) => {
+    const p2 = job.progress;
+    const bar = progressBar(p2.processed, p2.total);
+    const elapsed = Math.max(1, Math.floor((Date.now() - startedAt) / 1e3));
+    const rate = p2.processed / elapsed;
+    let etaStr = "\u2014";
+    if (rate > 0 && p2.total > p2.processed) {
+      const remaining = Math.ceil((p2.total - p2.processed) / rate);
+      etaStr = remaining < 60 ? `${remaining}s` : remaining < 3600 ? `${Math.floor(remaining / 60)}m` : `${Math.floor(remaining / 3600)}h`;
+    }
+    const sc = statusColor(job.status);
+    stdout.write(
+      `\r\x1B[2K  ${sc}${job.status}${RESET} ${bar} ${fmtNum(p2.processed)}/${fmtNum(p2.total)} ${DIM}\xB7${RESET} filled ${GREEN}${fmtNum(p2.filled)}${RESET} ${DIM}\xB7${RESET} verified ${CYAN}${fmtNum(p2.verified)}${RESET} ${DIM}\xB7${RESET} conflicts ${YELLOW}${fmtNum(p2.conflicts)}${RESET} ${DIM}\xB7${RESET} ETA ${etaStr}`
+    );
+  };
+  while (true) {
+    let job;
+    try {
+      job = await client.enrichJob(jobId);
+    } catch (err) {
+      stdout.write("\r\x1B[2K");
+      if (err instanceof CographError) printError(err.message);
+      else printError(err instanceof Error ? err.message : String(err));
+      return;
+    }
+    lastJob = job;
+    draw(job);
+    if (job.status !== "running" && job.status !== "queued") break;
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  stdout.write("\n");
+  if (!lastJob) return;
+  const p = lastJob.progress;
+  if (lastJob.status === "review") {
+    stdout.write(
+      `  ${YELLOW}\u2726${RESET} ${fmtNum(p.conflicts)} conflict${p.conflicts === 1 ? "" : "s"} need review. ${DIM}Run${RESET} /enrich review ${lastJob.id}${DIM} to walk through them.${RESET}
+`
+    );
+  } else if (lastJob.status === "applied") {
+    stdout.write(
+      `  ${GREEN}\u2713${RESET} Applied ${DIM}\xB7${RESET} filled ${fmtNum(p.filled)}, verified ${fmtNum(p.verified)}, skipped ${fmtNum(p.skipped)}
+`
+    );
+  } else if (lastJob.status === "failed") {
+    printError(`Job failed: ${lastJob.error ?? "(no error message)"}`);
+  } else if (lastJob.status === "cancelled") {
+    stdout.write(`  ${DIM}Job cancelled.${RESET}
+`);
+  }
+}
+async function cmdEnrichJobs(client) {
+  const sp = startSpinner("Loading enrichment jobs...");
+  let jobs;
+  try {
+    jobs = await client.enrichJobs();
+  } catch (err) {
+    sp.stop();
+    if (err instanceof CographError) printError(err.message);
+    else printError(err instanceof Error ? err.message : String(err));
+    return;
+  }
+  sp.stop();
+  if (jobs.length === 0) {
+    stdout.write(`  ${DIM}No enrichment jobs yet.${RESET}
+`);
+    return;
+  }
+  const truncAttrs = (attrs) => {
+    const max = 30;
+    const joined = attrs.join(", ");
+    if (joined.length <= max) return joined;
+    return joined.slice(0, max - 1) + "\u2026";
+  };
+  const rows = jobs.map((j) => ({
+    id: j.id,
+    type: j.type_name,
+    attrs: truncAttrs(j.attributes ?? []),
+    status: j.status,
+    progress: `${fmtNum(j.progress?.processed ?? 0)}/${fmtNum(j.progress?.total ?? 0)}`,
+    created: relativeTime(j.created_at)
+  }));
+  const w = {
+    id: Math.max("ID".length, ...rows.map((r) => r.id.length)),
+    type: Math.max("Type".length, ...rows.map((r) => r.type.length)),
+    attrs: Math.max("Attrs".length, ...rows.map((r) => r.attrs.length)),
+    status: Math.max("Status".length, ...rows.map((r) => r.status.length)),
+    progress: Math.max("Progress".length, ...rows.map((r) => r.progress.length))
+  };
+  stdout.write("\n");
+  stdout.write(
+    `  ${BOLD}${"ID".padEnd(w.id)}  ${"Type".padEnd(w.type)}  ${"Attrs".padEnd(w.attrs)}  ${"Status".padEnd(w.status)}  ${"Progress".padEnd(w.progress)}  Created${RESET}
+`
+  );
+  for (const r of rows) {
+    const sc = statusColor(r.status);
+    stdout.write(
+      `  ${CYAN}${r.id.padEnd(w.id)}${RESET}  ${r.type.padEnd(w.type)}  ${DIM}${r.attrs.padEnd(w.attrs)}${RESET}  ${sc}${r.status.padEnd(w.status)}${RESET}  ${r.progress.padEnd(w.progress)}  ${DIM}${r.created}${RESET}
+`
+    );
+  }
+  stdout.write("\n");
+}
+async function cmdEnrichReview(client, rl, jobId) {
+  if (!jobId) {
+    stdout.write(`  ${YELLOW}Usage:${RESET} /enrich review <job_id>
+`);
+    return;
+  }
+  const sp = startSpinner(`Loading conflicts for ${jobId}...`);
+  let conflicts;
+  try {
+    conflicts = await client.enrichConflicts(jobId);
+  } catch (err) {
+    sp.stop();
+    if (err instanceof CographError) printError(err.message);
+    else printError(err instanceof Error ? err.message : String(err));
+    return;
+  }
+  sp.stop();
+  if (conflicts.length === 0) {
+    stdout.write(`  ${DIM}No conflicts to review.${RESET}
+`);
+    return;
+  }
+  const decisions = [];
+  let acceptAll = false;
+  let quitEarly = false;
+  for (let i = 0; i < conflicts.length; i++) {
+    const c = conflicts[i];
+    const entity = lastUriSegment(c.entity_uri);
+    const conf = (c.proposed?.confidence ?? 0).toFixed(2);
+    stdout.write("\n");
+    stdout.write(
+      `  ${DIM}[${i + 1}/${conflicts.length}]${RESET} ${BOLD}${entity}${RESET}.${CYAN}${c.attribute}${RESET}
+`
+    );
+    stdout.write(
+      `    ${DIM}existing \u2192${RESET} ${c.existing_value}
+    ${DIM}proposed \u2192${RESET} ${BOLD}${c.proposed?.value ?? ""}${RESET} ${DIM}(conf ${conf}, src ${c.proposed?.source ?? "?"})${RESET}
+`
+    );
+    if (c.proposed?.source_url) {
+      stdout.write(`    ${DIM}url      \u2192${RESET} ${c.proposed.source_url}
+`);
+    }
+    let decision;
+    if (acceptAll) {
+      decision = "accept";
+      stdout.write(`    ${GREEN}auto-accepted${RESET}
+`);
+    } else {
+      const ans = (await ask(
+        rl,
+        `    [a]ccept / [r]eject / [s]kip / [A]ccept all remaining / [q]uit (saves progress) [s]: `
+      )).trim();
+      if (ans === "A") {
+        acceptAll = true;
+        decision = "accept";
+      } else if (ans === "a") {
+        decision = "accept";
+      } else if (ans === "r") {
+        decision = "reject";
+      } else if (ans === "q") {
+        quitEarly = true;
+        break;
+      } else {
+        decision = "skip";
+      }
+    }
+    decisions.push({ ...c, decision });
+  }
+  if (quitEarly) {
+    if (decisions.length === 0) {
+      stdout.write(`  ${DIM}No decisions made \u2014 nothing to save.${RESET}
+`);
+      return;
+    }
+    const save = (await ask(rl, `  Save ${decisions.length} decision(s) so far? [Y/n]: `)).trim().toLowerCase();
+    if (save !== "" && save !== "y" && save !== "yes") {
+      stdout.write(`  ${DIM}Discarded.${RESET}
+`);
+      return;
+    }
+  }
+  if (decisions.length === 0) {
+    stdout.write(`  ${DIM}No decisions to apply.${RESET}
+`);
+    return;
+  }
+  const sp2 = startSpinner(`Applying ${decisions.length} decision(s)...`);
+  try {
+    const res = await client.enrichApply(jobId, decisions);
+    sp2.stop();
+    stdout.write(
+      `  ${GREEN}\u2713${RESET} Applied ${BOLD}${fmtNum(res.applied)}${RESET} change${res.applied === 1 ? "" : "s"}.
+`
+    );
+  } catch (err) {
+    sp2.stop();
+    if (err instanceof CographError) printError(err.message);
+    else printError(err instanceof Error ? err.message : String(err));
+  }
+}
+function urlHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  }
+}
+function makePrompt(kg, triples, mode = "cloud", baseUrl) {
   const kgPart = `${DIM}(${kg})${RESET}`;
-  if (triples > 0) {
-    return `  ${CYAN_BOLD}cograph${RESET} ${kgPart} ${DIM}[${fmtNum(triples)}]${RESET} ${CYAN_BOLD}\u25B8${RESET} `;
+  const triplePart = triples > 0 ? `${DIM}[${fmtNum(triples)}]${RESET} ` : "";
+  if (mode === "self-hosted" && baseUrl) {
+    const host = urlHost(baseUrl);
+    return `  ${CYAN_BOLD}cograph${RESET}${DIM}@${host}${RESET} ${kgPart} ${triplePart}${CYAN_BOLD}\u25B8${RESET} `;
   }
-  return `  ${CYAN_BOLD}cograph${RESET} ${kgPart} ${CYAN_BOLD}\u25B8${RESET} `;
+  return `  ${CYAN_BOLD}cograph${RESET} ${kgPart} ${triplePart}${CYAN_BOLD}\u25B8${RESET} `;
 }
 function splitArgs(s) {
   const out = [];
@@ -507,8 +830,21 @@ function splitArgs(s) {
   return out;
 }
 async function runShell(opts) {
-  let client = new Client();
-  if (!client.apiKey) {
+  const CLOUD_DEFAULT = "https://api.cograph.cloud";
+  const envUrl = process.env.COGRAPH_API_URL || process.env.OMNIX_API_URL;
+  const envIsSelfHosted = !!envUrl && envUrl !== CLOUD_DEFAULT;
+  const selfHostedHint = !!opts.local || !!opts.noLogin || envIsSelfHosted;
+  let client = opts.local ? new Client({ baseUrl: "http://localhost:8000", tenant: "default" }) : selfHostedHint ? new Client({ tenant: "default" }) : new Client();
+  const health = await client.healthCheck();
+  if (!health.ok) {
+    printError(
+      `Could not reach ${health.url}. Is the server running?`
+    );
+    return;
+  }
+  const selfHosted = selfHostedHint || !health.requiresAuth;
+  const mode = selfHosted ? "self-hosted" : "cloud";
+  if (!selfHosted && health.requiresAuth && !client.apiKey) {
     stdout.write(
       `
   ${DIM}Not signed in \u2014 opening your browser to log in...${RESET}
@@ -528,6 +864,13 @@ async function runShell(opts) {
     terminal: true
   });
   showBanner();
+  if (selfHosted) {
+    stdout.write(
+      `${DIM}  Self-hosted mode \xB7 ${client.baseUrl} \xB7 tenant=${client.tenant}${RESET}
+
+`
+    );
+  }
   let kg = opts.kg;
   if (!kg) {
     const picked = await selectKg(client, rl);
@@ -564,7 +907,7 @@ async function runShell(opts) {
   while (running) {
     let line;
     try {
-      line = (await ask(rl, makePrompt(kg, triples))).trim();
+      line = (await ask(rl, makePrompt(kg, triples, mode, client.baseUrl))).trim();
     } catch {
       break;
     }
@@ -594,6 +937,29 @@ async function runShell(opts) {
       } else if (line.startsWith("/type ") || line === "/type") {
         const arg = line === "/type" ? "" : line.slice("/type ".length);
         await cmdType(client, kg, rl, arg);
+      } else if (line === "/enrich" || line.startsWith("/enrich ")) {
+        const args = splitArgs(line.slice("/enrich".length).trim());
+        if (args.length === 0) {
+          stdout.write(
+            `  ${YELLOW}Usage:${RESET} /enrich <Type> <attr> ... | /enrich watch <id> | /enrich jobs | /enrich review <id>
+`
+          );
+        } else if (args[0] === "jobs") {
+          await cmdEnrichJobs(client);
+        } else if (args[0] === "watch") {
+          const jid = args[1];
+          if (!jid) {
+            stdout.write(`  ${YELLOW}Usage:${RESET} /enrich watch <job_id>
+`);
+          } else {
+            await watchJob(client, jid);
+          }
+        } else if (args[0] === "review") {
+          await cmdEnrichReview(client, rl, args[1] ?? "");
+        } else {
+          await cmdEnrichRun(client, kg, rl, args);
+          await refresh();
+        }
       } else if (line === "/status") {
         await cmdStatus(client, kg);
         await refresh();
@@ -718,7 +1084,7 @@ async function runShell(opts) {
         }
       } else if (line.startsWith("/")) {
         stdout.write(
-          `  ${YELLOW}Unknown command.${RESET} Try /ingest, /ask, /kg, /types, /type, /login, /status, /reset, /help, /quit
+          `  ${YELLOW}Unknown command.${RESET} Try /ingest, /ask, /kg, /types, /type, /enrich, /login, /status, /reset, /help, /quit
 `
         );
       } else {
@@ -734,4 +1100,4 @@ async function runShell(opts) {
 export {
   runShell
 };
-//# sourceMappingURL=shell-2QXHLD4W.js.map
+//# sourceMappingURL=shell-VPPIRJSS.js.map