@plune-ai/cli 0.8.0 → 0.9.0

package/README.md

@@ -103,12 +103,41 @@ provider API key is read from the environment based on `provider.type`:
 | `plune login` | Save a [Plune platform](https://plune.ai/platform) API token so `sync` and `ingest` can reach it. The token is **checked against the API before it is saved**, so a wrong one fails here rather than two commands later. Get one at `https://beta.plune.ai` → Settings → API tokens. Flags: `--token <token>` (omit to paste it or pipe it via stdin), `--skip-verify` (save without checking, for offline setup). |
 | `plune logout` | Remove the saved token. |
 | `plune sync` | Upload the latest local run to the platform. Flags: `--file <path>` to send a specific run JSON. |
+| `plune run import <file>` | Turn a **JUnit XML** or **Playwright JSON** report into a run in Plune. Needs no provider key — nothing is generated. Flags: `--format junit\|playwright-json` (detected from the file when omitted), `--key <externalKey>` to land several reports in one run, `--create` to offer unmatched tests to the review queue. |
 | `plune ingest [dir]` | Record a [Cairn](https://github.com/plune-ai/cairn) run in Plune. Omit `[dir]` for the newest run under `./runs`, or name the directory holding `report.json`. Generated cases arrive as **review proposals** — nothing is created until a person approves it. |
 
 Global flags: `-c, --config <path>` · `-v, --verbose` · `--no-color`.
 
 **Exit codes:** `0` everything passed · `1` an assertion failed · `2` configuration or execution error.
 
+## Already running tests? Bring the results in
+
+Everything above generates checks, which is why it needs a provider key. If you already have a
+suite, there is nothing to generate — the results exist and only have to arrive, and that route
+costs nothing beyond a Plune token.
+
+```bash
+plune login
+plune run import ./junit.xml          # Jest, Vitest, pytest, PHPUnit, Surefire, Cypress, …
+plune run import ./playwright.json    # or Playwright's own JSON report
+```
+
+The format is read from the file, not from its name. Statuses go over as the report wrote them and
+Plune maps them per project, so `error` can mean something different to your team than to ours.
+A test Plune has no case for is counted, and `--create` offers it to the review queue instead —
+nothing becomes a test case until a person approves it.
+
+For a Playwright suite there is also [`@plune-ai/playwright`](https://www.npmjs.com/package/@plune-ai/playwright),
+which reports as the run happens and needs no second step:
+
+```js
+// playwright.config.ts
+reporter: [['list'], ['@plune-ai/playwright']],
+```
+
+Sharded CI? Give every job the same `--key` (or `PLUNE_RUN`), and close the run with
+`plune run finish <id>` once they are all done.
+
 ## Optional: keep a history
 
 Everything above works with no account, no network, and no token — that does not change. If you

package/dist/cli.cjs

@@ -2749,6 +2749,502 @@ var init_run_lifecycle = __esm({
   }
 });
 
+// src/reporter-core/result-key.ts
+function resultKey(testId, retry) {
+  const plain = `${testId}#${retry}`;
+  return plain.length <= RESULT_KEY_MAX ? plain : `${sha256(testId).slice(0, HASH_CHARS)}#${retry}`;
+}
+var RESULT_KEY_MAX, HASH_CHARS;
+var init_result_key = __esm({
+  "src/reporter-core/result-key.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_hash();
+    RESULT_KEY_MAX = 200;
+    HASH_CHARS = 32;
+  }
+});
+
+// src/importers/xml.ts
+function decode(raw) {
+  if (!raw.includes("&")) return raw;
+  return raw.replace(/&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g, (whole, body) => {
+    if (body.startsWith("#")) {
+      const hex = body[1] === "x" || body[1] === "X";
+      const code = Number.parseInt(hex ? body.slice(2) : body.slice(1), hex ? 16 : 10);
+      try {
+        return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+      } catch {
+        return whole;
+      }
+    }
+    return NAMED[body] ?? whole;
+  });
+}
+function parseXml(source, file) {
+  const root = { name: "#document", attrs: {}, children: [], text: "", line: 1 };
+  const stack = [root];
+  let i = 0;
+  let line = 1;
+  const advance = (to) => {
+    for (let j = i; j < to; j++) if (source[j] === "\n") line += 1;
+    i = to;
+  };
+  const top = () => stack[stack.length - 1];
+  while (i < source.length) {
+    const lt = source.indexOf("<", i);
+    if (lt === -1) break;
+    if (lt > i) {
+      const between = source.slice(i, lt);
+      if (between.trim() !== "") top().text += decode(between);
+      advance(lt);
+    }
+    if (source.startsWith("<!--", i)) {
+      const end = source.indexOf("-->", i + 4);
+      if (end === -1) throw new XmlParseError(file, line, "a comment is never closed");
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", i)) {
+      const end = source.indexOf("]]>", i + 9);
+      if (end === -1) throw new XmlParseError(file, line, "a CDATA section is never closed");
+      top().text += source.slice(i + 9, end);
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<?", i)) {
+      const end = source.indexOf("?>", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a processing instruction is never closed");
+      advance(end + 2);
+      continue;
+    }
+    if (source.startsWith("<!", i)) {
+      const end = source.indexOf(">", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a declaration is never closed");
+      advance(end + 1);
+      continue;
+    }
+    if (source.startsWith("</", i)) {
+      const end = source.indexOf(">", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a closing tag is never closed");
+      const name2 = source.slice(i + 2, end).trim();
+      const open = top();
+      if (open === root) throw new XmlParseError(file, line, `</${name2}> closes nothing`);
+      if (open.name !== name2) {
+        throw new XmlParseError(file, line, `</${name2}> closes <${open.name}>, opened on line ${open.line}`);
+      }
+      stack.pop();
+      advance(end + 1);
+      continue;
+    }
+    const startLine = line;
+    let j = i + 1;
+    const nameStart = j;
+    while (j < source.length && !NAME_END.test(source[j])) j += 1;
+    const name = source.slice(nameStart, j);
+    if (name === "") throw new XmlParseError(file, startLine, "a tag with no name");
+    const el = { name, attrs: {}, children: [], text: "", line: startLine };
+    let selfClosing = false;
+    for (; ; ) {
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      if (j >= source.length) throw new XmlParseError(file, startLine, `<${name}> is never closed`);
+      if (source[j] === "/" && source[j + 1] === ">") {
+        selfClosing = true;
+        j += 2;
+        break;
+      }
+      if (source[j] === ">") {
+        j += 1;
+        break;
+      }
+      const attrStart = j;
+      while (j < source.length && !ATTR_NAME_END.test(source[j])) j += 1;
+      const attr = source.slice(attrStart, j);
+      if (attr === "") throw new XmlParseError(file, startLine, `<${name}> has an attribute with no name`);
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      if (source[j] !== "=") {
+        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" has no value`);
+      }
+      j += 1;
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      const quote = source[j];
+      if (quote !== '"' && quote !== "'") {
+        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is not quoted`);
+      }
+      const close = source.indexOf(quote, j + 1);
+      if (close === -1) throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is never closed`);
+      el.attrs[attr] = decode(source.slice(j + 1, close));
+      j = close + 1;
+    }
+    top().children.push(el);
+    if (!selfClosing) stack.push(el);
+    advance(j);
+  }
+  if (stack.length > 1) {
+    const open = top();
+    throw new XmlParseError(file, open.line, `<${open.name}> is never closed`);
+  }
+  if (root.children.length === 0) throw new XmlParseError(file, 1, "no elements \u2014 is this an XML report?");
+  return root;
+}
+var XmlParseError, NAMED, NAME_END, ATTR_NAME_END, SPACE;
+var init_xml = __esm({
+  "src/importers/xml.ts"() {
+    "use strict";
+    init_cjs_shims();
+    XmlParseError = class extends Error {
+      constructor(file, line, detail) {
+        super(`${file}:${line} \u2014 ${detail}`);
+        this.file = file;
+        this.line = line;
+        this.name = "XmlParseError";
+      }
+      file;
+      line;
+    };
+    NAMED = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'"
+    };
+    NAME_END = /[\s/>]/;
+    ATTR_NAME_END = /[\s=/>]/;
+    SPACE = /\s/;
+  }
+});
+
+// src/importers/junit.ts
+function locate(el, suite, out) {
+  for (const child of el.children) {
+    if (child.name === "testcase") out.push({ test: child, suite });
+    else locate(child, child.name === "testsuite" ? child : suite, out);
+  }
+}
+function outcomeOf(test) {
+  for (const name of ["error", "failure", "skipped"]) {
+    const found = test.children.find((c) => c.name === name);
+    if (found !== void 0) return { status: name, detail: found };
+  }
+  return { status: "pass", detail: void 0 };
+}
+function errorTextOf(detail) {
+  if (detail === void 0) return "";
+  const head = [detail.attrs["message"], detail.attrs["type"]].filter((s) => s !== void 0 && s !== "");
+  return [...head, detail.text.trim()].filter((s) => s !== "").join("\n\n");
+}
+function keyOf(classname, name) {
+  return { kind: "path-title", value: classname === "" ? name : `${classname}#${name}` };
+}
+function titleOf(classname, name) {
+  if (classname === "") return name;
+  if (classname === name || classname.endsWith(` ${name}`) || classname.endsWith(`\u203A${name}`)) return classname;
+  return `${classname} \u203A ${name}`;
+}
+function specRefOf(test, suite, classname) {
+  const file = test.attrs["file"] ?? suite?.attrs["file"] ?? "";
+  if (file !== "") {
+    const line = test.attrs["line"];
+    return line !== void 0 && line !== "" ? `${file}:${line}` : file;
+  }
+  return classname === "" ? void 0 : classname;
+}
+function executionOf(test, suite) {
+  const stamp = suite?.attrs["timestamp"];
+  if (stamp === void 0 || stamp === "") return void 0;
+  const started = new Date(stamp);
+  if (Number.isNaN(started.getTime())) return void 0;
+  const seconds = Number.parseFloat(test.attrs["time"] ?? "");
+  const durationMs = Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : 0;
+  return {
+    startedAt: started.toISOString(),
+    finishedAt: new Date(started.getTime() + durationMs).toISOString(),
+    durationMs,
+    // The base format has no reruns. Surefire's `<rerunFailure>` does, and reading it is work for
+    // the day somebody asks; reporting 0 says «first attempt», which is true of every case here.
+    retry: 0
+  };
+}
+function readJUnit(source, file) {
+  const doc = parseXml(source, file);
+  const found = [];
+  locate(doc, void 0, found);
+  return found.map(({ test, suite }) => {
+    const name = test.attrs["name"] ?? "";
+    const classname = test.attrs["classname"] ?? test.attrs["class"] ?? "";
+    const { status, detail } = outcomeOf(test);
+    const key = keyOf(classname, name);
+    const specRef = specRefOf(test, suite, classname);
+    const errorContext = errorTextOf(detail);
+    const execution = executionOf(test, suite);
+    return {
+      resultKey: resultKey(key.value, 0),
+      keys: [key],
+      source: SOURCE,
+      rawStatus: status,
+      title: titleOf(classname, name),
+      ...specRef !== void 0 ? { specRef } : {},
+      ...execution !== void 0 ? { execution } : {},
+      ...errorContext !== "" ? { errorContext } : {}
+    };
+  });
+}
+function looksLikeJUnit(source) {
+  return /<\s*testsuites?\b/.test(source.slice(0, 4096));
+}
+var SOURCE;
+var init_junit = __esm({
+  "src/importers/junit.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_result_key();
+    init_xml();
+    SOURCE = "junit";
+  }
+});
+
+// src/importers/playwright-json.ts
+function statedIdOf(test, title) {
+  const annotation = test.annotations?.find((a) => a.type === "PluneId")?.description;
+  if (annotation !== void 0 && annotation !== "") return annotation;
+  return TOKEN.exec(title)?.[1];
+}
+function errorTextOf2(result) {
+  return (result.errors ?? []).map((e) => e.stack ?? e.message ?? e.value ?? "").filter((text2) => text2 !== "").join("\n\n");
+}
+function pendingFrom(spec, test, result, file, titles) {
+  const pathTitle = [file, ...titles].join("#");
+  const seed = test.id ?? pathTitle;
+  const stated = statedIdOf(test, spec.title ?? "");
+  const expected = test.expectedStatus;
+  const errorContext = errorTextOf2(result);
+  const keys = [
+    ...test.id !== void 0 ? [{ kind: "playwright-id", value: test.id }] : [],
+    { kind: "path-title", value: pathTitle }
+  ];
+  const started = result.startTime !== void 0 ? new Date(result.startTime) : void 0;
+  const durationMs = typeof result.duration === "number" && result.duration >= 0 ? result.duration : 0;
+  const retry = typeof result.retry === "number" && result.retry >= 0 ? result.retry : 0;
+  return {
+    resultKey: resultKey(seed, retry),
+    ...stated !== void 0 ? { testCaseId: stated } : {},
+    keys,
+    title: titles.join(" \u203A "),
+    specRef: spec.line !== void 0 ? `${file}:${spec.line}` : file,
+    source: SOURCE2,
+    // Untouched, as everywhere: `timedOut` means what the project's map says it means, not what
+    // this file decided.
+    rawStatus: result.status ?? "unknown",
+    ...expected === "failed" || expected === "skipped" ? { expectedStatus: expected } : {},
+    ...started !== void 0 && !Number.isNaN(started.getTime()) ? {
+      execution: {
+        startedAt: started.toISOString(),
+        finishedAt: new Date(started.getTime() + durationMs).toISOString(),
+        durationMs,
+        retry,
+        ...result.workerIndex !== void 0 ? { worker: String(result.workerIndex) } : {}
+      }
+    } : {},
+    ...errorContext !== "" ? { errorContext } : {}
+  };
+}
+function walk(suite, describes, depth, out) {
+  const here = depth === 0 ? [] : [...describes, suite.title ?? ""];
+  for (const spec of suite.specs ?? []) {
+    const file = spec.file ?? suite.file ?? suite.title ?? "";
+    const titles = [...here, spec.title ?? ""];
+    for (const test of spec.tests ?? []) {
+      for (const result of test.results ?? []) out.push(pendingFrom(spec, test, result, file, titles));
+    }
+  }
+  for (const child of suite.suites ?? []) walk(child, here, depth + 1, out);
+}
+function readPlaywrightJson(source, file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    throw new JsonReportError(file, `not JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.suites)) {
+    throw new JsonReportError(file, 'no "suites" array \u2014 is this a Playwright JSON report?');
+  }
+  const out = [];
+  for (const suite of parsed.suites) walk(suite, [], 0, out);
+  return out;
+}
+function looksLikePlaywrightJson(source) {
+  const head = source.slice(0, 4096);
+  return head.trimStart().startsWith("{") && head.includes('"suites"');
+}
+var SOURCE2, TOKEN, JsonReportError;
+var init_playwright_json = __esm({
+  "src/importers/playwright-json.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_result_key();
+    SOURCE2 = "playwright";
+    TOKEN = /@P([A-Za-z0-9_-]+)/;
+    JsonReportError = class extends Error {
+      constructor(file, detail) {
+        super(`${file} \u2014 ${detail}`);
+        this.file = file;
+        this.name = "JsonReportError";
+      }
+      file;
+    };
+  }
+});
+
+// src/importers/index.ts
+var importers_exports = {};
+__export(importers_exports, {
+  IMPORT_FORMATS: () => IMPORT_FORMATS,
+  JsonReportError: () => JsonReportError,
+  UnknownFormatError: () => UnknownFormatError,
+  XmlParseError: () => XmlParseError,
+  detectFormat: () => detectFormat,
+  readReport: () => readReport
+});
+function detectFormat(source, file) {
+  if (looksLikeJUnit(source)) return "junit";
+  if (looksLikePlaywrightJson(source)) return "playwright-json";
+  throw new UnknownFormatError(
+    file,
+    'no <testsuite> and no Playwright "suites" \u2014 this is not a report we can read.'
+  );
+}
+function readReport(source, file, format) {
+  const chosen = format ?? detectFormat(source, file);
+  return {
+    format: chosen,
+    results: chosen === "junit" ? readJUnit(source, file) : readPlaywrightJson(source, file)
+  };
+}
+var IMPORT_FORMATS, UnknownFormatError;
+var init_importers = __esm({
+  "src/importers/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_junit();
+    init_playwright_json();
+    init_xml();
+    init_playwright_json();
+    IMPORT_FORMATS = ["junit", "playwright-json"];
+    UnknownFormatError = class extends Error {
+      constructor(file, detail) {
+        super(`${file} \u2014 ${detail} Say which with --format ${IMPORT_FORMATS.join(" | ")}.`);
+        this.name = "UnknownFormatError";
+      }
+    };
+  }
+});
+
+// src/cli/commands/run-import.ts
+var run_import_exports = {};
+__export(run_import_exports, {
+  handleRunImport: () => handleRunImport
+});
+async function handleRunImport(options) {
+  const write = options.write ?? ((line) => void process.stdout.write(`${line}
+`));
+  let source;
+  try {
+    source = fs8.readFileSync(options.file, "utf8");
+  } catch {
+    throw new RunCommandError(`Cannot read ${options.file}.`);
+  }
+  const { format, results } = readReport(source, options.file, options.format);
+  if (results.length === 0) {
+    throw new RunCommandError(`No test cases in ${options.file} \u2014 it parsed, but there is nothing in it.`);
+  }
+  const env = readEnv();
+  const apiUrl = resolveApiUrl(options.apiUrl ?? env.config.apiUrl);
+  const token = options.token ?? env.config.token ?? loadToken() ?? "";
+  if (token === "") throw new NoTokenError();
+  const session = await startRun(
+    {
+      apiUrl,
+      token,
+      ...options.fetchImpl !== void 0 ? { fetchImpl: options.fetchImpl } : {},
+      ...options.key !== void 0 ? { externalKey: options.key } : {},
+      ...options.create === true ? { offerDiscovered: true } : {},
+      kind: "automated",
+      meta: { runner: format },
+      log: write
+    },
+    // The file is the complete list of what ran, so the platform can resolve every test in one
+    // request and derive what never ran from the same list (AC-09/AC-10) — the lazy path would be
+    // a lookup per result.
+    results.map((r) => r.keys)
+  );
+  for (const result2 of results) await session.add(result2);
+  await session.finish();
+  const stats = session.stats;
+  const result = {
+    runId: session.runId,
+    format,
+    parsed: results.length,
+    accepted: stats.accepted,
+    duplicate: stats.duplicate,
+    conflict: stats.conflict,
+    rejected: stats.rejected,
+    unresolved: stats.unresolved,
+    offered: stats.offered,
+    deferred: stats.deferred,
+    unlocatable: results.filter((r) => r.specRef === void 0).length,
+    offering: options.create === true
+  };
+  for (const line of describe(result, apiUrl)) write(line);
+  return result;
+}
+function runUrl2(apiUrl, id) {
+  const web = dashboardUrl(apiUrl);
+  return web === void 0 ? `${apiUrl}/v1/runs/${id}` : `${web}/runs/${id}`;
+}
+function describe(result, apiUrl) {
+  const lines = [
+    `Imported ${result.parsed} result(s) from a ${result.format} report: ${result.accepted} accepted, ${result.duplicate} already there, ${result.unresolved} unmatched.`
+  ];
+  if (result.conflict > 0 || result.rejected > 0) {
+    lines.push(`${result.conflict} conflicted and ${result.rejected} were refused.`);
+  }
+  if (result.deferred > 0) {
+    lines.push(
+      `${result.deferred} could not be sent and are in the fallback file \u2014 "plune run report" retries them.`
+    );
+  }
+  if (result.offered > 0) {
+    lines.push(`${result.offered} unknown test(s) offered to the review queue.`);
+  } else if (result.unresolved > 0 && !result.offering) {
+    lines.push("Nothing was offered to the review queue \u2014 pass --create to propose the unmatched tests.");
+  } else if (result.unresolved > 0) {
+    lines.push("Nothing new to offer \u2014 the unmatched tests are already in the review queue.");
+  }
+  if (result.unlocatable > 0) {
+    lines.push(
+      `${result.unlocatable} test(s) carry no file or class in the report, so they cannot be offered for review \u2014 a reviewer would have nowhere to look.`
+    );
+  }
+  if (result.runId !== null) lines.push(runUrl2(apiUrl, result.runId));
+  return lines;
+}
+var fs8;
+var init_run_import = __esm({
+  "src/cli/commands/run-import.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs8 = __toESM(require("fs"), 1);
+    init_session();
+    init_importers();
+    init_run_lifecycle();
+    init_api_url();
+    init_credentials();
+    init_env2();
+  }
+});
+
 // src/cli/commands/report.ts
 var report_exports = {};
 __export(report_exports, {
@@ -2765,7 +3261,7 @@ function handleReport(opts = {}) {
   const file = path7.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs8.readFileSync(file, "utf8");
+    raw = fs9.readFileSync(file, "utf8");
   } catch {
     throw new ReportNotFoundError('No saved run found. Run "plune run" first.');
   }
@@ -2780,12 +3276,12 @@ function handleReport(opts = {}) {
   }
   return parsed;
 }
-var fs8, path7, ReportNotFoundError;
+var fs9, path7, ReportNotFoundError;
 var init_report = __esm({
   "src/cli/commands/report.ts"() {
     "use strict";
     init_cjs_shims();
-    fs8 = __toESM(require("fs"), 1);
+    fs9 = __toESM(require("fs"), 1);
     path7 = __toESM(require("path"), 1);
     ReportNotFoundError = class extends Error {
       code = "NO_SAVED_RUN";
@@ -2860,7 +3356,7 @@ function isRunResult2(v) {
 function loadRunResult(file, label) {
   let raw;
   try {
-    raw = fs9.readFileSync(file, "utf8");
+    raw = fs10.readFileSync(file, "utf8");
   } catch {
     throw new DiffInputError(`Cannot read ${label} run file: ${file}`);
   }
@@ -2880,12 +3376,12 @@ function handleDiff(opts) {
   const current = loadRunResult(opts.currentPath, "current");
   return diffRuns(baseline, current);
 }
-var fs9, DiffInputError;
+var fs10, DiffInputError;
 var init_diff2 = __esm({
   "src/cli/commands/diff.ts"() {
     "use strict";
     init_cjs_shims();
-    fs9 = __toESM(require("fs"), 1);
+    fs10 = __toESM(require("fs"), 1);
     init_diff();
     DiffInputError = class extends Error {
       code = "DIFF_INPUT";
@@ -3011,7 +3507,7 @@ async function runInitWizard(cwd) {
     return;
   }
   const outputPath = path8.join(cwd, "plune.yaml");
-  if (fs10.existsSync(outputPath)) {
+  if (fs11.existsSync(outputPath)) {
     const overwrite = await clack.confirm({
       message: "plune.yaml already exists. Overwrite?"
     });
@@ -3050,17 +3546,17 @@ async function runInitWizard(cwd) {
 `;
   const spin = clack.spinner();
   spin.start("Writing plune.yaml\u2026");
-  fs10.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
+  fs11.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
   spin.stop("plune.yaml created!");
   clack.outro("plune.yaml is ready.");
 }
-var clack, fs10, path8, import_yaml2;
+var clack, fs11, path8, import_yaml2;
 var init_wizard = __esm({
   "src/config/init/wizard.ts"() {
     "use strict";
     init_cjs_shims();
     clack = __toESM(require("@clack/prompts"), 1);
-    fs10 = __toESM(require("fs"), 1);
+    fs11 = __toESM(require("fs"), 1);
     path8 = __toESM(require("path"), 1);
     import_yaml2 = require("yaml");
     init_errors();
@@ -3070,19 +3566,19 @@ var init_wizard = __esm({
 // src/cli/templates/index.ts
 function writeTemplateFile(cwd, rel, content, force) {
   const target = path9.join(cwd, rel);
-  if (!force && fs11.existsSync(target)) {
+  if (!force && fs12.existsSync(target)) {
     return "skipped";
   }
-  fs11.mkdirSync(path9.dirname(target), { recursive: true });
-  fs11.writeFileSync(target, content, "utf8");
+  fs12.mkdirSync(path9.dirname(target), { recursive: true });
+  fs12.writeFileSync(target, content, "utf8");
   return "written";
 }
-var fs11, path9, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
+var fs12, path9, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
 var init_templates = __esm({
   "src/cli/templates/index.ts"() {
     "use strict";
     init_cjs_shims();
-    fs11 = __toESM(require("fs"), 1);
+    fs12 = __toESM(require("fs"), 1);
     path9 = __toESM(require("path"), 1);
     ENV_EXAMPLE_TPL = `# Copy this file to .env and replace the placeholders with your real keys.
 # .env is gitignored; .env.example is safe to commit.
@@ -3342,7 +3838,7 @@ function readRun(cwd, file) {
   const target = file !== void 0 ? path10.resolve(cwd, file) : path10.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs12.readFileSync(target, "utf8");
+    raw = fs13.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>).'
@@ -3406,12 +3902,12 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
-var fs12, path10, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
+var fs13, path10, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
 var init_sync = __esm({
   "src/cli/commands/sync.ts"() {
     "use strict";
     init_cjs_shims();
-    fs12 = __toESM(require("fs"), 1);
+    fs13 = __toESM(require("fs"), 1);
     path10 = __toESM(require("path"), 1);
     init_run_result_schema();
     init_api_url();
@@ -3457,14 +3953,14 @@ var init_sync = __esm({
 
 // src/cli/commands/cairn-artifact.ts
 async function findLatestCairnRun(runsDir = "runs") {
-  const entries = await fs13.readdir(runsDir, { withFileTypes: true }).catch(() => null);
+  const entries = await fs14.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 = path11.join(runsDir, entry.name);
     try {
-      const report = await fs13.lstat(path11.join(dir, "report.json"));
+      const report = await fs14.lstat(path11.join(dir, "report.json"));
       if (!report.isFile()) continue;
       if (newest === void 0 || report.mtimeMs > newest.at) {
         newest = { dir, at: report.mtimeMs };
@@ -3477,7 +3973,7 @@ async function findLatestCairnRun(runsDir = "runs") {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs13.readFile(file, "utf8"));
+    return JSON.parse(await fs14.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -3562,12 +4058,12 @@ async function readCairnRun(dir, deps = {}) {
     cases
   };
 }
-var fs13, path11, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
+var fs14, path11, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
 var init_cairn_artifact = __esm({
   "src/cli/commands/cairn-artifact.ts"() {
     "use strict";
     init_cjs_shims();
-    fs13 = __toESM(require("fs/promises"), 1);
+    fs14 = __toESM(require("fs/promises"), 1);
     path11 = __toESM(require("path"), 1);
     SUPPORTED_ARTIFACT_VERSION = 1;
     INGEST_SCHEMA_VERSION = 1;
@@ -3914,6 +4410,36 @@ function createProgram() {
       await failRunCommand(err, verboseOf(command));
     }
   });
+  runCommand.command("import").argument("<file>", "A JUnit XML or Playwright JSON report").description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option("--format <fmt>", "junit | playwright-json; detected from the file when omitted").option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--create", "Offer tests nothing matched to the review queue", false).action(
+    async (file, options, command) => {
+      const [{ handleRunImport: handleRunImport2 }, { IMPORT_FORMATS: IMPORT_FORMATS2, UnknownFormatError: UnknownFormatError2, XmlParseError: XmlParseError2, JsonReportError: JsonReportError2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_run_import(), run_import_exports)),
+        Promise.resolve().then(() => (init_importers(), importers_exports))
+      ]);
+      const format = options.format;
+      if (format !== void 0 && !IMPORT_FORMATS2.includes(format)) {
+        process.stderr.write(`Unknown --format "${format}". Use ${IMPORT_FORMATS2.join(" or ")}.
+`);
+        process.exit(2);
+        return;
+      }
+      try {
+        await handleRunImport2({
+          file,
+          ...format !== void 0 ? { format } : {},
+          ...options.key !== void 0 ? { key: options.key } : {},
+          ...options.create ? { create: true } : {}
+        });
+      } catch (err) {
+        if (err instanceof UnknownFormatError2 || err instanceof XmlParseError2 || err instanceof JsonReportError2) {
+          process.stderr.write(err.message + "\n");
+          process.exit(2);
+          return;
+        }
+        await failRunCommand(err, verboseOf(command));
+      }
+    }
+  );
   program.command("report").description("Render the most recent run in a chosen format").option("--format <fmt>", "console | json | markdown", "console").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options, command) => {
     const globals = command.optsWithGlobals();
     const [{ loadEnv: loadEnv2 }, { handleReport: handleReport2, ReportNotFoundError: ReportNotFoundError2 }, { renderReport: renderReport2 }] = await Promise.all([

package/package.json

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