yarramate 0.1.0

package/dist/adapters/likec4-project.js

@@ -0,0 +1,176 @@
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { loadSourceDocument } from '../source-document.js';
+import { exportLikeC4, } from './likec4-export.js';
+import likeC4ProjectSchema from '../../schema/yarramate-likec4-project.schema.json' with {
+    type: 'json'
+};
+const Ajv2020 = Ajv2020Module.default;
+const validateLikeC4Project = new Ajv2020({ allErrors: true }).compile(likeC4ProjectSchema);
+export const loadLikeC4ProjectDefinition = (source) => loadSourceDocument(source, validateLikeC4Project, 'LikeC4 project');
+const quote = (value) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'").replaceAll('\n', '\\n')}'`;
+const unionProjection = (project, views) => ({
+    format: 'yarramate/projection-result/v1',
+    projection: `${project.id}@${project.version}`,
+    presentation: { title: project.title },
+    documents: [
+        ...new Map(views.flatMap(({ prepared }) => prepared.projection.documents.map((document) => [
+            document.id,
+            document,
+        ]))).values(),
+    ].sort((left, right) => left.id.localeCompare(right.id)),
+    subjects: [
+        ...new Map(views.flatMap(({ prepared }) => prepared.projection.subjects.map((subject) => [
+            subject.id,
+            subject,
+        ]))).values(),
+    ].sort((left, right) => left.id.localeCompare(right.id)),
+    claims: [
+        ...new Map(views.flatMap(({ prepared }) => prepared.projection.claims.map((claim) => [claim.id, claim]))).values(),
+    ].sort((left, right) => left.id.localeCompare(right.id)),
+});
+const viewBody = ({ id, prepared, dynamic, deployment, }) => {
+    const source = prepared.source;
+    const startToken = '\nviews {\n';
+    const start = source.indexOf(startToken);
+    const end = source.lastIndexOf('\n}\n');
+    const externalByNative = new Map(prepared.subjectMapping.mappings
+        .filter(({ type }) => type === 'concept')
+        .map(({ native, external }) => [native, external]));
+    const includedConcepts = prepared.projection.subjects
+        .filter(({ type }) => type === 'concept')
+        .flatMap(({ id }) => {
+        const external = externalByNative.get(id);
+        return external === undefined ? [] : [external];
+    })
+        .sort();
+    const includeRule = includedConcepts.length === 0
+        ? `    include * where metadata.yarramateId is '__yarramate_no_match__'`
+        : `    include ${includedConcepts.join(', ')}`;
+    const relationshipRules = prepared.projection.subjects
+        .filter(({ type }) => type === 'relationship')
+        .map(({ id }) => `    include * -> * where metadata.yarramateId is '${id}'`)
+        .sort();
+    if (deployment !== undefined) {
+        const roots = deployment.nodes
+            .filter(({ parent }) => parent === undefined)
+            .map(({ id }) => `${id}.**`)
+            .sort();
+        const viewId = id ?? prepared.projection.projection.split('@')[0];
+        return [
+            `  deployment view ${viewId} {`,
+            ...(prepared.projection.presentation?.title === undefined
+                ? []
+                : [`    title ${quote(prepared.projection.presentation.title)}`]),
+            ...(prepared.projection.presentation?.description === undefined
+                ? []
+                : [
+                    `    description ${quote(prepared.projection.presentation.description)}`,
+                ]),
+            `    include ${roots.join(', ')}`,
+            '    autoLayout LeftRight',
+            '  }',
+        ].join('\n');
+    }
+    if (dynamic !== undefined) {
+        const claimsById = new Map(prepared.projection.claims.map((claim) => [claim.id, claim]));
+        const lines = dynamic.steps.map((step) => {
+            const structural = claimsById.get(step.relationship);
+            const source = externalByNative.get(structural.subject);
+            const target = 'ref' in structural.object
+                ? externalByNative.get(structural.object.ref)
+                : '';
+            const declaredTitle = prepared.projection.claims.find((claim) => claim.subject === step.relationship &&
+                claim.predicate === 'yarramate/relationship/name' &&
+                'value' in claim.object);
+            const title = step.title ??
+                (declaredTitle !== undefined && 'value' in declaredTitle.object
+                    ? declaredTitle.object.value
+                    : undefined);
+            return `    ${source} -> ${target}${title === undefined ? '' : ` ${quote(title)}`}`;
+        });
+        const viewId = id ?? prepared.projection.projection.split('@')[0];
+        return [
+            `  dynamic view ${viewId} {`,
+            ...(prepared.projection.presentation?.title === undefined
+                ? []
+                : [`    title ${quote(prepared.projection.presentation.title)}`]),
+            ...(prepared.projection.presentation?.description === undefined
+                ? []
+                : [
+                    `    description ${quote(prepared.projection.presentation.description)}`,
+                ]),
+            ...lines,
+            '  }',
+        ].join('\n');
+    }
+    const membershipRules = [
+        includeRule,
+        '    exclude * -> *',
+        ...relationshipRules,
+    ].join('\n');
+    return source
+        .slice(start + startToken.length, end)
+        .replace(/^  view [A-Za-z_][A-Za-z0-9_-]* \{/, `  view ${id ?? prepared.projection.projection.split('@')[0]} {`)
+        .replace('    include *', membershipRules);
+};
+const deploymentBody = ({ deployment, prepared, }) => {
+    if (deployment === undefined)
+        return undefined;
+    const externalByNative = new Map(prepared.subjectMapping.mappings
+        .filter(({ type }) => type === 'concept')
+        .map(({ native, external }) => [native, external]));
+    const childrenByParent = new Map();
+    for (const node of deployment.nodes) {
+        childrenByParent.set(node.parent, [
+            ...(childrenByParent.get(node.parent) ?? []),
+            node,
+        ]);
+    }
+    const instancesByNode = new Map();
+    for (const instance of deployment.instances) {
+        instancesByNode.set(instance.node, [
+            ...(instancesByNode.get(instance.node) ?? []),
+            instance,
+        ]);
+    }
+    const renderNode = (node, indentation) => [
+        `${indentation}${node.kind} ${node.id} ${quote(node.name)} {`,
+        ...(childrenByParent.get(node.id) ?? [])
+            .slice()
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .flatMap((child) => renderNode(child, `${indentation}  `)),
+        ...(instancesByNode.get(node.id) ?? [])
+            .slice()
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((instance) => `${indentation}  ${instance.id} = instanceOf ${externalByNative.get(instance.subject)}`),
+        `${indentation}}`,
+    ];
+    return [
+        'deployment {',
+        ...(childrenByParent.get(undefined) ?? [])
+            .slice()
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .flatMap((node) => renderNode(node, '  ')),
+        '}',
+    ].join('\n');
+};
+export function exportLikeC4Project(project, views) {
+    const first = views[0];
+    if (first === undefined) {
+        throw new Error('LikeC4 project requires at least one view');
+    }
+    const model = exportLikeC4(unionProjection(project, views), first.prepared.subjectMapping, first.prepared.kindMapping);
+    if (!model.ok)
+        return model;
+    const startToken = '\nviews {\n';
+    const modelEnd = model.source.indexOf(startToken);
+    const deployments = views.flatMap((view) => {
+        const rendered = deploymentBody(view);
+        return rendered === undefined ? [] : [rendered];
+    });
+    const renderedViews = views.map(viewBody);
+    return {
+        ok: true,
+        source: `${model.source.slice(0, modelEnd)}${deployments.length === 0 ? '' : `\n${deployments.join('\n')}\n`}\nviews {\n${renderedViews.join('\n')}\n}\n`,
+    };
+}

package/dist/adapters/likec4.d.ts

@@ -0,0 +1,4 @@
+export { exportLikeC4, type LikeC4ExportDiagnostic, type LikeC4ExportOptions, type LikeC4ExportResult, } from './likec4-export.js';
+export { loadLikeC4KindMapping, type LikeC4KindEntry, type LikeC4KindMapping, type LikeC4KindMappingLoadResult, } from './likec4-kind-mapping.js';
+export { prepareLikeC4Export, type LikeC4PreparationDiagnostic, type LikeC4PreparationInput, type LikeC4PreparationResult, } from './likec4-prepare.js';
+export { exportLikeC4Project, loadLikeC4ProjectDefinition, type LikeC4ProjectDefinition, type PreparedLikeC4ProjectView, } from './likec4-project.js';

package/dist/adapters/likec4.js

@@ -0,0 +1,4 @@
+export { exportLikeC4, } from './likec4-export.js';
+export { loadLikeC4KindMapping, } from './likec4-kind-mapping.js';
+export { prepareLikeC4Export, } from './likec4-prepare.js';
+export { exportLikeC4Project, loadLikeC4ProjectDefinition, } from './likec4-project.js';

package/dist/architecture-state.d.ts

@@ -0,0 +1,22 @@
+import type { SemanticGraph } from './compiler.js';
+export interface StateComparison {
+    readonly format: 'yarramate/state-comparison/v1';
+    readonly from: string;
+    readonly to: string;
+    readonly added: SemanticGraph['subjects'];
+    readonly removed: SemanticGraph['subjects'];
+    readonly retained: SemanticGraph['subjects'];
+}
+export interface StateComparisonIssue {
+    readonly code: 'YMS101';
+    readonly message: string;
+    readonly state: string;
+}
+export type StateComparisonResult = {
+    readonly ok: true;
+    readonly comparison: StateComparison;
+} | {
+    readonly ok: false;
+    readonly issues: readonly StateComparisonIssue[];
+};
+export declare function compareArchitectureStates(graph: SemanticGraph, from: string, to: string): StateComparisonResult;

package/dist/architecture-state.js

@@ -0,0 +1,63 @@
+const references = (graph, subject, predicate) => graph.claims.flatMap((claim) => claim.subject === subject &&
+    claim.predicate === predicate &&
+    'ref' in claim.object
+    ? [claim.object.ref]
+    : []);
+export function compareArchitectureStates(graph, from, to) {
+    const architectureStates = new Set(graph.claims
+        .filter(({ predicate }) => predicate === 'yarramate/state/type')
+        .map(({ subject }) => subject));
+    const issues = [...new Set([from, to])]
+        .filter((state) => !architectureStates.has(state))
+        .map((state) => ({
+        code: 'YMS101',
+        message: `Architecture state "${state}" does not exist`,
+        state,
+    }));
+    if (issues.length > 0)
+        return { ok: false, issues };
+    const subjectsIn = (state) => {
+        const concepts = new Set(graph.subjects
+            .filter(({ id, type }) => type === 'concept' && !architectureStates.has(id))
+            .filter(({ id }) => {
+            const presence = references(graph, id, 'yarramate/state/present-in');
+            return presence.length === 0 || presence.includes(state);
+        })
+            .map(({ id }) => id));
+        const relationships = graph.subjects
+            .filter(({ type }) => type === 'relationship')
+            .filter(({ id }) => {
+            const structural = graph.claims.find((claim) => claim.id === id && 'ref' in claim.object);
+            if (structural === undefined || !('ref' in structural.object)) {
+                return false;
+            }
+            const presence = references(graph, id, 'yarramate/state/present-in');
+            return ((presence.length === 0 || presence.includes(state)) &&
+                concepts.has(structural.subject) &&
+                concepts.has(structural.object.ref));
+        })
+            .map(({ id }) => id);
+        return new Set([...concepts, ...relationships]);
+    };
+    const fromSubjects = subjectsIn(from);
+    const toSubjects = subjectsIn(to);
+    const classify = (predicate) => [...graph.subjects]
+        .sort((left, right) => left.id.localeCompare(right.id) ||
+        left.type.localeCompare(right.type))
+        .filter(({ id }) => {
+        if (architectureStates.has(id))
+            return false;
+        return predicate(fromSubjects.has(id), toSubjects.has(id));
+    });
+    return {
+        ok: true,
+        comparison: {
+            format: 'yarramate/state-comparison/v1',
+            from,
+            to,
+            added: classify((inFrom, inTo) => !inFrom && inTo),
+            removed: classify((inFrom, inTo) => inFrom && !inTo),
+            retained: classify((inFrom, inTo) => inFrom && inTo),
+        },
+    };
+}

package/dist/check-command.d.ts

@@ -0,0 +1,2 @@
+import { type CliResult } from './cli-support.js';
+export declare function runCheckCommand(options: readonly string[], cwd: string): CliResult;

package/dist/check-command.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { parseDocument } from 'yaml';
+import { loadAdapterMapping, validateAdapterMappings, } from './adapter-mapping.js';
+import { checkResultJson, humanDiagnostics, resolveCliWorkspaceSources, sortDiagnostics, usage, } from './cli-support.js';
+import { compileWorkspace } from './compiler.js';
+import { checkCoreContract, loadCoreContract, } from './core-contract.js';
+import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
+import { loadProjection } from './projection.js';
+const Ajv2020 = Ajv2020Module.default;
+export function runCheckCommand(options, cwd) {
+    const json = options.includes('--json');
+    const paths = options.filter((option) => option !== '--json');
+    const unknownOption = paths.find((path) => path.startsWith('-'));
+    if (unknownOption !== undefined || paths.length === 0) {
+        return { exitCode: 2, stdout: '', stderr: usage };
+    }
+    try {
+        const resolved = resolveCliWorkspaceSources(paths, cwd, {
+            includeAdapterMappings: true,
+        });
+        if (!resolved.ok) {
+            const output = json
+                ? checkResultJson(false, resolved.diagnostics)
+                : humanDiagnostics(resolved.diagnostics);
+            return { exitCode: 1, stdout: output, stderr: '' };
+        }
+        const contractDiagnostics = sortDiagnostics(resolved.contracts.flatMap((path) => {
+            const source = {
+                path,
+                source: readFileSync(resolve(cwd, path), 'utf8'),
+            };
+            const loaded = loadCoreContract(source);
+            if (!loaded.ok)
+                return loaded.diagnostics;
+            let packageManifest;
+            try {
+                packageManifest = JSON.parse(readFileSync(resolve(cwd, loaded.contract.packageManifest), 'utf8'));
+            }
+            catch {
+                packageManifest = undefined;
+            }
+            const packageRecord = typeof packageManifest === 'object' &&
+                packageManifest !== null &&
+                !Array.isArray(packageManifest)
+                ? packageManifest
+                : undefined;
+            const exportsRecord = typeof packageRecord?.exports === 'object' &&
+                packageRecord.exports !== null
+                ? Object.fromEntries(Object.entries(packageRecord.exports).filter((entry) => typeof entry[1] === 'string'))
+                : {};
+            const binaries = typeof packageRecord?.bin === 'object' &&
+                packageRecord.bin !== null
+                ? Object.keys(packageRecord.bin)
+                : typeof packageRecord?.bin === 'string' &&
+                    typeof packageRecord.name === 'string'
+                    ? [packageRecord.name]
+                    : [];
+            const schemas = {};
+            for (const { schema } of loaded.contract.formats) {
+                if (!existsSync(resolve(cwd, schema)))
+                    continue;
+                try {
+                    const value = JSON.parse(readFileSync(resolve(cwd, schema), 'utf8'));
+                    const record = typeof value === 'object' && value !== null
+                        ? value
+                        : undefined;
+                    const properties = typeof record?.properties === 'object' &&
+                        record.properties !== null
+                        ? record.properties
+                        : undefined;
+                    const format = typeof properties?.format === 'object' &&
+                        properties.format !== null
+                        ? properties.format
+                        : undefined;
+                    let validSchema = true;
+                    try {
+                        new Ajv2020({ strict: false }).compile(value);
+                    }
+                    catch {
+                        validSchema = false;
+                    }
+                    schemas[schema] = {
+                        ok: true,
+                        validSchema,
+                        ...(typeof format?.const === 'string'
+                            ? { format: format.const }
+                            : {}),
+                    };
+                }
+                catch {
+                    schemas[schema] = { ok: false };
+                }
+            }
+            const checked = checkCoreContract(source, {
+                files: [
+                    loaded.contract.packageManifest,
+                    ...loaded.contract.formats.map(({ schema }) => schema),
+                ].filter((file) => existsSync(resolve(cwd, file))),
+                packageManifestValid: packageRecord !== undefined,
+                packageExports: exportsRecord,
+                packageBinaries: binaries,
+                schemas,
+            });
+            return checked.ok ? [] : checked.diagnostics;
+        }));
+        if (contractDiagnostics.length > 0) {
+            const output = json
+                ? checkResultJson(false, contractDiagnostics)
+                : humanDiagnostics(contractDiagnostics);
+            return { exitCode: 1, stdout: output, stderr: '' };
+        }
+        const projectionDiagnostics = sortDiagnostics(resolved.projections.flatMap((path) => {
+            const loaded = loadProjection({
+                path,
+                source: readFileSync(resolve(cwd, path), 'utf8'),
+            });
+            return loaded.ok ? [] : loaded.diagnostics;
+        }));
+        if (projectionDiagnostics.length > 0) {
+            const output = json
+                ? checkResultJson(false, projectionDiagnostics)
+                : humanDiagnostics(projectionDiagnostics);
+            return { exitCode: 1, stdout: output, stderr: '' };
+        }
+        const loadedEvidence = resolved.evidence.map((path) => loadEvidence({
+            path,
+            source: readFileSync(resolve(cwd, path), 'utf8'),
+        }));
+        const evidenceLoadDiagnostics = sortDiagnostics(loadedEvidence.flatMap((loaded) => loaded.ok ? [] : loaded.diagnostics));
+        if (evidenceLoadDiagnostics.length > 0) {
+            const output = json
+                ? checkResultJson(false, evidenceLoadDiagnostics)
+                : humanDiagnostics(evidenceLoadDiagnostics);
+            return { exitCode: 1, stdout: output, stderr: '' };
+        }
+        const sources = resolved.paths.map((path) => ({
+            path,
+            source: readFileSync(resolve(cwd, path), 'utf8'),
+        }));
+        const mappingSources = sources.filter(({ source }) => parseDocument(source).get('format') ===
+            'yarramate/adapter-mapping/v1');
+        const coreSources = sources.filter((source) => !mappingSources.includes(source));
+        const loadedMappings = mappingSources.map((source) => loadAdapterMapping(source));
+        const mappingLoadDiagnostics = sortDiagnostics(loadedMappings.flatMap((loaded) => loaded.ok ? [] : loaded.diagnostics));
+        if (mappingLoadDiagnostics.length > 0) {
+            const output = json
+                ? checkResultJson(false, mappingLoadDiagnostics)
+                : humanDiagnostics(mappingLoadDiagnostics);
+            return { exitCode: 1, stdout: output, stderr: '' };
+        }
+        const result = compileWorkspace(coreSources);
+        const mappingValidation = result.ok
+            ? validateAdapterMappings(result.graph, loadedMappings.flatMap((loaded) => loaded.ok ? [loaded.mapping] : []))
+            : undefined;
+        const mappingDiagnostics = mappingValidation === undefined || mappingValidation.ok
+            ? []
+            : mappingValidation.diagnostics;
+        const evidenceEvaluation = result.ok
+            ? evaluateEvidenceWorkspace(result.graph, loadedEvidence.flatMap((loaded) => loaded.ok ? [loaded.evidence] : []))
+            : undefined;
+        const evidenceDiagnostics = evidenceEvaluation === undefined || evidenceEvaluation.ok
+            ? []
+            : evidenceEvaluation.diagnostics;
+        const optionalDiagnostics = sortDiagnostics([
+            ...mappingDiagnostics,
+            ...evidenceDiagnostics,
+        ]);
+        const ok = result.ok && optionalDiagnostics.length === 0;
+        const diagnostics = result.ok
+            ? optionalDiagnostics
+            : result.diagnostics;
+        if (json) {
+            return {
+                exitCode: ok ? 0 : 1,
+                stdout: checkResultJson(ok, ok ? [] : diagnostics),
+                stderr: '',
+            };
+        }
+        if (ok && result.ok) {
+            const documentCount = result.graph.documents.length;
+            const profileCount = coreSources.length - documentCount;
+            const mappingCount = mappingSources.length;
+            const projectionCount = resolved.projections.length;
+            const evidenceCount = resolved.evidence.length;
+            const contractCount = resolved.contracts.length;
+            const checked = [
+                `${documentCount} ${documentCount === 1 ? 'document' : 'documents'}`,
+                ...(profileCount > 0
+                    ? [
+                        `${profileCount} ${profileCount === 1 ? 'profile' : 'profiles'}`,
+                    ]
+                    : []),
+                ...(mappingCount > 0
+                    ? [
+                        `${mappingCount} ${mappingCount === 1 ? 'adapter mapping' : 'adapter mappings'}`,
+                    ]
+                    : []),
+                ...(projectionCount > 0
+                    ? [
+                        `${projectionCount} ${projectionCount === 1 ? 'projection' : 'projections'}`,
+                    ]
+                    : []),
+                ...(evidenceCount > 0
+                    ? [
+                        `${evidenceCount} ${evidenceCount === 1 ? 'evidence document' : 'evidence documents'}`,
+                    ]
+                    : []),
+                ...(contractCount > 0
+                    ? [
+                        `${contractCount} ${contractCount === 1 ? 'Core contract' : 'Core contracts'}`,
+                    ]
+                    : []),
+            ].join(' and ');
+            return {
+                exitCode: 0,
+                stdout: `Checked ${checked}: no errors\n`,
+                stderr: '',
+            };
+        }
+        return {
+            exitCode: 1,
+            stdout: humanDiagnostics(diagnostics),
+            stderr: '',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
+    }
+}

package/dist/cli-support.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic } from './compiler.js';
+export interface CliResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare const isMainModule: (moduleUrl: string, entrypoint: string | undefined) => boolean;
+export declare const usage = "Usage:\n  yarramate init <directory>\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--status <status>] [--mode <mode>] [--content <text>] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n";
+export declare const diagnosticJson: (diagnostics: unknown) => string;
+export declare const checkResultJson: (ok: boolean, diagnostics: unknown) => string;
+export declare const humanDiagnostics: (diagnostics: readonly Pick<Diagnostic, "path" | "line" | "column" | "code" | "message">[]) => string;
+export declare const sortDiagnostics: <T extends Diagnostic>(diagnostics: readonly T[]) => T[];
+export declare const resolveCliWorkspaceSources: (paths: readonly string[], cwd: string, options?: {
+    readonly includeAdapterMappings?: boolean;
+}) => {
+    readonly ok: true;
+    readonly paths: readonly string[];
+    readonly projections: readonly string[];
+    readonly evidence: readonly string[];
+    readonly contracts: readonly string[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};

package/dist/cli-support.js

@@ -0,0 +1,81 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseDocument } from 'yaml';
+import { loadWorkspaceManifest } from './workspace.js';
+export const isMainModule = (moduleUrl, entrypoint) => {
+    if (entrypoint === undefined)
+        return false;
+    try {
+        return (realpathSync(fileURLToPath(moduleUrl)) ===
+            realpathSync(entrypoint));
+    }
+    catch {
+        return false;
+    }
+};
+export const usage = 'Usage:\n  yarramate init <directory>\n  yarramate add <document.yaml> --id <id> --kind <kind> --name <name> [--status <status>] [--description <text>] [--owner <ref>] [--constraint <id>=<ref> ...] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate connect <document.yaml> --id <id> --kind <kind> --from <ref> --to <ref> [--name <name>] [--status <status>] [--mode <mode>] [--content <text>] [--present-in <state-ref> ...] [--source <source.yaml> ...]\n  yarramate check <source.yaml> [source.yaml ...] [--json]\n  yarramate compile <source.yaml> [source.yaml ...]\n  yarramate context <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate view <projection.yaml> <source.yaml> [source.yaml ...]\n  yarramate compare <from-state> <to-state> <source.yaml> [source.yaml ...]\n  yarramate evidence <evidence.yaml> <source.yaml> [source.yaml ...]\n  yarramate reconcile <workspace.yaml>\n';
+export const diagnosticJson = (diagnostics) => `${JSON.stringify({
+    format: 'yarramate/diagnostic-result/v1',
+    diagnostics,
+}, null, 2)}\n`;
+export const checkResultJson = (ok, diagnostics) => `${JSON.stringify({
+    format: 'yarramate/check-result/v1',
+    ok,
+    diagnostics,
+}, null, 2)}\n`;
+export const humanDiagnostics = (diagnostics) => diagnostics
+    .map((diagnostic) => `${diagnostic.path}:${diagnostic.line}:${diagnostic.column} error ${diagnostic.code} ${diagnostic.message}\n`)
+    .join('');
+export const sortDiagnostics = (diagnostics) => [...diagnostics].sort((left, right) => left.path.localeCompare(right.path) ||
+    left.line - right.line ||
+    left.column - right.column ||
+    left.code.localeCompare(right.code) ||
+    left.message.localeCompare(right.message));
+export const resolveCliWorkspaceSources = (paths, cwd, options = {}) => {
+    if (paths.length !== 1) {
+        return {
+            ok: true,
+            paths,
+            projections: [],
+            evidence: [],
+            contracts: [],
+        };
+    }
+    const manifestPath = paths[0];
+    if (manifestPath === undefined) {
+        return {
+            ok: true,
+            paths,
+            projections: [],
+            evidence: [],
+            contracts: [],
+        };
+    }
+    const source = readFileSync(resolve(cwd, manifestPath), 'utf8');
+    if (parseDocument(source).get('format') !== 'yarramate/workspace/v1') {
+        return {
+            ok: true,
+            paths,
+            projections: [],
+            evidence: [],
+            contracts: [],
+        };
+    }
+    const loaded = loadWorkspaceManifest({ path: manifestPath, source }, cwd);
+    return loaded.ok
+        ? {
+            ok: true,
+            paths: [
+                ...loaded.workspace.profiles,
+                ...loaded.workspace.documents,
+                ...(options.includeAdapterMappings === true
+                    ? loaded.workspace.adapterMappings
+                    : []),
+            ],
+            projections: loaded.workspace.projections,
+            evidence: loaded.workspace.evidence,
+            contracts: loaded.workspace.contracts,
+        }
+        : { ok: false, diagnostics: loaded.diagnostics };
+};

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { type CliResult } from './cli-support.js';
+export type { CliResult } from './cli-support.js';
+export declare function runCli(args: readonly string[], cwd?: string): CliResult;