yarramate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YarraMate contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# YarraMate
+
+YarraMate is a tool-neutral semantic architecture engine and guided
+methodology. It turns architectural intent into deterministic, testable
+context shared by people and agents.
+
+> YarraMate is pre-release software. Interfaces may evolve before the first
+> stable release.
+
+## Why YarraMate?
+
+Architecture documents often drift away from implementation or become tied to
+one notation and tool. YarraMate keeps concise, native YAML documents
+canonical and compiles them into an explicit semantic graph.
+
+The same model supports two workflows:
+
+- discover an existing project's architecture from repository evidence;
+- design a solution before implementation and later reconcile intent with
+  evidence.
+
+Git provides authorship, review, history, and acceptance. YarraMate does not
+introduce a parallel governance workflow.
+
+## Product boundaries
+
+YarraMate Core:
+
+- owns native, versioned architecture documents;
+- compiles a claim-centred, tool-neutral semantic graph;
+- checks deterministic correctness rather than architectural taste;
+- supports explicit workspaces, profiles, projections, evidence, and
+  architecture states;
+- exposes a stable CLI for people, CI, skills, and agent harnesses.
+
+Optional adapters provide:
+
+- LikeC4 visualization from semantic projections;
+- Graphify observations as evidence overlays;
+- separately governed compatibility profiles for external languages.
+
+Core does not depend on LikeC4, Graphify, or ArchiMate.
+
+YarraMate is not affiliated with or certified by The Open Group. ArchiMate® is
+a registered trademark of The Open Group. LikeC4 and Graphify are independent
+projects; their mention does not imply affiliation or endorsement.
+
+## Repository layout
+
+```text
+src/                 compiler, CLI, graph, and adapter sources
+schema/              normative JSON Schemas
+test/                tests and acceptance fixtures
+skills/              portable architecture workflow for agent harnesses
+docs/                contracts, guides, and decisions
+.yarramate/          canonical dogfooded architecture
+.yarramate-out/      reproducible generated output (ignored)
+```
+
+The [documentation index](docs/README.md) links the public guides and
+maintainer material. Start semantic work with the
+[product contract](docs/PRODUCT-CONTRACT.md) and
+[glossary](docs/GLOSSARY.md).
+
+## Development
+
+Requirements:
+
+- Node.js 22 or newer
+- Corepack
+
+```sh
+corepack enable
+pnpm install --frozen-lockfile
+pnpm run verify
+```
+
+The full CI command runs typechecking, tests, native self-validation, LikeC4
+generation, and LikeC4 validation.
+
+Useful focused commands:
+
+```sh
+pnpm build
+pnpm test
+pnpm typecheck
+pnpm self:check
+pnpm self:evidence
+pnpm self:reconcile
+pnpm self:check:likec4
+pnpm self:export:likec4
+pnpm docs:dev
+```
+
+## CLI
+
+Build the repository, then invoke the same executable surface intended for
+published use:
+
+```sh
+pnpm build
+
+node dist/cli.js init .
+node dist/cli.js check .yarramate/workspace.yaml --json
+node dist/cli.js compile .yarramate/workspace.yaml
+node dist/cli.js context .yarramate/projections/context.yaml .yarramate/workspace.yaml
+node dist/cli.js view .yarramate/projections/context.yaml .yarramate/workspace.yaml
+node dist/cli.js evidence .yarramate/evidence/repository.yaml .yarramate/workspace.yaml
+node dist/cli.js reconcile .yarramate/workspace.yaml
+```
+
+`init` creates `.yarramate/architecture/main.yaml` and
+`.yarramate/workspace.yaml`. Commands accept explicit source documents or one
+explicit workspace manifest.
+
+For a local consumer test, create a package artifact:
+
+```sh
+pnpm pack --pack-destination /tmp/yarramate-package
+npm install --global /tmp/yarramate-package/yarramate-0.1.0.tgz
+yarramate --help
+```
+
+See [Consuming YarraMate](docs/CONSUMING-YARRAMATE.md) for the packaged CLI,
+schemas, agent skill, and optional adapters.
+
+## Library API
+
+The typed library exposes the same deep compiler seam:
+
+```ts
+import { compileWorkspace } from 'yarramate'
+
+const result = compileWorkspace([
+  { path: 'architecture.yaml', source: yamlSource },
+])
+```
+
+`compileWorkspaceWithProfileContext` additionally returns resolved profile
+lineage for operations that explicitly require kind ancestry. Graph v2 remains
+the stable, graph-only interchange result.
+
+Normative schemas are available through package exports such as:
+
+```text
+yarramate/schema/document
+yarramate/schema/profile
+yarramate/schema/workspace
+yarramate/schema/graph-v2
+yarramate/schema/projection
+yarramate/schema/evidence
+yarramate/schema/core-contract
+```
+
+Optional adapter entry points are exported from:
+
+```text
+yarramate/adapter/likec4
+yarramate/adapter/graphify
+```
+
+## Contributing and security
+
+Found a bug, confusing behaviour, missing capability, documentation problem,
+or possible improvement? Please
+[open a GitHub Issue](https://github.com/yarrasys/yarramate/issues/new).
+Issues are welcome from users, contributors, agents, and curious observers.
+You do not need to provide a solution, formal proposal, or implementation.
+
+Read [CONTRIBUTING.md](CONTRIBUTING.md) before proposing changes to native
+semantics or stable interfaces. Report suspected vulnerabilities according to
+[SECURITY.md](SECURITY.md).
+
+YarraMate is available under the [MIT License](LICENSE).

package/dist/adapter-mapping.d.ts

@@ -0,0 +1,40 @@
+import type { Diagnostic, SemanticGraph, WorkspaceSource } from './compiler.js';
+import { type SourceLocation } from './source-document.js';
+export interface AdapterSubjectMapping {
+    readonly native: string;
+    readonly external: string;
+    readonly type: 'concept' | 'relationship';
+}
+export interface AdapterMapping {
+    readonly format: 'yarramate/adapter-mapping/v1';
+    readonly id: string;
+    readonly version: string;
+    readonly adapter: string;
+    readonly mappings: readonly AdapterSubjectMapping[];
+}
+export type AdapterMappingLoadResult = {
+    readonly ok: true;
+    readonly mapping: AdapterMapping;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export type AdapterMappingValidationResult = {
+    readonly ok: true;
+    readonly mapping: AdapterMapping;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export type AdapterMappingsValidationResult = {
+    readonly ok: true;
+    readonly mappings: readonly AdapterMapping[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function loadAdapterMapping(source: WorkspaceSource): AdapterMappingLoadResult;
+export declare function adapterMappingLocation(mapping: AdapterMapping, field: 'id' | 'adapter'): SourceLocation;
+export declare function adapterMappingEntryLocation(mapping: AdapterMapping, entry: AdapterSubjectMapping, field: 'native' | 'external' | 'type'): SourceLocation;
+export declare function validateAdapterMapping(graph: SemanticGraph, mapping: AdapterMapping): AdapterMappingValidationResult;
+export declare function validateAdapterMappings(graph: SemanticGraph, mappings: readonly AdapterMapping[]): AdapterMappingsValidationResult;

package/dist/adapter-mapping.js

@@ -0,0 +1,200 @@
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { diagnosticOrder, loadSourceDocument, locateSourcePath, } from './source-document.js';
+import adapterMappingSchema from '../schema/yarramate-adapter-mapping.schema.json' with {
+    type: 'json'
+};
+const Ajv2020 = Ajv2020Module.default;
+const validateSchema = new Ajv2020({ allErrors: true }).compile(adapterMappingSchema);
+const mappingLocations = new WeakMap();
+export function loadAdapterMapping(source) {
+    const loaded = loadSourceDocument(source, validateSchema, 'Adapter mapping');
+    if (!loaded.ok)
+        return loaded;
+    const { value, yaml, lineCounter } = loaded.document;
+    const mapping = {
+        ...value,
+        mappings: [...value.mappings].sort((left, right) => left.native.localeCompare(right.native) ||
+            left.external.localeCompare(right.external) ||
+            left.type.localeCompare(right.type)),
+    };
+    const locateNode = (yamlPath, pointer) => locateSourcePath(source.path, yaml, lineCounter, yamlPath, pointer);
+    mappingLocations.set(mapping, {
+        id: locateNode(['id'], '/id'),
+        adapter: locateNode(['adapter'], '/adapter'),
+        mappings: mapping.mappings.map((entry) => {
+            const authoredIndex = value.mappings.indexOf(entry);
+            const locate = (field) => locateNode(['mappings', authoredIndex, field], `/mappings/${authoredIndex}/${field}`);
+            return {
+                native: locate('native'),
+                external: locate('external'),
+                type: locate('type'),
+            };
+        }),
+    });
+    return { ok: true, mapping };
+}
+export function adapterMappingLocation(mapping, field) {
+    return (mappingLocations.get(mapping)?.[field] ?? {
+        path: `${mapping.id}.mapping.yaml`,
+        pointer: `/${field}`,
+        line: 1,
+        column: 1,
+    });
+}
+export function adapterMappingEntryLocation(mapping, entry, field) {
+    const index = mapping.mappings.indexOf(entry);
+    return (mappingLocations.get(mapping)?.mappings[index]?.[field] ?? {
+        path: `${mapping.id}.mapping.yaml`,
+        pointer: `/mappings/${Math.max(index, 0)}/${field}`,
+        line: 1,
+        column: 1,
+    });
+}
+export function validateAdapterMapping(graph, mapping) {
+    const subjectTypes = new Map(graph.subjects.map(({ id, type }) => [id, type]));
+    const locations = mappingLocations.get(mapping)?.mappings ?? [];
+    const diagnostics = [];
+    const seenNativeSubjects = new Set();
+    const seenExternalIdentities = new Set();
+    for (const [index, entry] of mapping.mappings.entries()) {
+        const fallback = (field) => ({
+            path: `${mapping.id}.mapping.yaml`,
+            pointer: `/mappings/${index}/${field}`,
+            line: 1,
+            column: 1,
+        });
+        const nativeLocation = locations[index]?.native ?? fallback('native');
+        const externalLocation = locations[index]?.external ?? fallback('external');
+        const typeLocation = locations[index]?.type ?? fallback('type');
+        const actualType = subjectTypes.get(entry.native);
+        if (actualType === undefined) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'YM601',
+                message: `Native subject "${entry.native}" does not exist`,
+                path: nativeLocation.path,
+                pointer: nativeLocation.pointer,
+                line: nativeLocation.line,
+                column: nativeLocation.column,
+            });
+        }
+        else if (actualType !== entry.type) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'YM602',
+                message: `Native subject "${entry.native}" is a ${actualType}, not a ${entry.type}`,
+                path: typeLocation.path,
+                pointer: typeLocation.pointer,
+                line: typeLocation.line,
+                column: typeLocation.column,
+            });
+        }
+        if (seenNativeSubjects.has(entry.native)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'YM603',
+                message: `Native subject "${entry.native}" is mapped more than once`,
+                path: nativeLocation.path,
+                pointer: nativeLocation.pointer,
+                line: nativeLocation.line,
+                column: nativeLocation.column,
+            });
+        }
+        seenNativeSubjects.add(entry.native);
+        if (seenExternalIdentities.has(entry.external)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'YM604',
+                message: `External identity "${entry.external}" is mapped more than once`,
+                path: externalLocation.path,
+                pointer: externalLocation.pointer,
+                line: externalLocation.line,
+                column: externalLocation.column,
+            });
+        }
+        seenExternalIdentities.add(entry.external);
+    }
+    return diagnostics.length === 0
+        ? { ok: true, mapping }
+        : { ok: false, diagnostics: diagnostics.sort(diagnosticOrder) };
+}
+export function validateAdapterMappings(graph, mappings) {
+    const ordered = [...mappings].sort((left, right) => {
+        const identityOrder = `${left.id}@${left.version}`.localeCompare(`${right.id}@${right.version}`);
+        if (identityOrder !== 0)
+            return identityOrder;
+        const leftPath = mappingLocations.get(left)?.id.path ?? '';
+        const rightPath = mappingLocations.get(right)?.id.path ?? '';
+        return leftPath.localeCompare(rightPath);
+    });
+    const diagnostics = [];
+    const seenIdentities = new Set();
+    const nativeOwnersByAdapter = new Map();
+    const externalOwnersByAdapter = new Map();
+    for (const mapping of ordered) {
+        const identity = `${mapping.id}@${mapping.version}`;
+        const validation = validateAdapterMapping(graph, mapping);
+        if (!validation.ok) {
+            diagnostics.push(...validation.diagnostics);
+        }
+        if (seenIdentities.has(identity)) {
+            const location = mappingLocations.get(mapping)?.id ?? {
+                path: `${mapping.id}.mapping.yaml`,
+                pointer: '/id',
+                line: 1,
+                column: 1,
+            };
+            diagnostics.push({
+                severity: 'error',
+                code: 'YM605',
+                message: `Adapter mapping "${identity}" is declared more than once`,
+                ...location,
+            });
+        }
+        seenIdentities.add(identity);
+        const nativeOwners = nativeOwnersByAdapter.get(mapping.adapter) ??
+            new Map();
+        const externalOwners = externalOwnersByAdapter.get(mapping.adapter) ??
+            new Map();
+        nativeOwnersByAdapter.set(mapping.adapter, nativeOwners);
+        externalOwnersByAdapter.set(mapping.adapter, externalOwners);
+        const locations = mappingLocations.get(mapping)?.mappings ?? [];
+        for (const [index, entry] of mapping.mappings.entries()) {
+            const nativeOwner = nativeOwners.get(entry.native);
+            if (nativeOwner !== undefined && nativeOwner !== mapping) {
+                const location = locations[index]?.native ?? {
+                    path: `${mapping.id}.mapping.yaml`,
+                    pointer: `/mappings/${index}/native`,
+                    line: 1,
+                    column: 1,
+                };
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'YM603',
+                    message: `Native subject "${entry.native}" is mapped more than once for adapter "${mapping.adapter}"`,
+                    ...location,
+                });
+            }
+            nativeOwners.set(entry.native, nativeOwner ?? mapping);
+            const externalOwner = externalOwners.get(entry.external);
+            if (externalOwner !== undefined && externalOwner !== mapping) {
+                const location = locations[index]?.external ?? {
+                    path: `${mapping.id}.mapping.yaml`,
+                    pointer: `/mappings/${index}/external`,
+                    line: 1,
+                    column: 1,
+                };
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'YM604',
+                    message: `External identity "${entry.external}" is mapped more than once for adapter "${mapping.adapter}"`,
+                    ...location,
+                });
+            }
+            externalOwners.set(entry.external, externalOwner ?? mapping);
+        }
+    }
+    return diagnostics.length === 0
+        ? { ok: true, mappings: ordered }
+        : { ok: false, diagnostics: diagnostics.sort(diagnosticOrder) };
+}

