@uwmd/core 1.7.0 → 1.9.0

package/dist/cli.js

@@ -3,10 +3,11 @@
 // Commands: parse, validate, compact, diff, init, summary, render
 // Usage: uwmd <command> <file> [options]
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'node:fs';
-import { resolve, basename, dirname } from 'node:path';
+import { resolve, basename } from 'node:path';
 import { parseUWFile } from './parser.js';
 import { validateUWFile } from './validator.js';
 import { compact, diff } from './compactor.js';
+import { migrateSourceTags } from './migrate-source-tags.js';
 import { generateBlankUWFile } from './init.js';
 import { render } from './renderer.js';
 import { renderReportHtml } from './report.js';
@@ -14,8 +15,9 @@ import { stringifyUWEnvelope } from './uwjson.js';
 import { stampEnvelopeDigest, toUWEnvelope, } from './envelope.js';
 import { CORE_CODEC_REGISTRY } from './codecs.js';
 import { writeAgentBlock } from './runner.js';
-import { applyEdit } from './editor.js';
+import { applyEdit, applyEditAsync } from './editor.js';
 import { verifyChain, verifyProvenance } from './integrity.js';
+import { REFERENCE_IMPLEMENTATION_MANIFEST } from './protocol.js';
 import { loadModuleManifest, createModuleRegistry, ModuleRegistryError } from './modules.js';
 import { cmdLeaseValidate, cmdLeaseProject, cmdPackageCreate, cmdPackageVerify, cmdPackageList, cmdPackageToContext, cmdPackageContextValidate, cmdPackageEdges, } from './cli-packages.js';
 import { evaluateCalc } from './calc/index.js';
