mixdog 0.9.2 → 0.9.4

package/src/runtime/agent/orchestrator/tools/code-graph/memory-cache.mjs

@@ -0,0 +1,66 @@
+// In-memory (TTL + LRU + runtime-byte budget) code-graph cache. Wraps the
+// shared codeGraphCache Map from code-graph-state.mjs with LRU touch/set and
+// eviction. Extracted verbatim from code-graph.mjs.
+import {
+  canonicalGraphCwd as _canonicalGraphCwd,
+  codeGraphCache as _codeGraphCache,
+} from '../code-graph-state.mjs';
+import {
+  CODE_GRAPH_MEMORY_MAX_ENTRIES,
+  CODE_GRAPH_MEMORY_MAX_SOURCE_BYTES,
+} from './constants.mjs';
+import {
+  _estimateGraphRuntimeCacheBytes,
+  _clearGraphRuntimeCaches,
+} from './graph-model.mjs';
+
+export function _touchCodeGraphCache(graphCwd) {
+  const key = _canonicalGraphCwd(graphCwd);
+  const entry = _codeGraphCache.get(key);
+  if (!entry) return;
+  _codeGraphCache.delete(key);
+  entry.lastAccess = Date.now();
+  _codeGraphCache.set(key, entry);
+}
+
+export function _setCodeGraphCache(graphCwd, entry) {
+  const key = _canonicalGraphCwd(graphCwd);
+  const payload = { ...entry, lastAccess: Date.now() };
+  if (_codeGraphCache.has(key)) _codeGraphCache.delete(key);
+  _codeGraphCache.set(key, payload);
+  _pruneCodeGraphMemoryCache();
+}
+
+export function _pruneCodeGraphMemoryCache(options = {}) {
+  const maxEntries = Number.isFinite(options.maxEntries)
+    ? Math.max(1, Math.floor(options.maxEntries))
+    : CODE_GRAPH_MEMORY_MAX_ENTRIES;
+  const maxBytes = Number.isFinite(options.maxBytes)
+    ? Math.max(0, Math.floor(options.maxBytes))
+    : CODE_GRAPH_MEMORY_MAX_SOURCE_BYTES;
+  const rows = [..._codeGraphCache.entries()].map(([cwd, entry]) => ({
+    cwd,
+    entry,
+    lastAccess: Number(entry?.lastAccess || entry?.ts || 0),
+    runtimeBytes: _estimateGraphRuntimeCacheBytes(entry?.graph),
+  }));
+  rows.sort((a, b) => (a.lastAccess - b.lastAccess) || String(a.cwd).localeCompare(String(b.cwd)));
+  const evicted = [];
+  let totalRuntimeBytes = rows.reduce((sum, row) => sum + row.runtimeBytes, 0);
+  for (const row of rows) {
+    if (totalRuntimeBytes <= maxBytes) break;
+    if (!row.entry?.graph || row.runtimeBytes <= 0) continue;
+    const freed = row.runtimeBytes;
+    _clearGraphRuntimeCaches(row.entry.graph);
+    row.runtimeBytes = 0;
+    totalRuntimeBytes -= freed;
+    evicted.push({ cwd: row.cwd, reason: 'max-bytes-runtime', freed });
+  }
+  while (_codeGraphCache.size > maxEntries) {
+    const oldestKey = _codeGraphCache.keys().next().value;
+    if (!oldestKey) break;
+    _codeGraphCache.delete(oldestKey);
+    evicted.push({ cwd: oldestKey, reason: 'max-entries' });
+  }
+  return { evicted, totalRuntimeBytes: Math.max(0, totalRuntimeBytes), entries: _codeGraphCache.size };
+}

package/src/runtime/agent/orchestrator/tools/code-graph/project-root.mjs

@@ -0,0 +1,44 @@
+// Project-root sentinel resolution + empty-arg stripping. Extracted verbatim
+// from code-graph.mjs. Used by the dispatcher to re-root file/dir queries.
+import { resolve as pathResolve, dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+// P1: project-root sentinels. A directory containing any of these (or with one
+// at an ancestor) is treated as a real project we may index.
+export const _PROJECT_ROOT_SENTINELS = ['package.json', '.git', 'Cargo.toml', 'go.mod', 'pyproject.toml', 'setup.py', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'build.sbt', 'Package.swift'];
+
+// P1: resolve a file to its nearest project root (sentinel ancestor).
+// Returns null when no root found; caller throws rather than falling back.
+export function _resolveFileProjectRoot(file) {
+  if (!file) return null;
+  const abs = pathResolve(file);
+  let dir = dirname(abs);
+  while (dir && dir !== dirname(dir)) {
+    if (_PROJECT_ROOT_SENTINELS.some((s) => existsSync(join(dir, s)))) return dir;
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+// P1: nearest project root for a DIRECTORY (the dir itself or any ancestor).
+// Returns null when the dir sits in no project.
+export function _findDirProjectRoot(dir) {
+  if (!dir) return null;
+  let d = pathResolve(dir);
+  while (d && d !== dirname(d)) {
+    if (_PROJECT_ROOT_SENTINELS.some((s) => existsSync(join(d, s)))) return d;
+    d = dirname(d);
+  }
+  return null;
+}
+
+// MCP clients sometimes inject empty-string defaults for optional schema
+// fields (e.g. `file: ""`). Strip empty/null optional path-like fields before
+// dispatch so a literal "" doesn't trip the "file not found in graph" path.
+export function _stripEmptyArgs(args) {
+  const a = { ...(args || {}) };
+  for (const k of ['file', 'language']) {
+    if (a[k] === '' || a[k] === null) delete a[k];
+  }
+  return a;
+}