@mortice/mapwright 0.8.0

package/dist/catalogue/store.d.ts

@@ -0,0 +1,41 @@
+import type { CatalogueSnapshot } from "./schema.js";
+export declare const OUTPUT_FILES: {
+    readonly catalogue: "catalogue.json";
+    readonly files: "files.json";
+    readonly packages: "packages.json";
+    readonly capabilities: "capabilities.json";
+    readonly publicApis: "public-apis.json";
+    readonly examples: "examples.json";
+    readonly symbols: "symbols.json";
+    readonly relationships: "relationships.json";
+    readonly tests: "tests.json";
+    readonly diagnostics: "diagnostics.json";
+    readonly lock: "catalogue.lock.json";
+};
+/** Schema versions this generator can load without migration. Schema 1 is rejected with upgrade_required. */
+export declare const SUPPORTED_SCHEMA_VERSIONS: readonly [2];
+export declare const CURRENT_SCHEMA_VERSION = 2;
+export declare const SUPPORTED_IDENTITY_SCHEMES: readonly ["stable-sha256-v1"];
+export type CommittedCatalogueErrorCode = "committed_catalogue_not_found" | "committed_catalogue_invalid" | "catalogue_schema_unsupported" | "catalogue_lock_mismatch" | "catalogue_upgrade_required" | "catalogue_identity_scheme_unsupported";
+export interface CommittedCatalogueError {
+    code: CommittedCatalogueErrorCode;
+    message: string;
+}
+export type LoadCommittedCatalogueResult = {
+    ok: true;
+    snapshot: CatalogueSnapshot;
+    warnings: string[];
+} | {
+    ok: false;
+    error: CommittedCatalogueError;
+};
+export declare function writeSnapshot(workspaceRoot: string, catalogueDir: string, snapshot: CatalogueSnapshot, pretty?: boolean): void;
+/**
+ * Load a committed catalogue without indexing source.
+ * Fails clearly for missing, corrupt, unsupported, or mismatched snapshots.
+ * Schema 1 → catalogue_upgrade_required. Unknown identityScheme → catalogue_identity_scheme_unsupported.
+ */
+export declare function loadCommittedCatalogue(workspaceRoot: string, catalogueDir: string): LoadCommittedCatalogueResult;
+/** @deprecated Prefer loadCommittedCatalogue for explicit error handling. */
+export declare function readCommittedSnapshot(workspaceRoot: string, catalogueDir: string): CatalogueSnapshot | undefined;
+export declare function computeCatalogueId(snapshot: Omit<CatalogueSnapshot, "catalogueId">): string;

package/dist/catalogue/store.js