package/dist/adapters/graphify-cli.d.ts

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

package/dist/adapters/graphify-cli.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { adapterMappingEntryLocation, adapterMappingLocation, loadAdapterMapping, validateAdapterMapping, } from '../adapter-mapping.js';
+import { compileWorkspace } from '../compiler.js';
+import { diagnosticJson, isMainModule, resolveCliWorkspaceSources, } from '../cli-support.js';
+import { observeGraphify, } from './graphify.js';
+const usage = 'Usage:\n' +
+    '  yarramate-graphify observe <graph.json> <mapping.yaml> <workspace-or-source...> --id <evidence-id> --version <major.minor>\n';
+const parseOptions = (options) => {
+    const idFlag = options.indexOf('--id');
+    const versionFlag = options.indexOf('--version');
+    if (idFlag < 3 ||
+        versionFlag < 3 ||
+        options[idFlag + 1] === undefined ||
+        options[versionFlag + 1] === undefined)
+        return undefined;
+    const flagIndexes = [idFlag, versionFlag].sort((left, right) => left - right);
+    const firstFlag = flagIndexes[0];
+    if (firstFlag === undefined)
+        return undefined;
+    const paths = options.slice(0, firstFlag);
+    const trailing = options.slice(firstFlag);
+    if (paths.length < 3 ||
+        trailing.length !== 4 ||
+        new Set([trailing[0], trailing[2]]).size !== 2)
+        return undefined;
+    return {
+        graphPath: paths[0],
+        mappingPath: paths[1],
+        sources: paths.slice(2),
+        id: options[idFlag + 1],
+        version: options[versionFlag + 1],
+    };
+};
+export function runGraphifyCli(args, cwd = process.cwd()) {
+    const [command, ...options] = args;
+    const parsed = command === 'observe' ? parseOptions(options) : undefined;
+    if (parsed === undefined ||
+        !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(parsed.id) ||
+        !/^[0-9]+\.[0-9]+$/.test(parsed.version)) {
+        return { exitCode: 2, stdout: '', stderr: usage };
+    }
+    try {
+        const resolved = resolveCliWorkspaceSources(parsed.sources, cwd);
+        if (!resolved.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticJson(resolved.diagnostics),
+                stderr: '',
+            };
+        }
+        const compilation = compileWorkspace(resolved.paths.map((path) => ({
+            path,
+            source: readFileSync(resolve(cwd, path), 'utf8'),
+        })));
+        if (!compilation.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticJson(compilation.diagnostics),
+                stderr: '',
+            };
+        }
+        const loadedMapping = loadAdapterMapping({
+            path: parsed.mappingPath,
+            source: readFileSync(resolve(cwd, parsed.mappingPath), 'utf8'),
+        });
+        if (!loadedMapping.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticJson(loadedMapping.diagnostics),
+                stderr: '',
+            };
+        }
+        const validatedMapping = validateAdapterMapping(compilation.graph, loadedMapping.mapping);
+        if (!validatedMapping.ok) {
+            return {
+                exitCode: 1,
+                stdout: diagnosticJson(validatedMapping.diagnostics),
+                stderr: '',
+            };
+        }
+        const graph = JSON.parse(readFileSync(resolve(cwd, parsed.graphPath), 'utf8'));
+        if (!Array.isArray(graph.nodes) ||
+            graph.nodes.some((node) => typeof node !== 'object' ||
+                node === null ||
+                typeof node.id !== 'string' ||
+                node.id.length === 0)) {
+            return {
+                exitCode: 2,
+                stdout: '',
+                stderr: `${parsed.graphPath} does not contain Graphify nodes with string IDs\n`,
+            };
+        }
+        const observation = observeGraphify(graph, validatedMapping.mapping, { id: parsed.id, version: parsed.version });
+        if (!observation.ok) {
+            const diagnostics = observation.issues.map((issue) => ({
+                severity: 'error',
+                code: issue.code,
+                message: issue.message,
+                ...(issue.mapping === undefined
+                    ? adapterMappingLocation(loadedMapping.mapping, 'adapter')
+                    : adapterMappingEntryLocation(loadedMapping.mapping, issue.mapping, 'type')),
+            }));
+            return {
+                exitCode: 1,
+                stdout: diagnosticJson(diagnostics),
+                stderr: '',
+            };
+        }
+        return {
+            exitCode: 0,
+            stdout: `${JSON.stringify(observation.evidence, null, 2)}\n`,
+            stderr: '',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
+    }
+}
+if (isMainModule(import.meta.url, process.argv[1])) {
+    const result = runGraphifyCli(process.argv.slice(2));
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}

