@intentset/cli 0.1.0

package/dist/git.js

@@ -0,0 +1,63 @@
+/**
+ * The git reads `review` needs: a base to compare with and the files changed
+ * since it. Every call is a read and passes --no-optional-locks, so not even
+ * git's own index refresh is written (invariant 7). Paths come back relative
+ * to the repository root the CLI is working in, which may be a subdirectory
+ * of the git work tree.
+ */
+import { execFileSync } from "node:child_process";
+import { compareStrings } from "@intentset/core";
+function git(root, args) {
+    try {
+        return execFileSync("git", ["--no-optional-locks", ...args], {
+            cwd: root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: 256 * 1024 * 1024,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function paths(out) {
+    return out === null ? [] : out.split("\0").filter((path) => path !== "");
+}
+/** The commit a ref names, or null. */
+export function resolveCommit(root, ref) {
+    const out = git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+    return out === null || out.trim() === "" ? null : out.trim();
+}
+/**
+ * The base: `given` when there is one (null when it names no commit), else
+ * the merge-base with main when that is not HEAD itself, else HEAD~1.
+ */
+export function chooseBase(root, given) {
+    if (given !== undefined) {
+        const commit = resolveCommit(root, given);
+        return commit === null ? null : { ref: given, commit };
+    }
+    const head = resolveCommit(root, "HEAD");
+    if (head === null)
+        return { unavailable: "the repository has no commit at HEAD" };
+    const mergeBase = git(root, ["merge-base", "HEAD", "main"])?.trim();
+    if (mergeBase !== undefined && mergeBase !== "" && mergeBase !== head) {
+        return { ref: "merge-base with main", commit: mergeBase };
+    }
+    const parent = resolveCommit(root, "HEAD~1");
+    if (parent !== null)
+        return { ref: "HEAD~1", commit: parent };
+    return { unavailable: "HEAD has no parent and no merge-base with main differs from it" };
+}
+export function changedFiles(root, base) {
+    const committed = base === null ? [] : paths(git(root, ["diff", "--relative", "--name-only", "-z", `${base.commit}...HEAD`]));
+    const uncommitted = [
+        ...paths(git(root, ["diff", "--relative", "--name-only", "-z", "HEAD"])),
+        ...paths(git(root, ["ls-files", "-z", "--others", "--exclude-standard"])),
+    ];
+    return {
+        committed: [...new Set(committed)].sort(compareStrings),
+        uncommitted: [...new Set(uncommitted)].sort(compareStrings),
+    };
+}
+//# sourceMappingURL=git.js.map

package/dist/git.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"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"}

package/dist/glob.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The pattern language of `.intentset/config.yaml` scope and ignore lists,
+ * which is VSA §3's: repository-relative POSIX paths made of literal segments,
+ * `*` within one segment, and `**` across zero or more segments. Nothing else
+ * is special: no `?`, no classes, no braces, no negation, so there is no
+ * precedence to explain. A pattern and a path match segment by segment, and
+ * `*` never crosses a `/`.
+ *
+ * The architecture package has its own copy for claims. Duplicating thirty
+ * lines keeps the CLI's core commands independent of it.
+ */
+/** VSA §3: true when the repository-relative POSIX `path` matches `pattern`. */
+export declare function matchGlob(pattern: string, path: string): boolean;
+/** True when any of `patterns` matches `path`. */
+export declare function matchAny(patterns: readonly string[], path: string): boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAiBhE;AAED,kDAAkD;AAClD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3E"}

package/dist/glob.js

@@ -0,0 +1,60 @@
+/**
+ * The pattern language of `.intentset/config.yaml` scope and ignore lists,
+ * which is VSA §3's: repository-relative POSIX paths made of literal segments,
+ * `*` within one segment, and `**` across zero or more segments. Nothing else
+ * is special: no `?`, no classes, no braces, no negation, so there is no
+ * precedence to explain. A pattern and a path match segment by segment, and
+ * `*` never crosses a `/`.
+ *
+ * The architecture package has its own copy for claims. Duplicating thirty
+ * lines keeps the CLI's core commands independent of it.
+ */
+/** VSA §3: true when the repository-relative POSIX `path` matches `pattern`. */
+export function matchGlob(pattern, path) {
+    const p = normalize(pattern).split("/");
+    const s = path.split("/");
+    // Memo of (pattern index, path index) pairs already known not to match, so
+    // several `**` in one pattern stay polynomial rather than exponential.
+    const failed = new Set();
+    const width = s.length + 1;
+    const match = (i, j) => {
+        if (failed.has(i * width + j))
+            return false;
+        let ok;
+        if (i === p.length)
+            ok = j === s.length;
+        else if (p[i] === "**")
+            ok = match(i + 1, j) || (j < s.length && match(i, j + 1));
+        else
+            ok = j < s.length && matchSegment(p[i], s[j]) && match(i + 1, j + 1);
+        if (!ok)
+            failed.add(i * width + j);
+        return ok;
+    };
+    return match(0, 0);
+}
+/** True when any of `patterns` matches `path`. */
+export function matchAny(patterns, path) {
+    return patterns.some((pattern) => matchGlob(pattern, path));
+}
+/** A leading `./` names the same path; repeated `/` separate nothing. */
+function normalize(pattern) {
+    return pattern.replace(/^(?:\.\/)+/, "").replace(/\/{2,}/g, "/");
+}
+const SEGMENTS = new Map();
+/** One segment: literal text, with each `*` standing for any run of characters other than `/`. */
+function matchSegment(pattern, name) {
+    if (!pattern.includes("*"))
+        return pattern === name;
+    let regex = SEGMENTS.get(pattern);
+    if (regex === undefined) {
+        const body = pattern
+            .split("*")
+            .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+            .join("[^/]*");
+        regex = new RegExp(`^${body}$`);
+        SEGMENTS.set(pattern, regex);
+    }
+    return regex.test(name);
+}
+//# sourceMappingURL=glob.js.map

package/dist/glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.js","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,gFAAgF;AAChF,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,IAAY;IACrD,MAAM,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC1B,2EAA2E;IAC3E,uEAAuE;IACvE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3B,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,CAAS,EAAW,EAAE;QAC9C,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5C,IAAI,EAAW,CAAC;QAChB,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM;YAAE,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;aACnC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;YAAE,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;YAC7E,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1E,IAAI,CAAC,EAAE;YAAE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC;QACnC,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACrB,CAAC;AAED,kDAAkD;AAClD,MAAM,UAAU,QAAQ,CAAC,QAA2B,EAAE,IAAY;IAChE,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,yEAAyE;AACzE,SAAS,SAAS,CAAC,OAAe;IAChC,OAAO,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AACnE,CAAC;AAED,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;AAE3C,kGAAkG;AAClG,SAAS,YAAY,CAAC,OAAe,EAAE,IAAY;IACjD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,OAAO,KAAK,IAAI,CAAC;IACpD,IAAI,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,OAAO;aACjB,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;aACzD,IAAI,CAAC,OAAO,CAAC,CAAC;QACjB,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC;QAChC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @intentset/cli as a library: `main` for running the command in-process,
+ * and the repository loader and pattern matcher it is built on.
+ */
+export { main, USAGE } from "./main.ts";
+export type { Io } from "./output.ts";
+export { matchAny, matchGlob } from "./glob.ts";
+export { CONFIG_PATH, enumerate, findRoot, loadRepository, readCommit, type Repository } from "./repository.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACxC,YAAY,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * @intentset/cli as a library: `main` for running the command in-process,
+ * and the repository loader and pattern matcher it is built on.
+ */
+export { main, USAGE } from "./main.js";
+export { matchAny, matchGlob } from "./glob.js";
+export { CONFIG_PATH, enumerate, findRoot, loadRepository, readCommit } from "./repository.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAmB,MAAM,iBAAiB,CAAC"}

package/dist/intentset.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=intentset.d.ts.map

package/dist/intentset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intentset.d.ts","sourceRoot":"","sources":["../src/intentset.ts"],"names":[],"mappings":""}

package/dist/intentset.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { main } from "./main.js";
+// The first SIGINT or SIGTERM asks a long-running command (serve, mcp) to stop
+// cleanly; the listener is removed as it fires, so a second one terminates.
+const controller = new AbortController();
+for (const signal of ["SIGINT", "SIGTERM"])
+    process.once(signal, () => controller.abort());
+const code = await main(process.argv.slice(2), {
+    stdout: (s) => process.stdout.write(s),
+    stderr: (s) => process.stderr.write(s),
+    cwd: process.cwd(),
+    signal: controller.signal,
+});
+process.exitCode = code;
+//# sourceMappingURL=intentset.js.map

package/dist/intentset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intentset.js","sourceRoot":"","sources":["../src/intentset.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,+EAA+E;AAC/E,4EAA4E;AAC5E,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;AACzC,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAU;IAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC;AAEpG,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IAC7C,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;IAClB,MAAM,EAAE,UAAU,CAAC,MAAM;CAC1B,CAAC,CAAC;AACH,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC"}

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+import type { Io } from "./output.ts";
+export type { Io } from "./output.ts";
+export declare const USAGE = "usage: intentset <command> [options]\n\ncommands\n  init [--repository <name>] [--example]\n                            create .intentset/config.yaml and an empty .intentset/registries.yaml;\n                            --example adds the scheduling example under product/scheduling/.\n                            Never overwrites a file.\n  validate                  every check the level asks for; exit 1 when any diagnostic is an error\n  graph [--format json] [--include-bodies] [--release <product>:<label>] [--out <file>]\n        [--generated-at <time>]\n                            print the intentset/export/0.1 envelope, or write it to --out\n  architecture check [--mode migration|strict] [--baseline <file>] [--write-baseline <file>]\n                            ownership, claims, imports, layers and regions (default level L2)\n  evidence import --from vitest|node-tap <report> --out <file> --product <ID> --release <label>\n        [--environment <text>] [--started-at <time>] [--finished-at <time>] [--uri-base <uri>]\n        [--tool-version <v>]\n                            turn a test report into run records bound to this commit and graph\n  impact <ID>               what depends on an artifact: direct, candidates, review context, ancestors\n  context <ID> [--include-restricted]\n                            the bounded engineering context of an artifact, with paths and bodies\n  review [--base <ref>]     the local review report: checks, coverage, and the impact of what changed\n  publish --visibility <v> --audience <a> --product <ID> --release <r> --role <r> --edition <e>\n        [--flag <f>]... [--authorized-internal] [--authorized-restricted] --out <dir> [--html]\n        [--published-at <time>]\n                            reviewed knowledge for one audience and release, as Markset with provenance\n  serve [--port <n>] [--host <address>] [--out <dir>]\n                            the Atlas, the internal review pages, on http://127.0.0.1:3000/ (rebuilt\n                            when a file changes), or written to --out; runs at L2, or L3 with run records\n  mcp --mode engineering [--include-restricted]\n  mcp --mode customer --visibility <public|customer> --audience <a> --product <ID> --release <r>\n        --role <r> --edition <e> [--flag <f>]...\n                            the read-only MCP server on stdio: the engineering graph, or one\n                            publication made in memory as publish makes it, and nothing else\n\noptions\n  --root <dir>              repository root (default: the nearest directory at or above this one\n                            holding .intentset/config.yaml)\n  --json                    machine-readable output, keys in canonical order\n  --carrier <markset|plain> how documents are read (default markset)\n  --level <L1..L4>          conformance level; each includes those below it (default L1):\n                            L2 adds architecture, L3 evidence, L4 publication readiness\n  --evidence <file>         L3 and above: run records to read, repeatable (default: every *.json in\n                            .intentset/evidence/, which holds local output and is not committed)\n  --product <ID> --release <label>\n                            L3 and above: the exact scope evidence is assessed for (default: every scope)\n  --mode <migration|strict> --baseline <file>\n                            L2 and above: whether a baseline of known violations applies, and which\n                            (for mcp, --mode names the server's mode instead)\n  -h, --help                show this help\n\nexit codes: 0 no errors, 1 validation errors, 2 invocation or tool failure";
+export declare function main(argv: string[], io: Io): Promise<number>;
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAItC,YAAY,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,eAAO,MAAM,KAAK,8lHAkDyD,CAAC;AA4E5E,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA0MlE"}

package/dist/main.js

@@ -0,0 +1,406 @@
+/**
+ * The `intentset` command: argument parsing, dispatch and exit codes, with
+ * every command's work in commands/. `main` returns the exit code rather than
+ * exiting, so tests run it in-process with captured io.
+ *
+ * Exit codes (Core §11, ADR 0004): 0 no errors, 1 validation errors, 2
+ * invocation or tool failure. validate, graph, architecture check, impact,
+ * context, review, serve and mcp never write; graph --out, architecture
+ * check --write-baseline, evidence import --out, publish --out and serve
+ * --out write only what they name; init only creates.
+ */
+import { parseArgs } from "node:util";
+import { LEVELS } from "@intentset/core";
+import { architectureCommand } from "./commands/architecture.js";
+import { contextCommand } from "./commands/context.js";
+import { evidenceImportCommand, evidenceUsageProblem } from "./commands/evidence.js";
+import { graphCommand, graphUsageProblem, parseRelease } from "./commands/graph.js";
+import { impactCommand } from "./commands/impact.js";
+import { initCommand } from "./commands/init.js";
+import { mcpCommand, mcpUsageProblem } from "./commands/mcp.js";
+import { publishCommand, publishUsageProblem } from "./commands/publish.js";
+import { reviewCommand } from "./commands/review.js";
+import { serveCommand } from "./commands/serve.js";
+import { validateCommand } from "./commands/validate.js";
+import { CARRIERS, findRoot } from "./repository.js";
+import { EVIDENCE_DIR, evidenceFiles, openSession } from "./session.js";
+export const USAGE = `usage: intentset <command> [options]
+
+commands
+  init [--repository <name>] [--example]
+                            create .intentset/config.yaml and an empty .intentset/registries.yaml;
+                            --example adds the scheduling example under product/scheduling/.
+                            Never overwrites a file.
+  validate                  every check the level asks for; exit 1 when any diagnostic is an error
+  graph [--format json] [--include-bodies] [--release <product>:<label>] [--out <file>]
+        [--generated-at <time>]
+                            print the intentset/export/0.1 envelope, or write it to --out
+  architecture check [--mode migration|strict] [--baseline <file>] [--write-baseline <file>]
+                            ownership, claims, imports, layers and regions (default level L2)
+  evidence import --from vitest|node-tap <report> --out <file> --product <ID> --release <label>
+        [--environment <text>] [--started-at <time>] [--finished-at <time>] [--uri-base <uri>]
+        [--tool-version <v>]
+                            turn a test report into run records bound to this commit and graph
+  impact <ID>               what depends on an artifact: direct, candidates, review context, ancestors
+  context <ID> [--include-restricted]
+                            the bounded engineering context of an artifact, with paths and bodies
+  review [--base <ref>]     the local review report: checks, coverage, and the impact of what changed
+  publish --visibility <v> --audience <a> --product <ID> --release <r> --role <r> --edition <e>
+        [--flag <f>]... [--authorized-internal] [--authorized-restricted] --out <dir> [--html]
+        [--published-at <time>]
+                            reviewed knowledge for one audience and release, as Markset with provenance
+  serve [--port <n>] [--host <address>] [--out <dir>]
+                            the Atlas, the internal review pages, on http://127.0.0.1:3000/ (rebuilt
+                            when a file changes), or written to --out; runs at L2, or L3 with run records
+  mcp --mode engineering [--include-restricted]
+  mcp --mode customer --visibility <public|customer> --audience <a> --product <ID> --release <r>
+        --role <r> --edition <e> [--flag <f>]...
+                            the read-only MCP server on stdio: the engineering graph, or one
+                            publication made in memory as publish makes it, and nothing else
+
+options
+  --root <dir>              repository root (default: the nearest directory at or above this one
+                            holding .intentset/config.yaml)
+  --json                    machine-readable output, keys in canonical order
+  --carrier <markset|plain> how documents are read (default markset)
+  --level <L1..L4>          conformance level; each includes those below it (default L1):
+                            L2 adds architecture, L3 evidence, L4 publication readiness
+  --evidence <file>         L3 and above: run records to read, repeatable (default: every *.json in
+                            ${EVIDENCE_DIR}/, which holds local output and is not committed)
+  --product <ID> --release <label>
+                            L3 and above: the exact scope evidence is assessed for (default: every scope)
+  --mode <migration|strict> --baseline <file>
+                            L2 and above: whether a baseline of known violations applies, and which
+                            (for mcp, --mode names the server's mode instead)
+  -h, --help                show this help
+
+exit codes: 0 no errors, 1 validation errors, 2 invocation or tool failure`;
+const COMMANDS = [
+    "init",
+    "validate",
+    "graph",
+    "architecture",
+    "evidence",
+    "impact",
+    "context",
+    "review",
+    "publish",
+    "serve",
+    "mcp",
+];
+const GLOBAL = ["root", "json", "carrier", "level", "help"];
+const LEVEL_OPTIONS = ["evidence", "product", "release", "mode", "baseline"];
+const COMMAND_OPTIONS = {
+    init: ["repository", "example"],
+    validate: LEVEL_OPTIONS,
+    graph: ["format", "include-bodies", "release", "out", "generated-at", "evidence", "mode", "baseline"],
+    architecture: ["mode", "baseline", "write-baseline"],
+    evidence: [
+        "from",
+        "out",
+        "product",
+        "release",
+        "environment",
+        "started-at",
+        "finished-at",
+        "uri-base",
+        "tool-version",
+    ],
+    impact: LEVEL_OPTIONS,
+    context: ["include-restricted", ...LEVEL_OPTIONS],
+    review: ["base", ...LEVEL_OPTIONS],
+    serve: ["port", "host", "out", ...LEVEL_OPTIONS],
+    mcp: [
+        "mode",
+        "include-restricted",
+        "visibility",
+        "audience",
+        "product",
+        "release",
+        "role",
+        "edition",
+        "flag",
+        "authorized-internal",
+        "authorized-restricted",
+        "published-at",
+    ],
+    publish: [
+        "visibility",
+        "audience",
+        "product",
+        "release",
+        "role",
+        "edition",
+        "flag",
+        "authorized-internal",
+        "authorized-restricted",
+        "out",
+        "html",
+        "published-at",
+    ],
+};
+/** Positional arguments after the command: a fixed subcommand, then how many more. */
+const POSITIONALS = {
+    architecture: { sub: "check", count: 0 },
+    evidence: { sub: "import", count: 1, what: "a report file" },
+    impact: { count: 1, what: "an artifact ID" },
+    context: { count: 1, what: "an artifact ID" },
+};
+export async function main(argv, io) {
+    let parsed;
+    try {
+        parsed = parse(argv);
+    }
+    catch (error) {
+        io.stderr(`intentset: ${error.message}\n\n${USAGE}\n`);
+        return 2;
+    }
+    const { values, positionals, tokens } = parsed;
+    const [command, ...rest] = positionals;
+    if (values.help || command === undefined) {
+        io.stdout(`${USAGE}\n`);
+        return values.help ? 0 : 2;
+    }
+    // The command is checked before its arguments, so a typo reads as a typo and not as a missing ID.
+    if (!COMMANDS.includes(command)) {
+        io.stderr(`intentset: unknown command "${command}"\n\n${USAGE}\n`);
+        return 2;
+    }
+    const usage = (message) => {
+        io.stderr(`intentset ${command}: ${message}\n`);
+        return 2;
+    };
+    const allowed = [...GLOBAL, ...(COMMAND_OPTIONS[command] ?? [])];
+    for (const token of tokens) {
+        if (token.kind === "option" && !allowed.includes(token.name)) {
+            return usage(`--${token.name} is not an option of ${command}`);
+        }
+    }
+    const shape = POSITIONALS[command] ?? { count: 0 };
+    let args = rest;
+    if (shape.sub !== undefined) {
+        if (args[0] !== shape.sub)
+            return usage(`the only subcommand is "${command} ${shape.sub}"`);
+        args = args.slice(1);
+    }
+    if (args.length < shape.count)
+        return usage(`${shape.what} is required`);
+    if (args.length > shape.count) {
+        const hint = shape.count === 0 ? " (use --root <dir> to name the repository)" : "";
+        return usage(`unexpected argument "${args[shape.count]}"${hint}`);
+    }
+    const carrier = values.carrier ?? "markset";
+    if (!Object.hasOwn(CARRIERS, carrier)) {
+        return usage(`--carrier ${carrier}: the carriers are ${Object.keys(CARRIERS).join(" and ")}`);
+    }
+    const levelGiven = values.level;
+    if (levelGiven !== undefined && !LEVELS.includes(levelGiven)) {
+        return usage(`--level ${levelGiven}: the levels are ${LEVELS.join(", ")}`);
+    }
+    if (levelGiven === "L5") {
+        return usage("L5 is a claim about continuous CI, not something one run can check (Core §11).");
+    }
+    if (command !== "mcp" && values.mode !== undefined && values.mode !== "migration" && values.mode !== "strict") {
+        return usage(`--mode ${values.mode}: the modes are migration and strict`);
+    }
+    if (command === "init") {
+        return initCommand({ root: values.root, repository: values.repository, example: values.example }, io);
+    }
+    // Evidence scope: --product with --release, or graph's --release <product>:<label>.
+    let scope = null;
+    if (command !== "evidence" && command !== "publish" && command !== "mcp") {
+        if (command === "graph") {
+            const release = values.release === undefined ? null : parseRelease(values.release);
+            scope = release === null ? null : { product: release.product, release: release.label };
+        }
+        else if ((values.product === undefined) !== (values.release === undefined)) {
+            return usage("--product and --release name one scope together; give both or neither");
+        }
+        else if (values.product !== undefined && values.release !== undefined) {
+            scope = { product: values.product, release: values.release };
+        }
+    }
+    const sessionOptions = (level) => ({
+        root: values.root,
+        carrier: carrier,
+        level,
+        mode: command === "mcp" ? undefined : values.mode,
+        baseline: values.baseline,
+        evidence: values.evidence,
+        scope,
+    });
+    switch (command) {
+        case "validate": {
+            const session = openSession(command, sessionOptions(levelGiven ?? "L1"), io);
+            return typeof session === "number" ? session : validateCommand(session, values.json, io);
+        }
+        case "graph": {
+            const options = {
+                format: values.format,
+                includeBodies: values["include-bodies"],
+                release: values.release,
+                out: values.out,
+                generatedAt: values["generated-at"],
+            };
+            const problem = graphUsageProblem(options);
+            if (problem !== null)
+                return usage(problem);
+            const session = openSession(command, sessionOptions(levelGiven ?? "L1"), io);
+            return typeof session === "number" ? session : graphCommand(session, options, io);
+        }
+        case "architecture": {
+            if (levelGiven === "L1")
+                return usage("the architecture check runs at L2 and above, where ownership joins");
+            const session = openSession("architecture check", sessionOptions(levelGiven ?? "L2"), io);
+            if (typeof session === "number")
+                return session;
+            return architectureCommand(session, { writeBaseline: values["write-baseline"] }, values.json, io);
+        }
+        case "evidence": {
+            const options = {
+                from: values.from,
+                report: args[0],
+                out: values.out,
+                product: values.product,
+                release: values.release,
+                environment: values.environment,
+                startedAt: values["started-at"],
+                finishedAt: values["finished-at"],
+                uriBase: values["uri-base"],
+                toolVersion: values["tool-version"],
+            };
+            const problem = evidenceUsageProblem(options);
+            if (problem !== null)
+                return usage(problem);
+            const session = openSession("evidence import", sessionOptions(levelGiven ?? "L1"), io);
+            return typeof session === "number" ? session : evidenceImportCommand(session, options, io);
+        }
+        case "impact": {
+            const session = openSession(command, sessionOptions(levelGiven ?? "L1"), io);
+            return typeof session === "number" ? session : impactCommand(session, args[0], values.json, io);
+        }
+        case "context": {
+            const session = openSession(command, sessionOptions(levelGiven ?? "L1"), io);
+            if (typeof session === "number")
+                return session;
+            return contextCommand(session, args[0], values["include-restricted"], values.json, io);
+        }
+        case "review": {
+            let level = levelGiven;
+            let reason = "as asked";
+            if (level === undefined) {
+                const root = findRoot(io.cwd, values.root);
+                const records = root === null ? [] : evidenceFiles(root, io.cwd, values.evidence);
+                level = records.length > 0 ? "L4" : "L2";
+                reason =
+                    records.length > 0
+                        ? "the highest the inputs allow: run records were given or found"
+                        : `the highest the inputs allow: no run records were given or found in ${EVIDENCE_DIR}/, so L3 and L4 were not checked`;
+            }
+            const session = openSession(command, sessionOptions(level), io);
+            if (typeof session === "number")
+                return session;
+            return reviewCommand(session, { base: values.base, levelReason: reason }, values.json, io);
+        }
+        case "serve": {
+            const port = values.port === undefined ? 3000 : Number(values.port);
+            if (!Number.isInteger(port) || port < 0 || port > 65535 || values.port === "") {
+                return usage(`--port ${values.port}: give a port number from 0 to 65535`);
+            }
+            let level = levelGiven;
+            if (level === undefined) {
+                const root = findRoot(io.cwd, values.root);
+                level = root !== null && evidenceFiles(root, io.cwd, values.evidence).length > 0 ? "L3" : "L2";
+            }
+            return serveCommand({ port, host: values.host ?? "127.0.0.1", out: values.out }, sessionOptions(level), io);
+        }
+        case "mcp": {
+            const options = {
+                mode: values.mode,
+                includeRestricted: values["include-restricted"],
+                visibility: values.visibility,
+                audience: values.audience,
+                product: values.product,
+                release: values.release,
+                role: values.role,
+                edition: values.edition,
+                flags: values.flag ?? [],
+                authorizedInternal: values["authorized-internal"],
+                authorizedRestricted: values["authorized-restricted"],
+                publishedAt: values["published-at"],
+            };
+            const problem = mcpUsageProblem(options);
+            if (problem !== null)
+                return usage(problem);
+            return mcpCommand(options, sessionOptions(levelGiven ?? "L1"), io);
+        }
+        default: {
+            const options = {
+                visibility: values.visibility,
+                audience: values.audience,
+                product: values.product,
+                release: values.release,
+                role: values.role,
+                edition: values.edition,
+                flags: values.flag ?? [],
+                authorizedInternal: values["authorized-internal"],
+                authorizedRestricted: values["authorized-restricted"],
+                out: values.out,
+                html: values.html,
+                publishedAt: values["published-at"],
+            };
+            const problem = publishUsageProblem(options);
+            if (problem !== null)
+                return usage(problem);
+            const session = openSession(command, sessionOptions(levelGiven ?? "L1"), io);
+            return typeof session === "number" ? session : publishCommand(session, options, io);
+        }
+    }
+}
+function parse(argv) {
+    return parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: true,
+        tokens: true,
+        options: {
+            root: { type: "string" },
+            json: { type: "boolean", default: false },
+            carrier: { type: "string" },
+            level: { type: "string" },
+            help: { type: "boolean", short: "h", default: false },
+            repository: { type: "string" },
+            example: { type: "boolean", default: false },
+            format: { type: "string" },
+            "include-bodies": { type: "boolean", default: false },
+            release: { type: "string" },
+            out: { type: "string" },
+            "generated-at": { type: "string" },
+            "include-restricted": { type: "boolean", default: false },
+            evidence: { type: "string", multiple: true },
+            product: { type: "string" },
+            mode: { type: "string" },
+            baseline: { type: "string" },
+            "write-baseline": { type: "string" },
+            from: { type: "string" },
+            environment: { type: "string" },
+            "started-at": { type: "string" },
+            "finished-at": { type: "string" },
+            "uri-base": { type: "string" },
+            "tool-version": { type: "string" },
+            base: { type: "string" },
+            visibility: { type: "string" },
+            audience: { type: "string" },
+            role: { type: "string" },
+            edition: { type: "string" },
+            flag: { type: "string", multiple: true },
+            "authorized-internal": { type: "boolean", default: false },
+            "authorized-restricted": { type: "boolean", default: false },
+            html: { type: "boolean", default: false },
+            "published-at": { type: "string" },
+            port: { type: "string" },
+            host: { type: "string" },
+        },
+    });
+}
+//# sourceMappingURL=main.js.map