mixdog 0.7.18 → 0.8.1

package/src/agent/orchestrator/session/cache/post-edit-marks.mjs

@@ -1,42 +0,0 @@
-// Post-edit advisory marks: one-shot sidecar on the next read after a write.
-import { _normalizeAbs } from './util.mjs';
-
-// sessionId -> Map<absPath, { ts, toolName }>
-const _postEditBySession = new Map();
-
-/**
- * Mark `path` as just-edited for `sessionId`. Caller invokes this after a
- * successful write/edit/apply_patch so the next read on the same path can
- * receive a one-shot advisory sidecar.
- */
-export function markPostEdit({ sessionId, path, cwd, toolName }) {
-    if (!sessionId) return;
-    const abs = _normalizeAbs(path, cwd);
-    if (!abs) return;
-    let m = _postEditBySession.get(sessionId);
-    if (!m) { m = new Map(); _postEditBySession.set(sessionId, m); }
-    m.set(abs, { ts: Date.now(), toolName: String(toolName || 'edit') });
-}
-
-/**
- * One-shot read of a post-edit mark for `sessionId`+`path`. Returns the
- * mark info on hit and removes it (so the advisory only fires once per
- * edit). Returns null on miss.
- */
-export function consumePostEditMark({ sessionId, path, cwd }) {
-    if (!sessionId) return null;
-    const abs = _normalizeAbs(path, cwd);
-    if (!abs) return null;
-    const m = _postEditBySession.get(sessionId);
-    if (!m) return null;
-    const entry = m.get(abs);
-    if (!entry) return null;
-    m.delete(abs);
-    return entry;
-}
-
-/** Drop all post-edit marks for a session on close. */
-export function clearPostEditMarks(sessionId) {
-    if (!sessionId) return;
-    _postEditBySession.delete(sessionId);
-}

package/src/agent/orchestrator/session/cache/prefetch-cache.mjs

