yarramate 0.6.0 → 0.7.0

package/dist/adapters/mcp-cli.js

@@ -10,14 +10,65 @@ const workspaceProperty = {
 };
 const tools = [
     {
-        name: 'yarramate_status',
-        description: 'One-call workspace orientation: check verdict, reconciliation summary, and a titled inventory of documents, states, projections, evidence, and contracts.',
+        name: 'yarramate_ask',
+        description: 'The consumed-now read surface. Without a query: orientation — check verdict, drift summary, open-question count, and the backlog in dependency order. With a query: free text matches concept ids, names, and descriptions and returns the connected slice; exact subject ids (document-id#local-id) and projection paths address precisely. Set mode for the roster (subjects), declarable vocabulary (kinds), build order (next), or the full open-questions report (open).',
         inputSchema: {
             type: 'object',
             required: ['workspace'],
-            properties: workspaceProperty,
+            properties: {
+                ...workspaceProperty,
+                query: {
+                    type: 'string',
+                    description: 'Free text, a globally qualified subject id, or a projection path',
+                },
+                mode: {
+                    type: 'string',
+                    enum: ['subjects', 'kinds', 'next', 'open'],
+                    description: 'Optional flag mode instead of a query: the filterable roster, the declarable kind vocabulary, dependency-ordered planned work, or the open-questions report',
+                },
+                budget: {
+                    type: 'integer',
+                    minimum: 1,
+                    description: 'Approximate token budget for the compact slice rendering (query form only)',
+                },
+            },
+        },
+        arguments: (input) => {
+            const workspace = String(input.workspace);
+            if (typeof input.mode === 'string') {
+                return ['ask', workspace, `--${input.mode}`, '--json'];
+            }
+            if (typeof input.query === 'string' && input.query.length > 0) {
+                const budget = typeof input.budget === 'number'
+                    ? ['--budget', String(input.budget)]
+                    : ['--json'];
+                return ['ask', workspace, input.query, ...budget];
+            }
+            return ['ask', workspace, '--json'];
+        },
+    },
+    {
+        name: 'yarramate_design',
+        description: 'The design interview, one stateless step: the top open question with its subject slice, materiality, and progress. Read-only — answers land through the CLI apply command in the repository, not through this server.',
+        inputSchema: {
+            type: 'object',
+            required: ['workspace'],
+            properties: {
+                ...workspaceProperty,
+                subject: {
+                    type: 'string',
+                    description: 'Optional globally qualified subject id to narrow the interview',
+                },
+            },
         },
-        arguments: (input) => ['status', String(input.workspace), '--json'],
+        arguments: (input) => [
+            'design',
+            String(input.workspace),
+            ...(typeof input.subject === 'string'
+                ? ['--subject', input.subject]
+                : []),
+            '--json',
+        ],
     },
     {
         name: 'yarramate_check',
@@ -39,51 +90,6 @@ const tools = [
         },
         arguments: (input) => ['reconcile', String(input.workspace)],
     },
-    {
-        name: 'yarramate_context',
-        description: 'Bounded architecture context. Provide either a projection path or one or more globally qualified subjects (document-id#local-id) for an ad-hoc connected neighbourhood. Optional token budget switches to a compact ranked rendering.',
-        inputSchema: {
-            type: 'object',
-            required: ['workspace'],
-            properties: {
-                ...workspaceProperty,
-                projection: {
-                    type: 'string',
-                    description: 'Path to an authored projection definition',
-                },
-                subjects: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Globally qualified subject identities for ad-hoc context',
-                },
-                budget: {
-                    type: 'integer',
-                    minimum: 1,
-                    description: 'Approximate token budget for the compact rendering',
-                },
-            },
-        },
-        arguments: (input) => {
-            const budget = typeof input.budget === 'number'
-                ? ['--budget', String(input.budget)]
-                : [];
-            if (typeof input.projection === 'string') {
-                return [
-                    'context',
-                    input.projection,
-                    String(input.workspace),
-                    ...budget,
-                ];
-            }
-            const subjects = Array.isArray(input.subjects)
-                ? input.subjects.flatMap((subject) => [
-                    '--subject',
-                    String(subject),
-                ])
-                : [];
-            return ['context', ...subjects, String(input.workspace), ...budget];
-        },
-    },
 ];
 const respond = (id, result) => {
     process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);

