@sdd-method/sdd-cli 1.29.1 → 1.30.0

package/scripts/build-verify-package.mjs

@@ -0,0 +1,199 @@
+// Assemble the publishable @sdd-method/verify-cli package — M-ADR 0212 §4.3b.
+//
+// ONE SOURCE, and this time a genuinely smaller ARTEFACT. The conformance
+// package copied the whole of dist/ under a second manifest, so its "excluded"
+// verbs were one `node dist/cli.js …` away. This script ships only the import
+// CLOSURE of dist/verify-bin.js: an excluded verb's code is not in the package
+// to be reached by any path.
+//
+// Fails closed on four conditions, each of which would otherwise let the
+// boundary pass while not holding:
+//   1. a relative import in the closure that does not resolve to a file;
+//   2. a bare import that is neither a Node built-in nor a declared dependency;
+//   3. a CANARY — a known authoring module — present in the closure;
+//   4. a canary that no longer EXISTS in dist. A canary that was renamed or
+//      deleted cannot be absent from anything, so the check above would pass
+//      vacuously; this makes it fail instead, and asks for the list to follow.
+//
+// The generated directory is gitignored and safe to delete.
+
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { builtinModules } from "node:module";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const DIST = join(ROOT, "dist");
+const OUT = join(ROOT, "build", "verify-cli");
+const ENTRY = join(DIST, "verify-bin.js");
+
+// Authoring and maintenance code that must never reach this package. Entry
+// modules of excluded verbs plus the full CLI's own entrypoints.
+const CANARIES = [
+  "cli.js",
+  "index.js",
+  "verbs/sync.js",
+  "verbs/catalogue.js",
+  "verbs/pack.js",
+  "verbs/mcp.js",
+  "verbs/init.js",
+  "verbs/render.js",
+  "verbs/metamodel.js",
+  "verbs/conformance.js",
+  "lib/sync/index.js",
+  "lib/catalogue/build.js",
+  "lib/catalogue/aggregate.js",
+  "lib/catalogue/graph-run.js",
+  "lib/catalogue/migration-map.js",
+  "lib/pack/builder.js",
+];
+
+const die = (msg) => {
+  process.stderr.write(`build-verify-package: FAIL — ${msg}\n`);
+  process.exit(1);
+};
+
+if (!existsSync(ENTRY)) die(`${relative(ROOT, ENTRY)} missing — run \`npm run build\` first`);
+
+// ---- 1. closure over imports ----------------------------------------------
+// Line-based over tsc output, skipping comment lines. An earlier regex over the
+// whole text read `// from "changed" produces…` in a comment as an import of a
+// package called `changed` — prose parsed as code, the same failure a grep over
+// workflow comments made the same day. Fail-closed caught it; this stops it.
+const STATIC = /^\s*(?:import|export|\})[^\n]*?\bfrom\s*["']([^"']+)["']/;
+const SIDE = /^\s*import\s*["']([^"']+)["']/;
+const DYNAMIC = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+function specifiers(src) {
+  const out = [];
+  for (const line of src.split("\n")) {
+    const t = line.trimStart();
+    if (t.startsWith("//") || t.startsWith("*") || t.startsWith("/*")) continue;
+    const m = line.match(STATIC) ?? line.match(SIDE);
+    if (m) out.push(m[1]);
+    for (const d of line.matchAll(DYNAMIC)) out.push(d[1]);
+  }
+  return out;
+}
+const closure = new Set();
+const bare = new Set();
+const stack = [ENTRY];
+while (stack.length) {
+  const f = stack.pop();
+  if (closure.has(f)) continue;
+  closure.add(f);
+  for (const spec of specifiers(readFileSync(f, "utf8"))) {
+    if (spec.startsWith(".")) {
+      const target = resolve(dirname(f), spec);
+      if (!existsSync(target)) die(`${relative(DIST, f)} imports '${spec}', which does not resolve`);
+      stack.push(target);
+    } else {
+      bare.add(spec);
+    }
+  }
+}
+
+// ---- 2. dependencies = only what the closure imports -----------------------
+const main = JSON.parse(await readFile(join(ROOT, "package.json"), "utf8"));
+const pkgName = (spec) =>
+  spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
+const builtins = new Set(builtinModules);
+const deps = {};
+for (const spec of bare) {
+  if (spec.startsWith("node:") || builtins.has(spec) || builtins.has(spec.split("/")[0])) continue;
+  const name = pkgName(spec);
+  const range = main.dependencies?.[name];
+  if (!range) die(`closure imports '${spec}', which is not a declared dependency of sdd-cli`);
+  deps[name] = range;
+}
+
+// ---- 3 + 4. canaries -------------------------------------------------------
+for (const c of CANARIES) {
+  const abs = join(DIST, c);
+  if (!existsSync(abs)) die(`canary '${c}' no longer exists in dist — the check would pass vacuously; update CANARIES`);
+  if (closure.has(abs)) die(`authoring module '${c}' is reachable from verify-bin.js — the boundary does not hold`);
+}
+
+// ---- bundled shell scripts -------------------------------------------------
+// Some validators are shell scripts SHIPPED WITH the package (dispatch.ts:
+// `kind: "bundled"`), resolved by lib/scripts.ts to <package-root>/scripts/.
+// They are launched by path, not imported, so the closure above cannot see
+// them. verify-cli 0.1.0 shipped without them and `app-docs` and
+// `integration-docs` failed with exit 127 on every app and integration repo —
+// found by a parity check against sdd-cli, not by the no-write acceptance,
+// because a validator that cannot find its script writes nothing.
+const bundled = new Set();
+for (const f of closure) {
+  for (const m of readFileSync(f, "utf8").matchAll(/kind:\s*"bundled",\s*script:\s*"([^"]+)"/g)) {
+    const p = join(ROOT, "scripts", m[1]);
+    if (!existsSync(p)) die(`${relative(DIST, f)} declares bundled script '${m[1]}', which does not exist in scripts/`);
+    bundled.add(p);
+  }
+}
+
+// ---- assets: yaml/json data beside a closure module ------------------------
+const assets = new Set();
+for (const f of closure) {
+  const dir = dirname(f);
+  for (const name of readdirSync(dir)) {
+    const p = join(dir, name);
+    if (/\.(ya?ml|json)$/.test(name) && statSync(p).isFile()) assets.add(p);
+  }
+}
+
+// ---- assemble --------------------------------------------------------------
+const version = process.env.VERIFY_VERSION ?? "0.1.0";
+// Empty the directory, never remove it: a shell sitting in build/verify-cli
+// (to run `npm publish`) keeps a handle on the directory itself, and deleting
+// it leaves that shell in a path that no longer exists — npm then dies with
+// ENOENT uv_cwd. That happened, twice, between a rebuild and a publish.
+await mkdir(OUT, { recursive: true });
+for (const entry of readdirSync(OUT)) await rm(join(OUT, entry), { recursive: true, force: true });
+for (const f of [...closure, ...assets]) {
+  const dest = join(OUT, "dist", relative(DIST, f));
+  await mkdir(dirname(dest), { recursive: true });
+  await cp(f, dest);
+}
+for (const p of bundled) {
+  await mkdir(join(OUT, "scripts"), { recursive: true });
+  await cp(p, join(OUT, "scripts", relative(join(ROOT, "scripts"), p)));
+}
+for (const f of ["LICENSE", "NOTICE"]) await cp(join(ROOT, f), join(OUT, f));
+
+if (main.publishConfig?.access !== "public") die("sdd-cli's package.json has no publishConfig.access=public — the verify package would publish private");
+
+const pkg = {
+  name: "@sdd-method/verify-cli",
+  version,
+  description:
+    "Verify an SDD repository without changing it — validate, list, and read-only catalogue and pack checks. Ships only the code those verbs reach; it cannot write to the repository it is pointed at. Authoring and maintenance are in @sdd-method/sdd-cli.",
+  license: main.license,
+  type: main.type,
+  bin: { "sdd-verify": "dist/verify-bin.js" },
+  engines: main.engines,
+  dependencies: deps,
+  repository: main.repository,
+  // Inherited, not assumed: a scoped package publishes PRIVATE by default, and
+  // the first publish of this one failed with E402 (private packages need a
+  // paid plan) because this field was missing. sdd-cli carries it; so must this.
+  publishConfig: main.publishConfig,
+  files: ["dist", "scripts", "README.md", "LICENSE", "NOTICE"],
+};
+await writeFile(join(OUT, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+await writeFile(
+  join(OUT, "README.md"),
+  `# @sdd-method/verify-cli\n\n` +
+    `\`sdd-verify\` checks an SDD repository and **cannot change it**.\n\n` +
+    `Verbs: \`validate\`, \`list\`, \`pack validate\`, \`catalogue validate\` (incl. \`--coverage\`), ` +
+    `\`catalogue impact\`, \`catalogue baseline-check\`, \`catalogue version\`.\n\n` +
+    `The package contains only the code those verbs reach. Authoring and maintenance verbs — ` +
+    `\`sync\`, \`catalogue build\`, \`init\`, \`scaffold\`, \`mcp\` and the rest — are not present in it, ` +
+    `and are in \`@sdd-method/sdd-cli\`. Invoking one fails with exit 1.\n`,
+);
+
+const kb = (fs) => Math.round(fs.reduce((n, f) => n + statSync(f).size, 0) / 1024);
+process.stdout.write(
+  `assembled ${pkg.name}@${version} at build/verify-cli\n` +
+    `  modules ${closure.size} (${kb([...closure])} kB) · assets ${assets.size} · bundled scripts ${bundled.size} · deps ${Object.keys(deps).join(", ")}\n` +
+    `  canaries absent: ${CANARIES.length}/${CANARIES.length}\n`,
+);

package/scripts/verify-acceptance.sh

@@ -0,0 +1,178 @@
+#!/usr/bin/env bash
+# Acceptance for the verify-only CLI — M-ADR 0212 §4.3b.
+#
+# The property: sdd-verify CANNOT WRITE to the repository it is pointed at.
+# Tested, not asserted — reading help text misfiled four verbs before this
+# existed. For each repository: a fresh clone, every verb in every mode, and
+# `git status --porcelain --ignored` must be empty after each one (ignored paths
+# count: a verb that drops a cache into a gitignored directory still wrote).
+#
+# Fails closed on:
+#   - any write, by any verb, in any mode;
+#   - an excluded verb that does not exit 1 with the refusal message;
+#   - the CONTROL: the full CLI's `catalogue graph` must dirty a clone, or the
+#     detector cannot see a write and every PASS above is vacuous;
+#   - COVERAGE: a surface verb exercised on no repository. A missing input must
+#     not silently shrink the test.
+#
+# usage: verify-acceptance.sh --bin <sdd-verify entry> --control-bin <sdd-cli entry> <repo>...
+set -uo pipefail
+
+BIN=""; CONTROL=""; REPOS=()
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --bin) BIN="$2"; shift 2 ;;
+    --control-bin) CONTROL="$2"; shift 2 ;;
+    *) REPOS+=("$1"); shift ;;
+  esac
+done
+[ -n "$BIN" ] && [ -n "$CONTROL" ] && [ ${#REPOS[@]} -gt 0 ] || {
+  echo "usage: $0 --bin <sdd-verify> --control-bin <sdd-cli> <repo>..." >&2; exit 2; }
+
+# Resolve both binaries to absolute paths BEFORE any cd. Each check runs from
+# inside a clone, so a relative --control-bin resolved to nothing, the control
+# exited 1 on every command, and every parity check reported a difference that
+# was the harness, not the tool. Refuse to start rather than measure that.
+abs() { [ -f "$1" ] || { echo "not found: $1" >&2; exit 2; }; echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"; }
+BIN="$(abs "$BIN")" || exit 2; CONTROL="$(abs "$CONTROL")" || exit 2
+node "$CONTROL" --version >/dev/null 2>&1 || { echo "control binary does not run: $CONTROL" >&2; exit 2; }
+node "$BIN" --version >/dev/null 2>&1 || { echo "binary under test does not run: $BIN" >&2; exit 2; }
+
+TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
+FAIL=0; RUNS=0
+declare -A SEEN
+SURFACE=("--version" "validate" "validate --strict" "list" "catalogue validate" \
+  "catalogue validate --strict" "catalogue validate --coverage" "catalogue impact" \
+  "catalogue baseline-check --findings" "catalogue baseline-check (stdin)" \
+  "catalogue version" "pack validate")
+
+clean() { [ -z "$(git -C "$1" status --porcelain --ignored)" ]; }
+
+# PARITY. No-write alone is not enough: a validator that cannot find its own
+# script writes nothing and passes that test. verify-cli 0.1.0 shipped exactly
+# that — `app-docs` and `integration-docs` exited 127 on every app and
+# integration repo — and this check is what found it. Each surface run is
+# repeated with the full CLI in the same clone; output and exit code must match.
+# Normalised: ANSI colour, and the tool name in error prefixes. Exempt: the two
+# version commands, which report each tool's own version by design.
+# The tool's OWN version is normalised too, and only there — a version directly
+# after `cli ` or `sdd-cli ` (catalogue headers print `cli <own version>`, and
+# unknown-key notices say `sdd-cli <own version>`). A version inside a finding
+# is left alone, so a real difference there still fails parity.
+norm() { sed -e 's/\x1b\[[0-9;]*m//g' -e 's/sdd-verify/sdd-cli/g' \
+             -e 's/\(cli \|sdd-cli \)[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*/\1<own-version>/g' "$1"; }
+parity() {  # parity <repo-dir> <label> <verify-rc> <args...> — compares $TMP/out with the control
+  local dir="$1" label="$2" vrc="$3"; shift 3
+  case "$label" in "--version"|"catalogue version") PAR="(version — n/a)"; return ;; esac
+  ( cd "$dir" && node "$CONTROL" "$@" >"$TMP/ctl" 2>&1 ); local crc=$?
+  git -C "$dir" clean -qfdx; git -C "$dir" checkout -q -- .
+  if [ "$vrc" = "$crc" ] && diff -q <(norm "$TMP/out") <(norm "$TMP/ctl") >/dev/null; then
+    PAR="= sdd-cli"
+  else
+    FAIL=1; PAR="⚠ DIFFERS from sdd-cli (exit $vrc vs $crc)"
+    diff <(norm "$TMP/out") <(norm "$TMP/ctl") | head -4 | sed 's/^/          /' >"$TMP/pardiff"
+  fi
+}
+
+run() {  # run <repo-dir> <surface-label> <args...>
+  local dir="$1" label="$2"; shift 2
+  RUNS=$((RUNS+1)); : >"$TMP/pardiff"
+  ( cd "$dir" && node "$BIN" "$@" >"$TMP/out" 2>&1 ); local rc=$?
+  if clean "$dir"; then
+    SEEN["$label"]=1
+    parity "$dir" "$label" "$rc" "$@"
+    printf "  %-46s exit %-3s clean  %s\n" "$label" "$rc" "$PAR"
+    cat "$TMP/pardiff"
+  else
+    FAIL=1
+    printf "  %-46s exit %-3s ⚠ WROTE:\n" "$label" "$rc"
+    git -C "$dir" status --porcelain --ignored | sed 's/^/        /' | head -8
+    git -C "$dir" clean -qfdx; git -C "$dir" checkout -q -- .
+  fi
+}
+
+refuse() {  # refuse <repo-dir> <args...> — must exit 1, name sdd-cli, write nothing
+  local dir="$1"; shift
+  ( cd "$dir" && node "$BIN" "$@" >"$TMP/out" 2>&1 ); local rc=$?
+  if [ "$rc" -eq 1 ] && grep -q "not part of sdd-verify" "$TMP/out" && clean "$dir"; then
+    printf "  %-46s refused (exit 1)\n" "✗ $*"
+  else
+    FAIL=1; printf "  %-46s ⚠ NOT REFUSED — exit %s\n" "✗ $*" "$rc"; sed 's/^/        /' "$TMP/out" | head -3
+  fi
+}
+
+for repo in "${REPOS[@]}"; do
+  name="$(basename "$repo")"; dir="$TMP/$name"
+  git clone -q --no-local "$repo" "$dir" || { echo "clone failed: $repo"; FAIL=1; continue; }
+  echo "=== $name @ $(git -C "$dir" rev-parse --short HEAD) ==="
+  clean "$dir" || { echo "  fresh clone is not clean — cannot test"; FAIL=1; continue; }
+
+  run "$dir" "--version" --version
+  run "$dir" "validate" validate --target-repo .
+  run "$dir" "validate --strict" validate --target-repo . --strict
+  run "$dir" "list" list --workspace-root .
+  if [ -d "$dir/catalogues" ]; then
+    run "$dir" "catalogue validate" catalogue validate --sdd-path .
+    run "$dir" "catalogue validate --strict" catalogue validate --sdd-path . --strict
+    run "$dir" "catalogue validate --coverage" catalogue validate --sdd-path . --coverage
+    [ -d "$dir/catalogues-aggregated" ] && run "$dir" "catalogue validate --coverage" \
+      catalogue validate --sdd-path . --coverage --tier aggregate --catalogues-dir catalogues-aggregated
+    node_id="$(awk -F, 'NR==2{print $1; exit}' "$dir/catalogues/services.csv" 2>/dev/null)"
+    [ -n "$node_id" ] && run "$dir" "catalogue impact" catalogue impact --sdd-path . --of "services/$node_id"
+    ( cd "$dir" && node "$BIN" catalogue validate --sdd-path . --coverage >"$TMP/findings.txt" 2>/dev/null )
+    clean "$dir" || { echo "  ⚠ findings capture wrote"; FAIL=1; }
+    run "$dir" "catalogue baseline-check --findings" catalogue baseline-check --sdd-path . --findings "$TMP/findings.txt"
+    RUNS=$((RUNS+1))
+    ( cd "$dir" && node "$BIN" catalogue baseline-check --sdd-path . <"$TMP/findings.txt" >"$TMP/out" 2>&1 ); rc=$?
+    if clean "$dir"; then SEEN["catalogue baseline-check (stdin)"]=1; printf "  %-46s exit %-3s clean\n" "catalogue baseline-check (stdin)" "$rc"
+    else FAIL=1; echo "  catalogue baseline-check (stdin) ⚠ WROTE"; fi
+    run "$dir" "catalogue version" catalogue version
+  fi
+  for seed in "$dir"/orchestration/distribution/*seed*.yaml; do
+    [ -f "$seed" ] && run "$dir" "pack validate" pack validate --seed "orchestration/distribution/$(basename "$seed")"
+  done
+
+  refuse "$dir" sync
+  refuse "$dir" catalogue build
+  refuse "$dir" pack build --seed x
+  refuse "$dir" mcp serve
+  refuse "$dir" sync --help
+done
+
+# CONTROL — the detector must be able to see a write. Two parts, because a
+# control that FAILS TO RUN is indistinguishable from a detector that cannot
+# see, unless its exit code is checked. The first version of this script
+# discarded both; `catalogue graph` errored on the first repo, wrote nothing,
+# and the run reported the detector blind when the control had simply not run.
+#   1. synthetic: a file written into a clone must show as dirty;
+#   2. real: the full CLI's `catalogue graph` (writes by default) must EXIT 0
+#      on at least one repo and then dirty it.
+ctl="$TMP/control"; git clone -q --no-local "${REPOS[0]}" "$ctl"
+echo probe >"$ctl/.acceptance-probe"
+if clean "$ctl"; then FAIL=1; echo "CONTROL ⚠ a synthetic write was not seen — the detector is blind"
+else echo "CONTROL  synthetic write seen"; fi
+real_ok=0
+for repo in "${REPOS[@]}"; do
+  c="$TMP/ctl-$(basename "$repo")"; git clone -q --no-local "$repo" "$c"
+  ( cd "$c" && node "$CONTROL" catalogue graph --sdd-path . >"$TMP/ctl.out" 2>&1 ); rc=$?
+  if [ "$rc" -ne 0 ]; then
+    echo "CONTROL  catalogue graph on $(basename "$repo"): exit $rc, did not run — $(head -c 110 "$TMP/ctl.out")"
+    continue
+  fi
+  if clean "$c"; then FAIL=1; echo "CONTROL ⚠ catalogue graph exited 0 on $(basename "$repo") and the detector saw no write"
+  else echo "CONTROL  catalogue graph on $(basename "$repo"): exit 0, $(git -C "$c" status --porcelain --ignored | wc -l) path(s) written and SEEN"; fi
+  real_ok=1; break
+done
+[ "$real_ok" -eq 1 ] || { FAIL=1; echo "CONTROL ⚠ INVALID — the authoring control ran successfully on no repository, so no write was ever demonstrated"; }
+
+# COVERAGE — every surface item must have been exercised somewhere.
+missing=()
+for s in "${SURFACE[@]}"; do [ -n "${SEEN[$s]:-}" ] || missing+=("$s"); done
+if [ ${#missing[@]} -gt 0 ]; then
+  FAIL=1; echo "COVERAGE ⚠ never exercised: ${missing[*]}"
+else
+  echo "COVERAGE every surface verb and mode exercised (${#SURFACE[@]}/${#SURFACE[@]}) across $RUNS runs"
+fi
+
+[ "$FAIL" -eq 0 ] && echo "ACCEPTANCE PASS — sdd-verify wrote nothing, anywhere" || echo "ACCEPTANCE FAIL"
+exit "$FAIL"

package/dist/conformance-bin.d.ts

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

package/dist/conformance-bin.d.ts.map

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

package/dist/conformance-bin.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import { runConformance } from "./conformance-program.js";
-runConformance(process.argv.slice(2)).catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`sdd-conformance: ${message}\n`);
-    process.exit(1);
-});
-//# sourceMappingURL=conformance-bin.js.map

package/dist/conformance-bin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conformance-bin.js","sourceRoot":"","sources":["../src/conformance-bin.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;IAC3D,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,OAAO,IAAI,CAAC,CAAC;IACtD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/conformance-program.d.ts

@@ -1,6 +0,0 @@
-import { Command } from "commander";
-/** The verbs this binary exposes. Asserted by test, not by convention. */
-export declare const CONFORMANCE_VERBS: ReadonlyArray<string>;
-export declare function runConformance(argv: readonly string[]): Promise<void>;
-export declare function buildConformanceProgram(): Command;
-//# sourceMappingURL=conformance-program.d.ts.map

package/dist/conformance-program.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conformance-program.d.ts","sourceRoot":"","sources":["../src/conformance-program.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,OAAO,EAAkB,MAAM,WAAW,CAAC;AASpD,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAgC,CAAC;AAErF,wBAAsB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB3E;AAED,wBAAgB,uBAAuB,IAAI,OAAO,CAwBjD"}

package/dist/conformance-program.js

@@ -1,59 +0,0 @@
-// Second entrypoint: the CONFORMANCE surface only.
-//
-// M-ADR 0212 §4.6 Phase 0 — this file exists so the conformance client can be
-// published alongside the full CLI without copying a line of verb source. It
-// imports the SAME register functions the full program uses, so the two
-// binaries cannot drift in behaviour: there is one implementation and two
-// command surfaces over it. Adding a verb here is a deliberate act; nothing
-// arrives by inheritance.
-//
-// The surface is what automated pipelines were MEASURED to invoke — conformance
-// validation, distribution sync, packaging — and deliberately excludes the
-// authoring verbs (catalogue, metamodel, init, scaffold, MCP, render, plan),
-// which measurement showed pipelines never call.
-import { Command, CommanderError } from "commander";
-import { getPackageVersion } from "./lib/package-version.js";
-import { registerPack } from "./verbs/pack.js";
-import { registerSync } from "./verbs/sync.js";
-import { registerValidate } from "./verbs/validate.js";
-const SPEC_URL = "https://github.com/tomfosteruk/sdd-method/blob/main/docs/method/cli/sdd-cli-specification.md";
-/** The verbs this binary exposes. Asserted by test, not by convention. */
-export const CONFORMANCE_VERBS = ["sync", "validate", "pack"];
-export async function runConformance(argv) {
-    const program = buildConformanceProgram();
-    try {
-        if (argv.length === 0) {
-            program.outputHelp();
-            return;
-        }
-        await program.parseAsync([...argv], { from: "user" });
-    }
-    catch (err) {
-        if (err instanceof CommanderError) {
-            if (err.code === "commander.help" ||
-                err.code === "commander.helpDisplayed" ||
-                err.code === "commander.version") {
-                return;
-            }
-        }
-        throw err;
-    }
-}
-export function buildConformanceProgram() {
-    const program = new Command();
-    program
-        .name("sdd-conformance")
-        .description("Conformance surface for SDD repositories — validate, sync, pack. The authoring verbs live in sdd-cli.")
-        .version(getPackageVersion(), "-v, --version")
-        .addHelpText("after", `\nSpec: ${SPEC_URL}\nAuthoring verbs (catalogue, metamodel, init, scaffold, mcp) are in @sdd-method/sdd-cli.`)
-        .exitOverride()
-        .configureOutput({
-        writeOut: (str) => process.stdout.write(str),
-        writeErr: (str) => process.stderr.write(str),
-    });
-    registerSync(program);
-    registerValidate(program);
-    registerPack(program);
-    return program;
-}
-//# sourceMappingURL=conformance-program.js.map

package/dist/conformance-program.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conformance-program.js","sourceRoot":"","sources":["../src/conformance-program.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,wEAAwE;AACxE,0EAA0E;AAC1E,4EAA4E;AAC5E,0BAA0B;AAC1B,EAAE;AACF,gFAAgF;AAChF,2EAA2E;AAC3E,6EAA6E;AAC7E,iDAAiD;AAEjD,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,QAAQ,GACZ,8FAA8F,CAAC;AAEjG,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAA0B,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;AAErF,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,IAAuB;IAC1D,MAAM,OAAO,GAAG,uBAAuB,EAAE,CAAC;IAC1C,IAAI,CAAC;QACH,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,CAAC,UAAU,EAAE,CAAC;YACrB,OAAO;QACT,CAAC;QACD,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IACxD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,GAAG,YAAY,cAAc,EAAE,CAAC;YAClC,IACE,GAAG,CAAC,IAAI,KAAK,gBAAgB;gBAC7B,GAAG,CAAC,IAAI,KAAK,yBAAyB;gBACtC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAChC,CAAC;gBACD,OAAO;YACT,CAAC;QACH,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAE9B,OAAO;SACJ,IAAI,CAAC,iBAAiB,CAAC;SACvB,WAAW,CACV,uGAAuG,CACxG;SACA,OAAO,CAAC,iBAAiB,EAAE,EAAE,eAAe,CAAC;SAC7C,WAAW,CACV,OAAO,EACP,WAAW,QAAQ,2FAA2F,CAC/G;SACA,YAAY,EAAE;SACd,eAAe,CAAC;QACf,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;QAC5C,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;KAC7C,CAAC,CAAC;IAEL,YAAY,CAAC,OAAO,CAAC,CAAC;IACtB,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC1B,YAAY,CAAC,OAAO,CAAC,CAAC;IAEtB,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/scripts/build-conformance-package.mjs

@@ -1,57 +0,0 @@
-// Assemble the publishable @sdd-method/conformance-cli package.
-//
-// M-ADR 0212 §4.6 condition 2 — ONE SOURCE, TWO ARTEFACTS. Nothing here is a
-// second editable copy: the compiled output is produced once by `npm run build`
-// and this script arranges it under a second package manifest. The conformance
-// binary imports the same compiled verb modules the full CLI does, so the two
-// cannot drift in behaviour; only the command surface differs.
-//
-// The assembled directory is generated, gitignored, and safe to delete.
-
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-const OUT = join(ROOT, "build", "conformance-cli");
-
-const main = await readFile(join(ROOT, "package.json"), "utf8").then(JSON.parse);
-
-// The version is deliberately NOT inherited from the full CLI. The two
-// artefacts version independently: a catalogue-engine release must not appear
-// to move the conformance client, which is the whole point of separating them.
-const version = process.env.CONFORMANCE_VERSION ?? "0.1.0";
-
-const pkg = {
-  name: "@sdd-method/conformance-cli",
-  version,
-  description:
-    "Conformance surface for SDD repositories — validate, sync, pack. Built from the same source as @sdd-method/sdd-cli; the authoring verbs live there.",
-  license: main.license,
-  type: main.type,
-  bin: { "sdd-conformance": "dist/conformance-bin.js" },
-  engines: main.engines,
-  dependencies: main.dependencies,
-  repository: main.repository,
-  files: ["dist", "scripts", "README.md", "LICENSE", "NOTICE"],
-};
-
-await rm(OUT, { recursive: true, force: true });
-await mkdir(OUT, { recursive: true });
-await cp(join(ROOT, "dist"), join(OUT, "dist"), { recursive: true });
-await cp(join(ROOT, "scripts"), join(OUT, "scripts"), { recursive: true });
-for (const f of ["LICENSE", "NOTICE"]) {
-  await cp(join(ROOT, f), join(OUT, f));
-}
-await writeFile(
-  join(OUT, "README.md"),
-  `# @sdd-method/conformance-cli\n\n` +
-    `The conformance surface of the SDD method CLI: \`sdd-conformance sync\`, \`validate\`, \`pack\`.\n\n` +
-    `Built from the same source as \`@sdd-method/sdd-cli\` — the verbs are the same implementations, ` +
-    `exposed under a smaller surface for automated pipelines, which were measured to invoke only these.\n\n` +
-    `Authoring verbs — catalogue, metamodel, init, scaffold, mcp, render, plan — are in \`@sdd-method/sdd-cli\`.\n\n` +
-    `This package is additive: it changes nothing about \`@sdd-method/sdd-cli\`, which continues to carry every verb.\n`,
-);
-await writeFile(join(OUT, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
-
-process.stdout.write(`assembled ${pkg.name}@${version} at build/conformance-cli\n`);