@@ -34,6 +36,7 @@ import { detectUWSourceRepresentation, UWX_REPRESENTATION_ID, UW_LITE_SOURCE_DES
 import { parseUWLite } from './lite.js';
 import { compileUWLite, projectUWEnvelopeToLite, stringifyUWX, } from './lite-bridge.js';
 import { UW_LITE_REPRESENTATION_ID } from './source-representation.js';
+import { parseFlags, extractPositionals, replaceUWExtension, hostTierFlag, defaultPartsDir, readManifestFile, } from './cli-args.js';
 const [, , command, ...args] = process.argv;
 function readFile(path) {
     const resolved = resolve(path);
@@ -54,30 +57,6 @@ function loadInstitutionConfig(path) {
         return undefined;
     }
 }
-function parseFlags(rawArgs) {
-    const flags = {};
-    for (let i = 0; i < rawArgs.length; i++) {
-        const arg = rawArgs[i];
-        if (arg.startsWith('--')) {
-            const body = arg.slice(2);
-            const eqIdx = body.indexOf('=');
-            if (eqIdx >= 0) {
-                flags[body.slice(0, eqIdx)] = body.slice(eqIdx + 1);
-                continue;
-            }
-            const key = body;
-            const next = rawArgs[i + 1];
-            if (next && !next.startsWith('--')) {
-                flags[key] = next;
-                i++;
-            }
-            else {
-                flags[key] = true;
-            }
-        }
-    }
-    return flags;
-}
 // ─── Commands ─────────────────────────────────────────────────────────────────
 function cmdParse(file, flags) {
     const content = readFile(file);
@@ -96,11 +75,24 @@ function cmdParse(file, flags) {
     for (const warning of detection.warnings)
         console.warn(`Warning: ${warning}`);
     const parsed = parseUWFile(content, { strict: flags['strict'] === true });
+    // The whole ParsedUWFile minus `raw` (which is just the input echoed back).
+    // Four fields — custom_calculations, custom_scenarios, extensions, and the
+    // full `superseded` blocks — used to be dropped here, so a caller that
+    // trusted `uwmd parse` to be "the parsed file" silently lost every custom
+    // calculation and every x_* extension in the document.
+    //
+    // `superseded_blocks` is kept alongside `superseded` for compatibility: it
+    // carries only each prior block's `content`, where `superseded` carries the
+    // whole block. New callers should read `superseded`.
     const output = {
         frontmatter: parsed.frontmatter,
         sections: Object.fromEntries(Object.entries(parsed.sections).map(([id, block]) => [id, block])),
         prose: parsed.prose,
         pipeline_log: parsed.pipeline_log.map(b => b.content),
+        custom_calculations: parsed.custom_calculations,
+        custom_scenarios: parsed.custom_scenarios,
+        extensions: parsed.extensions,
+        superseded: parsed.superseded,
         superseded_blocks: Object.fromEntries(Object.entries(parsed.superseded).map(([id, blocks]) => [id, blocks.map(b => b.content)])),
     };
     console.log(JSON.stringify(output, null, flags['compact'] ? 0 : 2));
@@ -171,6 +163,40 @@ function cmdValidate(file, flags) {
     console.log('');
     process.exit(result.errors.length > 0 ? 1 : 0);
 }
+/**
+ * Build the `verifyChain` options from `--signing --keystore=<path>`.
+ *
+ * `@uwmd/signing` is reached by dynamic import and declared as an optional peer
+ * - the same arrangement `@anthropic-ai/sdk` gets. `@uwmd/core` must not take a
+ * crypto dependency to satisfy a flag most invocations never pass, and the
+ * layering invariant (core depends on no sibling package) forbids a static
+ * import outright.
+ */
+async function signingOptions(flags) {
+    if (!flags['signing'])
+        return {};
+    const keystore = flags['keystore'];
+    if (typeof keystore !== 'string' || keystore.length === 0) {
+        console.error('--signing requires --keystore=<path> to a JSON key store.');
+        process.exit(1);
+    }
+    let signing;
+    try {
+        signing = (await import('@uwmd/signing'));
+    }
+    catch {
+        console.error('--signing needs the optional @uwmd/signing package. Install it with `npm i @uwmd/signing`.');
+        process.exit(1);
+    }
+    try {
+        const store = await signing.loadKeyStoreFile(resolve(keystore));
+        return { signatureVerifier: signing.createBlockSignatureVerifier(store) };
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
 async function cmdVerify(file, flags) {
     const content = readFile(file);
     // --resolved verifies the assembled record. Without it an externalized
@@ -191,8 +217,8 @@ async function cmdVerify(file, flags) {
     }
     let chain;
     let prov;
-    if (runAll || onlyIntegrity) {
-        chain = await verifyChain(parsed);
+    if (runAll || onlyIntegrity || flags['signing']) {
+        chain = await verifyChain(parsed, await signingOptions(flags));
         sections['integrity'] = chain;
         if (!chain.ok)
             hadError = true;
@@ -219,6 +245,12 @@ async function cmdVerify(file, flags) {
         }
         if (chain) {
             console.log(`\nIntegrity: ${chain.ok ? 'ok' : 'FAIL'} — chains_with_hashes=${chain.chains_with_hashes}, chains_verified=${chain.chains_verified}`);
+            if (chain.signatures_present > 0) {
+                const checked = flags['signing']
+                    ? `${chain.signatures_verified} verified`
+                    : 'not checked (pass --signing --keystore=<path>)';
+                console.log(`Signatures: ${chain.signatures_present} present, ${checked}`);
+            }
             for (const issue of chain.issues) {
                 console.log(`  [${issue.severity.toUpperCase()}] ${issue.code}${issue.section ? ` [${issue.section}]` : ''}: ${issue.message}`);
             }
@@ -253,6 +285,24 @@ function cmdCompact(file, flags) {
     writeFileSync(outPath, compacted, 'utf-8');
     console.log(`Compacted ${totalSuperseded} superseded block(s). Wrote to: ${outPath}`);
 }
+function cmdMigrateSourceTags(file, flags) {
+    const content = readFile(file);
+    const result = migrateSourceTags(content);
+    for (const source of result.unmapped) {
+        console.error(`[unmapped] _meta.source '${source}' was left in place — rewrite it by hand.`);
+    }
+    if (result.changed === 0) {
+        console.log(`No legacy _meta.source values found in ${basename(file)} — nothing to migrate.`);
+        return;
+    }
+    if (flags['dry-run']) {
+        console.log(`Would migrate ${result.changed} block(s) in ${basename(file)} (RFC 0031 actor/resolution split).`);
+        return;
+    }
+    const outPath = flags['output'] ? resolve(flags['output']) : resolve(file);
+    writeFileSync(outPath, result.content, 'utf-8');
+    console.log(`Migrated ${result.changed} block(s). Wrote to: ${outPath}`);
+}
 function cmdDiff(fileA, fileB) {
     const contentA = readFile(fileA);
     const contentB = readFile(fileB);
@@ -402,14 +452,6 @@ async function loadEnvelope(file) {
  * rather than `deal.uw.json`. (`.uw.md` does not match a `.uwx.md` filename —
  * the suffixes genuinely differ — so it was silently a no-op, not a mis-match.)
  */
-function replaceUWExtension(file, extension) {
-    const lower = file.toLowerCase();
-    for (const suffix of [UWX_EXTENSION, '.uw.csv.zip', '.uw.md', '.uw.json', '.uw.xml']) {
-        if (lower.endsWith(suffix))
-            return `${file.slice(0, -suffix.length)}${extension}`;
-    }
-    return `${file}${extension}`;
-}
 async function cmdConvert(file, flags) {
     const requested = flags['to'];
     if (typeof requested !== 'string') {
@@ -488,18 +530,6 @@ async function cmdReceiptIssue(file, flags) {
     console.log('A receipt attests that these outputs follow from this record. It does not attest that the inputs are true.');
 }
 // ─── Modules ──────────────────────────────────────────────────────────────────
-function readManifestFile(path) {
-    try {
-        return { ok: true, manifest: JSON.parse(readFileSync(resolve(path), 'utf-8')) };
-    }
-    catch (e) {
-        return { ok: false, message: e instanceof Error ? e.message : String(e) };
-    }
-}
-function hostTierFlag(flags) {
-    const tier = flags['tier'];
-    return typeof tier === 'string' ? tier : undefined;
-}
 function cmdModulesValidate(files, flags) {
     const hostTier = hostTierFlag(flags);
     const reports = files.map((file) => {
@@ -809,16 +839,7 @@ function cmdRefine(file, flags) {
 }
 // ─── Router ───────────────────────────────────────────────────────────────────
 const flags = parseFlags(args);
-// Positional args: non-flag tokens that don't immediately follow a --flag
-const positional = [];
-for (let _i = 0; _i < args.length; _i++) {
-    const a = args[_i];
-    if (a.startsWith('--')) {
-        _i++;
-        continue;
-    } // skip flag + its value
-    positional.push(a);
-}
+const positional = extractPositionals(args);
 // ─── Composition (RFC 0021) ──────────────────────────────────────────────────
 /** Load every `.uwpart.md` in a directory, keyed by `part_id`. */
 function loadPartsDir(dir) {
@@ -836,10 +857,6 @@ function loadPartsDir(dir) {
     }
     return parts;
 }
-/** Where fragments live for a record, unless told otherwise. */
-function defaultPartsDir(file) {
-    return resolve(dirname(resolve(file)), 'parts');
-}
 function cmdCompose(file, flags) {
     const section = flags['externalize'];
     if (typeof section !== 'string') {
@@ -969,7 +986,7 @@ function withResolved(parsed, file, flags) {
             break;
         case 'verify':
             if (!positional[0]) {
-                console.error('Usage: uwmd verify <file> [--validate] [--integrity] [--policy] [--resolved] [--json]');
+                console.error('Usage: uwmd verify <file> [--validate] [--integrity] [--policy] [--signing --keystore=<path>] [--resolved] [--json]');
                 process.exit(1);
             }
             await cmdVerify(positional[0], flags);
@@ -988,6 +1005,13 @@ function withResolved(parsed, file, flags) {
             }
             cmdDiff(positional[0], positional[1]);
             break;
+        case 'migrate':
+            if (!positional[0] || !flags['source-tags']) {
+                console.error('Usage: uwmd migrate <file> --source-tags [--output <file>] [--dry-run]');
+                process.exit(1);
+            }
+            cmdMigrateSourceTags(positional[0], flags);
+            break;
         case 'render': {
             if (!positional[0]) {
                 console.error('Usage: uwmd render <file> [--format <json|csv|chat|summary>] [--profile <summary|live|compact|full|relevant>] [--sections a,b,c] [--max-tokens 12000] [--no-meta] [--output <file>] [--tier screener|analyst]');
@@ -1153,7 +1177,7 @@ function withResolved(parsed, file, flags) {
             break;
         case 'edit': {
             if (!positional[0] || !positional[1]) {
-                console.error('Usage: uwmd edit <file> <operation.json> [--actor <name>] [--source <pattern>] [--agent-id <id>] [--agent-version <v>] [--confidence high|medium|low] [--output <file>]');
+                console.error('Usage: uwmd edit <file> <operation.json> [--actor <name>] [--source <pattern>] [--agent-id <id>] [--agent-version <v>] [--confidence high|medium|low] [--output <file>] [--capability-token <jwt> --coord-key <keystore.json>]');
                 process.exit(1);
             }
             const fileContent = readFile(positional[0]);
@@ -1174,7 +1198,47 @@ function withResolved(parsed, file, flags) {
                 agentVersion: flags['agent-version'] ?? null,
                 confidence: flags['confidence'] ?? 'medium',
             };
-            const result = applyEdit(fileContent, parsedFile, op, ctx);
+            // Capability enforcement (Protocol §XIV, RFC 0011). Same optional-peer
+            // dynamic-import arrangement as `--signing` above: core takes no crypto
+            // dependency to satisfy a flag most invocations never pass.
+            let result;
+            const capToken = flags['capability-token'];
+            if (typeof capToken === 'string' && capToken.length > 0) {
+                const coordKey = flags['coord-key'];
+                if (typeof coordKey !== 'string' || coordKey.length === 0) {
+                    console.error('--capability-token requires --coord-key=<path> to the coordinator\'s JSON key store.');
+                    process.exit(1);
+                }
+                let signing;
+                try {
+                    signing = (await import('@uwmd/signing'));
+                }
+                catch {
+                    console.error('--capability-token needs the optional @uwmd/signing package. Install it with `npm i @uwmd/signing`.');
+                    process.exit(1);
+                }
+                try {
+                    const store = await signing.loadKeyStoreFile(resolve(coordKey));
+                    ctx.capability_token = capToken;
+                    result = await applyEditAsync(fileContent, parsedFile, op, ctx, undefined, {
+                        capabilityVerifier: signing.createCapabilityVerifier(store),
+                    });
+                }
+                catch (error) {
+                    console.error(error.message);
+                    process.exit(1);
+                }
+            }
+            else {
+                result = applyEdit(fileContent, parsedFile, op, ctx);
+            }
+            // --json reports the edit instead of performing it: the conformance driver
+            // needs the resulting content, and a driver that rewrote fixtures as a side
+            // effect of reading them would corrupt the corpus it is testing.
+            if (flags['json']) {
+                console.log(JSON.stringify(result, null, 2));
+                process.exit(result.ok ? 0 : 1);
+            }
             if (!result.ok || !result.content) {
                 console.error(`Edit rejected: [${result.error?.code}] ${result.error?.message}`);
                 if (result.error?.pointer)
@@ -1214,16 +1278,21 @@ function withResolved(parsed, file, flags) {
                 locale: 'en-US',
             };
             const results = decls.map((d) => evaluateCalc(d, ctx));
-            for (const r of results) {
-                if (r.ok) {
-                    console.log(`${r.calc_id} = ${r.display ?? String(r.value)}`);
-                }
-                else {
-                    console.log(`${r.calc_id} ERROR [${r.error?.code}] ${r.error?.message}`);
-                }
-            }
+            // Under --json, stdout is exactly one JSON document — the conformance CLI
+            // protocol (§II.6a) depends on that, and printing the human lines first
+            // would make every calc response unparseable.
             if (flags['json']) {
-                console.log(JSON.stringify(results, null, 2));
+                console.log(JSON.stringify(results.length === 1 ? results[0] : results, null, 2));
+            }
+            else {
+                for (const r of results) {
+                    if (r.ok) {
+                        console.log(`${r.calc_id} = ${r.display ?? String(r.value)}`);
+                    }
+                    else {
+                        console.log(`${r.calc_id} ERROR [${r.error?.code}] ${r.error?.message}`);
+                    }
+                }
             }
             if (results.some((r) => !r.ok))
                 process.exit(1);
@@ -1402,6 +1471,11 @@ function withResolved(parsed, file, flags) {
             }
             break;
         }
+        case 'manifest':
+            // The conformance CLI protocol's identity call (§II.6a). Emitted with no
+            // surrounding prose so a driver can read it without a parser.
+            console.log(JSON.stringify(REFERENCE_IMPLEMENTATION_MANIFEST, null, 2));
+            break;
         case 'receipt': {
             const sub = positional[0];
             if (sub === 'issue') {
@@ -1432,11 +1506,14 @@ Commands:
   parse    <file>              Parse file and output JSON
   validate <file>              Run all validation checks
   verify   <file>              Validate + verify integrity (hashes) + provenance (actor/policy)
+                               --signing --keystore=<path> also checks block signatures (RFC 0010,
+                               via the optional @uwmd/signing package)
   render   <file>              Render to output format (see --format)
   run      <file>              Invoke a Bancroft agent (see --agent)
   edit     <file> <op.json>    Apply an EditOperation (Tier-2)
   compact  <file>              Strip superseded blocks
   diff     <file-a> <file-b>  Compare two files section by section
+  migrate  <file> --source-tags  Rewrite legacy _meta.source values into the actor/resolution split (RFC 0031)
   calc     <file> <calc.json>  Evaluate a calc declaration or inline formula (Tier-3)
   init                         Generate a blank .uwx.md file
   summary  <file>              Print quick metrics to terminal
@@ -1452,16 +1529,19 @@ Commands:
   modules  validate|list        Validate module manifest files, or list the registry they form
   lease    validate|project     Validate a lease abstract, or project it to a rent-roll row (RFC 0018)
   package  create|verify|...    Build, verify, list, or project a UW Deal Package (RFC 0018)
+  manifest                     Print this implementation's ImplementationManifest (conformance protocol)
   layers                       List Bancroft agent layers
 
 Options:
   --output <path>    Output file path (compact, init)
   --dry-run          Show what would change without writing (compact)
-  --json             JSON output (validate)
+  --json             JSON output on stdout, nothing else (validate, calc, edit)
   --strict           Throw on parse errors instead of collecting
   --format <f>       Render format: json|csv|chat|summary (render, default: summary)
   --no-superseded    Drop append-only history from the .uw.json export (export)
   --resolved         Resolve externalized sections first (verify, export)
+  --signing          Check _meta.signature on every block (verify; requires --keystore)
+  --keystore <path>  JSON key store mapping kid to public key (verify --signing)
   --parts <dir>      Fragment directory (compose, resolve, --resolved; default: ./parts)
   --externalize <s>  Section to split into fragments (compose)
   --collection-key <k>  Row identity field (compose, default: unit_id)