yarramate 0.5.0 → 0.7.0

package/dist/new-command.js

@@ -1,111 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { humanDiagnostics, usage } from './cli-support.js';
-import { loadProjection } from './projection.js';
-const singleValueFlags = new Set([
-    '--id',
-    '--version',
-    '--title',
-    '--description',
-    '--relationships',
-]);
-const repeatableFlags = new Set(['--document', '--subject', '--kind']);
-const yamlText = (value) => /^[A-Za-z0-9][A-Za-z0-9 ._/@#-]*$/.test(value)
-    ? value
-    : JSON.stringify(value);
-export function runNewCommand(options, cwd) {
-    const [family, target, ...flags] = options;
-    if (family !== 'projection' || target === undefined || target.startsWith('-')) {
-        return { exitCode: 2, stdout: '', stderr: usage };
-    }
-    const single = new Map();
-    const repeated = new Map();
-    for (let index = 0; index < flags.length; index += 2) {
-        const flag = flags[index];
-        const value = flags[index + 1];
-        if (flag === undefined ||
-            value === undefined ||
-            value.startsWith('--') ||
-            (!singleValueFlags.has(flag) && !repeatableFlags.has(flag))) {
-            return { exitCode: 2, stdout: '', stderr: usage };
-        }
-        if (singleValueFlags.has(flag)) {
-            if (single.has(flag)) {
-                return { exitCode: 2, stdout: '', stderr: usage };
-            }
-            single.set(flag, value);
-        }
-        else {
-            repeated.set(flag, [...(repeated.get(flag) ?? []), value]);
-        }
-    }
-    const id = single.get('--id');
-    if (id === undefined) {
-        return { exitCode: 2, stdout: '', stderr: usage };
-    }
-    const documents = repeated.get('--document');
-    const subjects = repeated.get('--subject');
-    const kinds = repeated.get('--kind');
-    if (documents === undefined && subjects === undefined && kinds === undefined) {
-        return {
-            exitCode: 2,
-            stdout: '',
-            stderr: 'new projection requires at least one selector: --document, --subject, or --kind\n',
-        };
-    }
-    const targetPath = resolve(cwd, target);
-    if (existsSync(targetPath)) {
-        return {
-            exitCode: 2,
-            stdout: '',
-            stderr: `${target} already exists; nothing was changed\n`,
-        };
-    }
-    const lines = [
-        'format: yarramate/projection/v1',
-        `id: ${yamlText(id)}`,
-        `version: "${single.get('--version') ?? '1.0'}"`,
-        'query:',
-    ];
-    const list = (key, values) => {
-        if (values === undefined)
-            return;
-        lines.push(`  ${key}:`);
-        for (const value of values)
-            lines.push(`    - ${yamlText(value)}`);
-    };
-    list('subjects', subjects);
-    list('documents', documents);
-    list('kinds', kinds);
-    const relationships = single.get('--relationships');
-    if (relationships !== undefined) {
-        lines.push(`  relationships: ${yamlText(relationships)}`);
-    }
-    const title = single.get('--title');
-    const description = single.get('--description');
-    if (title !== undefined || description !== undefined) {
-        lines.push('presentation:');
-        if (title !== undefined)
-            lines.push(`  title: ${yamlText(title)}`);
-        if (description !== undefined) {
-            lines.push(`  description: ${yamlText(description)}`);
-        }
-    }
-    const source = `${lines.join('\n')}\n`;
-    const loaded = loadProjection({ path: target, source });
-    if (!loaded.ok) {
-        return {
-            exitCode: 1,
-            stdout: '',
-            stderr: humanDiagnostics(loaded.diagnostics),
-        };
-    }
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, source, 'utf8');
-    return {
-        exitCode: 0,
-        stdout: `Created ${target} (${loaded.projection.id}@${loaded.projection.version})\n` +
-            'Include it in the workspace manifest projections list if no glob already covers it\n',
-        stderr: '',
-    };
-}

package/dist/status-command.js