@@ -0,0 +1,209 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { stableStringify, hashContent } from "./deterministic.js";
+import { MAPWRIGHT_GENERATOR_NAME, MAPWRIGHT_GENERATOR_VERSION } from "./version.js";
+import { IDENTITY_SCHEME } from "./identity.js";
+export const OUTPUT_FILES = {
+    catalogue: "catalogue.json",
+    files: "files.json",
+    packages: "packages.json",
+    capabilities: "capabilities.json",
+    publicApis: "public-apis.json",
+    examples: "examples.json",
+    symbols: "symbols.json",
+    relationships: "relationships.json",
+    tests: "tests.json",
+    diagnostics: "diagnostics.json",
+    lock: "catalogue.lock.json"
+};
+/** Schema versions this generator can load without migration. Schema 1 is rejected with upgrade_required. */
+export const SUPPORTED_SCHEMA_VERSIONS = [2];
+export const CURRENT_SCHEMA_VERSION = 2;
+export const SUPPORTED_IDENTITY_SCHEMES = [IDENTITY_SCHEME];
+export function writeSnapshot(workspaceRoot, catalogueDir, snapshot, pretty = true) {
+    const root = path.resolve(workspaceRoot, catalogueDir);
+    mkdirSync(root, { recursive: true });
+    writeJson(path.join(root, OUTPUT_FILES.catalogue), snapshot, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.files), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.files }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.packages), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.packages }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.capabilities), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.capabilities }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.publicApis), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.publicApis }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.examples), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.examples }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.symbols), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.symbols }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.relationships), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.relationships }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.tests), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.tests }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.diagnostics), { schemaVersion: CURRENT_SCHEMA_VERSION, items: snapshot.diagnostics }, pretty);
+    writeJson(path.join(root, OUTPUT_FILES.lock), { schemaVersion: CURRENT_SCHEMA_VERSION, catalogueId: snapshot.catalogueId }, pretty);
+}
+/**
+ * Load a committed catalogue without indexing source.
+ * Fails clearly for missing, corrupt, unsupported, or mismatched snapshots.
+ * Schema 1 → catalogue_upgrade_required. Unknown identityScheme → catalogue_identity_scheme_unsupported.
+ */
+export function loadCommittedCatalogue(workspaceRoot, catalogueDir) {
+    const root = path.resolve(workspaceRoot, catalogueDir);
+    const cataloguePath = path.join(root, OUTPUT_FILES.catalogue);
+    const lockPath = path.join(root, OUTPUT_FILES.lock);
+    if (!existsSync(cataloguePath)) {
+        return {
+            ok: false,
+            error: {
+                code: "committed_catalogue_not_found",
+                message: `No committed catalogue found in ${catalogueDir}.`
+            }
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(cataloguePath, "utf8"));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: "committed_catalogue_invalid",
+                message: `Committed catalogue exists but cannot be parsed: ${String(error)}`
+            }
+        };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            error: {
+                code: "committed_catalogue_invalid",
+                message: "Committed catalogue JSON must be an object."
+            }
+        };
+    }
+    const record = parsed;
+    const schemaVersion = record.schemaVersion;
+    if (schemaVersion === undefined || schemaVersion === null) {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_upgrade_required",
+                message: `Committed catalogue is missing schemaVersion. Regenerate with Mapwright ${MAPWRIGHT_GENERATOR_VERSION} (supported schema versions: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}).`
+            }
+        };
+    }
+    if (typeof schemaVersion !== "number" || !Number.isFinite(schemaVersion)) {
+        return {
+            ok: false,
+            error: {
+                code: "committed_catalogue_invalid",
+                message: "Committed catalogue schemaVersion must be a number."
+            }
+        };
+    }
+    if (schemaVersion === 1) {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_upgrade_required",
+                message: `Committed catalogue schemaVersion 1 is no longer supported. Regenerate the catalogue with Mapwright ${MAPWRIGHT_GENERATOR_VERSION} (schema ${CURRENT_SCHEMA_VERSION}, identityScheme ${IDENTITY_SCHEME}).`
+            }
+        };
+    }
+    if (schemaVersion > CURRENT_SCHEMA_VERSION) {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_schema_unsupported",
+                message: `Committed catalogue schemaVersion ${schemaVersion} is newer than supported versions (${SUPPORTED_SCHEMA_VERSIONS.join(", ")}). Upgrade Mapwright or regenerate with a compatible generator.`
+            }
+        };
+    }
+    if (!SUPPORTED_SCHEMA_VERSIONS.includes(schemaVersion)) {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_upgrade_required",
+                message: `Committed catalogue schemaVersion ${schemaVersion} is no longer supported. Regenerate with Mapwright ${MAPWRIGHT_GENERATOR_VERSION}.`
+            }
+        };
+    }
+    const identityScheme = record.identityScheme;
+    if (identityScheme === undefined || identityScheme === null || identityScheme === "") {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_identity_scheme_unsupported",
+                message: `Committed catalogue is missing identityScheme. Supported schemes: ${SUPPORTED_IDENTITY_SCHEMES.join(", ")}. Regenerate with Mapwright ${MAPWRIGHT_GENERATOR_VERSION}.`
+            }
+        };
+    }
+    if (typeof identityScheme !== "string" || !SUPPORTED_IDENTITY_SCHEMES.includes(identityScheme)) {
+        return {
+            ok: false,
+            error: {
+                code: "catalogue_identity_scheme_unsupported",
+                message: `Committed catalogue identityScheme "${String(identityScheme)}" is not supported. Supported schemes: ${SUPPORTED_IDENTITY_SCHEMES.join(", ")}.`
+            }
+        };
+    }
+    if (typeof record.catalogueId !== "string" || !record.catalogueId) {
+        return {
+            ok: false,
+            error: {
+                code: "committed_catalogue_invalid",
+                message: "Committed catalogue is missing catalogueId."
+            }
+        };
+    }
+    const warnings = [];
+    const generator = record.generator;
+    if (generator && typeof generator === "object" && !Array.isArray(generator)) {
+        const generatorRecord = generator;
+        const name = generatorRecord.name;
+        const version = generatorRecord.version;
+        if (typeof name === "string" && name !== MAPWRIGHT_GENERATOR_NAME) {
+            warnings.push(`Catalogue generator name "${name}" differs from current "${MAPWRIGHT_GENERATOR_NAME}".`);
+        }
+        if (typeof version === "string" && version !== MAPWRIGHT_GENERATOR_VERSION) {
+            warnings.push(`Catalogue generator version "${version}" differs from current "${MAPWRIGHT_GENERATOR_VERSION}". Reload remains allowed for schemaVersion ${schemaVersion}; regenerate if query results look stale.`);
+        }
+    }
+    else {
+        warnings.push("Catalogue is missing generator metadata.");
+    }
+    if (existsSync(lockPath)) {
+        try {
+            const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+            if (typeof lock.catalogueId === "string" && lock.catalogueId !== record.catalogueId) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "catalogue_lock_mismatch",
+                        message: `catalogue.lock.json catalogueId ${lock.catalogueId} does not match catalogue.json ${record.catalogueId}.`
+                    }
+                };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: {
+                    code: "committed_catalogue_invalid",
+                    message: `catalogue.lock.json exists but cannot be parsed: ${String(error)}`
+                }
+            };
+        }
+    }
+    return {
+        ok: true,
+        snapshot: parsed,
+        warnings
+    };
+}
+/** @deprecated Prefer loadCommittedCatalogue for explicit error handling. */
+export function readCommittedSnapshot(workspaceRoot, catalogueDir) {
+    const result = loadCommittedCatalogue(workspaceRoot, catalogueDir);
+    return result.ok ? result.snapshot : undefined;
+}
+export function computeCatalogueId(snapshot) {
+    const payload = stableStringify(snapshot, false);
+    return hashContent(payload);
+}
+function writeJson(filePath, payload, pretty) {
+    writeFileSync(filePath, stableStringify(payload, pretty), "utf8");
+}

