@onboardingiq/delivery-model-validator 0.0.1

package/README.md

@@ -0,0 +1,29 @@
+# Delivery Model Validator
+
+Local validation CLI for delivery model repositories used by OnboardingIQ.
+
+## Install
+
+```bash
+npm i -g @onboardingiq/delivery-model-validator
+```
+
+## Usage
+
+```bash
+delivery-model-validator "/path/to/delivery-model-root"
+```
+
+Examples:
+
+```bash
+delivery-model-validator "/Users/john/.../celeritas-delivery-model"
+delivery-model-validator "C:\\Users\\john\\...\\celeritas-delivery-model"
+```
+
+## Exit Codes
+
+- `0`: validation passed
+- `1`: validation failed
+- `2`: CLI/runtime error (bad path, unreadable files, exception)
+

package/dist/cli.d.ts

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

package/dist/cli.d.ts.map

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

package/dist/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+const validateDeliveryModel_1 = require("./validateDeliveryModel");
+const formatValidationOutput_1 = require("./formatValidationOutput");
+function printUsage() {
+    console.log("Usage: delivery-model-validator <path-to-delivery-model-root>");
+    console.log("Options: --debug");
+}
+async function main() {
+    const rawArgs = process.argv.slice(2).filter(Boolean);
+    const debugFlag = rawArgs.includes("--debug");
+    const debugEnv = process.env.DEBUG === "1";
+    const debug = debugFlag || debugEnv;
+    const args = rawArgs.filter((arg) => arg !== "--debug");
+    const inputPath = args[0];
+    if (!inputPath || inputPath === "--help" || inputPath === "-h") {
+        printUsage();
+        process.exit(inputPath ? 0 : 2);
+    }
+    const modelRoot = node_path_1.default.resolve(inputPath);
+    try {
+        const info = await (0, promises_1.stat)(modelRoot);
+        if (!info.isDirectory()) {
+            console.error(`Path is not a directory: ${modelRoot}`);
+            process.exit(2);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unable to read path";
+        console.error(`Unable to access path: ${modelRoot}`);
+        console.error(message);
+        process.exit(2);
+    }
+    const result = await (0, validateDeliveryModel_1.validateDeliveryModelAtPath)({
+        modelRoot,
+        repo: modelRoot,
+        branch: "local",
+        debug,
+    });
+    const formatted = (0, formatValidationOutput_1.formatValidationOutput)(result);
+    process.stdout.write(formatted.text + "\n");
+    process.exit(formatted.exitCode);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(message);
+    process.exit(2);
+});

package/dist/formatValidationOutput.d.ts

@@ -0,0 +1,9 @@
+import type { DeliveryModelValidationResponse } from "./validateDeliveryModel";
+export type FormattedValidationOutput = {
+    exitCode: 0 | 1;
+    text: string;
+};
+export declare function formatValidationOutput(result: DeliveryModelValidationResponse, opts?: {
+    showResolvedPath?: boolean;
+}): FormattedValidationOutput;
+//# sourceMappingURL=formatValidationOutput.d.ts.map

package/dist/formatValidationOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatValidationOutput.d.ts","sourceRoot":"","sources":["../src/formatValidationOutput.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAE/E,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAOF,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,+BAA+B,EACvC,IAAI,CAAC,EAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACpC,yBAAyB,CA6C3B"}

