@attest-ai/core 1.0.0-rc.3 → 1.0.0-rc.5

package/dist/esm/cli.js

@@ -8,8 +8,8 @@ import * as path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/version.ts
-var VERSION = "1.0.0-rc.3";
-var ENGINE_VERSION = "1.0.0-rc.3";
+var VERSION = "1.0.0-rc.5";
+var ENGINE_VERSION = "1.0.0-rc.5";
 
 // src/engine-manager.ts
 import { spawn, spawnSync } from "child_process";
@@ -319,10 +319,17 @@ jobs:
       - name: Run tests
         id: tests
         continue-on-error: true
+        # Traces (prompts, outputs, tool args; not redacted) travel in the artifact; on a public
+        # repository any signed-in GitHub user can download it. Enable on private repositories only:
+        # env:
+        #   ATTEST_REPORT_TRACES: "1"
         run: npx vitest run ${REPORT_ARGS}
       - name: Write the JUnit report
         if: always()
         run: npx attest report junit --report attest-report.json --out attest-junit.xml
+      - name: Write the failure viewer
+        if: always()
+        run: npx attest view attest-report.json --no-open --out attest-report.html
       - name: Upload the Attest report
         if: always()
         uses: actions/upload-artifact@v7
@@ -331,6 +338,7 @@ jobs:
           path: |
             attest-report.json
             attest-junit.xml
+            attest-report.html
           if-no-files-found: error
       - name: Evaluate the merge policy
         if: always()
@@ -359,28 +367,36 @@ jobs:
           echo "::error::vitest failed; see the Run tests step"
           exit 1
 `;
-function write(file, content) {
+function write(targetDir, rel, content, result, quiet) {
+  const file = path2.join(targetDir, ...rel.split("/"));
   if (fs2.existsSync(file)) {
-    process.stderr.write(`Skipped (exists): ${file}
+    result.skipped.push(rel);
+    if (!quiet) process.stderr.write(`Skipped (exists): ${file}
 `);
     return;
   }
   fs2.mkdirSync(path2.dirname(file), { recursive: true });
   fs2.writeFileSync(file, content);
-  process.stdout.write(`Created: ${file}
+  result.created.push(rel);
+  if (!quiet) process.stdout.write(`Created: ${file}
 `);
 }
 function scaffoldProject(targetDir, options2 = {}) {
-  write(path2.join(targetDir, "tests", "my-agent.test.ts"), SAMPLE_TEST_TEMPLATE);
-  write(path2.join(targetDir, "attest.policy.yaml"), POLICY_TEMPLATE);
+  const quiet = options2.quiet ?? false;
+  const result = { created: [], skipped: [] };
+  write(targetDir, "tests/my-agent.test.ts", SAMPLE_TEST_TEMPLATE, result, quiet);
+  write(targetDir, "attest.policy.yaml", POLICY_TEMPLATE, result, quiet);
   if (options2.ci === "github") {
-    write(path2.join(targetDir, ".github", "workflows", "attest.yml"), GITHUB_WORKFLOW_TEMPLATE);
+    write(targetDir, ".github/workflows/attest.yml", GITHUB_WORKFLOW_TEMPLATE, result, quiet);
   }
-  process.stdout.write(
-    `
+  if (!quiet) {
+    process.stdout.write(
+      `
 Next: run \`npx vitest run\`. Then change the line marked ${DEMO_MARKER} in tests/my-agent.test.ts and run it again to see a failure.
 `
-  );
+    );
+  }
+  return result;
 }
 
 // src/capture.ts
