@plune-ai/cli 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -39,7 +39,11 @@ __export(src_exports, {
   assertionConfigSchema: () => assertionConfigSchema,
   assertionResultRecordSchema: () => assertionResultRecordSchema,
   binaryVerdictSchema: () => binaryVerdictSchema,
+  formatIngestResult: () => formatIngestResult,
+  ingest: () => handleIngest,
   parseRunResult: () => parseRunResult,
+  readCairnRun: () => readCairnRun,
+  reportIngestFailure: () => reportIngestFailure,
   reportSyncFailure: () => reportSyncFailure,
   run: () => handleRun,
   runResultSchema: () => runResultSchema,
@@ -146,9 +150,9 @@ var modelPriceSchema = import_zod.z.object({
   input_per_1k_usd: import_zod.z.number().nonnegative(),
   output_per_1k_usd: import_zod.z.number().nonnegative()
 });
-var pricingSchema = import_zod.z.record(modelPriceSchema);
+var pricingSchema = import_zod.z.record(import_zod.z.string(), modelPriceSchema);
 var datasetRowSchema = import_zod.z.object({
-  vars: import_zod.z.record(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()])),
+  vars: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()])),
   expected: import_zod.z.string().optional()
 });
 var datasetRefSchema = import_zod.z.union([
@@ -178,7 +182,7 @@ var containsAllAssertionSchema = import_zod.z.object({
 });
 var jsonSchemaAssertionSchema = import_zod.z.object({
   type: import_zod.z.literal("json-schema"),
-  schema: import_zod.z.record(import_zod.z.unknown()),
+  schema: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
   extract: import_zod.z.enum(["auto", "strict"]).optional()
 });
 var llmJudgeAssertionSchema = import_zod.z.object({
@@ -644,9 +648,11 @@ var XenovaEmbedder = class {
     return rows.map((row) => Float32Array.from(row));
   }
   load() {
-    this.extractor ??= import("@huggingface/transformers").then(
-      ({ pipeline }) => pipeline("feature-extraction", MODEL_ID)
-    );
+    this.extractor ??= import("@huggingface/transformers").catch(() => {
+      throw new Error(
+        "The `semantic-similarity` and RAG assertions need local embeddings, which ship separately: install @huggingface/transformers to enable them. Every other assertion works without it."
+      );
+    }).then(({ pipeline }) => pipeline("feature-extraction", MODEL_ID));
     return this.extractor;
   }
 };
@@ -1538,7 +1544,7 @@ var runErrorSchema = import_zod2.z.object({
   message: import_zod2.z.string()
 });
 var rowResultSchema = import_zod2.z.object({
-  vars: import_zod2.z.record(import_zod2.z.unknown()),
+  vars: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
   output: import_zod2.z.string().nullable(),
   cached: import_zod2.z.boolean(),
   usage: usageSchema.optional(),
@@ -1573,6 +1579,13 @@ function parseRunResult(value) {
   return runResultSchema.parse(value);
 }
 
+// src/cli/api-url.ts
+var DEFAULT_API_URL = "https://beta-api.plune.ai";
+function resolveApiUrl(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+
 // src/cli/credentials.ts
 var import_node_fs = require("fs");
 var import_node_os = require("os");
@@ -1591,7 +1604,6 @@ function loadToken() {
 }
 
 // src/cli/commands/sync.ts
-var DEFAULT_API_URL = "https://beta-api.plune.ai";
 var NotLoggedInError = class extends Error {
   constructor() {
     super('Not logged in. Run "plune login" first to save your API token.');
@@ -1628,10 +1640,6 @@ var SyncHttpError = class extends Error {
   }
   status;
 };
-function resolveApiUrl(explicit) {
-  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL;
-  return raw.replace(/\/+$/, "");
-}
 function readRun(cwd, file) {
   const target = file !== void 0 ? path5.resolve(cwd, file) : path5.join(cwd, ".plune", "last-run.json");
   let raw;
@@ -1700,6 +1708,246 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
+
+// src/cli/commands/cairn-artifact.ts
+var fs7 = __toESM(require("fs/promises"), 1);
+var path6 = __toESM(require("path"), 1);
+var SUPPORTED_ARTIFACT_VERSION = 1;
+var INGEST_SCHEMA_VERSION = 1;
+var NoCairnRunsError = class extends Error {
+  constructor(runsDir) {
+    super(`No Cairn run found under ${runsDir} \u2014 name the directory instead: plune ingest <dir>.`);
+    this.name = "NoCairnRunsError";
+  }
+};
+async function findLatestCairnRun(runsDir = "runs") {
+  const entries = await fs7.readdir(runsDir, { withFileTypes: true }).catch(() => null);
+  if (entries === null) throw new NoCairnRunsError(runsDir);
+  let newest;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path6.join(runsDir, entry.name);
+    try {
+      const report = await fs7.lstat(path6.join(dir, "report.json"));
+      if (!report.isFile()) continue;
+      if (newest === void 0 || report.mtimeMs > newest.at) {
+        newest = { dir, at: report.mtimeMs };
+      }
+    } catch {
+    }
+  }
+  if (newest === void 0) throw new NoCairnRunsError(runsDir);
+  return newest.dir;
+}
+var CairnRunNotFoundError = class extends Error {
+  constructor(dir) {
+    super(
+      `No Cairn run found in ${dir} \u2014 expected a report.json written by "cairn design|explore|api".`
+    );
+    this.name = "CairnRunNotFoundError";
+  }
+};
+var CairnRunVersionError = class extends Error {
+  constructor(found) {
+    super(
+      found === void 0 ? "This run predates versioned Cairn artifacts. Re-run it with Cairn 0.7.0 or newer, which stamps the format so it can be read safely." : `Unsupported Cairn artifact version ${String(found)} (this CLI reads version ${SUPPORTED_ARTIFACT_VERSION}). Upgrade @plune-ai/cli.`
+    );
+    this.name = "CairnRunVersionError";
+  }
+};
+var CairnRunPartialError = class extends Error {
+  constructor(reason) {
+    super(`That Cairn run did not finish, so its cases are incomplete: ${reason}`);
+    this.name = "CairnRunPartialError";
+  }
+};
+var CairnEvidenceAmbiguousError = class extends Error {
+  constructor(name) {
+    super(
+      `Cannot attach results safely: the operation "${name}" appears more than once in this run's evidence, and the evidence file carries no case identity to disambiguate it. Nothing was uploaded.`
+    );
+    this.name = "CairnEvidenceAmbiguousError";
+  }
+};
+var asRecord = (v) => typeof v === "object" && v !== null ? v : {};
+var str = (v, fallback = "") => typeof v === "string" && v !== "" ? v : fallback;
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs7.readFile(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function defaultReadEvidence(dir) {
+  const raw = await readJson(path6.join(dir, "api-evidence.json"));
+  if (!Array.isArray(raw)) return void 0;
+  return raw.map((r) => {
+    const rec = asRecord(r);
+    return { name: str(rec["name"]), passed: rec["passed"] === true };
+  });
+}
+function casesFromDesign(report) {
+  const list = Array.isArray(report["testCases"]) ? report["testCases"] : [];
+  return list.map((raw) => {
+    const c = asRecord(raw);
+    const steps = (Array.isArray(c["steps"]) ? c["steps"] : []).map((s) => str(s)).filter((s) => s !== "");
+    return {
+      stableId: str(c["stableId"]),
+      title: str(c["title"], "untitled case"),
+      execution: c["execution"] === "manual" ? "manual" : "auto",
+      steps: steps.length > 0 ? steps : ["(no steps recorded)"],
+      expected: str(c["expected"], "(no expected result recorded)"),
+      ...typeof c["technique"] === "string" ? { technique: c["technique"] } : {},
+      ...typeof c["priority"] === "string" ? { priority: c["priority"] } : {}
+    };
+  });
+}
+function casesFromApi(report, verdicts) {
+  const list = Array.isArray(report["cases"]) ? report["cases"] : [];
+  return list.map((raw) => {
+    const c = asRecord(raw);
+    const name = str(c["name"], "unnamed operation");
+    const request = `${str(c["method"], "GET")} ${str(c["path"], "/")}`;
+    const verdict = verdicts.get(name);
+    return {
+      stableId: str(c["stableId"]),
+      title: name,
+      execution: "auto",
+      steps: [request],
+      expected: `HTTP ${str(c["expectedStatus"], "default")}`,
+      ...verdict !== void 0 ? { verdict } : {},
+      ...typeof c["technique"] === "string" ? { technique: c["technique"] } : {}
+    };
+  });
+}
+async function readCairnRun(dir, deps = {}) {
+  const raw = await readJson(path6.join(dir, "report.json"));
+  if (raw === void 0) throw new CairnRunNotFoundError(dir);
+  const report = asRecord(raw);
+  if (report["schemaVersion"] !== SUPPORTED_ARTIFACT_VERSION) {
+    throw new CairnRunVersionError(report["schemaVersion"]);
+  }
+  if (report["partial"] === true) {
+    throw new CairnRunPartialError(str(report["error"], "no reason recorded"));
+  }
+  const mode = report["mode"];
+  if (mode !== "design" && mode !== "explore" && mode !== "api") {
+    throw new CairnRunVersionError(
+      `${SUPPORTED_ARTIFACT_VERSION} (unknown run mode ${String(mode)})`
+    );
+  }
+  let cases;
+  if (mode === "api") {
+    const evidence = await (deps.readEvidence ?? defaultReadEvidence)(dir);
+    const verdicts = /* @__PURE__ */ new Map();
+    for (const e of evidence ?? []) {
+      if (verdicts.has(e.name)) throw new CairnEvidenceAmbiguousError(e.name);
+      verdicts.set(e.name, e.passed ? "passed" : "failed");
+    }
+    cases = casesFromApi(report, verdicts);
+  } else {
+    cases = casesFromDesign(report);
+  }
+  return {
+    schemaVersion: INGEST_SCHEMA_VERSION,
+    run: {
+      runId: str(report["runId"], path6.basename(dir)),
+      mode,
+      target: str(report["url"], "unknown")
+    },
+    cases
+  };
+}
+
+// src/cli/commands/ingest.ts
+var IngestNotLoggedInError = class extends Error {
+  constructor() {
+    super('Not logged in. Run "plune login" first to save your API token.');
+    this.name = "IngestNotLoggedInError";
+  }
+};
+var IngestTokenRejectedError = class extends Error {
+  constructor() {
+    super('Your API token was rejected (401). Run "plune login" again with a fresh token.');
+    this.name = "IngestTokenRejectedError";
+  }
+};
+var IngestNetworkError = class extends Error {
+  constructor(apiUrl) {
+    super(`Could not reach the Plune API at ${apiUrl}. Check your connection, then try again.`);
+    this.name = "IngestNetworkError";
+  }
+};
+var IngestHttpError = class extends Error {
+  constructor(status, detail) {
+    super(`Plune API returned ${status}${detail !== "" ? ` \u2014 ${detail}` : ""}.`);
+    this.status = status;
+    this.name = "IngestHttpError";
+  }
+  status;
+};
+async function safeErrorDetail2(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : "";
+  } catch {
+    return "";
+  }
+}
+async function handleIngest(deps) {
+  const apiUrl = resolveApiUrl(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new IngestNotLoggedInError();
+  const dir = deps.dir ?? await findLatestCairnRun(deps.runsDir);
+  const payload = await readCairnRun(dir);
+  const doFetch = deps.fetchImpl ?? fetch;
+  const endpoint = `${apiUrl}/v1/ingest/cairn`;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(payload)
+    });
+  } catch {
+    throw new IngestNetworkError(apiUrl);
+  }
+  if (!res.ok) {
+    const detail = await safeErrorDetail2(res);
+    if (res.status === 401) throw new IngestTokenRejectedError();
+    throw new IngestHttpError(res.status, detail);
+  }
+  const body = await res.json().catch(() => ({}));
+  return {
+    runId: typeof body.runId === "string" ? body.runId : "",
+    linked: typeof body.linked === "number" ? body.linked : 0,
+    proposed: typeof body.proposed === "number" ? body.proposed : 0,
+    skipped: typeof body.skipped === "number" ? body.skipped : 0
+  };
+}
+function reportIngestFailure(err, write) {
+  if (err instanceof IngestNotLoggedInError || err instanceof IngestTokenRejectedError || err instanceof CairnRunNotFoundError || err instanceof NoCairnRunsError || err instanceof CairnRunVersionError || err instanceof CairnRunPartialError || err instanceof CairnEvidenceAmbiguousError) {
+    write(`${err.message}
+`);
+    return 2;
+  }
+  if (err instanceof IngestNetworkError || err instanceof IngestHttpError) {
+    write(`${err.message}
+`);
+    return 1;
+  }
+  return null;
+}
+function formatIngestResult(r) {
+  const lines = [
+    `Ingested Cairn run \u2192 ${r.runId}`,
+    `  ${r.linked} result(s) attached to existing cases`,
+    `  ${r.proposed} case(s) proposed \u2014 review them in Plune to accept`,
+    `  ${r.skipped} skipped (already queued, already rejected, repeated, or never executed)`
+  ];
+  return `${lines.join("\n")}
+`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   NotLoggedInError,
@@ -1711,7 +1959,11 @@ function reportSyncFailure(err, write) {
   assertionConfigSchema,
   assertionResultRecordSchema,
   binaryVerdictSchema,
+  formatIngestResult,
+  ingest,
   parseRunResult,
+  readCairnRun,
+  reportIngestFailure,
   reportSyncFailure,
   run,
   runResultSchema,