mixdog 0.7.18 → 0.8.0

package/scripts/patch-interior-context-smoke.mjs

@@ -1,49 +0,0 @@
-// Regression: the JS diagnostic matcher must mirror native
-// evaluate_fuzzy_candidate's change-band logic. Content drift on INTERIOR
-// context (strictly between the first and last change) must NOT be
-// fuzz-consumable -> findFirstFailingUnifiedHunk reports the hunk as failing.
-// Content drift on OUTER context (before first change / after last change),
-// within the fuzz budget, still matches -> no failing hunk.
-import { __patchTestHooks } from '../src/agent/orchestrator/tools/patch.mjs';
-
-const { findFirstFailingUnifiedHunk, computeUnifiedChangeBand, collectUnifiedOps } = __patchTestHooks;
-
-function assert(cond, msg) {
-  if (!cond) throw new Error(`assertion failed: ${msg}`);
-}
-
-// Hunk shape used by the diagnostic matcher: { oldStart, lines: ['<tag><text>'] }.
-// keep1 (outer ctx) / del1 / mid (interior ctx) / del2 / keep2 (outer ctx).
-function makeHunk() {
-  return {
-    oldStart: 1,
-    lines: [' keep1', '-del1', ' mid', '-del2', ' keep2'],
-  };
-}
-
-// 1) Band sanity: changes (deletes) bound an interior context line.
-{
-  const ops = collectUnifiedOps(makeHunk());
-  assert(JSON.stringify(ops) === JSON.stringify(['context', 'delete', 'context', 'delete', 'context']), 'ops sequence');
-  const band = computeUnifiedChangeBand(ops);
-  // del1 -> (1+1)*2=4, del2 -> (3+1)*2=8; mid offset 2 -> (2+1)*2=6 is interior.
-  assert(band.first === 4 && band.last === 8, `band ${JSON.stringify(band)}`);
-}
-
-// 2) INTERIOR context content drift must NOT match (hunk reported as failing).
-{
-  const entry = { oldFileName: 'a/x', hunks: [makeHunk()] };
-  const source = ['keep1', 'del1', 'midDRIFTED', 'del2', 'keep2'];
-  const failing = findFirstFailingUnifiedHunk(entry, source, 2);
-  assert(failing === entry.hunks[0], 'interior drift must produce a failing hunk');
-}
-
-// 3) OUTER context content drift within fuzz budget still matches (no failure).
-{
-  const entry = { oldFileName: 'a/x', hunks: [makeHunk()] };
-  const source = ['keep1DRIFTED', 'del1', 'mid', 'del2', 'keep2'];
-  const failing = findFirstFailingUnifiedHunk(entry, source, 1);
-  assert(failing === null, 'outer drift within budget must match (no failing hunk)');
-}
-
-console.log('patch-interior-context-smoke OK');

package/scripts/patch-newline-utf8-smoke.mjs