package/dist/formatValidationOutput.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatValidationOutput = formatValidationOutput;
+const node_path_1 = __importDefault(require("node:path"));
+function line(status, label) {
+    const tag = status === "ok" ? "[OK]" : "[FAIL]";
+    return `${tag} ${label}`;
+}
+function formatValidationOutput(result, opts) {
+    const lines = [];
+    lines.push("");
+    lines.push(`Delivery model: ${result.modelId ?? "unknown"}`);
+    lines.push(`Version: ${result.version ?? "unknown"}`);
+    if (opts?.showResolvedPath) {
+        lines.push(`Path: ${node_path_1.default.resolve(result.modelPath)}`);
+    }
+    lines.push("");
+    const modelSpecOk = !result.errors.some((e) => e.includes("model-spec.yaml not found") || e.includes("model-spec.yaml parse failed"));
+    lines.push(line(modelSpecOk ? "ok" : "fail", "model-spec.yaml"));
+    const phasesOk = result.phases.length > 0
+        && !result.errors.some((e) => e.includes("Duplicate phase") || e.includes("phases["));
+    lines.push(line(phasesOk ? "ok" : "fail", `phases (${result.phases.length})`));
+    lines.push(line(result.taskErrors.length === 0 ? "ok" : "fail", `tasks (${result.taskCount})`));
+    lines.push(line(result.canonErrors.length === 0 ? "ok" : "fail", `canon (${result.canonCount})`));
+    if (result.warnings.length) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const w of result.warnings)
+            lines.push(`- ${w}`);
+    }
+    if (result.errors.length) {
+        lines.push("");
+        lines.push("Errors:");
+        for (const e of result.errors)
+            lines.push(`- ${e}`);
+    }
+    lines.push("");
+    if (result.status === "ok" && result.errors.length === 0) {
+        lines.push("Validation passed.");
+        return { exitCode: 0, text: lines.join("\n") };
+    }
+    lines.push("Validation failed.");
+    return { exitCode: 1, text: lines.join("\n") };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { validateDeliveryModelAtPath } from "./validateDeliveryModel";
+export type { DeliveryModelValidationResponse } from "./validateDeliveryModel";
+//# 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,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,YAAY,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDeliveryModelAtPath = void 0;
+var validateDeliveryModel_1 = require("./validateDeliveryModel");
+Object.defineProperty(exports, "validateDeliveryModelAtPath", { enumerable: true, get: function () { return validateDeliveryModel_1.validateDeliveryModelAtPath; } });

package/dist/validateDeliveryModel.d.ts

@@ -0,0 +1,29 @@
+type ParsedPhase = {
+    id: string | null;
+    sequence: number | null;
+};
+export type DeliveryModelValidationResponse = {
+    status: "ok" | "error";
+    repo: string;
+    branch: string;
+    modelPath: string;
+    modelId: string | null;
+    version: string | null;
+    modelType: string | null;
+    phases: ParsedPhase[];
+    taskCount: number;
+    canonCount: number;
+    taskErrors: string[];
+    canonErrors: string[];
+    errors: string[];
+    warnings: string[];
+};
+export declare function validateDeliveryModelAtPath(params: {
+    modelRoot: string;
+    repo: string;
+    branch: string;
+    warnings?: string[];
+    debug?: boolean;
+}): Promise<DeliveryModelValidationResponse>;
+export {};
+//# sourceMappingURL=validateDeliveryModel.d.ts.map

package/dist/validateDeliveryModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateDeliveryModel.d.ts","sourceRoot":"","sources":["../src/validateDeliveryModel.ts"],"names":[],"mappings":"AAKA,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AA0BF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAmKF,wBAAsB,2BAA2B,CAAC,MAAM,EAAE;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAyL3C"}

