mixdog 0.9.3 → 0.9.5

package/src/runtime/agent/orchestrator/tools/code-graph/text-columns.mjs

@@ -0,0 +1,45 @@
+// Column/byte-offset conversions and enclosing-symbol lookup. Pure over
+// {node,sourceText,line,col}; no graph/cache state. Extracted from search.mjs.
+
+export function _toByteColumn(lineText, charCol) {
+  if (!Number.isFinite(charCol) || charCol < 1) return charCol;
+  const prefix = String(lineText || '').slice(0, charCol - 1);
+  return Buffer.byteLength(prefix, 'utf8') + 1;
+}
+
+export function _byteColToCharCol(lineText, byteCol) {
+  if (!Number.isFinite(byteCol) || byteCol < 1) return 1;
+  const s = String(lineText || '');
+  let bytes = 0;
+  let k = 0;
+  while (k < s.length && bytes < byteCol - 1) {
+    const cp = s.codePointAt(k);
+    bytes += Buffer.byteLength(String.fromCodePoint(cp), 'utf8');
+    k += cp > 0xFFFF ? 2 : 1;
+  }
+  return k + 1;
+}
+
+export function _nearestEnclosingSymbol(node, sourceText, lineNumber, col = null) {
+  const FUNCTION_LIKE = new Set([
+    'function', 'method', 'arrow', 'class', 'generator', 'fn', 'async-function',
+    'constructor', 'record', 'local-function',
+  ]);
+  const symbols = Array.isArray(node?.symbols) ? node.symbols : [];
+  const inRange = (item) => {
+    if (item.line > lineNumber || Number(item.endLine) < lineNumber) return false;
+    if (col != null) {
+      const sl = Number(item.startLine);
+      const sc = Number(item.startCol);
+      const ec = Number(item.endCol);
+      if (Number.isFinite(sl) && sl === lineNumber && Number.isFinite(sc) && col < sc) return false;
+      if (Number(item.endLine) === lineNumber && Number.isFinite(ec) && col > ec) return false;
+    }
+    return true;
+  };
+  const candidates = symbols
+    .filter(inRange)
+    .sort((a, b) => (b.line - a.line) || ((Number(b.startCol) || 0) - (Number(a.startCol) || 0)));
+  const fn = candidates.find((item) => FUNCTION_LIKE.has(String(item.kind || '').toLowerCase()));
+  return fn || candidates[0] || null;
+}

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -3,20 +3,20 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Repo-local code structure/flow lookup, not web: symbols/references/calls/deps before text grep. Batch symbols[].',
+    description: 'Repo-local code structure/flow lookup, not web: symbols/references/calls/deps before text grep. Multiple targets = ONE call with symbols[]/files[], never parallel single-target calls.',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees', 'prewarm'], description: 'Repo-local operation; code flow before text search.' },
-        file: { type: 'string', description: 'Known source file.' },
-        symbol: { type: 'string', description: 'Identifier/keyword; one anchor is enough.' },
-        symbols: { type: 'array', items: { type: 'string' }, description: 'Batch identifiers in one call.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local operation; code flow before text search.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file(s): string or array; one call fans out per file (imports/dependents/related/impact/symbols/overview). `file` singular alias also accepted.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s): string or array; batch in one call. One anchor is enough. `symbol` singular alias also accepted.' },
+        symbol: { type: 'string', description: 'Singular alias for symbols.' },
+        file: { type: 'string', description: 'Singular alias for files.' },
         body: { type: 'boolean', description: 'Include body.' },
         language: { type: 'string', description: 'Language hint.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },
         page: { type: 'number', minimum: 1, description: 'Caller page.' },
-        cwd: { type: 'string', description: 'Project root.' },
       },
       required: ['mode'],
     },

package/src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs

@@ -41,13 +41,16 @@ function graphBinDir(dataDir) {
 }
 
 async function loadManifest(dataDir) {
+  // Bundled manifest FIRST: it always matches the installed mixdog version.
+  // A stale cached manifest.json from an older install must never shadow it
+  // (caused sha256 mismatches on already-installed machines after upgrades).
+  if (existsSync(BUNDLED_MANIFEST_PATH)) {
+    return JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'));
+  }
   const cached = join(graphBinDir(dataDir), 'manifest.json');
   if (existsSync(cached)) {
     try { return JSON.parse(readFileSync(cached, 'utf8')); } catch { /* fall through */ }
   }
-  if (existsSync(BUNDLED_MANIFEST_PATH)) {
-    return JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'));
-  }
   const res = await fetch(MANIFEST_URL, { signal: AbortSignal.timeout(30_000) });
   if (!res.ok) throw new Error(`[graph-fetcher] manifest fetch failed: ${res.status} ${res.statusText}`);
   return res.json();

package/src/runtime/agent/orchestrator/tools/patch/constants.mjs

@@ -0,0 +1,9 @@
+// Shared literal constants for the apply_patch modules. Extracted from
+// patch.mjs verbatim so parsing/dispatch behavior is unchanged.
+
+export const DEV_NULL = /^\/dev\/null$/;
+export const V4A_EOF_MARKER = '*** End of File';
+export const V4A_MOVE_TO_PREFIX = '*** Move to:';
+
+export const UNIFIED_HUNK_HEADER_RE = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
+export const UNIFIED_HUNK_HEADER_CAPTURE_RE = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@(.*)$/;

package/src/runtime/agent/orchestrator/tools/patch/dispatch.mjs

@@ -0,0 +1,171 @@
+// Native-engine dispatch + failure-context formatting for apply_patch. Moved
+// verbatim from patch.mjs; native protocol, cache/snapshot side effects, and
+// output formatting are unchanged.
+
+import { readFileSync } from 'node:fs';
+import { performance } from 'node:perf_hooks';
+import {
+  normalizeOutputPath,
+  invalidateBuiltinResultCache,
+  recordReadSnapshotForPath,
+  clearReadSnapshotForPath,
+} from '../builtin.mjs';
+import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
+import { classifyEntry, stripDiffPrefix, resolveEntryPath } from './paths.mjs';
+import {
+  getNativePatchServer,
+  scheduleNativePatchIdleClose,
+  nativePatchTraceEnabled,
+  patchTraceEnabled,
+  ioTrace,
+} from './native-server.mjs';
+import {
+  extractNativeFailurePath,
+  nativeFailureMatchesEntry,
+  findFirstFailingUnifiedHunk,
+  firstFailingUnifiedHunkLineDetail,
+  firstMeaningfulUnifiedHunkLine,
+  firstMeaningfulUnifiedEntryLine,
+  compactPatchPreviewLine,
+  nearestPatchLineHint,
+  normalizeTypographic,
+  splitBufferLinesForPatch,
+  splitTextLinesForPatch,
+} from './matcher.mjs';
+
+export function formatNativeFailureContext(parsed, basePath, failedPath = '', options = {}) {
+  const entries = Array.isArray(parsed) ? parsed : [];
+  const entry = entries.find((candidate) => classifyEntry(candidate) !== 'create' && nativeFailureMatchesEntry(candidate, failedPath))
+    || entries.find((candidate) => classifyEntry(candidate) !== 'create');
+  const headerName = entry?.oldFileName;
+  const displayPath = headerName ? normalizeOutputPath(stripDiffPrefix(headerName)) : '';
+  const fuzz = Number.isFinite(options?.fuzz) && options.fuzz > 0 ? Math.floor(options.fuzz) : 0;
+  let sourceLines = null;
+  let sourceByteLines = null;
+  try {
+    const fullPath = resolveEntryPath(basePath, entry.oldFileName);
+    const raw = readFileSync(fullPath); // Buffer — no 'utf8' decode
+    sourceByteLines = splitBufferLinesForPatch(raw);
+    sourceLines = splitTextLinesForPatch(raw.toString('utf8'));
+  } catch {}
+  const failingHunk = sourceByteLines ? findFirstFailingUnifiedHunk(entry, sourceByteLines, fuzz) : null;
+  const failingDetail = (failingHunk && sourceByteLines)
+    ? firstFailingUnifiedHunkLineDetail(sourceByteLines, failingHunk)
+    : null;
+  const expected = failingDetail || firstMeaningfulUnifiedHunkLine(failingHunk) || firstMeaningfulUnifiedEntryLine(entry);
+  if (!entry || !expected?.line) return '';
+  const expectedText = JSON.stringify(compactPatchPreviewLine(expected.line));
+  let nearest = '';
+  let normalizeHint = '';
+  if (sourceLines) {
+    nearest = nearestPatchLineHint(sourceLines, expected.line, expected.preferredLine);
+    const wantNorm = normalizeTypographic(expected.line);
+    if (wantNorm) {
+      for (let i = 0; i < sourceLines.length; i++) {
+        if (sourceLines[i] === expected.line) break; // exact match exists; not a normalization issue
+        if (
+          sourceLines[i].trim() !== expected.line.trim()
+          && normalizeTypographic(sourceLines[i]) === wantNorm
+        ) {
+          normalizeHint = `context matches after Unicode normalization at line ${i + 1} — source may contain typographic dashes/quotes/NBSP`;
+          break;
+        }
+      }
+    }
+  }
+  return ` expected first old/context line${displayPath ? ` in ${displayPath}` : ''}: ${expectedText}${nearest ? `; ${nearest}` : ''}${normalizeHint ? `; ${normalizeHint}` : ''}; use exact current lines, no stubs.`;
+}
+
+// Dispatch the (already validated, header-rewritten) patch to the native
+// engine. Throws on any native error; on success returns the formatted
+// human-readable response string. Never silently falls back to JS — the
+// caller MUST surface throws as `Error: ...` strings.
+export async function dispatchNativePatch({ entries, basePath, nativePatchStr, fuzz, rejectPartial, dryRun, readStateScope, signal, parsed }) {
+  const nativeStart = performance.now();
+  let stats;
+  try {
+    stats = await getNativePatchServer().apply(basePath, nativePatchStr, { fuzz, rejectPartial, dryRun, signal });
+  } catch (err) {
+    scheduleNativePatchIdleClose();
+    const msg = err?.message || String(err);
+    const failedPath = extractNativeFailurePath(msg, parsed);
+    return `Error: native patch failed — ${msg}${formatNativeFailureContext(parsed, basePath, failedPath, { fuzz })}`;
+  }
+  const afterInvalidateStart = performance.now();
+  const failedDisplaySet = new Set();
+  for (const f of stats.failures || []) {
+    if (!f?.path) continue;
+    failedDisplaySet.add(normalizeOutputPath(f.path));
+    failedDisplaySet.add(normalizeOutputPath(stripDiffPrefix(f.path)));
+  }
+  const writtenEntries = entries.filter((entry) => !failedDisplaySet.has(entry.displayPath));
+  const fullPaths = writtenEntries.map((entry) => entry.fullPath);
+  if (!dryRun) invalidateBuiltinResultCache(fullPaths);
+  const afterInvalidate = performance.now();
+  if (!dryRun) markCodeGraphDirtyPaths(fullPaths);
+  const afterDirty = performance.now();
+  if (!dryRun) {
+    for (let i = 0; i < writtenEntries.length; i++) {
+      const entry = writtenEntries[i];
+      if (entry.kind === 'delete') {
+        clearReadSnapshotForPath(entry.fullPath, readStateScope);
+      } else {
+        const snapshotMeta = {
+          source: 'apply_patch_native',
+          isPartialView: false,
+        };
+        const contentHash = stats.contentHashes?.[i] || null;
+        if (contentHash) snapshotMeta.contentHash = contentHash;
+        recordReadSnapshotForPath(entry.fullPath, readStateScope, snapshotMeta);
+      }
+    }
+  }
+  const afterSnapshot = performance.now();
+  ioTrace('apply_patch_native', {
+    files: writtenEntries.length,
+    dryRun,
+    partial: stats.partial,
+    failed: stats.failures.length,
+    roundtripMs: Number(stats.roundtripMs.toFixed(3)),
+    rustTotalMs: Number(stats.totalMs.toFixed(3)),
+    invalidateMs: Number((afterInvalidate - afterInvalidateStart).toFixed(3)),
+    dirtyMs: Number((afterDirty - afterInvalidate).toFixed(3)),
+    snapshotMs: Number((afterSnapshot - afterDirty).toFixed(3)),
+    contentHashes: (stats.contentHashes || []).filter(Boolean).length,
+  });
+  if (nativePatchTraceEnabled()) {
+    process.stderr.write(
+      `[patch-native-trace] files=${writtenEntries.length} partial=${stats.partial ? 1 : 0} failed=${stats.failures.length} roundtrip_ms=${stats.roundtripMs.toFixed(3)} rust_total_ms=${stats.totalMs.toFixed(3)} rust_hash_ms=${stats.hashMs.toFixed(3)} invalidate_ms=${(afterInvalidate - afterInvalidateStart).toFixed(3)} dirty_ms=${(afterDirty - afterInvalidate).toFixed(3)} snapshot_ms=${(afterSnapshot - afterDirty).toFixed(3)} total_js_ms=${(afterSnapshot - nativeStart).toFixed(3)} content_hashes=${(stats.contentHashes || []).filter(Boolean).length}\n`
+    );
+  }
+  if (patchTraceEnabled()) {
+    process.stderr.write(`[patch-native] applied files=${writtenEntries.length} partial=${stats.partial ? 1 : 0} ms=${stats.totalMs.toFixed(3)}\n`);
+  }
+  scheduleNativePatchIdleClose();
+  const verb = dryRun ? 'checked' : 'applied';
+  const verbLabel = dryRun ? 'Checked' : 'Applied';
+  const countLabel = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+  const kindLabel = (kind) => {
+    const text = String(kind || '').trim();
+    return text ? `${text.charAt(0).toUpperCase()}${text.slice(1).toLowerCase()}` : 'Update';
+  };
+  const summary = stats.partial
+    ? `Error: Patch Partially ${verbLabel} (${countLabel(writtenEntries.length, 'File')} ${verb} · ${countLabel(stats.failures.length, 'File')} Skipped) (Native)`
+    : `${verbLabel} ${countLabel(writtenEntries.length, 'File')} (Native)${dryRun ? ' Dry Run' : ''}`;
+  const lines = [summary];
+  for (const entry of writtenEntries) {
+    const added = entry.added || 0;
+    const removed = entry.removed || 0;
+    const parts = [];
+    if (added > 0) parts.push(`+${countLabel(added, 'Line')}`);
+    if (removed > 0) parts.push(`-${countLabel(removed, 'Line')}`);
+    const detail = parts.join(' · ');
+    lines.push(detail
+      ? `  OK ${kindLabel(entry.kind)} ${entry.displayPath} — ${detail}`
+      : `  OK ${kindLabel(entry.kind)} ${entry.displayPath}`);
+  }
+  for (const f of stats.failures || []) {
+    lines.push(`  SKIP ${f.path || '(unknown)'} — ${f.reason}${formatNativeFailureContext(parsed, basePath, f.path, { fuzz })}`);
+  }
+  return lines.join('\n');
+}