package/dist/adapters/graphify-entry.d.ts

@@ -0,0 +1 @@
+export { observeGraphify, type GraphifyGraph, type GraphifyObservationIssue, type GraphifyObservationResult, } from './graphify.js';

package/dist/adapters/graphify-entry.js

@@ -0,0 +1 @@
+export { observeGraphify, } from './graphify.js';

package/dist/adapters/graphify.d.ts

@@ -0,0 +1,23 @@
+import type { AdapterMapping, AdapterSubjectMapping } from '../adapter-mapping.js';
+import type { EvidenceDocument } from '../evidence.js';
+export interface GraphifyGraph {
+    readonly nodes: readonly {
+        readonly id: string;
+    }[];
+}
+export interface GraphifyObservationIssue {
+    readonly code: 'YMG101' | 'YMG102';
+    readonly message: string;
+    readonly mapping?: AdapterSubjectMapping;
+}
+export type GraphifyObservationResult = {
+    readonly ok: true;
+    readonly evidence: EvidenceDocument;
+} | {
+    readonly ok: false;
+    readonly issues: readonly GraphifyObservationIssue[];
+};
+export declare function observeGraphify(graph: GraphifyGraph, mapping: AdapterMapping, identity: {
+    readonly id: string;
+    readonly version: string;
+}): GraphifyObservationResult;