package/dist/catalogue/templates.d.ts

@@ -0,0 +1,18 @@
+import type { DocumentationTemplateId } from "../queries/adoption.js";
+export type TemplateSurface = "markdown" | "typescript" | "python" | "test" | "generic";
+export interface TemplateMetadata {
+    templateId: DocumentationTemplateId;
+    title: string;
+    description: string;
+    surface: TemplateSurface;
+}
+export interface TemplateResult {
+    templateId: DocumentationTemplateId;
+    title: string;
+    description: string;
+    surface: TemplateSurface;
+    content: string;
+}
+export declare function getDocumentationTemplate(templateId: DocumentationTemplateId): TemplateResult;
+export declare function listDocumentationTemplateIds(): DocumentationTemplateId[];
+export declare function listDocumentationTemplates(): TemplateMetadata[];

package/dist/catalogue/templates.js

@@ -0,0 +1,158 @@
+const TEMPLATE_CATALOGUE = {
+    "package-catalogue": {
+        templateId: "package-catalogue",
+        title: "Package CATALOGUE scaffold",
+        description: "Markdown scaffold for package metadata and one initial capability section.",
+        surface: "markdown",
+        content: [
+            "# Catalogue",
+            "",
+            "## Package",
+            "",
+            "Name: <package-name>",
+            "Purpose: TODO: Describe the package purpose.",
+            "Stability: unknown",
+            "",
+            "## Capability: TODO.capability-id",
+            "",
+            "Name: TODO capability name",
+            "Summary: TODO: Describe what this capability provides.",
+            "Stability: unknown",
+            "Intended use: TODO",
+            "",
+            "Public APIs:",
+            "- TODO",
+            "",
+            "Examples:",
+            "- TODO",
+            "",
+            "Tests:",
+            "- TODO",
+            "",
+            "Contracts:",
+            "- TODO",
+            "",
+            "Limitations:",
+            "- TODO",
+            ""
+        ].join("\n")
+    },
+    "capability-section": {
+        templateId: "capability-section",
+        title: "Capability section scaffold",
+        description: "Markdown capability section with conservative TODO placeholders.",
+        surface: "markdown",
+        content: [
+            "## Capability: TODO.capability-id",
+            "",
+            "Name: TODO capability name",
+            "Summary: TODO: Describe what this capability provides.",
+            "Stability: unknown",
+            "Intended use: TODO",
+            "",
+            "Public APIs:",
+            "- TODO",
+            "",
+            "Examples:",
+            "- TODO",
+            "",
+            "Tests:",
+            "- TODO",
+            "",
+            "Contracts:",
+            "- TODO",
+            "",
+            "Limitations:",
+            "- TODO",
+            ""
+        ].join("\n")
+    },
+    "typescript-public-api-jsdoc": {
+        templateId: "typescript-public-api-jsdoc",
+        title: "TypeScript public API JSDoc",
+        description: "JSDoc template for agent-facing public APIs in TypeScript or JavaScript.",
+        surface: "typescript",
+        content: [
+            "/**",
+            " * TODO: Describe what this public API does.",
+            " *",
+            " * @catalogue public-api",
+            " * @capability TODO.capability-id",
+            " * @stability unknown",
+            " * @intendedUse TODO",
+            " * @inputs TODO",
+            " * @returns TODO",
+            " * @contract TODO",
+            " * @example TODO",
+            " * @tests TODO",
+            " */",
+            ""
+        ].join("\n")
+    },
+    "python-public-api-docstring": {
+        templateId: "python-public-api-docstring",
+        title: "Python public API docstring",
+        description: "Docstring template for agent-facing public APIs in Python.",
+        surface: "python",
+        content: [
+            '"""',
+            "TODO: Describe what this public API does.",
+            "",
+            "@catalogue public-api",
+            "@capability TODO.capability-id",
+            "@stability unknown",
+            "@intendedUse TODO",
+            "@inputs TODO",
+            "@returns TODO",
+            "@contract TODO",
+            "@example TODO",
+            "@tests TODO",
+            '"""',
+            ""
+        ].join("\n")
+    },
+    "test-coverage-doc": {
+        templateId: "test-coverage-doc",
+        title: "Test coverage tags",
+        description: "Template comment for linking tests to capabilities and symbols.",
+        surface: "test",
+        content: [
+            "/**",
+            " * @catalogue test",
+            " * @coversCapability TODO.capability-id",
+            " * @coversSymbol TODO.symbol-name",
+            " * @contract TODO: Describe what behavior this test proves.",
+            " */",
+            ""
+        ].join("\n")
+    },
+    "example-reference": {
+        templateId: "example-reference",
+        title: "Example reference list",
+        description: "Metadata-only example references for capability or public API docs.",
+        surface: "generic",
+        content: [
+            "Examples:",
+            "- path/to/example.ts#anchor",
+            "- public-api:PublicApiName|path/to/example.md#anchor",
+            ""
+        ].join("\n")
+    }
+};
+export function getDocumentationTemplate(templateId) {
+    return TEMPLATE_CATALOGUE[templateId];
+}
+export function listDocumentationTemplateIds() {
+    return Object.keys(TEMPLATE_CATALOGUE).sort();
+}
+export function listDocumentationTemplates() {
+    return listDocumentationTemplateIds().map((templateId) => {
+        const template = TEMPLATE_CATALOGUE[templateId];
+        return {
+            templateId: template.templateId,
+            title: template.title,
+            description: template.description,
+            surface: template.surface
+        };
+    });
+}