@@ -608,23 +624,7 @@ function emitVitest(fixturePath) {
 
 // src/cli.ts
 var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help"]);
-var SDK_USAGE = "usage: attest <command> [args]\n\nSDK commands:\n  init [--ci github]  scaffold a sample test and merge policy here\n                      (--ci github also writes .github/workflows/attest.yml)\n\n`attest capture` (engine) also drafts tests/attest/<name>.test.ts from a verified\nfixture, unless that file exists.\n\noptions:\n  --version  print the SDK version and the engine version it requires\n  --help     print this help\n";
-var INIT_USAGE = "usage: attest init [--ci github]  (scaffolds into the current directory)";
-function cmdInit(args) {
-  if (args.some((a) => HELP_FLAGS.has(a))) {
-    process.stdout.write(`${INIT_USAGE}
-`);
-    return 0;
-  }
-  const joined = args.join(" ");
-  if (args.length > 0 && joined !== "--ci github" && joined !== "--ci=github") {
-    process.stderr.write(`${INIT_USAGE}
-`);
-    return 2;
-  }
-  scaffoldProject(process.cwd(), args.length > 0 ? { ci: "github" } : {});
-  return 0;
-}
+var SDK_USAGE = "usage: attest <command> [args]\n\nSDK commands:\n  init [--ci github] [--skills] [--mcp] [--json]\n                      scaffold a sample test and merge policy here\n                      (--ci github also writes .github/workflows/attest.yml;\n                      --skills installs the agent skills with attest-engine;\n                      --mcp writes the MCP client configs (.mcp.json, .cursor/mcp.json,\n                      .codex/config.toml) with attest-engine;\n                      --json prints {created, updated, skipped} paths as JSON)\n\n`attest capture` (engine) also drafts tests/attest/<name>.test.ts from a verified\nfixture, unless that file exists.\n\noptions:\n  --version  print the SDK version and the engine version it requires\n  --help     print this help\n";
 var HELP_PROBE_TIMEOUT_MS = 1e4;
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -682,24 +682,69 @@ function exitStatus(status, signal) {
   if (signal !== null) return 128 + (os2.constants.signals[signal] ?? 0);
   return 1;
 }
-async function forward(args) {
+async function engineProviding(command) {
   let engine;
   try {
     engine = await resolveEngine();
   } catch (err) {
     process.stderr.write(`attest: ${errorMessage(err)}
 `);
-    return 1;
+    return null;
   }
-  const command = args[0] ?? "";
   const commands = engineCommands(engine);
   if (commands === null || command !== "help" && !commands.has(command)) {
     process.stderr.write(
       `attest: attest-engine at ${engine} (version ${ENGINE_VERSION}) predates \`attest ${command}\`: its help does not list that command. Set ATTEST_ENGINE_PATH to an engine built from this release (make engine), or install a release whose engine provides it.
 `
     );
+    return null;
+  }
+  return engine;
+}
+var INIT_HELP_ENTRY = {
+  name: "init",
+  summary: "scaffold a sample test and policy; --ci github, --skills, --mcp, --json",
+  schema: "cli/init.schema.json",
+  exit_codes: [
+    { code: 0, meaning: "success" },
+    {
+      code: 1,
+      meaning: "--skills or --mcp could not install: the engine is missing, too old or failed"
+    },
+    { code: 2, meaning: "usage error" }
+  ]
+};
+function helpJson(engine) {
+  const proc = spawnSync2(engine, ["help", "--json"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8"
+  });
+  if (proc.error) throw proc.error;
+  if (proc.status !== 0) {
+    process.stderr.write(proc.stderr);
+    return exitStatus(proc.status, proc.signal);
+  }
+  let doc;
+  try {
+    doc = JSON.parse(proc.stdout);
+    if (!Array.isArray(doc.commands)) throw new Error("no commands array");
+  } catch (err) {
+    process.stderr.write(`attest: \`${engine} help --json\` printed an unexpected document: ${errorMessage(err)}
+`);
     return 1;
   }
+  doc.commands = [...doc.commands, INIT_HELP_ENTRY].sort(
+    (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+  );
+  process.stdout.write(`${JSON.stringify(doc, null, 2)}
+`);
+  return 0;
+}
+async function forward(args) {
+  const command = args[0] ?? "";
+  const engine = await engineProviding(command);
+  if (engine === null) return 1;
+  if (args.length === 2 && command === "help" && args[1] === "--json") return helpJson(engine);
   if (command === "capture" && captureWritesFixture(args.slice(1))) {
     return captureAndEmit(engine, args.slice(1));
   }
@@ -761,6 +806,167 @@ function captureAndEmit(engine, args) {
   );
   return code;
 }
+var INIT_USAGE = "usage: attest init [--ci github] [--skills] [--mcp] [--json]  (scaffolds into the current directory)";
+var INIT_KINDS = ["created", "updated", "skipped"];
+var INIT_KINDS_WITH_CONFLICT = [...INIT_KINDS, "conflict"];
+var SKILLS_KINDS = [
+  ["created", "created"],
+  ["updated", "updated"],
+  ["unchanged", "skipped"]
+];
+var MCP_KINDS = [
+  ["created", "created"],
+  ["updated", "updated"],
+  ["unchanged", "skipped"],
+  ["conflict", "conflict"]
+];
+function parseInitArgs(args) {
+  const parsed = { ci: false, skills: false, mcp: false, json: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--ci" && args[i + 1] === "github" && !parsed.ci) {
+      parsed.ci = true;
+      i++;
+    } else if (arg === "--ci=github" && !parsed.ci) {
+      parsed.ci = true;
+    } else if (arg === "--skills" && !parsed.skills) {
+      parsed.skills = true;
+    } else if (arg === "--mcp" && !parsed.mcp) {
+      parsed.mcp = true;
+    } else if (arg === "--json" && !parsed.json) {
+      parsed.json = true;
+    } else {
+      return null;
+    }
+  }
+  return parsed;
+}
+function emptyInitResult() {
+  return { created: [], updated: [], skipped: [], conflict: [] };
+}
+function runEngineInstall(engine, subcommand, kinds, what) {
+  const argv = [...subcommand, "--json"];
+  const shown = [engine, ...argv].join(" ");
+  const proc = spawnSync2(engine, argv, {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8"
+  });
+  if (proc.error) throw proc.error;
+  if (proc.status !== 0) {
+    const detail = proc.stderr.trim();
+    throw new Error(
+      `${what} failed (\`${shown}\` exited ${String(exitStatus(proc.status, proc.signal))})` + (detail === "" ? "" : `: ${detail}`)
+    );
+  }
+  process.stderr.write(proc.stderr);
+  let doc;
+  try {
+    doc = JSON.parse(proc.stdout);
+  } catch (err) {
+    throw new Error(`\`${shown}\` printed invalid JSON: ${errorMessage(err)}`);
+  }
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+    throw new Error(`\`${shown}\` printed ${JSON.stringify(doc)}, not an object`);
+  }
+  const record = doc;
+  const result = emptyInitResult();
+  for (const [engineKind, initKind] of kinds) {
+    const paths = record[engineKind];
+    if (!Array.isArray(paths) || !paths.every((p) => typeof p === "string")) {
+      throw new Error(`\`${shown}\` printed no \`${engineKind}\` list of paths: ${proc.stdout}`);
+    }
+    result[initKind].push(...paths);
+  }
+  return result;
+}
+function installSkills(engine, root) {
+  return runEngineInstall(engine, ["skills", "install", "--dir", root], SKILLS_KINDS, "skills install");
+}
+function mcpLaunchCommand(root) {
+  return fs4.existsSync(path4.join(root, "pnpm-lock.yaml")) ? ["pnpm", "exec", "attest", "mcp"] : ["npx", "--no", "attest", "mcp"];
+}
+function installMcp(engine, root) {
+  return runEngineInstall(
+    engine,
+    ["mcp", "install", "--dir", root, "--command", JSON.stringify(mcpLaunchCommand(root))],
+    MCP_KINDS,
+    "mcp install"
+  );
+}
+function printSkills(root, skills) {
+  const abs = (rel) => path4.join(root, ...rel.split("/"));
+  for (const rel of skills.created) process.stdout.write(`Created: ${abs(rel)}
+`);
+  for (const rel of skills.updated) process.stdout.write(`Updated: ${abs(rel)}
+`);
+  for (const rel of skills.skipped) process.stderr.write(`Skipped (unchanged): ${abs(rel)}
+`);
+  for (const rel of skills.conflict) {
+    process.stderr.write(
+      `Conflict (a different attest entry, left as it is; \`attest-engine mcp install --force\` replaces it): ${abs(rel)}
+`
+    );
+  }
+}
+async function runInit(parsed, root) {
+  const result = emptyInitResult();
+  const installs = [
+    [parsed.skills, "skills", installSkills],
+    [parsed.mcp, "mcp", installMcp]
+  ];
+  for (const [wanted, command, install] of installs) {
+    if (!wanted) continue;
+    const engine = await engineProviding(command);
+    if (engine === null) return null;
+    let installed;
+    try {
+      installed = install(engine, root);
+    } catch (err) {
+      process.stderr.write(`attest: ${errorMessage(err)}
+`);
+      return null;
+    }
+    if (!parsed.json) printSkills(root, installed);
+    for (const kind of INIT_KINDS_WITH_CONFLICT) result[kind].push(...installed[kind]);
+  }
+  const scaffolded = scaffoldProject(root, {
+    ...parsed.ci ? { ci: "github" } : {},
+    quiet: parsed.json
+  });
+  result.created.push(...scaffolded.created);
+  result.skipped.push(...scaffolded.skipped);
+  return result;
+}
+async function cmdInit(args) {
+  if (args.some((a) => HELP_FLAGS.has(a))) {
+    process.stdout.write(`${INIT_USAGE}
+`);
+    return 0;
+  }
+  const parsed = parseInitArgs(args);
+  if (parsed === null) {
+    process.stderr.write(`${INIT_USAGE}
+`);
+    return 2;
+  }
+  const root = process.cwd();
+  if (!parsed.json) return await runInit(parsed, root) === null ? 1 : 0;
+  const stdoutWrite = process.stdout.write;
+  process.stdout.write = process.stderr.write.bind(process.stderr);
+  let result;
+  try {
+    result = await runInit(parsed, root);
+  } finally {
+    process.stdout.write = stdoutWrite;
+  }
+  if (result === null) return 1;
+  const done = result;
+  const kinds = parsed.mcp ? INIT_KINDS_WITH_CONFLICT : INIT_KINDS;
+  const sorted = Object.fromEntries(kinds.map((k) => [k, [...done[k]].sort()]));
+  process.stdout.write(`${JSON.stringify(sorted)}
+`);
+  return 0;
+}
 async function main(argv = process.argv.slice(2)) {
   const [command] = argv;
   if (command === void 0 || HELP_FLAGS.has(command) || command === "help" && argv.length === 1) {
@@ -801,6 +1007,7 @@ export {
   captureWritesFixture,
   engineCommands,
   exitStatus,
+  helpJson,
   main
 };
 //# sourceMappingURL=cli.js.map