mixdog 0.7.1

package/scripts/edit-operation-smoke.mjs

@@ -0,0 +1,369 @@
+// Smoke test: consolidated `edit` tool operation ROUTING.
+//
+// The `edit` builtin now multiplexes three operations behind one tool:
+//   operation: 'replace' (default) -> executeEditTool   (text edit engine)
+//   operation: 'notebook'          -> executeNotebookEditTool (.ipynb cells)
+//   operation: 'rename'            -> executeRenameTool  (graph-based rename)
+//
+// We drive every case through the real dispatch entry `executeBuiltinTool`
+// (src/agent/orchestrator/tools/builtin.mjs), so what gets exercised is the
+// `case 'edit'` routing on args.operation — not the handlers in isolation.
+// Each operation has a handler-EXCLUSIVE output signature, so matching it
+// proves the dispatch routed operation -> handler correctly:
+//   • text edit   -> "Edited: ..."          (only edit-engine emits this)
+//   • notebook    -> "Updated/Inserted/Deleted cell ..." (only notebook handler)
+//   • rename      -> JSON { mode:'preview'|'apply', warning:'APPROXIMATE…' }
+//
+// Invariants asserted (not just smoke-imported):
+//   1. operation omitted defaults to replace and edits succeed.
+//   2. operation:'replace' explicit, single + batch edits[].
+//   3. notebook replace resets a code cell's execution_count -> null and
+//      clears THAT cell's outputs; insert adds a cell; delete removes one.
+//   4. rename PREVIEW (apply omitted/false) returns change list + APPROXIMATE
+//      warning AND writes NO file (temp file byte-identical before/after).
+//   5. rename apply:true renames only find_references-sanctioned code spans;
+//      a same-line string/comment occurrence is left untouched.
+//   6. invalid operation 'bogus' -> guard error, nothing mutated.
+//   7. routing: notebook/rename reach their handlers; replace/omitted reach
+//      the text-edit path (handler-exclusive output signatures).
+
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+// Derive CLAUDE_PLUGIN_DATA from the repo root so the rename case finds the
+// already-cached mixdog-graph binary instead of attempting a network fetch.
+process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
+process.env.MIXDOG_HINT_LEVEL ||= 'normal';
+
+const { executeBuiltinTool } = await import(
+    pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/builtin.mjs')).href
+);
+
+const SCOPE = 'edit-op-smoke';
+
+let failures = 0;
+function check(label, cond, detail = '') {
+    if (!cond) {
+        failures++;
+        console.error(`  FAIL ${label}${detail ? `: ${detail}` : ''}`);
+    }
+    return cond;
+}
+function caseResult(name, ok) {
+    process.stdout.write(`Case ${name}: ${ok ? 'PASS' : 'FAIL'}\n`);
+}
+function isErr(out) {
+    return typeof out === 'string' && out.startsWith('Error');
+}
+
+// Warm a read snapshot so edit/notebook read-before-write guards are satisfied
+// deterministically (text edits also auto-snapshot, but notebook does not).
+async function warmRead(dir, path, opts = {}) {
+    return executeBuiltinTool('read', { path, ...opts }, dir, {
+        readStateScope: SCOPE,
+        mediaTextOnly: true,
+    });
+}
+
+function makeNotebook() {
+    return {
+        cells: [
+            {
+                cell_type: 'code',
+                id: 'cellA',
+                metadata: {},
+                execution_count: 7,
+                outputs: [{ output_type: 'stream', name: 'stdout', text: ['old output\n'] }],
+                source: ['print("old")\n'],
+            },
+            {
+                cell_type: 'markdown',
+                id: 'cellB',
+                metadata: {},
+                source: ['# heading\n'],
+            },
+            {
+                cell_type: 'code',
+                id: 'cellC',
+                metadata: {},
+                execution_count: 3,
+                outputs: [],
+                source: ['x = 1\n'],
+            },
+        ],
+        metadata: {},
+        nbformat: 4,
+        nbformat_minor: 5,
+    };
+}
+
+const RENAME_SOURCE = [
+    'const widget = 1;',
+    'export function getWidget() {',
+    '  return widget; // widget label retained',
+    '}',
+    'const note = "widget literal stays";',
+    '',
+].join('\n');
+
+const dir = await mkdtemp(join(tmpdir(), 'mixdog-edit-op-smoke-'));
+const renameDir = await mkdtemp(join(tmpdir(), 'mixdog-edit-op-rename-'));
+
+async function rmTree(p) {
+    await rm(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+}
+
+try {
+    // ── Case 1: operation omitted -> defaults to replace ────────────────────
+    {
+        const file = 'c1.txt';
+        await writeFile(join(dir, file), 'const a = 1;\n', 'utf8');
+        await warmRead(dir, file);
+        const out = await executeBuiltinTool('edit', {
+            path: file,
+            old_string: 'const a = 1;',
+            new_string: 'const a = 2;',
+        }, dir, { readStateScope: SCOPE });
+        const ok =
+            check('1.no-error', !isErr(out), String(out).slice(0, 160)) &
+            check('1.edit-signature', /^Edited:/.test(String(out)), String(out).slice(0, 80)) &
+            check('1.file-content', (await readFile(join(dir, file), 'utf8')) === 'const a = 2;\n');
+        caseResult('1 (omitted -> replace)', !!ok);
+    }
+
+    // ── Case 2: operation:'replace' explicit + batch edits[] ────────────────
+    {
+        const single = 'c2-single.txt';
+        await writeFile(join(dir, single), 'value = old;\n', 'utf8');
+        await warmRead(dir, single);
+        const sOut = await executeBuiltinTool('edit', {
+            operation: 'replace',
+            path: single,
+            old_string: 'value = old;',
+            new_string: 'value = NEW;',
+        }, dir, { readStateScope: SCOPE });
+
+        const batch = 'c2-batch.txt';
+        await writeFile(join(dir, batch), 'alpha\nbeta\ngamma\n', 'utf8');
+        await warmRead(dir, batch);
+        const bOut = await executeBuiltinTool('edit', {
+            operation: 'replace',
+            path: batch,
+            edits: [
+                { old_string: 'alpha', new_string: 'ALPHA' },
+                { old_string: 'gamma', new_string: 'GAMMA' },
+            ],
+        }, dir, { readStateScope: SCOPE });
+
+        const ok =
+            check('2.single-no-error', !isErr(sOut), String(sOut).slice(0, 160)) &
+            check('2.single-signature', /^Edited:/.test(String(sOut))) &
+            check('2.single-content', (await readFile(join(dir, single), 'utf8')) === 'value = NEW;\n') &
+            check('2.batch-no-error', !isErr(bOut), String(bOut).slice(0, 160)) &
+            check('2.batch-signature', /^Edited:/.test(String(bOut))) &
+            check('2.batch-content', (await readFile(join(dir, batch), 'utf8')) === 'ALPHA\nbeta\nGAMMA\n');
+        caseResult('2 (replace explicit + batch)', !!ok);
+    }
+
+    // ── Case 3: operation:'notebook' replace / insert / delete ──────────────
+    {
+        const nb = 'c3.ipynb';
+        await writeFile(join(dir, nb), JSON.stringify(makeNotebook(), null, 1), 'utf8');
+        await warmRead(dir, nb);
+
+        // replace a code cell's source -> execution_count reset, outputs cleared.
+        const repOut = await executeBuiltinTool('edit', {
+            operation: 'notebook',
+            notebook_path: nb,
+            edit_mode: 'replace',
+            cell_id: 'cellA',
+            new_source: 'print("brand new")\n',
+        }, dir, { readStateScope: SCOPE });
+        let afterRep = JSON.parse(await readFile(join(dir, nb), 'utf8'));
+        const cellA = afterRep.cells.find((c) => c.id === 'cellA');
+        const repOk =
+            check('3.replace-no-error', !isErr(repOut), String(repOut).slice(0, 160)) &
+            check('3.replace-signature', /^Updated cell/.test(String(repOut)), String(repOut).slice(0, 80)) &
+            check('3.replace-source', cellA && String(cellA.source) === 'print("brand new")\n') &
+            check('3.replace-exec-count-null', cellA && cellA.execution_count === null, JSON.stringify(cellA?.execution_count)) &
+            check('3.replace-outputs-cleared', cellA && Array.isArray(cellA.outputs) && cellA.outputs.length === 0, JSON.stringify(cellA?.outputs)) &
+            // sibling code cell C must keep its own outputs/exec_count untouched.
+            check('3.replace-sibling-untouched', (() => {
+                const c = afterRep.cells.find((x) => x.id === 'cellC');
+                return c && c.execution_count === 3;
+            })());
+
+        const countBeforeInsert = afterRep.cells.length;
+        const insOut = await executeBuiltinTool('edit', {
+            operation: 'notebook',
+            notebook_path: nb,
+            edit_mode: 'insert',
+            cell_id: 'cellA',
+            cell_type: 'code',
+            new_source: 'inserted = True\n',
+        }, dir, { readStateScope: SCOPE });
+        let afterIns = JSON.parse(await readFile(join(dir, nb), 'utf8'));
+        const insOk =
+            check('3.insert-no-error', !isErr(insOut), String(insOut).slice(0, 160)) &
+            check('3.insert-signature', /^Inserted/.test(String(insOut)), String(insOut).slice(0, 80)) &
+            check('3.insert-count', afterIns.cells.length === countBeforeInsert + 1,
+                `${countBeforeInsert} -> ${afterIns.cells.length}`) &
+            check('3.insert-source-present', afterIns.cells.some((c) => String(c.source) === 'inserted = True\n'));
+
+        const countBeforeDelete = afterIns.cells.length;
+        const delOut = await executeBuiltinTool('edit', {
+            operation: 'notebook',
+            notebook_path: nb,
+            edit_mode: 'delete',
+            cell_id: 'cellB',
+        }, dir, { readStateScope: SCOPE });
+        let afterDel = JSON.parse(await readFile(join(dir, nb), 'utf8'));
+        const delOk =
+            check('3.delete-no-error', !isErr(delOut), String(delOut).slice(0, 160)) &
+            check('3.delete-signature', /^Deleted/.test(String(delOut)), String(delOut).slice(0, 80)) &
+            check('3.delete-count', afterDel.cells.length === countBeforeDelete - 1,
+                `${countBeforeDelete} -> ${afterDel.cells.length}`) &
+            check('3.delete-gone', !afterDel.cells.some((c) => c.id === 'cellB'));
+
+        caseResult('3 (notebook replace/insert/delete)', !!(repOk & insOk & delOk));
+    }
+
+    // ── Case 4: rename PREVIEW writes NO file ───────────────────────────────
+    {
+        await writeFile(join(renameDir, 'package.json'), '{"name":"rename-fixture","private":true}\n', 'utf8');
+        await writeFile(join(renameDir, 'mod.mjs'), RENAME_SOURCE, 'utf8');
+        const before = await readFile(join(renameDir, 'mod.mjs'));
+
+        const out = await executeBuiltinTool('edit', {
+            operation: 'rename',
+            symbol: 'widget',
+            new_name: 'gadget',
+            // apply omitted -> preview only.
+        }, renameDir, { readStateScope: SCOPE });
+
+        let parsed = null;
+        try { parsed = JSON.parse(out); } catch { /* keep null */ }
+        const after = await readFile(join(renameDir, 'mod.mjs'));
+
+        const ok =
+            check('4.json-parse', parsed && typeof parsed === 'object', String(out).slice(0, 160)) &
+            check('4.mode-preview', parsed && parsed.mode === 'preview', parsed && parsed.mode) &
+            check('4.approx-warning', parsed && /APPROXIMATE/.test(String(parsed.warning))) &
+            check('4.changes-list', parsed && Array.isArray(parsed.changes) && parsed.changes.length > 0,
+                parsed && JSON.stringify(parsed.count)) &
+            check('4.no-write-byte-identical', before.equals(after), 'preview mutated the file');
+        caseResult('4 (rename preview no-write)', !!ok);
+    }
+
+    // ── Case 5: rename apply:true renames only sanctioned spans ─────────────
+    {
+        const out = await executeBuiltinTool('edit', {
+            operation: 'rename',
+            symbol: 'widget',
+            new_name: 'gadget',
+            apply: true,
+        }, renameDir, { readStateScope: SCOPE });
+
+        let parsed = null;
+        try { parsed = JSON.parse(out); } catch { /* keep null */ }
+        const text = await readFile(join(renameDir, 'mod.mjs'), 'utf8');
+
+        const ok =
+            check('5.json-parse', parsed && typeof parsed === 'object', String(out).slice(0, 160)) &
+            check('5.mode-apply', parsed && parsed.mode === 'apply', parsed && parsed.mode) &
+            check('5.replacements', parsed && parsed.replacements > 0, parsed && JSON.stringify(parsed.replacements)) &
+            // Code declaration + use renamed.
+            check('5.decl-renamed', text.includes('const gadget = 1;'), text) &
+            check('5.use-renamed', /return gadget;/.test(text), text) &
+            // Same-line comment occurrence left untouched.
+            check('5.comment-untouched', text.includes('// widget label retained'), text) &
+            // String literal occurrence left untouched.
+            check('5.string-untouched', text.includes('"widget literal stays"'), text);
+        caseResult('5 (rename apply, masked spans skipped)', !!ok);
+    }
+
+    // ── Case 6: invalid operation 'bogus' -> guard error, no mutation ───────
+    {
+        const file = 'c6.txt';
+        const original = 'do not touch\n';
+        await writeFile(join(dir, file), original, 'utf8');
+        await warmRead(dir, file);
+        const before = await readFile(join(dir, file));
+        const out = await executeBuiltinTool('edit', {
+            operation: 'bogus',
+            path: file,
+            old_string: 'do not touch',
+            new_string: 'mutated',
+        }, dir, { readStateScope: SCOPE });
+        const after = await readFile(join(dir, file));
+        const ok =
+            check('6.is-error', isErr(out), String(out).slice(0, 160)) &
+            check('6.error-mentions-operation', /operation/.test(String(out))) &
+            check('6.error-lists-valid', /replace\|notebook\|rename/.test(String(out)), String(out)) &
+            check('6.no-mutation', before.equals(after), 'guard error still mutated the file');
+        caseResult('6 (invalid operation guarded)', !!ok);
+    }
+
+    // ── Case 7: routing — operation -> handler (exclusive signatures) ───────
+    {
+        // omitted/replace -> text edit engine ("Edited:")
+        const r1 = 'c7-omit.txt';
+        await writeFile(join(dir, r1), 'route a\n', 'utf8');
+        await warmRead(dir, r1);
+        const omit = await executeBuiltinTool('edit', {
+            path: r1, old_string: 'route a', new_string: 'route A',
+        }, dir, { readStateScope: SCOPE });
+
+        const r2 = 'c7-replace.txt';
+        await writeFile(join(dir, r2), 'route b\n', 'utf8');
+        await warmRead(dir, r2);
+        const replace = await executeBuiltinTool('edit', {
+            operation: 'replace', path: r2, old_string: 'route b', new_string: 'route B',
+        }, dir, { readStateScope: SCOPE });
+
+        // notebook -> notebook handler ("Updated cell")
+        const r3 = 'c7.ipynb';
+        await writeFile(join(dir, r3), JSON.stringify(makeNotebook(), null, 1), 'utf8');
+        await warmRead(dir, r3);
+        const notebook = await executeBuiltinTool('edit', {
+            operation: 'notebook', notebook_path: r3, edit_mode: 'replace',
+            cell_id: 'cellC', new_source: 'y = 2\n',
+        }, dir, { readStateScope: SCOPE });
+
+        // rename -> rename handler (JSON preview, never reaches text engine)
+        const rename = await executeBuiltinTool('edit', {
+            operation: 'rename', symbol: 'getWidget', new_name: 'getGadget',
+        }, renameDir, { readStateScope: SCOPE });
+        let renameParsed = null;
+        try { renameParsed = JSON.parse(rename); } catch { /* keep null */ }
+
+        const ok =
+            // text-edit path exclusive signature
+            check('7.omitted->text-edit', /^Edited:/.test(String(omit)), String(omit).slice(0, 80)) &
+            check('7.replace->text-edit', /^Edited:/.test(String(replace)), String(replace).slice(0, 80)) &
+            // notebook handler exclusive signature (text engine never emits "Updated cell")
+            check('7.notebook->notebook-handler', /^Updated cell/.test(String(notebook)), String(notebook).slice(0, 80)) &
+            check('7.notebook-not-text-edit', !/^Edited:/.test(String(notebook))) &
+            // rename handler exclusive signature (text engine never emits this JSON shape)
+            check('7.rename->rename-handler',
+                renameParsed && (renameParsed.mode === 'preview' || renameParsed.mode === 'apply')
+                    && /APPROXIMATE/.test(String(renameParsed.warning)),
+                String(rename).slice(0, 120)) &
+            check('7.rename-not-text-edit', !/^Edited:/.test(String(rename)));
+        caseResult('7 (operation -> handler routing)', !!ok);
+    }
+} finally {
+    await rmTree(dir);
+    await rmTree(renameDir);
+}
+
+if (failures > 0) {
+    console.error(`\n${failures} smoke check(s) failed.`);
+    process.stdout.write('ALL_FAIL\n');
+    process.exit(1);
+}
+process.stdout.write('edit-operation-smoke: all cases passed.\nALL_PASS\n');
+process.exit(0);

package/scripts/edit2-smoke.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// edit2-smoke.mjs — end-to-end check of the native --edit2 (persistent server)
+// path through runNativeExactEdit: exact / curly / nfc / crlf tiers +
+// replace_all. Exercises B1 (server EDIT2 handler) + B2 (server client).
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
+// Pin the freshly built local binary: the runtime CLAUDE_PLUGIN_ROOT may point
+// at the installed plugin copy, whose cached prebuilt predates --edit2.
+process.env.MIXDOG_PATCH_NATIVE_BIN ||= join(
+  ROOT,
+  'native/mixdog-patch/target/release',
+  process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch',
+);
+
+const { runNativeExactEdit } = await import(
+  pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/builtin/native-edit-runner.mjs')).href
+);
+const { closeNativePatchServerForTests } = await import(
+  pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/patch.mjs')).href
+);
+
+const dir = mkdtempSync(join(tmpdir(), 'edit2-smoke-'));
+let failures = 0;
+
+function check(name, cond, detail) {
+  if (cond) {
+    console.log(`ok   ${name}`);
+  } else {
+    console.log(`FAIL ${name}${detail ? ' :: ' + detail : ''}`);
+    failures++;
+  }
+}
+
+async function run(name, content, args, expectFile, expectTier) {
+  const f = join(dir, name + '.txt');
+  writeFileSync(f, content);
+  const r = await runNativeExactEdit({ fullPath: f, ...args });
+  const got = r.ok ? readFileSync(f, 'utf8') : null;
+  check(name, r.ok && got === expectFile && r.stage === expectTier, JSON.stringify({ r, got }));
+}
+
+try {
+  await run('exact', 'hello world', { oldStr: 'world', newStr: 'earth', replaceAll: false }, 'hello earth', 'exact');
+  await run('curly', 'say “hi”', { oldStr: '"hi"', newStr: 'BYE', replaceAll: false }, 'say BYE', 'curly');
+  await run('nfc', 'café bar', { oldStr: 'café', newStr: 'CAFE', replaceAll: false }, 'CAFE bar', 'nfc');
+  await run('crlf', 'a\r\nb\r\nc', { oldStr: 'a\nb', newStr: 'X', replaceAll: false }, 'X\r\nc', 'crlf');
+  await run('replace_all', 'x x x', { oldStr: 'x', newStr: 'y', replaceAll: true }, 'y y y', 'exact');
+  // EOL preservation: a CRLF file keeps CRLF even when new text is LF-style.
+  await run('crlf-eol', 'a\r\nold\r\nc', { oldStr: 'old', newStr: 'NEW', replaceAll: false }, 'a\r\nNEW\r\nc', 'exact');
+  // pure-deletion: empty new removes the line including its trailing newline.
+  await run('pure-del', 'keep1\ndrop\nkeep2', { oldStr: 'drop', newStr: '', replaceAll: false }, 'keep1\nkeep2', 'exact');
+} finally {
+  await closeNativePatchServerForTests().catch(() => {});
+  rmSync(dir, { recursive: true, force: true });
+}
+
+console.log(failures === 0 ? '\nedit2-smoke: PASS' : `\nedit2-smoke: FAIL (${failures})`);
+process.exit(failures === 0 ? 0 : 1);

package/scripts/fuzzy-e2e.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// fuzzy-e2e.mjs — end-to-end check of `list` fuzzy mode against the real repo:
+// a partial name should surface the matching file via rg --files + ranking.
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
+
+const { executeListTool } = await import(
+  pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/builtin/list-tool.mjs')).href
+);
+
+let fail = 0;
+const check = (name, cond, detail) => {
+  console.log(`${cond ? 'ok  ' : 'FAIL'} ${name}${cond ? '' : ' :: ' + detail}`);
+  if (!cond) fail++;
+};
+
+const out = await executeListTool({ fuzzy: 'edeng', path: 'src' }, ROOT);
+console.log('--- top results ---\n' + String(out).split('\n').slice(0, 5).join('\n') + '\n---');
+check('edeng surfaces edit-engine.mjs', typeof out === 'string' && out.includes('edit-engine.mjs'), String(out).slice(0, 120));
+
+const miss = await executeListTool({ fuzzy: 'zzqqxx', path: 'src' }, ROOT);
+check('no-match returns a clean message', typeof miss === 'string' && /no fuzzy match/.test(miss), String(miss).slice(0, 120));
+
+console.log(fail === 0 ? '\nfuzzy-e2e: PASS' : `\nfuzzy-e2e: FAIL (${fail})`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/fuzzy-smoke.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// fuzzy-smoke.mjs — unit check for the fuzzy filename scorer.
+import { fuzzyScore, fuzzyRank } from '../src/agent/orchestrator/tools/builtin/fuzzy-match.mjs';
+
+let fail = 0;
+const check = (name, cond) => { console.log(`${cond ? 'ok  ' : 'FAIL'} ${name}`); if (!cond) fail++; };
+
+const items = [
+  { path: 'src/agent/orchestrator/tools/builtin/edit-engine.mjs' },
+  { path: 'src/agent/orchestrator/tools/builtin/edit-normalize.mjs' },
+  { path: 'docs/readme.md' },
+  { path: 'src/agent/index.mjs' },
+];
+
+const ranked = fuzzyRank('edeng', items);
+check('edeng -> edit-engine ranks first', ranked.length > 0 && ranked[0].item.path.includes('edit-engine.mjs'));
+
+const idx = fuzzyRank('agidx', items);
+check('agidx -> agent/index ranks first', idx.length > 0 && idx[0].item.path.endsWith('agent/index.mjs'));
+
+check('non-subsequence returns null', fuzzyScore('zzz', 'abc') === null);
+check('empty query scores 0', fuzzyScore('', 'whatever') === 0);
+check('basename beats dir match', fuzzyScore('readme', 'docs/readme.md') > fuzzyScore('readme', 'readme/other.txt'));
+
+console.log(fail === 0 ? '\nfuzzy-smoke: PASS' : `\nfuzzy-smoke: FAIL (${fail})`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/generate-runtime-manifest.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// generate-runtime-manifest.mjs
+// Aggregator step run after all matrix build jobs succeed.
+// Reads release assets via gh CLI, filters mixdog-runtime-*.tar.gz,
+// fetches sha256 from .sha256 sidecar files, and emits runtime-manifest.json
+// to both dist/ and src/memory/data/ (for the auto-PR).
+//
+// Environment:
+//   GITHUB_TOKEN  — PAT or GITHUB_TOKEN secret with contents:read
+//   RELEASE_TAG   — e.g. "runtime-v0.4.0" (falls back to process.argv[2])
+//   GITHUB_REPOSITORY — auto-set by Actions (e.g. "owner/repo")
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+
+const RELEASE_TAG = process.env.RELEASE_TAG ?? process.argv[2];
+const GITHUB_REPOSITORY = process.env.GITHUB_REPOSITORY ?? '';
+
+if (!RELEASE_TAG) {
+  console.error('ERROR: RELEASE_TAG env var or argv[2] required');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// 1. List release assets via gh CLI
+// ---------------------------------------------------------------------------
+console.log(`Listing assets for release: ${RELEASE_TAG}`);
+
+let assetsJson;
+try {
+  assetsJson = execSync(
+    `gh release view ${RELEASE_TAG} --repo ${GITHUB_REPOSITORY} --json assets`,
+    { encoding: 'utf8', env: process.env }
+  );
+} catch (err) {
+  console.error('gh release view failed:', err.message);
+  process.exit(1);
+}
+
+const { assets } = JSON.parse(assetsJson);
+
+// Filter tarball assets
+const tarballs = assets.filter(a => /^mixdog-runtime-.+\.tar\.gz$/.test(a.name));
+console.log(`Found ${tarballs.length} tarball(s):`, tarballs.map(a => a.name));
+
+if (tarballs.length === 0) {
+  console.error('No mixdog-runtime-*.tar.gz assets found on release.');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// 2. Parse version strings from a filename
+//    Format: mixdog-runtime-{os}-{arch}-pg{major}.{minor}-pgvector{vec}.tar.gz
+// ---------------------------------------------------------------------------
+const PG_RE = /pg(\d+)\.(\d+)/;
+const VEC_RE = /pgvector(\d+(?:\.\d+)+)/;
+
+let pgMajor = 16, pgMinor = 4, pgvectorVersion = '0.7.4';
+for (const t of tarballs) {
+  const pgM = PG_RE.exec(t.name);
+  const vM  = VEC_RE.exec(t.name);
+  if (pgM) { pgMajor = parseInt(pgM[1], 10); pgMinor = parseInt(pgM[2], 10); }
+  if (vM)  { pgvectorVersion = vM[1]; }
+  break; // all tarballs share the same version; just read the first
+}
+
+// ---------------------------------------------------------------------------
+// 3. Fetch sha256 sidecar content for each tarball
+// ---------------------------------------------------------------------------
+async function fetchSha256(sha256AssetName, downloadUrl) {
+  // Try matching .sha256 sidecar from the asset list first
+  const sidecar = assets.find(a => a.name === sha256AssetName);
+  if (sidecar) {
+    // Download the sidecar file text
+    try {
+      const tmpDir = resolve(tmpdir(), 'mixdog-manifest-sha256');
+      mkdirSync(tmpDir, { recursive: true });
+      execSync(
+        `gh release download ${RELEASE_TAG} --repo ${GITHUB_REPOSITORY} --pattern ${sha256AssetName} --dir "${tmpDir}" --clobber`,
+        { encoding: 'utf8', env: process.env }
+      );
+      const content = readFileSync(resolve(tmpDir, sha256AssetName), 'utf8').trim();
+      // Format: "<hex>  <filename>"
+      return content.split(/\s+/)[0];
+    } catch (e) {
+      console.warn(`Could not download sidecar ${sha256AssetName}: ${e.message}`);
+    }
+  }
+  return 'TBD'; // fallback if sidecar not present
+}
+
+// ---------------------------------------------------------------------------
+// 4. Build asset map
+// ---------------------------------------------------------------------------
+const PLATFORM_RE = /mixdog-runtime-([a-z0-9]+)-([a-z0-9]+)-/;
+
+const assetsMap = {};
+
+for (const tarball of tarballs) {
+  const m = PLATFORM_RE.exec(tarball.name);
+  if (!m) { console.warn(`Skipping unrecognised tarball: ${tarball.name}`); continue; }
+  const key = `${m[1]}-${m[2]}`; // e.g. "linux-x64"
+
+  const sha256Key = `${tarball.name}.sha256`;
+  const sha256 = await fetchSha256(sha256Key, tarball.url);
+
+  assetsMap[key] = {
+    url:    tarball.url,
+    sha256,
+    size:   tarball.size ?? 0,
+  };
+}
+
+// Ensure all expected platforms are present (fill missing with TBD)
+const EXPECTED = ['linux-x64', 'linux-arm64', 'darwin-x64', 'darwin-arm64', 'win32-x64'];
+for (const p of EXPECTED) {
+  if (!assetsMap[p]) {
+    console.warn(`WARNING: No asset found for platform ${p} — filling with TBD`);
+    assetsMap[p] = { url: 'TBD', sha256: 'TBD', size: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 5. Assemble manifest
+// ---------------------------------------------------------------------------
+const manifest = {
+  schema_version: 1,
+  generated_at:   new Date().toISOString(),
+  release_tag:    RELEASE_TAG,
+  pg: {
+    major: pgMajor,
+    minor: pgMinor,
+  },
+  pgvector: {
+    version: pgvectorVersion,
+  },
+  assets: assetsMap,
+};
+
+const manifestJson = JSON.stringify(manifest, null, 2) + '\n';
+console.log('Manifest:', manifestJson);
+
+// ---------------------------------------------------------------------------
+// 6. Write outputs
+// ---------------------------------------------------------------------------
+const distDir = resolve(ROOT, 'dist');
+mkdirSync(distDir, { recursive: true });
+
+const distPath   = resolve(distDir, 'runtime-manifest.json');
+const bundledPath = resolve(ROOT, 'src', 'memory', 'data', 'runtime-manifest.json');
+
+writeFileSync(distPath, manifestJson);
+console.log(`Written: ${distPath}`);
+
+mkdirSync(dirname(bundledPath), { recursive: true });
+writeFileSync(bundledPath, manifestJson);
+console.log(`Written: ${bundledPath}`);
+
+console.log('generate-runtime-manifest.mjs complete.');