package/dist/catalogue/version.d.ts

@@ -0,0 +1,12 @@
+/** Product display name. */
+export declare const MAPWRIGHT_PRODUCT_NAME = "Mortice Mapwright";
+/** Short product name. */
+export declare const MAPWRIGHT_NAME = "Mapwright";
+/**
+ * Generator name written into new catalogues: "mapwright".
+ * Compatible Schema 2 catalogues previously emitted generator.name "code-atlas" instead of "mapwright"; loaders accept both.
+ */
+export declare const MAPWRIGHT_GENERATOR_NAME = "mapwright";
+export declare const MAPWRIGHT_GENERATOR_VERSION: string;
+/** Generator names accepted when loading catalogues: current "mapwright" plus pre-release Code Atlas "code-atlas". */
+export declare const SUPPORTED_GENERATOR_NAMES: readonly ["mapwright", "code-atlas"];

package/dist/catalogue/version.js

@@ -0,0 +1,30 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Product display name. */
+export const MAPWRIGHT_PRODUCT_NAME = "Mortice Mapwright";
+/** Short product name. */
+export const MAPWRIGHT_NAME = "Mapwright";
+/**
+ * Generator name written into new catalogues: "mapwright".
+ * Compatible Schema 2 catalogues previously emitted generator.name "code-atlas" instead of "mapwright"; loaders accept both.
+ */
+export const MAPWRIGHT_GENERATOR_NAME = "mapwright";
+const FALLBACK_GENERATOR_VERSION = "0.0.0";
+export const MAPWRIGHT_GENERATOR_VERSION = resolveGeneratorVersion();
+/** Generator names accepted when loading catalogues: current "mapwright" plus pre-release Code Atlas "code-atlas". */
+export const SUPPORTED_GENERATOR_NAMES = ["mapwright", "code-atlas"];
+function resolveGeneratorVersion() {
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const packageJsonPath = path.resolve(currentDir, "../../package.json");
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (typeof parsed.version === "string" && parsed.version.trim()) {
+            return parsed.version.trim();
+        }
+    }
+    catch {
+        // Keep a stable fallback instead of throwing during indexing or server startup.
+    }
+    return FALLBACK_GENERATOR_VERSION;
+}

