@plune-ai/cli 0.5.0 → 0.6.0

package/dist/cli.cjs

@@ -808,9 +808,11 @@ var init_embedder = __esm({
         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;
       }
     };
@@ -2796,6 +2798,247 @@ var init_sync = __esm({
   }
 });
 
+// src/cli/commands/cairn-artifact.ts
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs11.readFile(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function defaultReadEvidence(dir) {
+  const raw = await readJson(path10.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(path10.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"], path10.basename(dir)),
+      mode,
+      target: str(report["url"], "unknown")
+    },
+    cases
+  };
+}
+var fs11, path10, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
+var init_cairn_artifact = __esm({
+  "src/cli/commands/cairn-artifact.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs11 = __toESM(require("fs/promises"), 1);
+    path10 = __toESM(require("path"), 1);
+    SUPPORTED_ARTIFACT_VERSION = 1;
+    INGEST_SCHEMA_VERSION = 1;
+    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";
+      }
+    };
+    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";
+      }
+    };
+    CairnRunPartialError = class extends Error {
+      constructor(reason) {
+        super(`That Cairn run did not finish, so its cases are incomplete: ${reason}`);
+        this.name = "CairnRunPartialError";
+      }
+    };
+    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";
+      }
+    };
+    asRecord = (v) => typeof v === "object" && v !== null ? v : {};
+    str = (v, fallback = "") => typeof v === "string" && v !== "" ? v : fallback;
+  }
+});
+
+// src/cli/commands/ingest.ts
+var ingest_exports = {};
+__export(ingest_exports, {
+  IngestHttpError: () => IngestHttpError,
+  IngestNetworkError: () => IngestNetworkError,
+  IngestNotLoggedInError: () => IngestNotLoggedInError,
+  IngestTokenRejectedError: () => IngestTokenRejectedError,
+  formatIngestResult: () => formatIngestResult,
+  handleIngest: () => handleIngest,
+  reportIngestFailure: () => reportIngestFailure
+});
+function resolveApiUrl2(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL2;
+  return raw.replace(/\/+$/, "");
+}
+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 = resolveApiUrl2(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new IngestNotLoggedInError();
+  const payload = await readCairnRun(deps.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 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")}
+`;
+}
+var DEFAULT_API_URL2, IngestNotLoggedInError, IngestTokenRejectedError, IngestNetworkError, IngestHttpError;
+var init_ingest = __esm({
+  "src/cli/commands/ingest.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_credentials();
+    init_cairn_artifact();
+    DEFAULT_API_URL2 = "https://beta-api.plune.ai";
+    IngestNotLoggedInError = class extends Error {
+      constructor() {
+        super('Not logged in. Run "plune login" first to save your API token.');
+        this.name = "IngestNotLoggedInError";
+      }
+    };
+    IngestTokenRejectedError = class extends Error {
+      constructor() {
+        super('Your API token was rejected (401). Run "plune login" again with a fresh token.');
+        this.name = "IngestTokenRejectedError";
+      }
+    };
+    IngestNetworkError = class extends Error {
+      constructor(apiUrl) {
+        super(`Could not reach the Plune API at ${apiUrl}. Check your connection, then try again.`);
+        this.name = "IngestNetworkError";
+      }
+    };
+    IngestHttpError = class extends Error {
+      constructor(status, detail) {
+        super(`Plune API returned ${status}${detail !== "" ? ` \u2014 ${detail}` : ""}.`);
+        this.status = status;
+        this.name = "IngestHttpError";
+      }
+      status;
+    };
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -2996,8 +3239,8 @@ function createProgram() {
     const { handleLogin: handleLogin2, EmptyTokenError: EmptyTokenError2 } = await Promise.resolve().then(() => (init_login(), login_exports));
     try {
       const token = options.token ?? await readTokenFromStdin();
-      const { path: path10 } = handleLogin2({ token });
-      process.stdout.write(`Logged in. Token saved to ${path10}
+      const { path: path11 } = handleLogin2({ token });
+      process.stdout.write(`Logged in. Token saved to ${path11}
 `);
     } catch (err) {
       if (err instanceof EmptyTokenError2) {
@@ -3012,9 +3255,9 @@ function createProgram() {
     const verbose = command.optsWithGlobals().verbose === true;
     const { handleLogout: handleLogout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
     try {
-      const { removed, path: path10 } = handleLogout2();
+      const { removed, path: path11 } = handleLogout2();
       process.stdout.write(
-        removed ? `Logged out. Removed ${path10}
+        removed ? `Logged out. Removed ${path11}
 ` : "Not logged in \u2014 nothing to remove.\n"
       );
     } catch (err) {
@@ -3043,6 +3286,22 @@ function createProgram() {
       failUnexpected(err, verbose);
     }
   });
+  program.command("ingest").argument("<dir>", "A Cairn run directory (the one holding report.json)").description("Record a Cairn run in Plune \u2014 generated cases arrive as review proposals").action(async (dir, _options, command) => {
+    const globals = command.optsWithGlobals();
+    const verbose = globals.verbose === true;
+    const { handleIngest: handleIngest2, reportIngestFailure: reportIngestFailure2, formatIngestResult: formatIngestResult2 } = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
+    try {
+      process.stdout.write(formatIngestResult2(await handleIngest2({ dir })));
+    } catch (err) {
+      const code = reportIngestFailure2(err, (s) => process.stderr.write(s));
+      if (code !== null) {
+        maybeStack(err, verbose);
+        process.exitCode = code;
+        return;
+      }
+      failUnexpected(err, verbose);
+    }
+  });
   program.on("command:*", (operands) => {
     process.stderr.write(`Unknown command: ${operands.join(" ")}
 `);

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,
@@ -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;
   }
 };
@@ -1700,6 +1706,221 @@ 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 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 DEFAULT_API_URL2 = "https://beta-api.plune.ai";
+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;
+};
+function resolveApiUrl2(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL2;
+  return raw.replace(/\/+$/, "");
+}
+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 = resolveApiUrl2(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new IngestNotLoggedInError();
+  const payload = await readCairnRun(deps.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 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 +1932,11 @@ function reportSyncFailure(err, write) {
   assertionConfigSchema,
   assertionResultRecordSchema,
   binaryVerdictSchema,
+  formatIngestResult,
+  ingest,
   parseRunResult,
+  readCairnRun,
+  reportIngestFailure,
   reportSyncFailure,
   run,
   runResultSchema,

package/dist/index.d.cts

@@ -799,4 +799,70 @@ type BinaryVerdict = z.infer<typeof binaryVerdictSchema>;
 /** Parse + validate an unknown value as a RunResult. Throws ZodError on failure. */
 declare function parseRunResult(value: unknown): ParsedRunResult;
 
-export { type AssertionResultRecord, type BinaryVerdict, type Config, type EvalResult, NotLoggedInError, type ParsedRunResult, RUN_RESULT_SCHEMA_VERSION, type RowResult, type RunError, type RunOptions, type RunResult, type Summary, type SyncDeps, SyncFileError, SyncHttpError, SyncNetworkError, type SyncResult, TokenRejectedError, type Usage, assertionConfigSchema, assertionResultRecordSchema, binaryVerdictSchema, parseRunResult, reportSyncFailure, handleRun as run, runResultSchema, handleSync as sync };
+interface IngestDeps {
+    /** The Cairn run directory to read. */
+    dir: string;
+    apiUrl?: string;
+    loadToken?: () => string | null;
+    fetchImpl?: typeof fetch;
+}
+/** What the server recorded — the three counters that account for every case sent. */
+interface IngestResult {
+    runId: string;
+    linked: number;
+    proposed: number;
+    skipped: number;
+}
+declare function handleIngest(deps: IngestDeps): Promise<IngestResult>;
+/**
+ * Map an ingest failure to a stderr line and an exit code, or `null` when it is not ours to explain.
+ *
+ * The split follows `sync`: something the user can fix here and now exits 2, something that may work
+ * on the next attempt exits 1. A malformed or unfinished run is the user's to fix, so it is 2.
+ */
+declare function reportIngestFailure(err: unknown, write: (s: string) => void): number | null;
+/** One line per counter, in the order a reader cares about: what landed, what needs them, what did not. */
+declare function formatIngestResult(r: IngestResult): string;
+
+/** The payload version the Plune ingest endpoint validates — ours, not Cairn's. */
+declare const INGEST_SCHEMA_VERSION = 1;
+type CairnRunMode = 'explore' | 'design' | 'api';
+type CairnExecution = 'auto' | 'manual';
+type CairnVerdict = 'passed' | 'failed';
+interface CairnIngestCase {
+    stableId: string;
+    title: string;
+    execution: CairnExecution;
+    steps: string[];
+    expected: string;
+    /** Absent means the run never executed this case — NOT "no result yet". */
+    verdict?: CairnVerdict;
+    technique?: string;
+    priority?: string;
+}
+interface CairnIngestPayload {
+    schemaVersion: typeof INGEST_SCHEMA_VERSION;
+    run: {
+        runId: string;
+        mode: CairnRunMode;
+        target: string;
+    };
+    cases: CairnIngestCase[];
+}
+interface EvidenceRecord {
+    name: string;
+    passed: boolean;
+}
+interface ReadCairnRunDeps {
+    /** Injected for tests; returns `undefined` when the run executed nothing and wrote no evidence. */
+    readEvidence?: (dir: string) => Promise<EvidenceRecord[] | undefined>;
+}
+/**
+ * Read a Cairn run directory into an upload payload, or throw a typed error explaining why not.
+ *
+ * Pure apart from the two file reads, which are injectable, so the mapping rules can be exercised
+ * against real artifacts without a filesystem dance.
+ */
+declare function readCairnRun(dir: string, deps?: ReadCairnRunDeps): Promise<CairnIngestPayload>;
+
+export { type AssertionResultRecord, type BinaryVerdict, type CairnIngestCase, type CairnIngestPayload, type Config, type EvalResult, type IngestDeps, type IngestResult, NotLoggedInError, type ParsedRunResult, RUN_RESULT_SCHEMA_VERSION, type RowResult, type RunError, type RunOptions, type RunResult, type Summary, type SyncDeps, SyncFileError, SyncHttpError, SyncNetworkError, type SyncResult, TokenRejectedError, type Usage, assertionConfigSchema, assertionResultRecordSchema, binaryVerdictSchema, formatIngestResult, handleIngest as ingest, parseRunResult, readCairnRun, reportIngestFailure, reportSyncFailure, handleRun as run, runResultSchema, handleSync as sync };

package/dist/index.d.ts

@@ -799,4 +799,70 @@ type BinaryVerdict = z.infer<typeof binaryVerdictSchema>;
 /** Parse + validate an unknown value as a RunResult. Throws ZodError on failure. */
 declare function parseRunResult(value: unknown): ParsedRunResult;
 
-export { type AssertionResultRecord, type BinaryVerdict, type Config, type EvalResult, NotLoggedInError, type ParsedRunResult, RUN_RESULT_SCHEMA_VERSION, type RowResult, type RunError, type RunOptions, type RunResult, type Summary, type SyncDeps, SyncFileError, SyncHttpError, SyncNetworkError, type SyncResult, TokenRejectedError, type Usage, assertionConfigSchema, assertionResultRecordSchema, binaryVerdictSchema, parseRunResult, reportSyncFailure, handleRun as run, runResultSchema, handleSync as sync };
+interface IngestDeps {
+    /** The Cairn run directory to read. */
+    dir: string;
+    apiUrl?: string;
+    loadToken?: () => string | null;
+    fetchImpl?: typeof fetch;
+}
+/** What the server recorded — the three counters that account for every case sent. */
+interface IngestResult {
+    runId: string;
+    linked: number;
+    proposed: number;
+    skipped: number;
+}
+declare function handleIngest(deps: IngestDeps): Promise<IngestResult>;
+/**
+ * Map an ingest failure to a stderr line and an exit code, or `null` when it is not ours to explain.
+ *
+ * The split follows `sync`: something the user can fix here and now exits 2, something that may work
+ * on the next attempt exits 1. A malformed or unfinished run is the user's to fix, so it is 2.
+ */
+declare function reportIngestFailure(err: unknown, write: (s: string) => void): number | null;
+/** One line per counter, in the order a reader cares about: what landed, what needs them, what did not. */
+declare function formatIngestResult(r: IngestResult): string;
+
+/** The payload version the Plune ingest endpoint validates — ours, not Cairn's. */
+declare const INGEST_SCHEMA_VERSION = 1;
+type CairnRunMode = 'explore' | 'design' | 'api';
+type CairnExecution = 'auto' | 'manual';
+type CairnVerdict = 'passed' | 'failed';
+interface CairnIngestCase {
+    stableId: string;
+    title: string;
+    execution: CairnExecution;
+    steps: string[];
+    expected: string;
+    /** Absent means the run never executed this case — NOT "no result yet". */
+    verdict?: CairnVerdict;
+    technique?: string;
+    priority?: string;
+}
+interface CairnIngestPayload {
+    schemaVersion: typeof INGEST_SCHEMA_VERSION;
+    run: {
+        runId: string;
+        mode: CairnRunMode;
+        target: string;
+    };
+    cases: CairnIngestCase[];
+}
+interface EvidenceRecord {
+    name: string;
+    passed: boolean;
+}
+interface ReadCairnRunDeps {
+    /** Injected for tests; returns `undefined` when the run executed nothing and wrote no evidence. */
+    readEvidence?: (dir: string) => Promise<EvidenceRecord[] | undefined>;
+}
+/**
+ * Read a Cairn run directory into an upload payload, or throw a typed error explaining why not.
+ *
+ * Pure apart from the two file reads, which are injectable, so the mapping rules can be exercised
+ * against real artifacts without a filesystem dance.
+ */
+declare function readCairnRun(dir: string, deps?: ReadCairnRunDeps): Promise<CairnIngestPayload>;
+
+export { type AssertionResultRecord, type BinaryVerdict, type CairnIngestCase, type CairnIngestPayload, type Config, type EvalResult, type IngestDeps, type IngestResult, NotLoggedInError, type ParsedRunResult, RUN_RESULT_SCHEMA_VERSION, type RowResult, type RunError, type RunOptions, type RunResult, type Summary, type SyncDeps, SyncFileError, SyncHttpError, SyncNetworkError, type SyncResult, TokenRejectedError, type Usage, assertionConfigSchema, assertionResultRecordSchema, binaryVerdictSchema, formatIngestResult, handleIngest as ingest, parseRunResult, readCairnRun, reportIngestFailure, reportSyncFailure, handleRun as run, runResultSchema, handleSync as sync };

package/dist/index.js

@@ -595,9 +595,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;
   }
 };
@@ -1651,6 +1653,221 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
+
+// src/cli/commands/cairn-artifact.ts
+import * as fs7 from "fs/promises";
+import * as path6 from "path";
+var SUPPORTED_ARTIFACT_VERSION = 1;
+var INGEST_SCHEMA_VERSION = 1;
+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 DEFAULT_API_URL2 = "https://beta-api.plune.ai";
+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;
+};
+function resolveApiUrl2(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL2;
+  return raw.replace(/\/+$/, "");
+}
+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 = resolveApiUrl2(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new IngestNotLoggedInError();
+  const payload = await readCairnRun(deps.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 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")}
+`;
+}
 export {
   NotLoggedInError,
   RUN_RESULT_SCHEMA_VERSION,
@@ -1661,7 +1878,11 @@ export {
   assertionConfigSchema,
   assertionResultRecordSchema,
   binaryVerdictSchema,
+  formatIngestResult,
+  handleIngest as ingest,
   parseRunResult,
+  readCairnRun,
+  reportIngestFailure,
   reportSyncFailure,
   handleRun as run,
   runResultSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "AI-powered assertion testing for LLM apps — write assertions, run them against any provider, get a pass/fail report (local, CI, or diff).",
   "keywords": [
     "ai",
@@ -53,8 +53,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.102.0",
     "@clack/prompts": "^1.5.1",
-    "@huggingface/transformers": "4.2.0",
-    "ajv": "^8.20.0",
+    "ajv": "^8.17.1",
     "better-sqlite3": "^12.10.0",
     "commander": "^12.0.0",
     "dotenv": "^16.4.0",
@@ -63,6 +62,7 @@
     "zod": "^3.23.0"
   },
   "devDependencies": {
+    "@huggingface/transformers": "4.2.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.9.1",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -96,5 +96,13 @@
       "protobufjs",
       "sharp"
     ]
+  },
+  "peerDependencies": {
+    "@huggingface/transformers": "4.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
   }
 }