@@ -1,157 +0,0 @@
-// Regression: the JS DIAGNOSTIC matcher compares RAW BYTES like native
-// (main.rs:1867-1875 exact, 1891-1899 ws byte-trim, 1936-1944 normalize ONLY
-// when BOTH bodies are valid UTF-8). It must mirror two native guards in
-// evaluate_fuzzy_candidate:
-//   (a) the per-line trailing-newline guard (main.rs:1500-1526 marker flip,
-//       1867-1875 exact, 1891-1899 ws, 1936-1944 normalize, 1832-1835 delete
-//       reject) — a tier matches only when expected/actual newline state agree.
-//   (b) the byte-level UTF-8 validity gate (main.rs:1936-1944) — the normalize
-//       tier matches ONLY when BOTH sides are valid UTF-8. Invalid-UTF-8 source
-//       bytes are NOT pre-collapsed to U+FFFD, so an EXACT byte match of invalid
-//       bytes still succeeds, while normalize is refused on invalid bytes; a
-//       VALID literal U+FFFD present in both sides DOES normalize-match (the old
-//       U+FFFD heuristic is gone — real validity replaces it).
-import { __patchTestHooks } from '../src/agent/orchestrator/tools/patch.mjs';
-
-const { findFirstFailingUnifiedHunk, unifiedOldLinesMatchAt, splitBufferLinesForPatch } = __patchTestHooks;
-
-function assert(cond, msg) {
-  if (!cond) throw new Error(`assertion failed: ${msg}`);
-}
-
-// (a) Old line expects a trailing newline (no "\ No newline" marker) but the
-// source's matching line is the final line of a file WITHOUT a trailing newline
-// -> newline state differs -> the delete line falls through to reject.
-{
-  const entry = { oldFileName: 'a/x', hunks: [{ oldStart: 1, lines: [' a', '-b'] }] };
-  const source = ['a', 'b'];
-  source.hasFinalNewline = false; // EOF line 'b' has no trailing newline
-  const failing = findFirstFailingUnifiedHunk(entry, source, 2);
-  assert(failing === entry.hunks[0], 'newline mismatch (expect-newline vs EOF-no-newline) must fail');
-}
-
-// (a-control) Same hunk against a source whose final line DOES end in a newline
-// -> newline state agrees -> exact match -> no failing hunk.
-{
-  const entry = { oldFileName: 'a/x', hunks: [{ oldStart: 1, lines: [' a', '-b'] }] };
-  const source = ['a', 'b'];
-  source.hasFinalNewline = true;
-  const failing = findFirstFailingUnifiedHunk(entry, source, 2);
-  assert(failing === null, 'matching newline state must match (no failing hunk)');
-}
-
-// (b-1) Invalid-UTF-8 source bytes: an EXACT raw-byte match of the invalid bytes
-// must SUCCEED (native compares bytes; the bytes are NOT collapsed to U+FFFD).
-// 0x80 alone is an invalid UTF-8 continuation byte. The expected old line is
-// injected as a raw Buffer carrying the SAME invalid bytes.
-{
-  const srcBytes = Buffer.from([0x61, 0x80, 0x62]); // a <0x80> b  (invalid UTF-8)
-  const source = [srcBytes];
-  source.hasFinalNewline = true;
-  const oldLines = [{ tag: '-', line: Buffer.from([0x61, 0x80, 0x62]), hasNewline: true }];
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched !== null, 'exact byte match of invalid-UTF-8 bytes must succeed');
-}
-
-// (b-2) Normalize tier REFUSED on invalid UTF-8: source and expected differ only
-// by a typographic dash and would normalize-match IF valid, but the source line
-// carries an invalid lone 0x80 byte -> from_utf8 gate fails -> no normalize
-// match -> the hunk is reported as failing.
-{
-  // source: a <0x80> <en-dash 0xE2 0x80 0x93> b  -> invalid due to lone 0x80
-  const srcBytes = Buffer.from([0x61, 0x80, 0xe2, 0x80, 0x93, 0x62]);
-  const source = [srcBytes];
-  source.hasFinalNewline = true;
-  // expected: a <0x80> - b  (ASCII dash, also invalid due to 0x80)
-  const oldLines = [{ tag: '-', line: Buffer.from([0x61, 0x80, 0x2d, 0x62]), hasNewline: true }];
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched === null, 'normalize tier must be refused when a side is invalid UTF-8');
-}
-
-// (b-3) VALID literal U+FFFD in BOTH sides now normalize-MATCHES (native parity:
-// the old U+FFFD heuristic is removed; real UTF-8 validity governs). Source has a
-// genuine, properly-encoded U+FFFD (0xEF 0xBF 0xBD) plus an en-dash; expected has
-// the same valid U+FFFD plus an ASCII dash -> both valid UTF-8 -> normalize tier
-// matches -> no failing hunk.
-{
-  const fffd = [0xef, 0xbf, 0xbd];
-  const enDash = [0xe2, 0x80, 0x93];
-  const srcBytes = Buffer.from([0x61, ...fffd, ...enDash, 0x62]);   // a <U+FFFD> <en-dash> b
-  const source = [srcBytes];
-  source.hasFinalNewline = true;
-  const oldLines = [{ tag: '-', line: Buffer.from([0x61, ...fffd, 0x2d, 0x62]), hasNewline: true }]; // a <U+FFFD> - b
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched !== null && matched.normCount === 1, 'valid literal U+FFFD in both sides must normalize-match');
-}
-
-// (b-4) End-to-end via findFirstFailingUnifiedHunk with the byte source view:
-// typographic-only drift between VALID-UTF-8 source/patch normalize-matches.
-{
-  const buf = Buffer.from('a\u2013b\n', 'utf8'); // en-dash, valid UTF-8, trailing NL
-  const source = splitBufferLinesForPatch(buf);
-  const entry = { oldFileName: 'a/x', hunks: [{ oldStart: 1, lines: ['-a-b'] }] }; // ASCII dash
-  const failing = findFirstFailingUnifiedHunk(entry, source, 2);
-  assert(failing === null, 'valid typographic-only drift matches via normalize (byte view)');
-}
-
-// (c-1) CR-parity: the FINAL unterminated line keeps a bare trailing \r. Native
-// strips \r ONLY when immediately before \n (main.rs:1967-1972); a final line
-// with NO trailing \n keeps its \r in the compared body (main.rs:1981-1987,
-// exact byte compare 1867-1875). Source ends in a bare \r (no \n) -> the split
-// must retain 'abc\r' and hasFinalNewline=false, so comparing against old line
-// 'abc' must NOT match (native would compare 'abc\r' != 'abc').
-{
-  const buf = Buffer.from([0x61, 0x62, 0x63, 0x0d]); // 'abc\r', no trailing \n
-  const source = splitBufferLinesForPatch(buf);
-  assert(source.length === 1, 'bare-\\r source splits into one line');
-  assert(source[0].equals(Buffer.from('abc\r')), 'final unterminated line KEEPS its bare \\r');
-  assert(source.hasFinalNewline === false, 'bare-\\r source has no final newline');
-  const oldLines = [{ tag: '-', line: Buffer.from('abc'), hasNewline: false }];
-  // fuzz=0 isolates the exact byte-compare tier (main.rs:1867-1875), the path
-  // the CR-parity split fix targets: 'abc\r' != 'abc'.
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 0, null);
-  assert(matched === null, 'bare trailing \\r must NOT match patch old line abc (native compares abc\\r)');
-}
-
-// (c-2) CRLF control: a \r\n-terminated line still strips its \r (CRLF -> drop
-// the \r before \n) and matches the patch old line 'abc'.
-{
-  const buf = Buffer.from('abc\r\n', 'utf8'); // CRLF-terminated
-  const source = splitBufferLinesForPatch(buf);
-  assert(source[0].equals(Buffer.from('abc')), 'CRLF line strips its \\r');
-  assert(source.hasFinalNewline === true, 'CRLF-terminated source has a final newline');
-  const oldLines = [{ tag: '-', line: Buffer.from('abc'), hasNewline: true }];
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched !== null, 'CRLF line (\\r stripped) must match patch old line abc');
-}
-
-// (d-1) Rust-White_Space trim parity: U+0085 (NEL) is Unicode White_Space, so
-// native str::trim() strips it. JS String.trim() does NOT — hence the custom
-// rustTrim() inside normalizeTypographic(). Source carries U+0085 at BOTH ends
-// plus an em-dash; expected is the ASCII-dash form. After rust-trim (U+0085
-// removed) + dash map, both sides reduce to 'a-b' -> normalize tier MATCHES,
-// exactly as native does.
-{
-  const srcBytes = Buffer.from('\u0085a\u2014b\u0085', 'utf8'); // <NEL>a<em-dash>b<NEL>
-  const source = [srcBytes];
-  source.hasFinalNewline = true;
-  const oldLines = [{ tag: '-', line: Buffer.from('a-b', 'utf8'), hasNewline: true }];
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched !== null && matched.normCount === 1, 'U+0085 boundary must be trimmed (native White_Space) so normalize-matches');
-}
-
-// (d-2) U+FEFF (BOM/ZWNBSP) is NOT Unicode White_Space, so native str::trim()
-// leaves it in place; our rustTrim() must likewise NOT strip it (diverging from
-// JS String.trim(), which WOULD). Source carries U+FEFF at both ends plus an
-// em-dash; expected is ASCII 'a-b'. The U+FEFF survives the trim, so the sides
-// differ -> normalize tier does NOT match, exactly as native.
-{
-  const srcBytes = Buffer.from('\uFEFFa\u2014b\uFEFF', 'utf8'); // <BOM>a<em-dash>b<BOM>
-  const source = [srcBytes];
-  source.hasFinalNewline = true;
-  const oldLines = [{ tag: '-', line: Buffer.from('a-b', 'utf8'), hasNewline: true }];
-  const matched = unifiedOldLinesMatchAt(source, oldLines, 0, 2, null);
-  assert(matched === null, 'U+FEFF must NOT be trimmed (not White_Space) so normalize must NOT match');
-}
-
-console.log('patch-newline-utf8-smoke OK');