package/dist/cli/commands/adoptionPlan.d.ts

@@ -0,0 +1,8 @@
+export interface AdoptionPlanCommandOptions {
+    workspace: string;
+    config?: string;
+    includeInfo?: boolean;
+    includeGenerated?: boolean;
+    maxGaps?: number;
+}
+export declare function runAdoptionPlanCommand(options: AdoptionPlanCommandOptions): Record<string, unknown>;

package/dist/cli/commands/adoptionPlan.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { indexWorkspace } from "../../catalogue/indexer.js";
+import { getAdoptionPlan } from "../../queries/adoption.js";
+export function runAdoptionPlanCommand(options) {
+    const workspaceRoot = path.resolve(options.workspace);
+    const { snapshot } = indexWorkspace({
+        workspaceRoot,
+        configPath: options.config,
+        mode: "memory",
+        write: false
+    });
+    return {
+        ok: true,
+        data: getAdoptionPlan(snapshot, {
+            includeInfo: options.includeInfo,
+            includeGenerated: options.includeGenerated,
+            maxGaps: options.maxGaps
+        }),
+        warnings: [],
+        provenance: {
+            source: "mapwright"
+        }
+    };
+}

package/dist/cli/commands/auditDocs.d.ts

@@ -0,0 +1,8 @@
+export interface AuditDocsCommandOptions {
+    workspace: string;
+    config?: string;
+    includeInfo?: boolean;
+    includeGenerated?: boolean;
+    maxGaps?: number;
+}
+export declare function runAuditDocsCommand(options: AuditDocsCommandOptions): Record<string, unknown>;

package/dist/cli/commands/auditDocs.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { indexWorkspace } from "../../catalogue/indexer.js";
+import { getAdoptionAudit } from "../../queries/adoption.js";
+export function runAuditDocsCommand(options) {
+    const workspaceRoot = path.resolve(options.workspace);
+    const { snapshot } = indexWorkspace({
+        workspaceRoot,
+        configPath: options.config,
+        mode: "memory",
+        write: false
+    });
+    return {
+        ok: true,
+        data: getAdoptionAudit(snapshot, {
+            includeInfo: options.includeInfo,
+            includeGenerated: options.includeGenerated,
+            maxGaps: options.maxGaps
+        }),
+        warnings: [],
+        provenance: {
+            source: "mapwright"
+        }
+    };
+}

package/dist/cli/commands/changeImpact.d.ts

