@plune-ai/cli 0.4.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(" ")}
 `);