package/scripts/perf-hook-smoke.mjs

@@ -1,71 +0,0 @@
-import { spawn } from 'child_process';
-import { performance } from 'perf_hooks';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const HOOKS_DIR = join(__dirname, '..', 'hooks');
-
-const HOOKS = [
-  'pre-tool-subagent.cjs',
-  'pre-mcp-sandbox.cjs',
-  'post-tool-use.cjs',
-];
-const RUNTIMES = ['bun', 'node'];
-const N = 5;
-const THRESHOLDS = { node: 200, bun: 400 };
-
-const PAYLOAD = JSON.stringify({
-  tool_name: 'Edit',
-  tool_input: { file_path: '/tmp/x.js' },
-  cwd: process.cwd(),
-});
-
-function runOnce(runtime, hookPath) {
-  return new Promise((resolve) => {
-    const start = performance.now();
-    const child = spawn(runtime, [hookPath], { stdio: ['pipe', 'ignore', 'ignore'] });
-    child.stdin.write(PAYLOAD);
-    child.stdin.end();
-    child.on('close', () => resolve(performance.now() - start));
-    child.on('error', () => resolve(performance.now() - start));
-  });
-}
-
-async function median(runtime, hookPath) {
-  const times = [];
-  for (let i = 0; i < N; i++) times.push(await runOnce(runtime, hookPath));
-  times.sort((a, b) => a - b);
-  return times[Math.floor(N / 2)];
-}
-
-const results = [];
-for (const hook of HOOKS) {
-  const hookPath = join(HOOKS_DIR, hook);
-  for (const runtime of RUNTIMES) {
-    const med = await median(runtime, hookPath);
-    const threshold = THRESHOLDS[runtime];
-    results.push({ hook, runtime, med, threshold, pass: med <= threshold });
-  }
-}
-
-const col0 = Math.max(...results.map(r => r.hook.length));
-const header = `${'hook'.padEnd(col0)}  runtime  median(ms)  threshold  pass`;
-const sep = '-'.repeat(header.length);
-console.log(sep);
-console.log(header);
-console.log(sep);
-for (const r of results) {
-  const line = [
-    r.hook.padEnd(col0),
-    r.runtime.padEnd(7),
-    String(r.med.toFixed(1)).padStart(10),
-    String(r.threshold).padStart(9),
-    r.pass ? '  OK' : '  FAIL',
-  ].join('  ');
-  console.log(line);
-}
-console.log(sep);
-
-const allPass = results.every(r => r.pass);
-process.exit(allPass ? 0 : 1);