@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/verbs/api-surface.js

@@ -0,0 +1,71 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { analyzeRepo } from "../lib/api-surface/index.js";
+import { toMarkdownBlock, toYaml } from "../lib/api-surface/emit.js";
+export function registerApiSurface(program) {
+    program
+        .command("api-surface")
+        .description("Extract operation-level interface + dependency + deployment evidence from a source repo — the " +
+        "four things the reverse repo-doc-quality rubric needs for interface_and_dependency_coverage=2: " +
+        "endpoints (method+path+auth), the upstream/downstream dependency graph, external contracts, and " +
+        "deployment coupling (shared infra/DB/queue). Detects the stack (node-serverless | java-spring | " +
+        "terraform | library) and emits contracts/api-surface.yaml (extends the existing shape).")
+        .requiredOption("--source <dir>", "source repo root (a <repo>-master@<sha>/ dir or any repo root)")
+        .option("--repo <name>", "repo slug (default: derived from the source dir name)")
+        .option("--domain <d>", "domain tag for the emitted surface")
+        .option("--profile <p>", "profile tag (default: reverse)")
+        .option("--out <file>", "write YAML to a file (default: stdout)")
+        .option("--emit-md", "also emit the markdown interface block")
+        .option("--dry-run", "force stdout even when --out is given")
+        .action(async (opts) => {
+        if (!existsSync(opts.source)) {
+            process.stderr.write(`[FAIL] source dir not found: ${opts.source}\n`);
+            process.exit(1);
+            return;
+        }
+        let surface;
+        try {
+            surface = await analyzeRepo({
+                source: opts.source,
+                ...(opts.repo ? { repo: opts.repo } : {}),
+                ...(opts.domain ? { domain: opts.domain } : {}),
+                ...(opts.profile ? { profile: opts.profile } : {}),
+            });
+        }
+        catch (err) {
+            process.stderr.write(`[FAIL] api-surface analysis failed: ${err.message}\n`);
+            process.exit(1);
+            return;
+        }
+        const yaml = toYaml(surface);
+        const md = opts.emitMd === true ? toMarkdownBlock(surface) : "";
+        const toStdout = opts.dryRun === true || opts.out === undefined;
+        if (toStdout) {
+            process.stdout.write(yaml);
+            if (!yaml.endsWith("\n"))
+                process.stdout.write("\n");
+            if (md) {
+                process.stdout.write("\n");
+                process.stdout.write(md);
+                if (!md.endsWith("\n"))
+                    process.stdout.write("\n");
+            }
+        }
+        else {
+            await mkdir(dirname(opts.out), { recursive: true });
+            await writeFile(opts.out, yaml.endsWith("\n") ? yaml : yaml + "\n", "utf-8");
+            process.stdout.write(`[OK] wrote ${opts.out}\n`);
+            if (md) {
+                const mdPath = opts.out.replace(/\.ya?ml$/i, ".md");
+                await writeFile(mdPath, md.endsWith("\n") ? md : md + "\n", "utf-8");
+                process.stdout.write(`[OK] wrote ${mdPath}\n`);
+            }
+        }
+        const epCount = surface.endpoints.length;
+        const depCount = surface.dependencies.downstream.length;
+        process.stderr.write(`[OK] ${surface.repo} (${surface.stack}): ${epCount} endpoint(s), ${depCount} downstream dep(s), ` +
+            `runtime=${surface.deployment.runtime || "?"}\n`);
+    });
+}
+//# sourceMappingURL=api-surface.js.map

package/dist/verbs/catalogue-check.js

@@ -0,0 +1,28 @@
+import { resolve } from "node:path";
+import { checkCataloguesFresh } from "../lib/catalogue/freshness.js";
+/**
+ * `catalogue check` (M-ADR 0220 §4.2, ruling 3): whether the committed catalogues are what the
+ * committed specifications build to. It builds into temporary space and writes nothing to the
+ * repository: `catalogue build --check` under its own name, so the author's surface holds no verb
+ * that writes the model. Its own registrar, so an artefact can carry it without the build,
+ * aggregate and graph registrations in catalogue-maintain.ts.
+ */
+export function registerCatalogueCheck(catalogue) {
+    catalogue
+        .command("check")
+        .description("Report whether the committed catalogues/ are what the committed specifications build to; builds in a temporary directory and writes nothing (exit 1 lists every stale file)")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--strict", "Treat build findings as failures")
+        .option("--snapshot-store <dir>", "Snapshot store root the binding's snapshot_area is relative to (default: $SDD_SNAPSHOT_STORE; M-ADR 0214)")
+        .action(async (opts) => {
+        const snapshotStore = opts.snapshotStore ?? process.env.SDD_SNAPSHOT_STORE;
+        const r = await checkCataloguesFresh(resolve(opts.sddPath ?? process.cwd()), {
+            label: "catalogue check",
+            ...(opts.strict !== undefined ? { strict: opts.strict } : {}),
+            ...(snapshotStore !== undefined ? { snapshotStore } : {}),
+        }, (s) => process.stdout.write(s));
+        if (r.exitCode !== 0)
+            process.exit(r.exitCode);
+    });
+}
+//# sourceMappingURL=catalogue-check.js.map