@@ -1,171 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { parseDocument } from 'yaml';
-import { runCheckCommand } from './check-command.js';
-import { diagnosticJson, humanDiagnostics, usage, } from './cli-support.js';
-import { compileWorkspace } from './compiler.js';
-import { evaluateEvidenceWorkspace, loadEvidence } from './evidence.js';
-import { loadProjection } from './projection.js';
-import { reconcileEvidenceReports, } from './reconciliation.js';
-import { loadWorkspaceManifest } from './workspace.js';
-const plural = (count, singular, pluralForm) => `${count} ${count === 1 ? singular : (pluralForm ?? `${singular}s`)}`;
-export function runStatusCommand(options, cwd) {
-    const json = options.includes('--json');
-    const paths = options.filter((option) => option !== '--json');
-    const [workspacePath] = paths;
-    if (paths.length !== 1 ||
-        workspacePath === undefined ||
-        workspacePath.startsWith('-')) {
-        return { exitCode: 2, stdout: '', stderr: usage };
-    }
-    try {
-        const manifestSource = readFileSync(resolve(cwd, workspacePath), 'utf8');
-        if (parseDocument(manifestSource).get('format') !==
-            'yarramate/workspace/v1') {
-            return {
-                exitCode: 2,
-                stdout: '',
-                stderr: 'status requires an explicit workspace manifest (yarramate/workspace/v1)\n',
-            };
-        }
-        const loadedWorkspace = loadWorkspaceManifest({ path: workspacePath, source: manifestSource }, cwd);
-        if (!loadedWorkspace.ok) {
-            return {
-                exitCode: 1,
-                stdout: json
-                    ? diagnosticJson(loadedWorkspace.diagnostics)
-                    : humanDiagnostics(loadedWorkspace.diagnostics),
-                stderr: '',
-            };
-        }
-        const workspace = loadedWorkspace.workspace;
-        const checked = runCheckCommand([workspacePath, '--json'], cwd);
-        const checkPayload = JSON.parse(checked.stdout);
-        const projections = workspace.projections.map((path) => {
-            const loaded = loadProjection({
-                path,
-                source: readFileSync(resolve(cwd, path), 'utf8'),
-            });
-            return loaded.ok
-                ? {
-                    id: loaded.projection.id,
-                    path,
-                    ...(loaded.projection.presentation?.title === undefined
-                        ? {}
-                        : { title: loaded.projection.presentation.title }),
-                }
-                : { id: path, path };
-        });
-        let documents = workspace.documents.map((path) => ({ id: path, path }));
-        let states = [];
-        let reconciliation;
-        if (checkPayload.ok) {
-            const compilation = compileWorkspace([...workspace.profiles, ...workspace.documents].map((path) => ({
-                path,
-                source: readFileSync(resolve(cwd, path), 'utf8'),
-            })));
-            if (compilation.ok) {
-                const sourceByDocument = new Map(compilation.graph.documents.map((document) => [
-                    document.id,
-                    document.source,
-                ]));
-                documents = workspace.documents.map((path) => {
-                    const id = [...sourceByDocument.entries()].find(([, source]) => source === path)?.[0];
-                    return { id: id ?? path, path };
-                });
-                states = compilation.graph.claims
-                    .filter(({ predicate }) => predicate === 'yarramate/state/type')
-                    .map(({ subject, object }) => ({
-                    id: subject,
-                    type: 'value' in object && typeof object.value === 'string'
-                        ? object.value
-                        : 'baseline',
-                }));
-                if (workspace.evidence.length > 0) {
-                    const evidenceDocuments = workspace.evidence.flatMap((path) => {
-                        const loaded = loadEvidence({
-                            path,
-                            source: readFileSync(resolve(cwd, path), 'utf8'),
-                        });
-                        return loaded.ok ? [loaded.evidence] : [];
-                    });
-                    const evaluation = evaluateEvidenceWorkspace(compilation.graph, evidenceDocuments);
-                    if (evaluation.ok) {
-                        reconciliation = reconcileEvidenceReports(workspace.id, evaluation.reports, compilation.graph).summary;
-                    }
-                }
-            }
-        }
-        const result = {
-            format: 'yarramate/status-result/v1',
-            workspace: workspace.id,
-            ok: checkPayload.ok,
-            check: {
-                ok: checkPayload.ok,
-                diagnostics: checkPayload.ok ? [] : checkPayload.diagnostics,
-                ...(checkPayload.counted === undefined
-                    ? {}
-                    : { counted: checkPayload.counted }),
-            },
-            ...(reconciliation === undefined ? {} : { reconciliation }),
-            inventory: {
-                documents,
-                profiles: workspace.profiles,
-                states,
-                projections,
-                evidence: workspace.evidence,
-                adapterMappings: workspace.adapterMappings,
-                contracts: workspace.contracts,
-            },
-        };
-        if (json) {
-            return {
-                exitCode: result.ok ? 0 : 1,
-                stdout: `${JSON.stringify(result, null, 2)}\n`,
-                stderr: '',
-            };
-        }
-        const lines = [];
-        const counted = result.check.counted;
-        lines.push(`Workspace ${result.workspace}: check ${result.ok ? 'ok' : 'failing'}` +
-            (counted === undefined
-                ? ''
-                : ` (${plural(counted.concepts, 'concept')}, ` +
-                    `${plural(counted.relationships, 'relationship')}, ` +
-                    `${plural(counted.states, 'state')}, ` +
-                    `${plural(counted.documents, 'document')})`));
-        if (!result.ok) {
-            lines.push(`Diagnostics: ${plural(result.check.diagnostics.length, 'error')}; run \`yarramate check ${workspacePath}\` for details`);
-        }
-        if (result.reconciliation !== undefined) {
-            lines.push(`Reconciliation: ${plural(result.reconciliation.observations, 'observation')}, ` +
-                `${result.reconciliation.confirmed} confirmed, ` +
-                `${plural(result.reconciliation.findings, 'finding')}` +
-                (result.reconciliation.findings > 0
-                    ? ` (${result.reconciliation.contradicted} contradicted, ` +
-                        `${result.reconciliation.unknown} unknown, ` +
-                        `${result.reconciliation.notObserved} not observed)`
-                    : ''));
-        }
-        lines.push(`Documents: ${documents.map(({ id }) => id).join(', ') || 'none'}`);
-        if (states.length > 0) {
-            lines.push(`States: ${states.map(({ id, type }) => `${id} (${type})`).join(', ')}`);
-        }
-        lines.push(`Projections: ${projections
-            .map(({ id, title }) => title === undefined ? id : `${id} — ${title}`)
-            .join('; ') || 'none'}`);
-        lines.push(`Profiles: ${workspace.profiles.length} · ` +
-            `Evidence: ${workspace.evidence.length} · ` +
-            `Adapter mappings: ${workspace.adapterMappings.length} · ` +
-            `Contracts: ${workspace.contracts.length}`);
-        return {
-            exitCode: result.ok ? 0 : 1,
-            stdout: `${lines.join('\n')}\n`,
-            stderr: '',
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
-    }
-}

package/schema/yarramate-status-result.schema.json

@@ -1,273 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://yarramate.org/schema/status-result/v1",
-  "title": "YarraMate workspace status result",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "format",
-    "workspace",
-    "ok",
-    "check",
-    "inventory"
-  ],
-  "properties": {
-    "format": {
-      "const": "yarramate/status-result/v1"
-    },
-    "workspace": {
-      "type": "string",
-      "minLength": 1
-    },
-    "ok": {
-      "type": "boolean"
-    },
-    "check": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "ok",
-        "diagnostics"
-      ],
-      "properties": {
-        "ok": {
-          "type": "boolean"
-        },
-        "diagnostics": {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/diagnostic"
-          }
-        },
-        "counted": {
-          "type": "object",
-          "additionalProperties": false,
-          "required": [
-            "documents",
-            "concepts",
-            "relationships",
-            "states"
-          ],
-          "properties": {
-            "documents": {
-              "type": "integer",
-              "minimum": 0
-            },
-            "concepts": {
-              "type": "integer",
-              "minimum": 0
-            },
-            "relationships": {
-              "type": "integer",
-              "minimum": 0
-            },
-            "states": {
-              "type": "integer",
-              "minimum": 0
-            }
-          }
-        }
-      }
-    },
-    "reconciliation": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "evidenceDocuments",
-        "observations",
-        "confirmed",
-        "findings",
-        "contradicted",
-        "unknown",
-        "notObserved"
-      ],
-      "properties": {
-        "evidenceDocuments": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "observations": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "confirmed": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "findings": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "contradicted": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "unknown": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "notObserved": {
-          "type": "integer",
-          "minimum": 0
-        }
-      }
-    },
-    "inventory": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "documents",
-        "profiles",
-        "states",
-        "projections",
-        "evidence",
-        "adapterMappings",
-        "contracts"
-      ],
-      "properties": {
-        "documents": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": [
-              "id",
-              "path"
-            ],
-            "properties": {
-              "id": {
-                "type": "string",
-                "minLength": 1
-              },
-              "path": {
-                "type": "string",
-                "minLength": 1
-              }
-            }
-          }
-        },
-        "profiles": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "states": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": [
-              "id",
-              "type"
-            ],
-            "properties": {
-              "id": {
-                "type": "string",
-                "minLength": 1
-              },
-              "type": {
-                "enum": [
-                  "baseline",
-                  "transition",
-                  "target"
-                ]
-              }
-            }
-          }
-        },
-        "projections": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": [
-              "id",
-              "path"
-            ],
-            "properties": {
-              "id": {
-                "type": "string",
-                "minLength": 1
-              },
-              "path": {
-                "type": "string",
-                "minLength": 1
-              },
-              "title": {
-                "type": "string",
-                "minLength": 1
-              }
-            }
-          }
-        },
-        "evidence": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "adapterMappings": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "contracts": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        }
-      }
-    }
-  },
-  "$defs": {
-    "diagnostic": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "severity",
-        "code",
-        "message",
-        "path",
-        "pointer",
-        "line",
-        "column"
-      ],
-      "properties": {
-        "severity": {
-          "const": "error"
-        },
-        "code": {
-          "type": "string",
-          "pattern": "^YM[0-9]{3}$"
-        },
-        "message": {
-          "type": "string",
-          "minLength": 1
-        },
-        "path": {
-          "type": "string",
-          "minLength": 1
-        },
-        "pointer": {
-          "type": "string",
-          "pattern": "^/"
-        },
-        "line": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "column": {
-          "type": "integer",
-          "minimum": 1
-        }
-      }
-    }
-  }
-}