package/dist/apply-command.d.ts

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

package/dist/apply-command.js

@@ -0,0 +1,199 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { isSeq, parseDocument } from 'yaml';
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { diagnosticJson, humanDiagnostics, usage, } from './cli-support.js';
+import { compileWorkspace } from './compiler.js';
+import { loadSourceDocument, locateSourcePath, } from './source-document.js';
+import { loadWorkspaceManifest } from './workspace.js';
+import operationsSchema from '../schema/yarramate-operations.schema.json' with {
+    type: 'json'
+};
+const Ajv2020 = Ajv2020Module.default;
+const validateOperations = new Ajv2020({ allErrors: true }).compile(operationsSchema);
+// Scalar fields replace; list fields append. An answer enriches what is
+// there — it never silently shrinks it (removals stay Git edits).
+const SCALAR_CONCEPT_FIELDS = ['kind', 'name', 'description', 'status', 'owner'];
+const LIST_CONCEPT_FIELDS = ['constraints', 'references', 'presentIn', 'attestations'];
+const SCALAR_RELATIONSHIP_FIELDS = ['kind', 'from', 'to', 'name', 'description', 'status', 'mode', 'content'];
+const LIST_RELATIONSHIP_FIELDS = ['references', 'presentIn'];
+const appendBlockItem = (document, collection, item) => {
+    document.addIn([collection], item);
+    const sequence = document.getIn([collection], true);
+    if (isSeq(sequence)) {
+        sequence.flow = false;
+    }
+};
+const findItem = (document, collection, id) => {
+    const sequence = document.get(collection, true);
+    if (!isSeq(sequence))
+        return undefined;
+    return sequence.items.find((item) => typeof item === 'object' &&
+        item !== null &&
+        'get' in item &&
+        item.get('id') === id);
+};
+const applyFields = (document, item, fields, scalars, lists) => {
+    for (const key of scalars) {
+        if (fields[key] !== undefined)
+            item.set(key, fields[key]);
+    }
+    for (const key of lists) {
+        const additions = fields[key];
+        if (additions === undefined || additions.length === 0)
+            continue;
+        const existing = item.get(key);
+        if (existing === undefined) {
+            item.set(key, additions);
+        }
+        else if (isSeq(existing)) {
+            for (const entry of additions) {
+                existing.items.push(document.createNode(entry));
+            }
+        }
+    }
+};
+export function runApplyCommand(options, cwd) {
+    const json = options.includes('--json');
+    const rest = options.filter((option) => option !== '--json');
+    const [operationsPath, workspacePath] = rest;
+    if (rest.length !== 2 ||
+        operationsPath === undefined ||
+        workspacePath === undefined ||
+        rest.some((option) => option.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: 'apply requires an explicit workspace manifest (yarramate/workspace/v1)\n',
+            };
+        }
+        const failed = (diagnostics) => ({
+            exitCode: 1,
+            stdout: json ? diagnosticJson(diagnostics) : humanDiagnostics(diagnostics),
+            stderr: '',
+        });
+        const loadedWorkspace = loadWorkspaceManifest({ path: workspacePath, source: manifestSource }, cwd);
+        if (!loadedWorkspace.ok)
+            return failed(loadedWorkspace.diagnostics);
+        const workspace = loadedWorkspace.workspace;
+        const operationsSource = readFileSync(resolve(cwd, operationsPath), 'utf8');
+        const loadedOperations = loadSourceDocument({ path: operationsPath, source: operationsSource }, validateOperations, 'Operations');
+        if (!loadedOperations.ok)
+            return failed(loadedOperations.diagnostics);
+        const operations = loadedOperations.document.value.operations;
+        const yaml = loadedOperations.document.yaml;
+        const lineCounter = loadedOperations.document.lineCounter;
+        // Documents are addressed by their manifest paths; an operation aimed
+        // anywhere else is rejected before anything is touched.
+        const workspaceDocuments = new Map(workspace.documents.map((path) => [resolve(cwd, path), path]));
+        const parsed = new Map();
+        const counts = {
+            addedConcepts: 0,
+            addedRelationships: 0,
+            updatedConcepts: 0,
+            updatedRelationships: 0,
+        };
+        for (const [index, operation] of operations.entries()) {
+            const absolute = resolve(cwd, operation.document);
+            const manifestPath = workspaceDocuments.get(absolute);
+            const locate = (message) => ({
+                severity: 'error',
+                code: 'YM912',
+                message,
+                ...locateSourcePath(operationsPath, yaml, lineCounter, ['operations', index, 'document'], `/operations/${index}/document`),
+            });
+            if (manifestPath === undefined) {
+                return failed([
+                    locate(`Operation ${index} targets "${operation.document}", which is not a document of workspace "${workspace.id}"`),
+                ]);
+            }
+            let document = parsed.get(absolute);
+            if (document === undefined) {
+                document = parseDocument(readFileSync(absolute, 'utf8'));
+                parsed.set(absolute, document);
+            }
+            if (operation.op === 'add-concept') {
+                appendBlockItem(document, 'concepts', operation.concept);
+                counts.addedConcepts += 1;
+            }
+            else if (operation.op === 'add-relationship') {
+                appendBlockItem(document, 'relationships', operation.relationship);
+                counts.addedRelationships += 1;
+            }
+            else {
+                const collection = operation.op === 'update-concept' ? 'concepts' : 'relationships';
+                const payload = operation.op === 'update-concept'
+                    ? operation.concept
+                    : operation.relationship;
+                const item = findItem(document, collection, payload.id);
+                if (item === undefined) {
+                    return failed([
+                        locate(`Operation ${index} updates "${payload.id}", which does not exist in ${operation.document}`),
+                    ]);
+                }
+                applyFields(document, item, payload, operation.op === 'update-concept'
+                    ? SCALAR_CONCEPT_FIELDS
+                    : SCALAR_RELATIONSHIP_FIELDS, operation.op === 'update-concept'
+                    ? LIST_CONCEPT_FIELDS
+                    : LIST_RELATIONSHIP_FIELDS);
+                if (operation.op === 'update-concept') {
+                    counts.updatedConcepts += 1;
+                }
+                else {
+                    counts.updatedRelationships += 1;
+                }
+            }
+        }
+        // The atomic gate: the whole candidate workspace must compile before a
+        // single byte is written; any diagnostic rejects the entire batch.
+        const candidates = new Map([...parsed.entries()].map(([absolute, document]) => [
+            absolute,
+            document.toString({ lineWidth: 0 }),
+        ]));
+        const compilation = compileWorkspace([...workspace.profiles, ...workspace.documents].map((path) => {
+            const absolute = resolve(cwd, path);
+            return {
+                path,
+                source: candidates.get(absolute) ?? readFileSync(absolute, 'utf8'),
+            };
+        }));
+        if (!compilation.ok)
+            return failed(compilation.diagnostics);
+        for (const [absolute, source] of candidates) {
+            writeFileSync(absolute, source, 'utf8');
+        }
+        const touched = [...parsed.keys()]
+            .map((absolute) => workspaceDocuments.get(absolute))
+            .sort();
+        if (json) {
+            return {
+                exitCode: 0,
+                stdout: `${JSON.stringify({
+                    format: 'yarramate/apply-result/v1',
+                    workspace: workspace.id,
+                    applied: counts,
+                    documents: touched,
+                }, null, 2)}\n`,
+                stderr: '',
+            };
+        }
+        const applied = counts.addedConcepts +
+            counts.addedRelationships +
+            counts.updatedConcepts +
+            counts.updatedRelationships;
+        return {
+            exitCode: 0,
+            stdout: `Applied ${applied} operation${applied === 1 ? '' : 's'} to ${touched.join(', ')}\n`,
+            stderr: '',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
+    }
+}

package/dist/{new-command.d.ts → ask-command.d.ts}

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