package/dist/verbs/catalogue-verify.js

@@ -0,0 +1,114 @@
+// The read-only `catalogue` subcommands — validate (incl. --coverage), impact,
+// baseline-check, version — split from `catalogue.ts` so a program can register
+// them without importing the catalogue BUILD path. The verify-only CLI ships
+// these and must not ship code that writes the derived model (M-ADR 0212 §4.3b).
+// `registerCatalogue` calls each at its original position, so sdd-cli's
+// `catalogue` surface and help order are unchanged.
+//
+// ⚠ Import each run* from its own module, NEVER from `../lib/catalogue/index.js`:
+// that barrel re-exports the build and aggregate paths, and one convenience
+// import from it would silently put authoring code back into the verify package.
+import { runBaselineCheck } from "../lib/catalogue/baseline-check.js";
+import { runCatalogueCoverage } from "../lib/catalogue/coverage-run.js";
+import { runCatalogueImpact } from "../lib/catalogue/impact-run.js";
+import { runCatalogueValidate } from "../lib/catalogue/validate.js";
+import { runCatalogueVersion } from "../lib/catalogue/version.js";
+export function registerCatalogueValidate(catalogue) {
+    catalogue
+        .command("validate")
+        .description("Re-run column-shape + FK validation against existing catalogues/ (no rebuild)")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--strict", "Treat findings as failures")
+        .option("--coverage", "Coverage mode: run the engine coverage predicates instead (same lines the gate scripts printed; exit 0 — gating stays the baseline's job)")
+        .option("--tier <tier>", "Coverage tier, explicit never inferred (member | aggregate; default member)")
+        .option("--catalogues-dir <dir>", "Coverage mode: catalogues directory relative to the SDD root (default catalogues)")
+        .action(async (opts) => {
+        if (opts.coverage === true) {
+            if (opts.tier !== undefined &&
+                opts.tier !== "member" &&
+                opts.tier !== "aggregate") {
+                process.stderr.write(`--tier must be 'member' or 'aggregate' (got: ${opts.tier})\n`);
+                process.exit(2);
+            }
+            const result = await runCatalogueCoverage({
+                ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+                ...(opts.cataloguesDir !== undefined
+                    ? { cataloguesDir: opts.cataloguesDir }
+                    : {}),
+                ...(opts.tier !== undefined
+                    ? { tier: opts.tier }
+                    : {}),
+            }, (s) => process.stdout.write(s));
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+            return;
+        }
+        const result = await runCatalogueValidate({
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.strict !== undefined ? { strict: opts.strict } : {}),
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueImpact(catalogue) {
+    catalogue
+        .command("impact")
+        .description("Change-impact closure of a node (M-ADR 0206): each relationship is traversed per its declared impact-flow from the rubric-coverage-map — dependency edges reach their consumers, membership edges propagate part-to-whole only, xref/lineage records are inert — computed by recursive SQL on the embedded engine, with the co-directionality invariant asserted on every run")
+        .requiredOption("--of <node-id>", 'Node to compute impact of, in the projection\'s "<catalogue>/<id>" form (e.g. contracts/orders-api)')
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--catalogues-dir <dir>", "Catalogues directory relative to the SDD root (default: catalogues, or catalogues-aggregated at --tier aggregate)")
+        .option("--tier <tier>", "Tier, explicit never inferred (member | aggregate; default member)")
+        .action(async (opts) => {
+        if (opts.tier !== undefined &&
+            opts.tier !== "member" &&
+            opts.tier !== "aggregate") {
+            process.stderr.write(`--tier must be 'member' or 'aggregate' (got: ${opts.tier})\n`);
+            process.exit(2);
+        }
+        const result = await runCatalogueImpact({
+            of: opts.of,
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.cataloguesDir !== undefined
+                ? { cataloguesDir: opts.cataloguesDir }
+                : {}),
+            ...(opts.tier !== undefined
+                ? { tier: opts.tier }
+                : {}),
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueBaselineCheck(catalogue) {
+    catalogue
+        .command("baseline-check")
+        .description("Compare emitted findings against the repo's findings baseline BY IDENTITY (M-ADR 0132 §9) — a reworded finding reports as reworded, not as one closed and one new")
+        .option("--sdd-path <path>", "Path to the SDD repo root (defaults to cwd)")
+        .option("--findings <path>", "File of findings to compare (defaults to stdin, so it composes with `catalogue validate --coverage`)")
+        .option("--baseline <path>", "Baseline file (defaults to <sdd-path>/orchestration/catalogue-findings-baseline.txt)")
+        .action(async (opts) => {
+        const result = await runBaselineCheck({
+            ...(opts.sddPath !== undefined ? { sddPath: opts.sddPath } : {}),
+            ...(opts.findings !== undefined ? { findings: opts.findings } : {}),
+            ...(opts.baseline !== undefined ? { baseline: opts.baseline } : {}),
+            stdin: async () => {
+                const chunks = [];
+                for await (const c of process.stdin)
+                    chunks.push(Buffer.from(c));
+                return Buffer.concat(chunks).toString("utf-8");
+            },
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+export function registerCatalogueVersion(catalogue) {
+    catalogue
+        .command("version")
+        .description("Print the catalogue schema version + sdd-cli version pin")
+        .action(async () => {
+        await runCatalogueVersion((s) => process.stdout.write(s));
+    });
+}
+//# sourceMappingURL=catalogue-verify.js.map

package/dist/verbs/conformance.js

@@ -0,0 +1,34 @@
+import { runConformance } from "../lib/conformance/index.js";
+import { resolvePathOption } from "./path-option.js";
+export function registerConformance(program) {
+    program
+        .command("conformance")
+        .description("Conformance-reverse: diff the declared surface (spec/binding/contract) against the observed " +
+        "surface (code) and report drift with PROVISIONAL verdicts (ADR 0180). Advisory by default — " +
+        "disposition (code-defect vs spec-stale vs divergence) is a triage step, not this verb's call. " +
+        "Checks are derived from the spec-implementation binding (.sdd/implementation-binding.yaml, " +
+        "ADR 0181) when present; else .sdd/conformance-checks.yaml.")
+        .option("--target-repo <dir>", "target SDD repo", resolvePathOption, process.cwd())
+        .option("--config <path>", "explicit checks file (overrides the binding)")
+        .option("--code-root <dir>", "checkout root for implementation member repos (resolves @code/ sources)", resolvePathOption)
+        .option("--check <id>", "run only the named check")
+        .option("--json", "machine-readable report (CI ingestion)")
+        .option("--reconcile", "for binding-vs-reality checks, emit the binding fragment regenerated from the observed-set (ADR 0181 §2.3)")
+        .option("--emit-finding <dir>", "write the conformance_finding catalogue CSV into <dir> (federates via aggregate)")
+        .option("--strict", "exit non-zero when any check needs triage (default: advisory, exit 0)")
+        .action(async (opts) => {
+        const { exitCode } = await runConformance({
+            targetRepo: opts.targetRepo,
+            ...(opts.config ? { config: opts.config } : {}),
+            ...(opts.codeRoot ? { codeRoot: opts.codeRoot } : {}),
+            ...(opts.check ? { check: opts.check } : {}),
+            json: opts.json === true,
+            reconcile: opts.reconcile === true,
+            strict: opts.strict === true,
+            ...(opts.emitFinding ? { emitFinding: opts.emitFinding } : {}),
+        });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=conformance.js.map

package/dist/verbs/context.js

@@ -0,0 +1,39 @@
+import { resolvePathOption } from "./path-option.js";
+import { AGENT_HARNESSES, resolveAgentHarness } from "../lib/agent-harness.js";
+import { runContextPull } from "../lib/context-pull/index.js";
+const collect = (value, previous = []) => [...previous, resolvePathOption(value)];
+export function registerContext(program) {
+    const context = program
+        .command("context")
+        .description("Briefing for a code repository an SDD specifies (M-ADR 0128 §1, M-ADR 0150 §4.4)");
+    context
+        .command("pull")
+        .description("Write agent-instructions.md and the harness wrapper's method-managed block into this code repository, rendered from the templates its upstream SDD carries. The SDD is found by looking this repository up in the catalogues/repositories.csv of the SDDs beside it. Writes nothing else.")
+        .option("--target-repo <dir>", "the code repository to write into", resolvePathOption, process.cwd())
+        .option("--sdd <dir>", "the upstream SDD, skipping discovery", resolvePathOption)
+        .option("--repo <id>", "this repository's id in the SDD's catalogue (default: its git top-level directory name)")
+        .option("--search <dir>", "discover SDDs under this directory (repeatable; default: the code repository's parent)", collect)
+        .option("--agent-harness <name>", `target agent harness. Default: claude-code. Supported: ${AGENT_HARNESSES.join(", ")}`)
+        .option("--allow-overwrite", "replace a harness wrapper that has no method-managed markers")
+        .action(async (opts) => {
+        let agentHarness;
+        try {
+            agentHarness = resolveAgentHarness(opts.agentHarness);
+        }
+        catch (err) {
+            process.stderr.write(`[FAIL] ${err.message}\n`);
+            process.exit(1);
+        }
+        const { exitCode } = await runContextPull({
+            codeRepo: opts.targetRepo,
+            agentHarness,
+            allowOverwrite: opts.allowOverwrite === true,
+            sddPath: opts.sdd,
+            repoName: opts.repo,
+            searchRoots: opts.search,
+        });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=context.js.map

package/dist/verbs/contracts.js

@@ -0,0 +1,34 @@
+import { runAttest } from "../lib/contracts-availability/index.js";
+import { resolvePathOption } from "./path-option.js";
+export function registerContracts(program) {
+    const contracts = program
+        .command("contracts")
+        .description("Contract artefact operations (M-ADR 0202)");
+    contracts
+        .command("attest")
+        .description("Maintain/verify .sdd/contract-availability.yaml — the committed attestation for " +
+        "contract artefacts living in sibling repositories (M-ADR 0202). --refresh runs " +
+        "where the siblings are checked out and writes entries (path, sha256, repo@commit); " +
+        "--verify runs anywhere: present artefacts are digest-checked for drift, " +
+        "absent-but-attested is satisfied, referenced-but-unattested-and-absent fails.")
+        .option("--target-repo <dir>", "target SDD repo", resolvePathOption, process.cwd())
+        .option("--code-root <dir>", "root under which sibling-resident declared paths resolve (default: parent of target repo)", resolvePathOption)
+        .option("--refresh", "attest what is visible from this machine and update the manifest")
+        .option("--verify", "check references and attestations without writing (default)")
+        .action(async (opts) => {
+        if (opts.refresh && opts.verify) {
+            process.stderr.write("[FAIL] --refresh and --verify are mutually exclusive\n");
+            process.exit(1);
+        }
+        const { exitCode, log } = await runAttest({
+            targetRepo: opts.targetRepo,
+            mode: opts.refresh ? "refresh" : "verify",
+            ...(opts.codeRoot ? { codeRoot: opts.codeRoot } : {}),
+        });
+        for (const line of log)
+            process.stdout.write(line + "\n");
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=contracts.js.map

package/dist/verbs/generate-briefing.js

@@ -0,0 +1,29 @@
+import { resolvePathOption } from "./path-option.js";
+import { AGENT_HARNESSES, resolveAgentHarness, } from "../lib/agent-harness.js";
+import { runGenerateBriefing } from "../lib/generate-briefing/index.js";
+export function registerGenerateBriefing(program) {
+    program
+        .command("generate-briefing")
+        .description("Regenerate agent-instructions.md + the harness wrapper for an existing SDD repository (no bundle sync)")
+        .option("--target-dir <dir>", "target SDD repo", resolvePathOption, process.cwd())
+        .option("--agent-harness <name>", `target agent harness. Default: claude-code. Supported: ${AGENT_HARNESSES.join(", ")}`)
+        .option("--allow-overwrite", "accept overwrites of locally-modified wrapper files")
+        .action(async (opts) => {
+        let agentHarness;
+        try {
+            agentHarness = resolveAgentHarness(opts.agentHarness);
+        }
+        catch (err) {
+            process.stderr.write(`[FAIL] ${err.message}\n`);
+            process.exit(1);
+        }
+        const { exitCode } = await runGenerateBriefing({
+            targetDir: opts.targetDir,
+            agentHarness,
+            allowOverwrite: opts.allowOverwrite === true,
+        });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=generate-briefing.js.map

package/dist/verbs/list.js

@@ -0,0 +1,45 @@
+import { runList } from "../lib/list/index.js";
+const VALID_PROFILES = [
+    "platform",
+    "application",
+    "integration",
+];
+export function registerList(program) {
+    program
+        .command("list")
+        .description("Enumerate SDD repositories discoverable in the current workspace, including adopter pack provenance (ADR 0151)")
+        .option("--profile <profile>", "filter by profile: platform | application | integration")
+        .option("--workspace-root <path>", "workspace directory to walk (repeatable; defaults to cwd)", collectRoots, [])
+        .option("--format <format>", "output format: text | json", "text")
+        .option("--verbose", "show managed_path counts per bundle (text format)")
+        .action(async (opts) => {
+        const profileFilter = parseProfile(opts.profile);
+        const format = parseFormat(opts.format);
+        const { exitCode } = await runList({
+            workspaceRoots: opts.workspaceRoot ?? [],
+            format,
+            verbose: opts.verbose === true,
+            ...(profileFilter ? { profileFilter } : {}),
+        }, (s) => process.stdout.write(s));
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+function collectRoots(value, prior) {
+    prior.push(value);
+    return prior;
+}
+function parseProfile(value) {
+    if (value === undefined)
+        return undefined;
+    if (!VALID_PROFILES.includes(value)) {
+        throw new Error(`Unknown --profile "${value}". Expected one of: ${VALID_PROFILES.join(", ")}`);
+    }
+    return value;
+}
+function parseFormat(value) {
+    if (value === "text" || value === "json")
+        return value;
+    throw new Error(`Unknown --format "${value}". Expected "text" or "json".`);
+}
+//# sourceMappingURL=list.js.map

package/dist/verbs/pack-validate.js

@@ -0,0 +1,17 @@
+// `pack validate` registration, split from `pack.ts` so a program can register
+// it without importing `runPackBuild` — the verify-only CLI must not ship the
+// code that writes a pack (M-ADR 0212 §4.3b). `registerPack` calls this, so
+// sdd-cli's `pack` surface and help order are unchanged.
+import { runPackValidate } from "../lib/pack/validate.js";
+export function registerPackValidate(pack) {
+    pack
+        .command("validate")
+        .description("Validate a context-pack seed file against the canonical schema. Fast feedback for authoring.")
+        .requiredOption("--seed <path>", "path to the seed file (orchestration/distribution/{name}-seed.yaml)")
+        .action(async (opts) => {
+        const { exitCode } = await runPackValidate({ seedPath: opts.seed });
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    });
+}
+//# sourceMappingURL=pack-validate.js.map

package/dist/verbs/path-option.js

@@ -0,0 +1,25 @@
+import { resolve } from "node:path";
+/**
+ * Commander parse-arg coercion for an option naming a DIRECTORY ON DISK.
+ *
+ * Resolves the operand to an absolute path ONCE, at the option boundary, before
+ * any verb sees it. That placement is the fix, not a detail: B6 was a relative
+ * `--target-repo` that resolved far enough to succeed at the first read and
+ * then failed at every later one.
+ *
+ * `validate` read `.sdd-repo-kind` relative to the process cwd — which WORKS,
+ * so the run announced the correct profile and dispatched the full validator
+ * set — then handed the same unresolved string to bash validators running from
+ * a different working directory, which reported `App root not found` and exit
+ * 127. A healthy repo came back `passed=0 failed=5`, so the operator saw a
+ * broken REPO rather than a bad ARGUMENT. Repairing those messages would have
+ * been the wrong fix; the path is what is wrong, and it is wrong exactly once.
+ *
+ * Resolving at the boundary also means a verb cannot forget: there is no
+ * per-consumer `resolve()` to omit, and a new consumer of the option inherits
+ * an absolute path by construction.
+ */
+export function resolvePathOption(value) {
+    return resolve(value);
+}
+//# sourceMappingURL=path-option.js.map

package/dist/verbs/plan.js

@@ -0,0 +1,42 @@
+import { resolvePathOption } from "./path-option.js";
+import { runPlanPilot } from "../lib/plan/index.js";
+export function registerPlan(program) {
+    program
+        .command("plan")
+        .description("Scaffold a plan markdown file from a method-distributed template. Currently supports --pilot for pilot-kickoff plans; future subcommands may add --initiative / --migration.")
+        .option("--pilot", "scaffold a pilot-kickoff plan (requires --service, --capability, --domain)", false)
+        .option("--service <name>", "service / pilot name, e.g. party-management")
+        .option("--capability <name>", "capability under test, e.g. organization-management")
+        .option("--domain <name>", "domain the capability belongs to, e.g. party")
+        .option("--workspace-root <path>", "SDD root (defaults to cwd)", resolvePathOption)
+        .option("--output <path>", "destination file (defaults to content/product/plans/{service}-pilot-kickoff.md)")
+        .option("--dry-run", "print rendered output to stdout without writing", false)
+        .action(async (opts) => {
+        if (opts.pilot !== true) {
+            process.stderr.write("[FAIL] plan: no mode specified. Pass --pilot (other modes not yet implemented).\n");
+            process.exit(1);
+        }
+        const missing = [];
+        if (!opts.service)
+            missing.push("--service");
+        if (!opts.capability)
+            missing.push("--capability");
+        if (!opts.domain)
+            missing.push("--domain");
+        if (missing.length > 0) {
+            process.stderr.write(`[FAIL] plan --pilot: missing required flag(s): ${missing.join(", ")}\n`);
+            process.exit(1);
+        }
+        const result = await runPlanPilot({
+            sddRoot: opts.workspaceRoot ?? process.cwd(),
+            service: opts.service,
+            capability: opts.capability,
+            domain: opts.domain,
+            ...(opts.output !== undefined ? { outputPath: opts.output } : {}),
+            ...(opts.dryRun === true ? { dryRun: true } : {}),
+        }, (s) => process.stdout.write(s));
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+}
+//# sourceMappingURL=plan.js.map

package/dist/verbs/render.js

@@ -0,0 +1,87 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+import { renderWireframe } from "../lib/catalogue/archetype/wireframe.js";
+import { loadScreenValidationConfig } from "../lib/catalogue/screen-validation-loader.js";
+export function registerRender(program) {
+    const render = program
+        .command("render")
+        .description("Render method artefacts to visual form");
+    render
+        .command("screen <file>")
+        .description("Render a screen-spec's openui-lang block to a structural wireframe SVG (ADR 0169). " +
+        "Platform comes from the `platform:` frontmatter; an adopter overlay is read from " +
+        ".sdd/screen-validation.yaml when present.")
+        .option("--out <file>", "write the SVG to a file (default: stdout)")
+        .action(async (file, opts) => {
+        let text;
+        try {
+            text = await readFile(file, "utf-8");
+        }
+        catch (err) {
+            process.stderr.write(`[FAIL] cannot read ${file}: ${err.message}\n`);
+            process.exit(1);
+            return;
+        }
+        const block = extractBlock(text);
+        if (block === null) {
+            process.stderr.write(`[FAIL] ${file} has no \`\`\`openui-lang block\n`);
+            process.exit(1);
+            return;
+        }
+        const fm = parseFrontmatter(text);
+        const platform = typeof fm.platform === "string" ? fm.platform : undefined;
+        const title = typeof fm.screen === "string" ? fm.screen : basename(file).replace(/\.md$/i, "");
+        // An overlay lives in the SDD's .sdd/; when the file sits under screens/,
+        // the SDD root is its grandparent. Best-effort — absent → no overlay.
+        const overlay = platform !== undefined ? await loadOverlay(file, platform) : undefined;
+        const svg = renderWireframe({ block, platform, overlay, title });
+        if (opts.out !== undefined) {
+            await writeFile(opts.out, svg, "utf-8");
+            process.stdout.write(`[OK] wrote ${opts.out}\n`);
+        }
+        else {
+            process.stdout.write(svg + "\n");
+        }
+    });
+}
+function extractBlock(text) {
+    const m = /```openui-lang\r?\n([\s\S]*?)```/.exec(text);
+    return m ? (m[1] ?? "") : null;
+}
+function parseFrontmatter(text) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    if (!m)
+        return {};
+    try {
+        const parsed = parseYaml(m[1] ?? "");
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function loadOverlay(file, platform) {
+    // The overlay lives in the SDD's .sdd/. Screens may sit directly under
+    // screens/ or in a subfolder (screens/<group>/<file>.md per the grouping
+    // convention), so walk up from the file to the nearest ancestor that
+    // contains a .sdd/ directory. Best-effort — absent → no overlay.
+    let dir = dirname(resolve(file));
+    for (let depth = 0; depth < 16; depth++) {
+        if (existsSync(join(dir, ".sdd")))
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    try {
+        const cfg = await loadScreenValidationConfig(dir);
+        return cfg?.archetypeOverlays.get(platform);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=render.js.map