@@ -0,0 +1,10 @@
+export declare function runChangeImpactCommand(options: {
+    comparisonDir: string;
+    changeId?: string;
+    maxDepth?: number;
+    offset?: number;
+    limit?: number;
+}): {
+    output: Record<string, unknown>;
+    exitCode: number;
+};

package/dist/cli/commands/changeImpact.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { loadComparisonArtefact } from "../../comparison/store.js";
+import { getChangeImpact } from "../../queries/changes.js";
+export function runChangeImpactCommand(options) {
+    if (!options.comparisonDir) {
+        return {
+            output: { ok: false, error: { code: "usage_error", message: "--comparison-dir is required" } },
+            exitCode: 2
+        };
+    }
+    if (!options.changeId) {
+        return {
+            output: { ok: false, error: { code: "usage_error", message: "--change-id is required" } },
+            exitCode: 2
+        };
+    }
+    const loaded = loadComparisonArtefact(path.resolve(options.comparisonDir));
+    if (!loaded.ok) {
+        return {
+            output: { ok: false, error: loaded.error },
+            exitCode: loaded.error.code === "comparison_path_rejected" ? 4 : 3
+        };
+    }
+    const impact = getChangeImpact(loaded.comparison, options.changeId, {
+        maxDepth: options.maxDepth,
+        offset: options.offset,
+        limit: options.limit
+    });
+    if (!impact) {
+        return {
+            output: { ok: false, error: { code: "change_not_found", message: `Unknown changeId ${options.changeId}` } },
+            exitCode: 3
+        };
+    }
+    return { output: { ok: true, data: impact }, exitCode: 0 };
+}

package/dist/cli/commands/changes.d.ts

@@ -0,0 +1,12 @@
+import type { FailOn } from "./diff.js";
+export declare function runChangesCommand(options: {
+    comparisonDir: string;
+    domain?: string;
+    status?: string;
+    offset?: number;
+    limit?: number;
+    failOn?: FailOn;
+}): {
+    output: Record<string, unknown>;
+    exitCode: number;
+};

package/dist/cli/commands/changes.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { loadComparisonArtefact } from "../../comparison/store.js";
+import { listChanges } from "../../queries/changes.js";
+export function runChangesCommand(options) {
+    if (!options.comparisonDir) {
+        return {
+            output: { ok: false, error: { code: "usage_error", message: "--comparison-dir is required" } },
+            exitCode: 2
+        };
+    }
+    const loaded = loadComparisonArtefact(path.resolve(options.comparisonDir));
+    if (!loaded.ok) {
+        return { output: { ok: false, error: loaded.error }, exitCode: 3 };
+    }
+    const page = listChanges(loaded.comparison, {
+        domain: options.domain,
+        status: options.status,
+        offset: options.offset,
+        limit: options.limit
+    });
+    const failOn = options.failOn ?? "never";
+    const counts = loaded.comparison.manifest.counts;
+    const total = counts.added + counts.removed + counts.modified;
+    let exitCode = 0;
+    if (failOn === "any-change" && total > 0)
+        exitCode = 1;
+    if (failOn === "any-public-change" && loaded.comparison.changes.some((c) => c.domain === "publicApis" && c.status !== "unchanged")) {
+        exitCode = 1;
+    }
+    return { output: { ok: true, data: page }, exitCode };
+}

package/dist/cli/commands/check.d.ts

@@ -0,0 +1,9 @@
+export interface CheckCommandOptions {
+    workspace: string;
+    config?: string;
+    failOn?: "info" | "warning" | "error" | "never";
+}
+export declare function runCheckCommand(options: CheckCommandOptions): {
+    output: Record<string, unknown>;
+    exitCode: number;
+};

package/dist/cli/commands/check.js

@@ -0,0 +1,4 @@
+import { runValidateCommand } from "./validate.js";
+export function runCheckCommand(options) {
+    return runValidateCommand(options);
+}

package/dist/cli/commands/compatibility.d.ts

@@ -0,0 +1,10 @@
+import type { FailOn } from "./diff.js";
+export declare function runCompatibilityCommand(options: {
+    comparisonDir: string;
+    offset?: number;
+    limit?: number;
+    failOn?: FailOn;
+}): {
+    output: Record<string, unknown>;
+    exitCode: number;
+};