package/dist/validateDeliveryModel.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDeliveryModelAtPath = validateDeliveryModelAtPath;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+function phaseSummary(phases) {
+    if (!Array.isArray(phases))
+        return [];
+    return phases.map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return { id: null, sequence: null };
+        }
+        const row = entry;
+        return {
+            id: typeof row.id === "string" && row.id.trim() ? row.id.trim() : null,
+            sequence: typeof row.sequence === "number" ? row.sequence : null,
+        };
+    });
+}
+function asNonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function duplicateValues(values) {
+    const counts = new Map();
+    for (const value of values) {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .filter(([, count]) => count > 1)
+        .map(([value]) => value);
+}
+async function walkFiles(root) {
+    const entries = await (0, promises_1.readdir)(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function parseTasks(tasksRoot, debug) {
+    const taskErrors = [];
+    const tasks = [];
+    let files = [];
+    try {
+        files = (await walkFiles(tasksRoot)).filter((file) => file.toLowerCase().endsWith(".md"));
+    }
+    catch {
+        taskErrors.push(`Tasks directory not found: ${tasksRoot}`);
+        return { taskCount: 0, tasks, taskErrors };
+    }
+    debugLog(debug, "[git-validate] tasks discovered", { taskCount: files.length, tasksRoot });
+    for (const filePath of files) {
+        try {
+            const raw = await (0, promises_1.readFile)(filePath, "utf8");
+            const frontmatter = (0, gray_matter_1.default)(raw).data;
+            const id = asNonEmptyString(frontmatter.id);
+            const title = asNonEmptyString(frontmatter.title);
+            const phase = asNonEmptyString(frontmatter.phase);
+            const canonRefs = [];
+            const canonField = frontmatter.canon;
+            if (canonField !== undefined) {
+                if (!Array.isArray(canonField)) {
+                    taskErrors.push(`Task ${filePath} has invalid canon field: expected array`);
+                }
+                else {
+                    for (const item of canonField) {
+                        const ref = asNonEmptyString(item);
+                        if (!ref) {
+                            taskErrors.push(`Task ${filePath} has invalid canon entry: expected non-empty string`);
+                        }
+                        else {
+                            canonRefs.push(ref);
+                        }
+                    }
+                }
+            }
+            if (!id)
+                taskErrors.push(`Task ${filePath} is missing required field: id`);
+            if (!title)
+                taskErrors.push(`Task ${filePath} is missing required field: title`);
+            if (!phase)
+                taskErrors.push(`Task ${filePath} is missing required field: phase`);
+            tasks.push({ id, title, phase, canonRefs, filePath });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown parse error";
+            taskErrors.push(`Task ${filePath} parse failed: ${message}`);
+        }
+    }
+    const duplicateTaskIds = duplicateValues(tasks.map((task) => task.id).filter((id) => Boolean(id)));
+    if (duplicateTaskIds.length > 0) {
+        debugLog(debug, "[git-validate] duplicate task ids", { duplicateTaskIds });
+        for (const duplicateId of duplicateTaskIds) {
+            taskErrors.push(`Duplicate task id found: ${duplicateId}`);
+        }
+    }
+    return { taskCount: files.length, tasks, taskErrors };
+}
+async function parseCanon(canonRoot, debug) {
+    const canonErrors = [];
+    const canonAssets = [];
+    let files = [];
+    try {
+        files = await walkFiles(canonRoot);
+    }
+    catch {
+        canonErrors.push(`Canon directory not found: ${canonRoot}`);
+        return { canonCount: 0, canonAssets, canonErrors };
+    }
+    debugLog(debug, "[git-validate] canon discovered", { canonCount: files.length, canonRoot });
+    for (const filePath of files) {
+        try {
+            const raw = await (0, promises_1.readFile)(filePath, "utf8");
+            const frontmatter = (0, gray_matter_1.default)(raw).data;
+            const id = asNonEmptyString(frontmatter.id);
+            const title = asNonEmptyString(frontmatter.title);
+            const summary = asNonEmptyString(frontmatter.summary);
+            const assetType = asNonEmptyString(frontmatter.asset_type);
+            if (!id)
+                canonErrors.push(`Canon ${filePath} is missing required field: id`);
+            if (!title)
+                canonErrors.push(`Canon ${filePath} is missing required field: title`);
+            if (!summary)
+                canonErrors.push(`Canon ${filePath} is missing required field: summary`);
+            if (!assetType)
+                canonErrors.push(`Canon ${filePath} is missing required field: asset_type`);
+            canonAssets.push({ id, title, summary, assetType, filePath });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown parse error";
+            canonErrors.push(`Canon ${filePath} parse failed: ${message}`);
+        }
+    }
+    const duplicateCanonIds = duplicateValues(canonAssets.map((asset) => asset.id).filter((id) => Boolean(id)));
+    if (duplicateCanonIds.length > 0) {
+        debugLog(debug, "[git-validate] duplicate canon ids", { duplicateCanonIds });
+        for (const duplicateId of duplicateCanonIds) {
+            canonErrors.push(`Duplicate canon id found: ${duplicateId}`);
+        }
+    }
+    return { canonCount: files.length, canonAssets, canonErrors };
+}
+async function validateDeliveryModelAtPath(params) {
+    const errors = [];
+    const warnings = [...(params.warnings ?? [])];
+    const taskErrors = [];
+    const canonErrors = [];
+    const debug = Boolean(params.debug);
+    const modelRoot = params.modelRoot;
+    const modelSpecPath = node_path_1.default.join(modelRoot, "model-spec.yaml");
+    const tasksRoot = node_path_1.default.join(modelRoot, "tasks");
+    const canonRoot = node_path_1.default.join(modelRoot, "canon");
+    debugLog(debug, "[git-validate] resolved paths", { modelRoot, tasksRoot, canonRoot });
+    let modelSpecRaw = "";
+    try {
+        modelSpecRaw = await (0, promises_1.readFile)(modelSpecPath, "utf8");
+        debugLog(debug, "[git-validate] model-spec found", { modelSpecPath });
+    }
+    catch {
+        debugLog(debug, "[git-validate] model-spec not found", { modelSpecPath });
+        return {
+            status: "error",
+            repo: params.repo,
+            branch: params.branch,
+            modelPath: modelRoot,
+            modelId: null,
+            version: null,
+            modelType: null,
+            phases: [],
+            taskCount: 0,
+            canonCount: 0,
+            taskErrors,
+            canonErrors,
+            errors: [`model-spec.yaml not found at ${modelSpecPath}`],
+            warnings,
+        };
+    }
+    let spec = null;
+    try {
+        const parsed = js_yaml_1.default.load(modelSpecRaw);
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error("YAML root must be an object");
+        }
+        spec = parsed;
+        debugLog(debug, "[git-validate] parse success", { modelSpecPath });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+        debugLog(debug, "[git-validate] parse failure", { modelSpecPath, error: message });
+        return {
+            status: "error",
+            repo: params.repo,
+            branch: params.branch,
+            modelPath: modelRoot,
+            modelId: null,
+            version: null,
+            modelType: null,
+            phases: [],
+            taskCount: 0,
+            canonCount: 0,
+            taskErrors,
+            canonErrors,
+            errors: [`model-spec.yaml parse failed: ${message}`],
+            warnings,
+        };
+    }
+    if (!spec) {
+        return {
+            status: "error",
+            repo: params.repo,
+            branch: params.branch,
+            modelPath: modelRoot,
+            modelId: null,
+            version: null,
+            modelType: null,
+            phases: [],
+            taskCount: 0,
+            canonCount: 0,
+            taskErrors,
+            canonErrors,
+            errors: ["model-spec.yaml parse failed: parser returned no data"],
+            warnings,
+        };
+    }
+    const modelId = typeof spec.id === "string" && spec.id.trim() ? spec.id.trim() : null;
+    const version = typeof spec.version === "string"
+        ? spec.version
+        : typeof spec.version === "number"
+            ? String(spec.version)
+            : null;
+    const modelType = typeof spec.model_type === "string"
+        ? spec.model_type
+        : typeof spec.type === "string"
+            ? spec.type
+            : null;
+    const phases = phaseSummary(spec.phases);
+    if (!modelId)
+        errors.push("model-spec.yaml is missing required field: id");
+    if (!version)
+        errors.push("model-spec.yaml is missing required field: version");
+    if (!Array.isArray(spec.phases) || spec.phases.length === 0) {
+        errors.push("model-spec.yaml is missing required field: phases (non-empty list)");
+    }
+    else {
+        phases.forEach((phase, index) => {
+            if (!phase.id)
+                errors.push(`phases[${index}] is missing required field: id`);
+            if (phase.sequence === null)
+                errors.push(`phases[${index}] is missing required field: sequence`);
+        });
+    }
+    const duplicatePhaseIds = duplicateValues(phases.map((phase) => phase.id).filter((id) => Boolean(id)));
+    if (duplicatePhaseIds.length > 0) {
+        debugLog(debug, "[git-validate] duplicate phase ids", { duplicatePhaseIds });
+        for (const duplicateId of duplicatePhaseIds) {
+            errors.push(`Duplicate phase id found: ${duplicateId}`);
+        }
+    }
+    const duplicatePhaseSequences = duplicateValues(phases
+        .map((phase) => phase.sequence)
+        .filter((value) => value !== null)
+        .map((value) => String(value)));
+    if (duplicatePhaseSequences.length > 0) {
+        debugLog(debug, "[git-validate] duplicate phase sequences", { duplicatePhaseSequences });
+        for (const duplicateSequence of duplicatePhaseSequences) {
+            errors.push(`Duplicate phase sequence found: ${duplicateSequence}`);
+        }
+    }
+    const { taskCount, tasks, taskErrors: parsedTaskErrors } = await parseTasks(tasksRoot, debug);
+    const { canonCount, canonAssets, canonErrors: parsedCanonErrors } = await parseCanon(canonRoot, debug);
+    taskErrors.push(...parsedTaskErrors);
+    canonErrors.push(...parsedCanonErrors);
+    const validPhaseIds = new Set(phases.map((phase) => phase.id).filter((id) => Boolean(id)));
+    const validCanonIds = new Set(canonAssets.map((asset) => asset.id).filter((id) => Boolean(id)));
+    const invalidPhaseRefs = [];
+    const brokenCanonRefs = [];
+    for (const task of tasks) {
+        if (task.phase && !validPhaseIds.has(task.phase)) {
+            invalidPhaseRefs.push(`${task.id ?? task.filePath} -> ${task.phase}`);
+            taskErrors.push(`Task ${task.id ?? task.filePath} references unknown phase: ${task.phase}`);
+        }
+        for (const canonRef of task.canonRefs) {
+            if (!validCanonIds.has(canonRef)) {
+                brokenCanonRefs.push(`${task.id ?? task.filePath} -> ${canonRef}`);
+                taskErrors.push(`Task ${task.id ?? task.filePath} references unknown canon id: ${canonRef}`);
+            }
+        }
+    }
+    if (invalidPhaseRefs.length > 0) {
+        debugLog(debug, "[git-validate] invalid phase references", { invalidPhaseRefs });
+    }
+    if (brokenCanonRefs.length > 0) {
+        debugLog(debug, "[git-validate] broken canon references", { brokenCanonRefs });
+    }
+    errors.push(...taskErrors, ...canonErrors);
+    return {
+        status: errors.length ? "error" : "ok",
+        repo: params.repo,
+        branch: params.branch,
+        modelPath: modelRoot,
+        modelId,
+        version,
+        modelType,
+        phases,
+        taskCount,
+        canonCount,
+        taskErrors,
+        canonErrors,
+        errors,
+        warnings,
+    };
+}
+function debugLog(enabled, ...args) {
+    if (!enabled)
+        return;
+    // Keep the existing logging shape/prefixes; only gate output.
+    try {
+        console.error(...args);
+    }
+    catch (error) {
+        // If output is being piped and the reader closes early (e.g. `| head`), ignore EPIPE.
+        if (typeof error === "object" && error && error.code === "EPIPE")
+            return;
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@onboardingiq/delivery-model-validator",
+  "version": "0.0.1",
+  "description": "Local validation CLI for OnboardingIQ delivery model repositories (model-spec, phases, tasks, canon).",
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "delivery-model-validator": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/postbuild.mjs",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}