@@ -1,142 +0,0 @@
-// Cross-dispatch prefetch cache. Memory-first; disk-backed so a process
-// restart (mcp child respawn / reload-plugins / dev-sync child kill) does
-// not start cold. Keyed by canonical absolute path; stores raw read-tool
-// output per file. Disk entries are stat-validated on read just like the
-// memory entries, so an external write to the source file invalidates the
-// cached slice automatically.
-import { classifyResultKind } from '../result-classification.mjs';
-import { _normalizeAbs, _normalizeCacheKey, _statTuple, _statEqual } from './util.mjs';
-import { readFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
-import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
-
-// I: cap is configurable via MIXDOG_PREFETCH_CACHE_MAX env var; default 200.
-const _envCap = Number(process.env.MIXDOG_PREFETCH_CACHE_MAX);
-const PREFETCH_CACHE_MAX = (Number.isFinite(_envCap) && _envCap > 0) ? _envCap : 200;
-const PREFETCH_TTL_MS_DEFAULT = 60 * 60 * 1000; // 1 hour
-let _prefetchTtlMs = PREFETCH_TTL_MS_DEFAULT;
-
-// absPath → { content: string, stat: _statTuple, ts: number }
-const _prefetchCache = new Map();
-const _pendingDiskWrites = new Map();
-let _diskWriteTimer = null;
-
-const DISK_CACHE_DIR = join(homedir(), '.claude', 'plugins', 'data', 'mixdog-trib-plugin', 'cache', 'prefetch');
-function _diskPath(absPath) {
-    const hash = createHash('sha256').update(absPath).digest('hex').slice(0, 16);
-    return join(DISK_CACHE_DIR, `${hash}.json`);
-}
-function _readDiskEntry(absPath) {
-    const p = _diskPath(absPath);
-    if (!existsSync(p)) return null;
-    try {
-        const parsed = JSON.parse(readFileSync(p, 'utf8'));
-        if (!parsed || typeof parsed.content !== 'string' || !parsed.stat) return null;
-        return { content: parsed.content, stat: parsed.stat, ts: parsed.ts };
-    } catch { return null; }
-}
-function _writeDiskEntryNow(absPath, entry) {
-    const p = _diskPath(absPath);
-    try {
-        mkdirSync(dirname(p), { recursive: true });
-        writeJsonAtomicSync(p, { absPath, ...entry }, { compact: true, fsync: false });
-    } catch { /* best-effort — disk persist failure must never break in-memory path */ }
-}
-function _flushDiskWrites() {
-    _diskWriteTimer = null;
-    if (_pendingDiskWrites.size === 0) return;
-    const batch = [..._pendingDiskWrites.entries()];
-    _pendingDiskWrites.clear();
-    for (const [absPath, entry] of batch) _writeDiskEntryNow(absPath, entry);
-}
-function _scheduleDiskWrite(absPath, entry) {
-    _pendingDiskWrites.set(absPath, entry);
-    if (_diskWriteTimer !== null) return;
-    const t = setTimeout(_flushDiskWrites, 100);
-    if (typeof t.unref === 'function') t.unref();
-    _diskWriteTimer = t;
-}
-function _deleteDiskEntry(absPath) {
-    _pendingDiskWrites.delete(absPath);
-    try { unlinkSync(_diskPath(absPath)); } catch { /* missing is fine */ }
-}
-
-/**
- * Look up a cached prefetch result for `absPath`. Stat-validates the file on
- * every hit. Returns null on miss, TTL expiry, or stat mismatch. Returns
- * `{ content, ts }` on a fresh hit.
- */
-export function tryPrefetchCached(absPath) {
-    if (typeof absPath !== 'string' || absPath.length === 0) return null;
-    absPath = _normalizeCacheKey(absPath);
-    let entry = _prefetchCache.get(absPath);
-    if (!entry) {
-        // Memory miss — fall through to disk so a fresh process can still hit.
-        const disk = _readDiskEntry(absPath);
-        if (!disk) return null;
-        entry = disk;
-        _prefetchCache.set(absPath, entry);
-    }
-    if (Date.now() - entry.ts > _prefetchTtlMs) {
-        _prefetchCache.delete(absPath);
-        _deleteDiskEntry(absPath);
-        return null;
-    }
-    const fresh = _statTuple(absPath);
-    if (!_statEqual(entry.stat, fresh)) {
-        _prefetchCache.delete(absPath);
-        _deleteDiskEntry(absPath);
-        return null;
-    }
-    // LRU touch: move to end of insertion-order sequence.
-    _prefetchCache.delete(absPath);
-    _prefetchCache.set(absPath, entry);
-    return { content: entry.content, ts: entry.ts };
-}
-
-/**
- * Store a per-file prefetch result. Silently skips empty or error-prefixed
- * content so only clean read output enters the cache.
- */
-export function setPrefetchCached(absPath, content) {
-    if (typeof absPath !== 'string' || absPath.length === 0) return;
-    if (typeof content !== 'string' || content.length === 0) return;
-    if (classifyResultKind(content) === 'error') return;
-    absPath = _normalizeCacheKey(absPath);
-    const stat = _statTuple(absPath);
-    if (!stat) return;
-    if (_prefetchCache.size >= PREFETCH_CACHE_MAX) {
-        const firstKey = _prefetchCache.keys().next().value;
-        if (firstKey !== undefined) {
-            _prefetchCache.delete(firstKey);
-            _deleteDiskEntry(firstKey);
-        }
-    }
-    const entry = { content, stat, ts: Date.now() };
-    _prefetchCache.set(absPath, entry);
-    _scheduleDiskWrite(absPath, entry);
-}
-
-/**
- * Drop the cache entry for `path` (cross-session). Called from loop.mjs
- * wherever a write-class tool invalidates a path.
- */
-export function invalidatePrefetchCache(path, cwd) {
-    if (typeof path !== 'string' || path.length === 0) return;
-    const abs = _normalizeAbs(path, cwd);
-    if (!abs) return;
-    _prefetchCache.delete(abs);
-    _deleteDiskEntry(abs);
-}
-
-export function drainPrefetchDiskWrites() {
-    if (_diskWriteTimer !== null) {
-        clearTimeout(_diskWriteTimer);
-        _diskWriteTimer = null;
-    }
-    _flushDiskWrites();
-}
-
-try { process.once('beforeExit', drainPrefetchDiskWrites); } catch {}

package/src/agent/orchestrator/session/cache/read-cache.mjs

@@ -1,319 +0,0 @@
-// Session-scoped read result cache with stat-tuple invalidation.
-// Scoped per sessionId; write-class tools explicitly invalidate touched paths.
-import { statSync } from 'node:fs';
-import { _normalizeAbs, _statTuple, _statEqual } from './util.mjs';
-import { clearScopedToolsForSession, clearScopedCounters } from './scoped-cache.mjs';
-import { clearPostEditMarks } from './post-edit-marks.mjs';
-
-const MAX_PER_SESSION = 100;
-
-// sessionId -> Map<key, { content, stat, ts, firstToolUseId }>
-const _bySession = new Map();
-
-// sessionId -> Map<absPath, Set<cacheKey>>  — reverse index for O(1) path-targeted invalidation
-const _reverseIdx = new Map();
-
-// Normalize one element of an array-form path to { abs, off, lim, mode, n }.
-// When top-level options (off/lim/mode/n) are supplied, they are applied as
-// defaults to elements that don't specify their own.
-function _normalizeArrayElem(elem, cwd) {
-    if (typeof elem === 'string') {
-        const abs = _normalizeAbs(elem, cwd);
-        return abs ? { abs, off: '', lim: '', mode: '', n: '', line: '', context: '', full: '' } : null;
-    }
-    if (elem && typeof elem === 'object' && (typeof elem.path === 'string' || typeof elem.file_path === 'string')) {
-        const abs = _normalizeAbs(elem.path || elem.file_path, cwd);
-        if (!abs) return null;
-        return {
-            abs,
-            off: elem.offset ?? '',
-            lim: elem.limit ?? '',
-            mode: elem.mode ?? '',
-            n: elem.n ?? '',
-            line: elem.line ?? '',
-            context: elem.context ?? '',
-            full: elem.full ?? '',
-        };
-    }
-    return null;
-}
-
-function _normalizeArrayElemWithDefaults(elem, cwd, topOff, topLim, topMode, topN, topLine, topContext, topFull) {
-    const n = _normalizeArrayElem(elem, cwd);
-    if (!n) return null;
-    // Apply top-level options as defaults only when element did not specify its own.
-    return {
-        abs: n.abs,
-        off: n.off !== '' ? n.off : topOff,
-        lim: n.lim !== '' ? n.lim : topLim,
-        mode: n.mode !== '' ? n.mode : topMode,
-        n: n.n !== '' ? n.n : topN,
-        line: n.line !== '' ? n.line : topLine,
-        context: n.context !== '' ? n.context : topContext,
-        full: n.full !== '' ? n.full : topFull,
-    };
-}
-
-// Build cache key and statsByAbs map for array-form path args.
-function _arrayKeyAndStats(args, cwd) {
-    const elems = args.path;
-    const pages = args?.pages ?? '';
-    const full = args?.full ?? '';
-    // Top-level options applied as per-element defaults (C: array-form parity).
-    const topOff = args?.offset ?? '';
-    const topLim = args?.limit ?? '';
-    const topMode = args?.mode ?? '';
-    const topN = args?.n ?? '';
-    const topLine = args?.line ?? '';
-    const topContext = args?.context ?? '';
-    const topFull = args?.full ?? '';
-    const parts = [];
-    const statsByAbs = {};
-    for (const elem of elems) {
-        const n = _normalizeArrayElemWithDefaults(elem, cwd, topOff, topLim, topMode, topN, topLine, topContext, topFull);
-        if (!n) return null;
-        parts.push(`${n.abs}|o=${n.off}|l=${n.lim}|m=${n.mode}|n=${n.n}|line=${n.line}|ctx=${n.context}|f=${n.full}`);
-        if (!statsByAbs[n.abs]) statsByAbs[n.abs] = _statTuple(n.abs);
-    }
-    const key = `[ARR]${parts.join('||')}|p=${pages}|f=${full}|to=${topOff}|tl=${topLim}|tm=${topMode}|tn=${topN}|tline=${topLine}|tctx=${topContext}|tf=${topFull}`;
-    return { key, statsByAbs };
-}
-
-function _keyFor(args, cwd) {
-    const p = args?.path ?? args?.file_path;
-    if (Array.isArray(p)) return null;
-    if (typeof p !== 'string') return null;
-    const abs = _normalizeAbs(p, cwd);
-    if (!abs) return null;
-    const usedFilePathAlias = typeof args?.file_path === 'string' && !args?.path;
-    const rawOff = args?.offset ?? '';
-    let off = rawOff;
-    if (usedFilePathAlias && rawOff !== '') {
-        const n = Number(rawOff);
-        off = Number.isFinite(n) ? Math.max(0, Math.trunc(n) - 1) : rawOff;
-    }
-    const lim = args?.limit ?? '';
-    const mode = args?.mode ?? '';
-    const n = args?.n ?? '';
-    const pages = args?.pages ?? '';
-    const full = args?.full ?? '';
-    const line = args?.line ?? '';
-    const context = args?.context ?? '';
-    return `${abs}|o=${off}|l=${lim}|m=${mode}|n=${n}|p=${pages}|f=${full}|line=${line}|ctx=${context}`;
-}
-
-// Re-stat every path in statsByAbs; return true only if ALL match stored tuples.
-function _arrayStatsValid(statsByAbs) {
-    for (const [absPath, stored] of Object.entries(statsByAbs)) {
-        if (!_statEqual(stored, _statTuple(absPath))) return false;
-    }
-    return true;
-}
-
-function _getOrCreate(sessionId) {
-    let m = _bySession.get(sessionId);
-    if (!m) { m = new Map(); _bySession.set(sessionId, m); }
-    return m;
-}
-
-function _ridxRegister(sessionId, absPath, key) {
-    let ridx = _reverseIdx.get(sessionId);
-    if (!ridx) { ridx = new Map(); _reverseIdx.set(sessionId, ridx); }
-    let s = ridx.get(absPath);
-    if (!s) { s = new Set(); ridx.set(absPath, s); }
-    s.add(key);
-}
-
-function _ridxPruneKey(sessionId, key) {
-    const ridx = _reverseIdx.get(sessionId);
-    if (!ridx) return;
-    for (const [absKey, keySet] of ridx) {
-        keySet.delete(key);
-        if (keySet.size === 0) ridx.delete(absKey);
-    }
-}
-
-function _absFromKey(key) {
-    const idx = key.indexOf('|');
-    return idx === -1 ? key : key.slice(0, idx);
-}
-
-/**
- * Look up a cached read result for this session+args. Stats the file at
- * lookup time and only returns when the stat tuple still matches. Returns
- * null on miss, on path-form mismatch, or on stat failure. On hit returns
- * the full entry { content, firstToolUseId, ts }.
- */
-export function tryReadCached({ sessionId, args, cwd }) {
-    if (!sessionId) return null;
-    const key = _keyFor(args, cwd);
-    if (key === null && Array.isArray(args?.path)) {
-        const parsed = _arrayKeyAndStats(args, cwd);
-        if (!parsed) return null;
-        const map = _bySession.get(sessionId);
-        if (!map) return null;
-        const entry = map.get(parsed.key);
-        if (!entry || entry.kind !== 'array') return null;
-        if (!_arrayStatsValid(entry.statsByAbs)) {
-            map.delete(parsed.key);
-            return null;
-        }
-        map.delete(parsed.key);
-        map.set(parsed.key, entry);
-        return { content: entry.content, firstToolUseId: entry.firstToolUseId || null, ts: entry.ts };
-    }
-    if (!key) return null;
-    const map = _bySession.get(sessionId);
-    if (!map) return null;
-    const entry = map.get(key);
-    if (!entry) return null;
-    const fresh = _statTuple(_absFromKey(key));
-    if (!_statEqual(entry.stat, fresh)) {
-        map.delete(key);
-        return null;
-    }
-    map.delete(key);
-    map.set(key, entry);
-    return { content: entry.content, firstToolUseId: entry.firstToolUseId || null, ts: entry.ts };
-}
-
-/**
- * Cache a successful read result. Skip caching if the file no longer exists.
- * `toolUseId` is the tool_use id of the FIRST call that populated the entry.
- */
-export function setReadCached({ sessionId, args, cwd, content, toolUseId }) {
-    if (!sessionId) return;
-    if (typeof content !== 'string' || content.length === 0) return;
-    const key = _keyFor(args, cwd);
-    if (key === null && Array.isArray(args?.path)) {
-        const parsed = _arrayKeyAndStats(args, cwd);
-        if (!parsed) return;
-        for (const st of Object.values(parsed.statsByAbs)) {
-            if (!st) return;
-        }
-        const map = _getOrCreate(sessionId);
-        if (map.size >= MAX_PER_SESSION) {
-            const firstKey = map.keys().next().value;
-            if (firstKey) { map.delete(firstKey); _ridxPruneKey(sessionId, firstKey); }
-        }
-        map.set(parsed.key, {
-            kind: 'array',
-            content,
-            statsByAbs: parsed.statsByAbs,
-            ts: Date.now(),
-            firstToolUseId: toolUseId || null,
-        });
-        // Register every constituent abs path in the reverse index.
-        for (const absPath of Object.keys(parsed.statsByAbs)) {
-            _ridxRegister(sessionId, absPath, parsed.key);
-        }
-        return;
-    }
-    if (!key) return;
-    const fresh = _statTuple(_absFromKey(key));
-    if (!fresh) return;
-    const map = _getOrCreate(sessionId);
-    if (map.size >= MAX_PER_SESSION) {
-        const firstKey = map.keys().next().value;
-        if (firstKey) { map.delete(firstKey); _ridxPruneKey(sessionId, firstKey); }
-    }
-    map.set(key, { content, stat: fresh, ts: Date.now(), firstToolUseId: toolUseId || null });
-    _ridxRegister(sessionId, _absFromKey(key), key);
-}
-
-/**
- * Invalidate all cache entries for `path` in the given session. Called when
- * a write-class tool (write/edit/apply_patch) touches the path.
- */
-export function invalidatePathForSession(sessionId, path, cwd) {
-    if (!sessionId) return;
-    const abs = _normalizeAbs(path, cwd);
-    if (!abs) return;
-    const map = _bySession.get(sessionId);
-    if (!map) return;
-    const ridx = _reverseIdx.get(sessionId);
-    const keys = ridx ? ridx.get(abs) : null;
-    if (keys && keys.size > 0) {
-        // O(1) lookup via reverse index.
-        const evicted = new Set(keys);
-        for (const k of evicted) map.delete(k);
-        keys.clear();
-        ridx.delete(abs);
-        // Clean evicted keys from other reverse-index sets; prune empty Sets.
-        for (const [absKey, keySet] of ridx) {
-            for (const k of evicted) keySet.delete(k);
-            if (keySet.size === 0) ridx.delete(absKey);
-        }
-    }
-    // Index miss = entry has no path identity; no-op is correct.
-}
-
-/**
- * Drop everything for a session. Called when the session closes.
- * Also clears scoped cache, counters, and post-edit marks for the session.
- */
-export function clearReadDedupSession(sessionId) {
-    if (!sessionId) return;
-    _bySession.delete(sessionId);
-    _reverseIdx.delete(sessionId);
-    clearPostEditMarks(sessionId);
-    clearScopedToolsForSession(sessionId);
-    clearScopedCounters(sessionId);
-}
-
-/**
- * Extract the set of touched filesystem paths from a unified-diff patch text.
- * Handles git-style `--- a/<path>` / `+++ b/<path>` headers and `/dev/null` markers.
- * Returns relative paths as written in the diff.
- */
-export function extractTouchedPathsFromPatch(patchText) {
-    if (typeof patchText !== 'string' || patchText.length === 0) return [];
-    const lines = patchText.split('\n');
-    const out = [];
-    const seen = new Set();
-    const stripPathMetadata = (rawPath) => {
-        let text = String(rawPath || '').trim();
-        if (!text) return '';
-        const tabIdx = text.indexOf('\t');
-        if (tabIdx !== -1) text = text.slice(0, tabIdx).trimEnd();
-        const quote = text[0];
-        if ((quote === '"' || quote === "'") && text.length > 1) {
-            const end = text.indexOf(quote, 1);
-            if (end > 0) text = text.slice(1, end);
-        }
-        return text;
-    };
-    const push = (rawPath) => {
-        let touched = stripPathMetadata(rawPath);
-        if (!touched || touched === '/dev/null') return;
-        touched = touched.replace(/^["']|["']$/g, '').replace(/\\/g, '/');
-        if (touched.startsWith('a/') || touched.startsWith('b/')) touched = touched.slice(2);
-        if (!touched || touched === '/dev/null' || seen.has(touched)) return;
-        seen.add(touched);
-        out.push(touched);
-    };
-    for (const line of lines) {
-        if (line.startsWith('*** Update File:')) push(line.slice('*** Update File:'.length));
-        else if (line.startsWith('*** Add File:')) push(line.slice('*** Add File:'.length));
-        else if (line.startsWith('*** Delete File:')) push(line.slice('*** Delete File:'.length));
-    }
-    for (let i = 0; i < lines.length - 1; i += 1) {
-        const minus = lines[i];
-        const plus = lines[i + 1];
-        if (!minus.startsWith('--- ')) continue;
-        if (!plus.startsWith('+++ ')) continue;
-        const fromRaw = minus.slice(4).trim();
-        const toRaw = plus.slice(4).trim();
-        const fromStripped = fromRaw.startsWith('a/') ? fromRaw.slice(2) : fromRaw;
-        const toStripped = toRaw.startsWith('b/') ? toRaw.slice(2) : toRaw;
-        let touched;
-        if (toStripped === '/dev/null') {
-            touched = fromStripped === '/dev/null' ? null : fromStripped;
-        } else {
-            touched = toStripped;
-        }
-        push(touched);
-        i += 1;
-    }
-    return out;
-}