@rsaglobaltech/specgate 0.8.1

package/dist/scripts/cli/commands/pack/InitPackCommand.js.map

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

package/dist/scripts/cli/commands/pack/LintPackCommand.js

@@ -0,0 +1,631 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LintPackCommand = exports.isGenericTitle = void 0;
+exports.parseArgs = parseArgs;
+exports.parseFeature = parseFeature;
+exports.lintScenarioQuality = lintScenarioQuality;
+exports.runLint = runLint;
+exports.buildPackGraph = buildPackGraph;
+exports.renderMermaid = renderMermaid;
+exports.renderDot = renderDot;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const DiskPackRepository_1 = require("../../../../packages/core/src/infrastructure/DiskPackRepository");
+const PackSpec_1 = require("../../../../packages/core/src/domain/PackSpec");
+const command_1 = require("../../../lib/command");
+const Gherkin_1 = require("../../../../packages/core/src/domain/Gherkin");
+const GherkinQuality_1 = require("../../../../packages/core/src/domain/GherkinQuality");
+const agent_1 = require("../../../lib/agent");
+const diagnostics_1 = require("../../../lib/diagnostics");
+function logInfo(msg) {
+    process.stdout.write(`ℹ️  [INFO] ${msg}\n`);
+}
+function logWarn(msg) {
+    process.stdout.write(`⚠️  [WARN] ${msg}\n`);
+}
+function logError(msg) {
+    process.stderr.write(`❌ [ERROR] ${msg}\n`);
+}
+function usage() {
+    process.stdout.write("Usage:\n" +
+        "  specgate pack lint --pack-root <path> --pack <domain/type> [--strict]\n" +
+        "  specgate pack lint --pack-root <path> --pack <domain/type> --graph [--graph-format mermaid|dot]\n\n" +
+        "Options:\n" +
+        "  --pack-root      Root directory containing domain packs (required)\n" +
+        "  --pack           Pack identifier, e.g. parking-management/backend (required)\n" +
+        "  --strict         Promote scenario-quality warnings to errors. Use in CI and\n" +
+        "                   before a pack feeds `harness run` — a weak scenario is a\n" +
+        "                   weak reward signal.\n" +
+        "  --graph          Print the REQ→UC→AGG/EVT/CMD reference graph instead of the\n" +
+        "                   lint report. Broken references are highlighted and listed;\n" +
+        "                   exits non-zero when any reference is dangling.\n" +
+        "  --graph-format   Graph output format: mermaid (default) or dot.\n");
+}
+function parseArgs(argv) {
+    const opts = {
+        packRoot: null,
+        packId: null,
+        strict: false,
+        graph: false,
+        graphFormat: "mermaid",
+        json: (0, agent_1.wantsJson)(argv),
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--pack-root" && argv[i + 1]) {
+            opts.packRoot = argv[++i];
+        }
+        else if (a === "--pack" && argv[i + 1]) {
+            opts.packId = argv[++i];
+        }
+        else if (a === "--strict") {
+            opts.strict = true;
+        }
+        else if (a === "--graph") {
+            opts.graph = true;
+        }
+        else if (a === "--graph-format" && argv[i + 1]) {
+            opts.graphFormat = argv[++i];
+        }
+        else if (a === "--json") {
+            opts.json = true;
+        }
+        else if (a === "--format" && argv[i + 1] === "json") {
+            opts.json = true;
+            i++;
+        }
+        else if (a === "--help" || a === "-h") {
+            usage();
+            process.exit(0);
+        }
+    }
+    if (!["mermaid", "dot"].includes(opts.graphFormat)) {
+        logError(`Invalid --graph-format: ${opts.graphFormat}. Expected: mermaid | dot.`);
+        process.exit(2);
+    }
+    return opts;
+}
+const NULL_SHAPE = { pack: null, packRoot: null, graph: null };
+function lintTodos(pack, errors, warnings) {
+    const yaml = JSON.stringify(pack);
+    const count = (yaml.match(/TODO/g) || []).length;
+    if (count > 0) {
+        warnings.push(`Pack contains ${count} TODO placeholder(s). Replace before shipping.`);
+    }
+}
+function lintRequirementsCoverage(pack, errors, _warnings) {
+    const reqIds = new Set((0, PackSpec_1.asArray)(pack.requirements).map((r) => r.id));
+    const usedInUC = new Set((0, PackSpec_1.asArray)(pack.use_cases).flatMap((uc) => (0, PackSpec_1.asArray)(uc.requirements || (uc.requirement ? [uc.requirement] : []))));
+    const usedInSCN = new Set((0, PackSpec_1.asArray)(pack.scenarios)
+        .map((s) => s.requirement)
+        .filter(Boolean));
+    const usedInAC = new Set((0, PackSpec_1.asArray)(pack.api_contracts)
+        .map((ac) => ac.requirement)
+        .filter(Boolean));
+    const usedInCDT = new Set((0, PackSpec_1.asArray)(pack.consumer_driven_tests)
+        .map((cdt) => cdt.requirement)
+        .filter(Boolean));
+    const usedInBCR = new Set((0, PackSpec_1.asArray)(pack.breaking_change_rules)
+        .map((bcr) => bcr.requirement)
+        .filter(Boolean));
+    for (const id of reqIds) {
+        if (!usedInUC.has(id) &&
+            !usedInSCN.has(id) &&
+            !usedInAC.has(id) &&
+            !usedInCDT.has(id) &&
+            !usedInBCR.has(id)) {
+            errors.push(`REQ ${id} is not referenced by any use case, scenario, api_contract, consumer_driven_test, or breaking_change_rules entry.`);
+        }
+    }
+}
+function lintUseCaseActors(pack, _errors, warnings) {
+    for (const uc of (0, PackSpec_1.asArray)(pack.use_cases)) {
+        if (!uc.actor || uc.actor.trim() === "") {
+            warnings.push(`UC ${uc.id} has no actor defined.`);
+        }
+    }
+}
+function lintBoundedContextAggregates(pack, errors, _warnings) {
+    const bcIds = new Set((0, PackSpec_1.asArray)(pack.bounded_contexts).map((bc) => bc.id));
+    for (const agg of (0, PackSpec_1.asArray)(pack.aggregates)) {
+        if (agg.bounded_context && !bcIds.has(agg.bounded_context)) {
+            errors.push(`Aggregate ${agg.id || agg.name} references unknown bounded_context: ${agg.bounded_context}`);
+        }
+    }
+}
+function lintEventAggregates(pack, errors, _warnings) {
+    const aggNames = new Set((0, PackSpec_1.asArray)(pack.aggregates).map((a) => a.name));
+    for (const evt of (0, PackSpec_1.asArray)(pack.events)) {
+        if (evt.aggregate && aggNames.size > 0 && !aggNames.has(evt.aggregate)) {
+            errors.push(`Event ${evt.id || evt.name} references unknown aggregate: ${evt.aggregate}`);
+        }
+    }
+}
+function lintScenarioRefs(pack, errors, _warnings) {
+    const reqIds = new Set((0, PackSpec_1.asArray)(pack.requirements).map((r) => r.id));
+    const ucIds = new Set((0, PackSpec_1.asArray)(pack.use_cases).map((uc) => uc.id));
+    for (const scn of (0, PackSpec_1.asArray)(pack.scenarios)) {
+        if (scn.requirement && !reqIds.has(scn.requirement)) {
+            errors.push(`Scenario ${scn.id} references unknown requirement: ${scn.requirement}`);
+        }
+        if (scn.use_case && !ucIds.has(scn.use_case)) {
+            errors.push(`Scenario ${scn.id} references unknown use_case: ${scn.use_case}`);
+        }
+    }
+}
+function lintRuleContextRefs(pack, _errors, warnings) {
+    const bcIds = new Set((0, PackSpec_1.asArray)(pack.bounded_contexts).map((bc) => bc.id));
+    for (const rule of (0, PackSpec_1.asArray)(pack.rules)) {
+        if (rule.context && bcIds.size > 0 && !bcIds.has(rule.context)) {
+            warnings.push(`Rule ${rule.id} context '${rule.context}' does not match any bounded_context id.`);
+        }
+    }
+}
+function lintIdUniqueness(pack, errors, _warnings) {
+    const sections = [
+        "requirements",
+        "use_cases",
+        "bounded_contexts",
+        "aggregates",
+        "value_objects",
+        "events",
+        "rules",
+        "scenarios",
+        "commands",
+    ];
+    for (const section of sections) {
+        const items = (0, PackSpec_1.asArray)(pack[section]);
+        const seen = new Set();
+        for (const item of items) {
+            if (!item.id)
+                continue;
+            if (seen.has(item.id)) {
+                errors.push(`Duplicate id '${item.id}' in ${section}.`);
+            }
+            seen.add(item.id);
+        }
+    }
+}
+function lintVariables(pack, errors, _warnings) {
+    const required = (0, PackSpec_1.asArray)(pack.variables && pack.variables.required);
+    for (const v of required) {
+        if (typeof v !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(v)) {
+            errors.push(`Variable '${v}' must be UPPER_SNAKE_CASE.`);
+        }
+    }
+}
+/**
+ * What `pack lint` reads out of a `.feature` template.
+ *
+ * Delegates to `parseGherkin`, the one reader in this repository (F1). This is
+ * the parser that shipped H14: it matched keywords case-insensitively, so it
+ * saw three steps in a scenario where Cucumber saw none and reported the pack
+ * as fine. A linter that approves what the runner ignores is worse than no
+ * linter, because it grants a guarantee that does not exist.
+ *
+ * Reading through the shared parser makes the linter case-sensitive, which is
+ * the whole point: it now judges the file the runner will actually execute.
+ */
+function parseFeature(content) {
+    return (0, Gherkin_1.parseGherkin)(content).scenarios.map((scenario) => ({
+        outline: scenario.outline,
+        title: scenario.name,
+        steps: scenario.steps.map((step) => ({ keyword: step.keyword, text: step.text })),
+        hasExamples: scenario.hasExamples,
+    }));
+}
+/** Re-exported so `pack lint`'s public surface is unchanged; the rule is in the domain. */
+exports.isGenericTitle = GherkinQuality_1.isGenericTitle;
+/**
+ * The eight quality rules, applied to one scenario.
+ *
+ * The rules themselves moved to `GherkinQuality` in the domain (A3) so that
+ * `validate`, `doctor` and `harness run` judge a scenario the same way this
+ * does. What stays here is delivery: which bucket a finding lands in and how
+ * the line reads. `errors` fail the lint; `scenarioIssues` are reported and
+ * only fail under `--strict`.
+ *
+ * Severity comes from the rule, never from the caller — `scenario_has_no_steps`
+ * is an error wherever it is raised, which is the correction H14 forced.
+ */
+function checkGherkin(where, gherkin, errors, scenarioIssues) {
+    const findings = (0, GherkinQuality_1.analyseScenario)({
+        name: gherkin.title || "",
+        steps: gherkin.steps,
+        outline: Boolean(gherkin.outline),
+        hasExamples: Boolean(gherkin.hasExamples),
+    }, where);
+    for (const finding of findings) {
+        // The message carries its own code where the code is worth reading aloud
+        // (`scenario_has_no_steps`); the rest read as prose. Preserved verbatim:
+        // this extraction changes where the rules live, not what a user sees.
+        const line = `${where}: ${finding.message}`;
+        if (finding.severity === "error")
+            errors.push(line);
+        else
+            scenarioIssues.push(line);
+    }
+}
+function inlineGherkin(scn) {
+    const steps = [];
+    for (const keyword of ["given", "when", "then"]) {
+        for (const text of (0, PackSpec_1.asArray)(scn[keyword])) {
+            if (typeof text === "string" && text.trim())
+                steps.push({ keyword, text: text.trim() });
+        }
+    }
+    return { title: scn.title || scn.scenario || "", steps, outline: false, hasExamples: true };
+}
+function lintScenarioQuality(pack, packRoot, errors, scenarioIssues) {
+    for (const scn of (0, PackSpec_1.asArray)(pack.scenarios)) {
+        const label = scn.id || scn.title || scn.scenario || "(unnamed scenario)";
+        if (!scn.template && (scn.given || scn.when || scn.then)) {
+            checkGherkin(`${label} → "${scn.title || "(no title)"}"`, inlineGherkin(scn), errors, scenarioIssues);
+            continue;
+        }
+        if (!scn.template) {
+            scenarioIssues.push(`Scenario ${label} declares no scenario content (template file or given/when/then).`);
+            continue;
+        }
+        const templatePath = path.resolve(packRoot, scn.template);
+        if (!fs.existsSync(templatePath)) {
+            errors.push(`Scenario ${label} template not found: ${scn.template}`);
+            continue;
+        }
+        const templateSource = fs.readFileSync(templatePath, "utf8");
+        // `keyword_case_invalid` — an error, always. Cucumber discards these lines
+        // in silence, which is precisely what makes them dangerous: the file looks
+        // like it has steps and behaves as if it has none. Named with the literal
+        // correction, because "it must be `Given`" is a fix and "no steps found" is
+        // a riddle.
+        for (const finding of (0, GherkinQuality_1.analyseKeywordCase)(templateSource, scn.template)) {
+            errors.push(`${finding.file}:${finding.line}: ${finding.code} — ${finding.message}`);
+        }
+        const parsed = parseFeature(templateSource);
+        if (parsed.length === 0) {
+            scenarioIssues.push(`Scenario ${label} (${scn.template}) contains no Gherkin scenario.`);
+            continue;
+        }
+        for (const gherkin of parsed) {
+            checkGherkin(`${label} → "${gherkin.title || "(no title)"}"`, gherkin, errors, scenarioIssues);
+        }
+        if (scn.scenario &&
+            parsed.length === 1 &&
+            parsed[0].title &&
+            scn.scenario.trim() !== parsed[0].title.trim()) {
+            scenarioIssues.push(`${label}: pack.yaml scenario "${scn.scenario}" does not match template title "${parsed[0].title}".`);
+        }
+    }
+}
+function lintInstallable(pack, packRoot, errors, _warnings) {
+    try {
+        (0, DiskPackRepository_1.validatePackModel)(pack, packRoot);
+    }
+    catch (err) {
+        errors.push(`Pack cannot be installed: ${err.message} ` +
+            "(`expand` enforces this, so lint has to as well)");
+    }
+}
+function runLint(pack, packRoot, opts = {}) {
+    const errors = [];
+    const warnings = [];
+    const scenarioIssues = [];
+    lintInstallable(pack, packRoot, errors, warnings);
+    lintTodos(pack, errors, warnings);
+    lintIdUniqueness(pack, errors, warnings);
+    lintVariables(pack, errors, warnings);
+    lintRequirementsCoverage(pack, errors, warnings);
+    lintUseCaseActors(pack, errors, warnings);
+    lintBoundedContextAggregates(pack, errors, warnings);
+    lintEventAggregates(pack, errors, warnings);
+    lintScenarioRefs(pack, errors, warnings);
+    lintRuleContextRefs(pack, errors, warnings);
+    lintScenarioQuality(pack, packRoot, errors, scenarioIssues);
+    if (opts.strict) {
+        errors.push(...scenarioIssues);
+    }
+    else {
+        warnings.push(...scenarioIssues);
+    }
+    return { errors, warnings };
+}
+function buildPackGraph(pack) {
+    const nodes = [];
+    const edges = [];
+    const broken = [];
+    const seen = new Set();
+    function addNode(id, type, label) {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        nodes.push({ id, type, label });
+    }
+    function addEdge(from, to, kind) {
+        edges.push({ from, to, kind });
+    }
+    function missingNode(kind, ref) {
+        const id = `MISSING:${kind}:${ref}`;
+        addNode(id, "missing", ref);
+        return id;
+    }
+    const requirements = (0, PackSpec_1.asArray)(pack.requirements);
+    const useCases = (0, PackSpec_1.asArray)(pack.use_cases);
+    const commands = (0, PackSpec_1.asArray)(pack.commands);
+    const queries = (0, PackSpec_1.asArray)(pack.queries);
+    const aggregates = (0, PackSpec_1.asArray)(pack.aggregates);
+    const events = (0, PackSpec_1.asArray)(pack.events);
+    const reqById = new Map(requirements.filter((r) => r.id).map((r) => [r.id, r]));
+    const cmdByKey = new Map();
+    for (const c of commands) {
+        if (c.id)
+            cmdByKey.set(c.id, c);
+        if (c.name)
+            cmdByKey.set(c.name, c);
+    }
+    const queryByKey = new Map();
+    for (const q of queries) {
+        if (q.id)
+            queryByKey.set(q.id, q);
+        if (q.name)
+            queryByKey.set(q.name, q);
+    }
+    const aggByKey = new Map();
+    for (const a of aggregates) {
+        if (a.id)
+            aggByKey.set(a.id, a);
+        if (a.name)
+            aggByKey.set(a.name, a);
+    }
+    const evtByKey = new Map();
+    for (const e of events) {
+        if (e.id)
+            evtByKey.set(e.id, e);
+        if (e.name)
+            evtByKey.set(e.name, e);
+    }
+    const nodeId = {
+        req: (r) => `REQ:${r.id}`,
+        uc: (u) => `UC:${u.id}`,
+        cmd: (c) => `CMD:${c.id || c.name}`,
+        query: (q) => `QUERY:${q.id || q.name}`,
+        agg: (a) => `AGG:${a.id || a.name}`,
+        evt: (e) => `EVT:${e.id || e.name}`,
+    };
+    const labelOf = (entity, fallback) => {
+        if (entity.id && entity.name)
+            return `${entity.id} ${entity.name}`;
+        return entity.id || entity.name || fallback;
+    };
+    for (const r of requirements)
+        addNode(nodeId.req(r), "requirement", r.id || "(no id)");
+    for (const u of useCases)
+        addNode(nodeId.uc(u), "use_case", labelOf(u, "(use case)"));
+    for (const c of commands)
+        addNode(nodeId.cmd(c), "command", labelOf(c, "(command)"));
+    for (const q of queries)
+        addNode(nodeId.query(q), "query", labelOf(q, "(query)"));
+    for (const a of aggregates)
+        addNode(nodeId.agg(a), "aggregate", labelOf(a, "(aggregate)"));
+    for (const e of events)
+        addNode(nodeId.evt(e), "event", labelOf(e, "(event)"));
+    for (const u of useCases) {
+        const from = nodeId.uc(u);
+        const label = u.id || u.name || "(use case)";
+        const reqRefs = (0, PackSpec_1.asArray)(u.requirements || (u.requirement ? [u.requirement] : []));
+        for (const ref of reqRefs) {
+            const target = reqById.get(ref);
+            if (target) {
+                addEdge(nodeId.req(target), from, "implements");
+            }
+            else {
+                broken.push({ from: label, kind: "requirement", ref });
+                addEdge(missingNode("requirement", ref), from, "implements");
+            }
+        }
+        if (u.command) {
+            const target = cmdByKey.get(u.command);
+            if (target) {
+                addEdge(from, nodeId.cmd(target), "dispatches");
+            }
+            else {
+                broken.push({ from: label, kind: "command", ref: u.command });
+                addEdge(from, missingNode("command", u.command), "dispatches");
+            }
+        }
+        if (u.query) {
+            const target = queryByKey.get(u.query);
+            if (target) {
+                addEdge(from, nodeId.query(target), "runs");
+            }
+            else {
+                broken.push({ from: label, kind: "query", ref: u.query });
+                addEdge(from, missingNode("query", u.query), "runs");
+            }
+        }
+        if (u.aggregate) {
+            const target = aggByKey.get(u.aggregate);
+            if (target) {
+                addEdge(from, nodeId.agg(target), "handled by");
+            }
+            else {
+                broken.push({ from: label, kind: "aggregate", ref: u.aggregate });
+                addEdge(from, missingNode("aggregate", u.aggregate), "handled by");
+            }
+        }
+        for (const ref of (0, PackSpec_1.asArray)(u.emits)) {
+            const target = evtByKey.get(ref);
+            if (target) {
+                addEdge(from, nodeId.evt(target), "emits");
+            }
+            else {
+                broken.push({ from: label, kind: "event", ref });
+                addEdge(from, missingNode("event", ref), "emits");
+            }
+        }
+    }
+    return { nodes, edges, broken };
+}
+function sanitizeId(id) {
+    return id.replace(/[^A-Za-z0-9]/g, "_");
+}
+function renderMermaid(graph) {
+    const lines = ["graph LR"];
+    for (const node of graph.nodes) {
+        const safe = sanitizeId(node.id);
+        const label = node.label.replace(/"/g, "'");
+        lines.push(`  ${safe}["${label}"]:::${node.type}`);
+    }
+    for (const edge of graph.edges) {
+        lines.push(`  ${sanitizeId(edge.from)} -->|${edge.kind}| ${sanitizeId(edge.to)}`);
+    }
+    lines.push("");
+    lines.push("  classDef requirement fill:#e7f5ff,stroke:#1c7ed6;");
+    lines.push("  classDef use_case fill:#fff9db,stroke:#f08c00;");
+    lines.push("  classDef command fill:#f3f0ff,stroke:#7048e8;");
+    lines.push("  classDef query fill:#f3f0ff,stroke:#7048e8;");
+    lines.push("  classDef aggregate fill:#ebfbee,stroke:#2f9e44;");
+    lines.push("  classDef event fill:#fff0f6,stroke:#c2255c;");
+    lines.push("  classDef missing fill:#ff6b6b,stroke:#c92a2a,color:#fff;");
+    return lines.join("\n");
+}
+function renderDot(graph) {
+    const lines = ["digraph pack {", "  rankdir=LR;", "  node [shape=box, style=rounded];"];
+    const fill = {
+        requirement: "#e7f5ff",
+        use_case: "#fff9db",
+        command: "#f3f0ff",
+        query: "#f3f0ff",
+        aggregate: "#ebfbee",
+        event: "#fff0f6",
+        missing: "#ff6b6b",
+    };
+    for (const node of graph.nodes) {
+        const label = node.label.replace(/"/g, "'");
+        lines.push(`  "${node.id}" [label="${label}", style="rounded,filled", fillcolor="${fill[node.type] || "#ffffff"}"];`);
+    }
+    for (const edge of graph.edges) {
+        lines.push(`  "${edge.from}" -> "${edge.to}" [label="${edge.kind}"];`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function emitGraph(pack, opts) {
+    const graph = buildPackGraph(pack);
+    const rendered = opts.graphFormat === "dot" ? renderDot(graph) : renderMermaid(graph);
+    process.stdout.write(rendered + "\n");
+    if (graph.broken.length > 0) {
+        logError(`Pack '${opts.packId}' has ${graph.broken.length} dangling reference(s):`);
+        for (const b of graph.broken) {
+            logError(`  ${b.from} references unknown ${b.kind}: ${b.ref}`);
+        }
+        process.exit(1);
+    }
+    process.exit(0);
+}
+class LintPackCommand extends command_1.BaseCommand {
+    execute() {
+        const rawArgs = this.args[0] === "pack" ? this.args.slice(1) : this.args;
+        const args = rawArgs[0] === "lint" ? rawArgs.slice(1) : rawArgs;
+        const opts = parseArgs(args);
+        const io = (0, agent_1.agentIo)(opts.json);
+        if (!opts.packRoot || !opts.packId) {
+            if (!io.json)
+                usage();
+            io.usage(NULL_SHAPE, [
+                (0, diagnostics_1.error)("pack_args_required", "--pack-root and --pack are required.", {
+                    fix: "specgate pack lint --pack-root <path> --pack <domain/type>",
+                }),
+            ]);
+            return;
+        }
+        let loadResult;
+        try {
+            loadResult = (0, DiskPackRepository_1.loadPack)(opts.packRoot, opts.packId);
+        }
+        catch (err) {
+            io.fail({ ...NULL_SHAPE, pack: opts.packId }, [
+                (0, diagnostics_1.error)("pack_load_failed", `Failed to load pack: ${err.message}`, {
+                    target: opts.packId,
+                    fix: "Check --pack-root points at the directory that contains the pack, and --pack at its id.",
+                }),
+            ]);
+            return;
+        }
+        const { pack, packRoot } = loadResult;
+        if (opts.graph) {
+            if (io.json) {
+                const graph = buildPackGraph(pack);
+                const rendered = opts.graphFormat === "dot" ? renderDot(graph) : renderMermaid(graph);
+                io.emitAndGate({
+                    pack: opts.packId,
+                    packRoot,
+                    format: opts.graphFormat,
+                    graph: rendered,
+                    status: graph.broken.map((b) => (0, diagnostics_1.error)("pack_graph_dangling_reference", `${b.from} references unknown ${b.kind}: ${b.ref}`, {
+                        target: b.from,
+                        fix: `Define ${b.ref}, or remove the reference from ${b.from}.`,
+                    })),
+                });
+                return;
+            }
+            emitGraph(pack, opts);
+            return;
+        }
+        const { errors, warnings } = runLint(pack, packRoot, { strict: opts.strict });
+        const status = [
+            ...warnings.map((w) => (0, diagnostics_1.warning)("pack_lint_warning", w, { target: opts.packId })),
+            ...errors.map((e) => (0, diagnostics_1.error)("pack_lint_error", e, { target: opts.packId })),
+        ];
+        io.emitAndGate({ pack: opts.packId, packRoot, graph: null, status }, () => {
+            for (const w of warnings)
+                logWarn(w);
+            for (const e of errors)
+                logError(e);
+            if (errors.length === 0 && warnings.length === 0) {
+                logInfo(`Pack '${opts.packId}' passed all lint checks.`);
+            }
+            else if (errors.length === 0) {
+                logInfo(`Pack '${opts.packId}' has ${warnings.length} warning(s) but no errors.`);
+            }
+            else {
+                logError(`Pack '${opts.packId}' failed lint with ${errors.length} error(s).`);
+            }
+        });
+        process.exit(0);
+    }
+}
+exports.LintPackCommand = LintPackCommand;
+//# sourceMappingURL=LintPackCommand.js.map