@plune-ai/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -315,7 +315,7 @@ function normalizeProviderError(err, secret, envVar) {
 }
 
 // src/providers/retry.ts
-var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 function retryAfterMs(err) {
   if (typeof err !== "object" || err === null || !("headers" in err)) return void 0;
   const raw = readHeader(err.headers, "retry-after");
@@ -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;
   }
 };
@@ -1461,6 +1463,10 @@ async function handleRun(options, depsFactory) {
   }
 }
 
+// src/cli/commands/sync.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+
 // src/types/run-result-schema.ts
 import { z as z2 } from "zod";
 var RUN_RESULT_SCHEMA_VERSION = 1;
@@ -1519,12 +1525,366 @@ var runResultSchema = z2.object({
 function parseRunResult(value) {
   return runResultSchema.parse(value);
 }
+
+// src/cli/credentials.ts
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+function credentialsFile() {
+  const base = process.env["XDG_CONFIG_HOME"]?.trim() || join3(homedir(), ".config");
+  return join3(base, "plune", "credentials.json");
+}
+function loadToken() {
+  try {
+    const parsed = JSON.parse(readFileSync3(credentialsFile(), "utf-8"));
+    return typeof parsed.token === "string" && parsed.token.length > 0 ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+
+// 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.');
+    this.name = "NotLoggedInError";
+  }
+};
+var TokenRejectedError = class extends Error {
+  constructor() {
+    super(
+      'Your API token was rejected (revoked or invalid). Run "plune login" with a fresh token.'
+    );
+    this.name = "TokenRejectedError";
+  }
+};
+var SyncFileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SyncFileError";
+  }
+};
+var SyncNetworkError = class extends Error {
+  constructor(apiUrl) {
+    super(
+      `Could not reach the Plune API at ${apiUrl}. Check your connection (or PLUNE_API_URL) and try again.`
+    );
+    this.name = "SyncNetworkError";
+  }
+};
+var SyncHttpError = class extends Error {
+  constructor(status, detail) {
+    super(`Sync failed \u2014 the server returned HTTP ${status}${detail ? ` (${detail})` : ""}.`);
+    this.status = status;
+    this.name = "SyncHttpError";
+  }
+  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;
+  try {
+    raw = fs6.readFileSync(target, "utf8");
+  } catch {
+    throw new SyncFileError(
+      file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new SyncFileError(`Run file is not valid JSON: ${target}`);
+  }
+  try {
+    return parseRunResult(json);
+  } catch {
+    throw new SyncFileError(`Run file does not match the RunResult schema: ${target}`);
+  }
+}
+async function safeErrorDetail(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : "";
+  } catch {
+    return "";
+  }
+}
+async function handleSync(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const apiUrl = resolveApiUrl(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new NotLoggedInError();
+  const run = readRun(cwd, deps.file);
+  const doFetch = deps.fetchImpl ?? fetch;
+  const endpoint = `${apiUrl}/v1/runs`;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(run)
+    });
+  } catch {
+    throw new SyncNetworkError(apiUrl);
+  }
+  if (!res.ok) {
+    const detail = await safeErrorDetail(res);
+    if (res.status === 401) throw new TokenRejectedError();
+    throw new SyncHttpError(res.status, detail);
+  }
+  const body = await res.json().catch(() => ({}));
+  const id = typeof body.id === "string" ? body.id : "";
+  return { id, url: `${endpoint}/${id}` };
+}
+function reportSyncFailure(err, write) {
+  if (err instanceof NotLoggedInError || err instanceof TokenRejectedError || err instanceof SyncFileError) {
+    write(err.message + "\n");
+    return 2;
+  }
+  if (err instanceof SyncNetworkError || err instanceof SyncHttpError) {
+    write(err.message + "\n");
+    return 1;
+  }
+  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,
+  SyncFileError,
+  SyncHttpError,
+  SyncNetworkError,
+  TokenRejectedError,
   assertionConfigSchema,
   assertionResultRecordSchema,
   binaryVerdictSchema,
+  formatIngestResult,
+  handleIngest as ingest,
   parseRunResult,
+  readCairnRun,
+  reportIngestFailure,
+  reportSyncFailure,
   handleRun as run,
-  runResultSchema
+  runResultSchema,
+  handleSync as sync
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.4.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
+    }
   }
 }