package/dist/adapters/graphify.js

@@ -0,0 +1,47 @@
+export function observeGraphify(graph, mapping, identity) {
+    if (mapping.adapter !== 'graphify') {
+        return {
+            ok: false,
+            issues: [{
+                    code: 'YMG101',
+                    message: `Adapter mapping "${mapping.id}@${mapping.version}" belongs to "${mapping.adapter}", not "graphify"`,
+                }],
+        };
+    }
+    const relationshipMappings = mapping.mappings.filter(({ type }) => type === 'relationship');
+    if (relationshipMappings.length > 0) {
+        return {
+            ok: false,
+            issues: relationshipMappings.map((entry) => ({
+                code: 'YMG102',
+                message: `Graphify node evidence cannot evaluate relationship subject "${entry.native}"`,
+                mapping: entry,
+            })),
+        };
+    }
+    const nodeIds = new Set(graph.nodes.map(({ id }) => id));
+    const observations = mapping.mappings.map((entry) => nodeIds.has(entry.external)
+        ? {
+            subject: entry.native,
+            result: 'confirmed',
+            evidence: { uri: `graphify:${entry.external}` },
+        }
+        : {
+            subject: entry.native,
+            result: 'not-observed',
+            evidence: {
+                uri: `graphify:${entry.external}`,
+                message: `Graphify node "${entry.external}" was not observed`,
+            },
+        });
+    return {
+        ok: true,
+        evidence: {
+            format: 'yarramate/evidence/v1',
+            id: identity.id,
+            version: identity.version,
+            provider: 'graphify',
+            observations,
+        },
+    };
+}

package/dist/adapters/likec4-cli.d.ts

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