mixdog 0.9.174 → 1.0.0

package/src/runtime/tidy/report.mjs

@@ -2,7 +2,7 @@
 // bounded the way every model-facing tool bounds output: per-engine diagnostic
 // caps with a `more` count first, then progressive trimming until the encoded
 // report fits the tool output budget.
-import { TOOL_OUTPUT_MAX_BYTES } from '../agent/orchestrator/tools/builtin/tool-output-limit.mjs';
+import { TOOL_OUTPUT_MAX_BYTES } from '../shared/tool-output-limit.mjs';
 import { shadowNote } from './shadow.mjs';
 import { worktreeNotes } from './worktree.mjs';
 
@@ -11,10 +11,10 @@ const FILE_LIST_CAP = 25;
 export const RESULTS_PAGE_MAX = 100;
 const TRIM_STEPS = [8, 3, 0];
 
-export function tidyToolResult(value, isError = false) {
+export function tidyToolResult(value, isError = value?.ok === false) {
   return {
     content: [{ type: 'text', text: JSON.stringify(value) }],
-    ...(isError || value?.ok === false ? { isError: true } : {}),
+    ...(isError ? { isError: true } : {}),
   };
 }
 
@@ -267,6 +267,7 @@ export function buildTidyReport({
   engines = [],
   results = null,
   structural = null,
+  functionLength = null,
   needsApproval = null,
   installed = null,
   errors = [],
@@ -317,6 +318,7 @@ export function buildTidyReport({
     rolled: rollupEngineCounts(results),
     structural,
     structuralSummary: summarizeDiagnostics(structural?.matches),
+    functionLength: isRunAction(action) ? functionLength : null,
     shadows: !isRunAction(action) && Array.isArray(shadows) ? shadows : [],
     workingTree,
     passErrors,
@@ -421,6 +423,7 @@ function composeTidyReport(parts, diagnosticCap) {
         }
       : {}),
     ...(workingTree && Object.keys(workingTree).length ? { workingTree } : {}),
+    ...(parts.functionLength ? { functionLength: parts.functionLength } : {}),
     ...(paged ? { paging: { offset: pageOffset, limit: diagnosticCap } } : {}),
     ...(parts.rules ? { rules: parts.rules } : {}),
     ...(parts.installed ? { installed: parts.installed } : {}),

package/src/runtime/tidy/runners/shared.mjs

@@ -24,6 +24,7 @@ export function chunkFiles(files = [], size = FILES_PER_SPAWN) {
 // Engines colorize the paths they report (air underlines them, mago colors its
 // diffs), so every path-matching parser strips SGR sequences first.
 // eslint-disable-next-line no-control-regex -- SGR escapes are the point
+// biome-ignore lint/suspicious/noControlCharactersInRegex: SGR escapes are the point
 const ANSI_SGR = /\u001B\[[0-9;]*m/g;
 
 export function stripAnsi(text) {

package/src/runtime/tidy/runners/shellcheck.mjs

@@ -21,7 +21,7 @@ export function parseShellcheckJson(stdout, cwd) {
       code: row?.code ? `SC${row.code}` : 'shellcheck',
       message: String(row?.message || ''),
       severity: severityOf(row?.level),
-      fixable: Boolean(row?.fix),
+      fixable: false,
     })
   );
 }

package/src/runtime/tidy/tool.mjs

@@ -18,6 +18,7 @@ import { resolveEngines, runnableEngines } from './resolve.mjs';
 import { DIAGNOSTIC_CAP, RESULTS_PAGE_MAX, buildTidyReport, tidyToolResult } from './report.mjs';
 import { runProcess } from './process.mjs';
 import { detectEngineShadows } from './shadow.mjs';
+import { summarizeFunctionLengths } from './function-length.mjs';
 import { listWorkingTreeChanges, splitFindingsByWorktree } from './worktree.mjs';
 
 const GRAPH_LANGS_TIMEOUT_MS = 8000;
@@ -146,8 +147,8 @@ function normalizeScope(paths, cwd) {
 
 async function pluginDataDir() {
   try {
-    const { getPluginData } = await import('../agent/orchestrator/config.mjs');
-    return getPluginData() || '';
+    const { resolvePluginData } = await import('../shared/plugin-paths.mjs');
+    return resolvePluginData() || '';
   } catch {
     return '';
   }
@@ -401,6 +402,7 @@ async function runAction({ action, args, cwd, scope, languageFilter, engineFilte
     workingTree: await splitRunFindings({ cwd, results, structural, signal }),
     results,
     structural,
+    functionLength: await summarizeFunctionLengths({ cwd, files: detected.files, signal }),
     needsApproval,
     installed: installed ? installed.engines : null,
     ...(scope.length ? { scope } : {}),
@@ -569,7 +571,12 @@ export async function executeTidyTool(args = {}, { cwd = process.cwd(), signal =
       return tidyToolResult(await rulesAction({ cwd, signal, startedAt }));
     }
     if (action === 'results') {
-      return tidyToolResult(await resultsAction({ args, cwd, sessionId, engineFilter, pathFilter: scope, startedAt }));
+      // Paging a stored run succeeds even when that run was incomplete; the
+      // report's ok/status still describe the run itself.
+      return tidyToolResult(
+        await resultsAction({ args, cwd, sessionId, engineFilter, pathFilter: scope, startedAt }),
+        false
+      );
     }
     return tidyToolResult(
       await runAction({

package/src/runtime/web-search/index.mjs

@@ -3,19 +3,9 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import fs from 'node:fs';
 import { ensureDataDir, getRequestTimeoutMs, loadConfig } from './lib/config.mjs';
 import { normalizeErrorMessage } from '../agent/orchestrator/tools/builtin/path-diagnostics.mjs';
 import { presentErrorText } from '../shared/err-text.mjs';
-
-function readPluginVersion() {
-  try {
-    return JSON.parse(fs.readFileSync(new URL('../../../package.json', import.meta.url), 'utf8')).version || '0.0.1';
-  } catch {
-    return '0.0.1';
-  }
-}
-const PLUGIN_VERSION = readPluginVersion();
 import {
   buildCacheKey,
   buildCacheMeta,
@@ -28,6 +18,9 @@ import { flushUsageState, loadUsageState, updateProviderState } from './lib/stat
 import { closeScrapeBrowserPool, getScrapeCapabilities, scrapeUrls } from './lib/web-tools.mjs';
 import { fetchLoopbackText, fetchPublicImage } from './lib/http-fetch.mjs';
 import { applyFetchPagination, formatResponse } from './lib/formatter.mjs';
+import { PACKAGE_VERSION } from './lib/package-version.mjs';
+import { TOOL_DEFS as toolDefinitions } from './tool-defs.mjs';
+
 ensureDataDir();
 
 const webSearchArgsSchema = z.object({
@@ -172,9 +165,7 @@ function getWebSearchCacheTtlMs(type = 'web') {
   }
 }
 
-function getScrapeCacheTtlMs() {
-  return 60 * 60 * 1000;
-}
+const SCRAPE_CACHE_TTL_MS = 60 * 60 * 1000;
 
 function normalizeCacheUrl(url) {
   try {
@@ -458,7 +449,7 @@ async function _fetchCore(args, { usageState, cacheState, timeoutMs, signal }) {
         };
       }
       const payload = { tool: 'web_fetch', ...page };
-      const cachedEntry = setCachedEntry(cacheState, fetchCacheKey, payload, getScrapeCacheTtlMs());
+      const cachedEntry = setCachedEntry(cacheState, fetchCacheKey, payload, SCRAPE_CACHE_TTL_MS);
       return {
         index: index + 1,
         status: 'success',
@@ -499,14 +490,12 @@ async function _fetchCore(args, { usageState, cacheState, timeoutMs, signal }) {
 
 // Web search is supplied by the runtime through the configured native search
 // route. The module owns argument validation, caching, fan-out, and formatting.
-import { TOOL_DEFS as toolDefinitions } from './tool-defs.mjs';
-
 const WEB_SEARCH_INSTRUCTIONS = '';
 
 const server = new Server(
   {
     name: 'mixdog-web',
-    version: PLUGIN_VERSION,
+    version: PACKAGE_VERSION,
   },
   {
     capabilities: {

package/src/runtime/web-search/lib/cache.mjs

@@ -1,5 +1,6 @@
 import crypto from 'node:crypto';
-import { CACHE_PATH, readJson, writeJson } from './config.mjs';
+import { CACHE_PATH, readJson } from './config.mjs';
+import { createDebouncedJsonWriter } from './debounced-json-writer.mjs';
 
 const DEFAULT_CACHE_STATE = {
   entries: {},
@@ -60,62 +61,15 @@ function enforceCacheSizeBounds(state) {
   }
 }
 
-const FLUSH_DELAY_MS = 5000;
-
-let cacheDirty = false;
-let cacheFlushTimer = null;
-let activeCacheState = null;
-let lastCacheFlushWarnAt = 0;
-
 function nowMs() {
   return Date.now();
 }
 
-// 5s debounce so a single web-search invocation that touches the cache multiple
-// times (lookup + insert + prune) coalesces into one writeJson roundtrip.
-// Without this, callers like crawl/batch that don't explicitly flush would
-// either spam fsync (immediate write per mutation) or silently drop dirty
-// state on crash (bare dirty flag).
-function scheduleCacheFlush(state) {
-  cacheDirty = true;
-  activeCacheState = state;
-  if (cacheFlushTimer) return;
-  cacheFlushTimer = setTimeout(() => {
-    cacheFlushTimer = null;
-    flushCacheState();
-  }, FLUSH_DELAY_MS);
-  if (cacheFlushTimer.unref) cacheFlushTimer.unref();
-}
-
-function flushCacheState() {
-  if (cacheFlushTimer) {
-    clearTimeout(cacheFlushTimer);
-    cacheFlushTimer = null;
-  }
-  if (cacheDirty && activeCacheState) {
-    try {
-      writeJson(CACHE_PATH, activeCacheState);
-      cacheDirty = false;
-    } catch (err) {
-      // Cache state is best-effort. Windows AV/indexer can hold the
-      // destination open. Keep the dirty state and retry quietly.
-      const now = Date.now();
-      if (now - lastCacheFlushWarnAt > 60000) {
-        lastCacheFlushWarnAt = now;
-        process.stderr.write(`[web-search-cache] flushCacheState delayed: ${err?.code || err?.message || err}\n`);
-      }
-      if (!cacheFlushTimer) {
-        cacheFlushTimer = setTimeout(() => {
-          cacheFlushTimer = null;
-          flushCacheState();
-        }, FLUSH_DELAY_MS * 2);
-        if (cacheFlushTimer.unref) cacheFlushTimer.unref();
-      }
-    }
-  }
-}
-
-process.on('exit', flushCacheState);
+// A single web-search invocation that touches the cache several times (lookup +
+// insert + prune) coalesces into one write.
+const cacheWriter = createDebouncedJsonWriter({ path: CACHE_PATH, label: 'web-search-cache' });
+const scheduleCacheFlush = cacheWriter.schedule;
+const flushCacheState = cacheWriter.flush;
 
 export { flushCacheState };
 
@@ -128,7 +82,7 @@ export function loadCacheState() {
     state.entries = {};
   }
   _instance = state;
-  activeCacheState = state;
+  cacheWriter.track(state);
   pruneExpiredEntries(state);
   cacheApproxBytes(state);
   enforceCacheSizeBounds(state);

package/src/runtime/web-search/lib/config.mjs

@@ -15,12 +15,8 @@ export const DEFAULT_CONFIG = {
   requestTimeoutMs: 120000,
 };
 
-export function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-
 export function ensureDataDir() {
-  ensureDir(DATA_DIR);
+  fs.mkdirSync(DATA_DIR, { recursive: true });
 }
 
 export function readJson(filePath, fallback) {
@@ -42,7 +38,7 @@ export function readJson(filePath, fallback) {
 }
 
 export function writeJson(filePath, value) {
-  ensureDir(path.dirname(filePath));
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   writeJsonAtomicSync(filePath, value, { lock: true, fsyncDir: true });
 }
 

package/src/runtime/web-search/lib/debounced-json-writer.mjs

@@ -0,0 +1,62 @@
+import { writeJson } from './config.mjs';
+
+const FLUSH_DELAY_MS = 5000;
+const WARN_INTERVAL_MS = 60000;
+
+/**
+ * Debounced, best-effort persistence of one JSON state object.
+ *
+ * Every mutation calls `schedule(state)`; writes coalesce into one roundtrip
+ * per delay window instead of an fsync per call, and `process.on('exit')`
+ * still flushes on graceful shutdown. A failed write (a Windows AV/indexer can
+ * hold the destination open) keeps the state dirty and retries quietly.
+ * `track(state)` names the object to persist without marking it dirty.
+ */
+export function createDebouncedJsonWriter({ path, label }) {
+  let dirty = false;
+  let timer = null;
+  let active = null;
+  let lastWarnAt = 0;
+
+  const arm = (delayMs) => {
+    timer = setTimeout(() => {
+      timer = null;
+      flush();
+    }, delayMs);
+    timer.unref?.();
+  };
+
+  function schedule(state) {
+    dirty = true;
+    active = state;
+    if (!timer) arm(FLUSH_DELAY_MS);
+  }
+
+  function flush() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!dirty || !active) return;
+    try {
+      writeJson(path, active);
+      dirty = false;
+    } catch (err) {
+      const now = Date.now();
+      if (now - lastWarnAt > WARN_INTERVAL_MS) {
+        lastWarnAt = now;
+        process.stderr.write(`[${label}] flush delayed: ${err?.code || err?.message || err}\n`);
+      }
+      if (!timer) arm(FLUSH_DELAY_MS * 2);
+    }
+  }
+
+  process.on('exit', flush);
+  return {
+    schedule,
+    flush,
+    track(state) {
+      active = state;
+    },
+  };
+}

package/src/runtime/web-search/lib/http-fetch.mjs

@@ -1,15 +1,7 @@
-import { readFileSync } from 'node:fs';
 import dns from 'node:dns';
 
-import { assertPublicUrl, pinnedFetch } from './ssrf-guard.mjs';
-
-const PKG_VERSION = (() => {
-  try {
-    return JSON.parse(readFileSync(new URL('../../../../package.json', import.meta.url), 'utf8')).version;
-  } catch {
-    return '0.0.1';
-  }
-})();
+import { PACKAGE_VERSION } from './package-version.mjs';
+import { abortRace, assertPublicUrl, fetchThroughAgent, pinnedFetch } from './ssrf-guard.mjs';
 
 export function withTimeout(controller, timeoutMs) {
   return setTimeout(() => controller.abort(), timeoutMs);
@@ -17,7 +9,7 @@ export function withTimeout(controller, timeoutMs) {
 
 export function buildHeaders() {
   return {
-    'User-Agent': `mixdog-web-search/${PKG_VERSION}`,
+    'User-Agent': `mixdog-web-search/${PACKAGE_VERSION}`,
     Accept: 'text/html, application/xhtml+xml, text/markdown, text/plain, application/json;q=0.9, */*;q=0.5',
     'Accept-Language': 'en, ko;q=0.9',
   };
@@ -42,13 +34,18 @@ export function isFatalHttpPathPolicyError(error) {
   return false;
 }
 
+/** Release the socket of a response whose body will not be read. */
+async function discardBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {}
+}
+
 /** Content-Length already exceeds the cap: reject before reading any byte. */
 async function assertAnnouncedSizeWithinCap(response, maxBytes) {
   const contentLength = Number(response.headers.get('content-length') || 0);
   if (contentLength <= maxBytes) return;
-  try {
-    await response.body?.cancel();
-  } catch {}
+  await discardBody(response);
   throw new Error(`response body too large: Content-Length=${contentLength} > cap=${maxBytes}`);
 }
 
@@ -92,9 +89,7 @@ async function readBodyWithCap(response, maxBytes) {
     if (!isText) {
       // Cancel body before throwing so the underlying socket isn't held
       // until GC — fetchDocument's caller would otherwise leak the connection.
-      try {
-        await response.body?.cancel();
-      } catch {}
+      await discardBody(response);
       throw new Error(`Blocked non-text content-type: ${contentType.split(';')[0].trim()}`);
     }
   }
@@ -108,9 +103,7 @@ async function readBodyWithCap(response, maxBytes) {
     const text = await response.text();
     if (Buffer.byteLength(text, 'utf8') > maxBytes) {
       // response.text() already drained the body, but guard symmetrically.
-      try {
-        await response.body?.cancel();
-      } catch {}
+      await discardBody(response);
       throw new Error(`response body too large: ${text.length} bytes > cap=${maxBytes}`);
     }
     return text;
@@ -135,9 +128,7 @@ async function readBodyBytesWithCap(response, maxBytes) {
   if (!reader) {
     const buf = Buffer.from(await response.arrayBuffer());
     if (buf.byteLength > maxBytes) {
-      try {
-        await response.body?.cancel();
-      } catch {}
+      await discardBody(response);
       throw new Error(`response body too large: ${buf.byteLength} bytes > cap=${maxBytes}`);
     }
     return buf;
@@ -155,39 +146,19 @@ function loopbackHost(hostname) {
   return Boolean(match && Number(match[1]) === 127);
 }
 
-function abortRace(promise, signal) {
-  if (!signal) return promise;
-  if (signal.aborted) return Promise.reject(signal.reason || new Error('local_fetch aborted'));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(signal.reason || new Error('local_fetch aborted'));
-    signal.addEventListener('abort', onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener('abort', onAbort);
-        resolve(value);
-      },
-      (error) => {
-        signal.removeEventListener('abort', onAbort);
-        reject(error);
-      }
-    );
-  });
-}
-
 async function pinnedLoopbackFetch(url, options = {}) {
   const parsed = assertLoopbackUrl(url);
   const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
   const literalFamily = host.includes(':') ? 6 : 4;
   const addresses =
     host === 'localhost'
-      ? await abortRace(dns.promises.lookup(host, { all: true }), options.signal)
+      ? await abortRace(dns.promises.lookup(host, { all: true }), options.signal, 'local_fetch')
       : [{ address: host, family: literalFamily }];
   if (!addresses.length || addresses.some((entry) => !loopbackHost(entry.address))) {
     throw new Error(`Blocked non-loopback local_fetch resolution: ${host}`);
   }
   const pinned = addresses[0];
-  const { Agent, fetch: undiciFetch } = await import('undici');
-  const dispatcher = new Agent({
+  return fetchThroughAgent(url, options, {
     connect: {
       lookup: (_hostname, opts, cb) =>
         opts?.all
@@ -195,49 +166,6 @@ async function pinnedLoopbackFetch(url, options = {}) {
           : cb(null, pinned.address, pinned.family),
     },
   });
-  let response;
-  try {
-    response = await undiciFetch(url, { ...options, dispatcher });
-  } catch (error) {
-    dispatcher.destroy().catch(() => {});
-    throw error;
-  }
-  if (!response.body) {
-    dispatcher.destroy().catch(() => {});
-    return response;
-  }
-  const reader = response.body.getReader();
-  let cleaned = false;
-  const cleanup = () => {
-    if (cleaned) return;
-    cleaned = true;
-    dispatcher.destroy().catch(() => {});
-  };
-  const monitored = new ReadableStream({
-    async pull(controller) {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          controller.close();
-          cleanup();
-        } else {
-          controller.enqueue(value);
-        }
-      } catch (error) {
-        controller.error(error);
-        cleanup();
-      }
-    },
-    cancel(reason) {
-      reader.cancel(reason).catch(() => {});
-      cleanup();
-    },
-  });
-  return new Response(monitored, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-  });
 }
 
 function assertLoopbackUrl(url) {
@@ -264,9 +192,7 @@ async function boundedManualFetch(url, { signal, fetchImpl, validateUrl, sameHos
       redirect: 'manual',
     });
     if (!REDIRECT_STATUSES.has(response.status)) return response;
-    try {
-      await response.body?.cancel();
-    } catch {}
+    await discardBody(response);
     if (hops >= MAX_REDIRECTS) throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
     const location = response.headers.get('location');
     if (!location) throw new Error(`Redirect ${response.status} without Location header`);
@@ -281,9 +207,7 @@ export async function fetchLoopbackText(url, { signal, fetchImpl = pinnedLoopbac
     validateUrl: assertLoopbackUrl,
   });
   if (!response.ok) {
-    try {
-      await response.body?.cancel();
-    } catch {}
+    await discardBody(response);
     throw new Error(`HTTP ${response.status}`);
   }
   return readBodyWithCap(response, MAX_BODY_BYTES);
@@ -300,16 +224,12 @@ export async function fetchPublicImage(url, { signal, fetchImpl = pinnedFetch }
     sameHost: true,
   });
   if (!response.ok) {
-    try {
-      await response.body?.cancel();
-    } catch {}
+    await discardBody(response);
     throw new Error(`HTTP ${response.status}`);
   }
   const mimeType = (response.headers.get('content-type') || '').split(';')[0].trim().toLowerCase();
   if (!SAFE_IMAGE_MIMES.has(mimeType)) {
-    try {
-      await response.body?.cancel();
-    } catch {}
+    await discardBody(response);
     throw new Error(`Blocked unsupported image content-type: ${mimeType || '(missing)'}`);
   }
   const bytes = await readBodyBytesWithCap(response, MAX_BODY_BYTES);
@@ -357,9 +277,7 @@ export async function fetchPinnedForPausedRequest(
       body: respBody,
     };
   } catch (error) {
-    try {
-      await response.body?.cancel();
-    } catch {}
+    await discardBody(response);
     throw error;
   }
 }
@@ -421,17 +339,13 @@ export async function fetchDocument(url, timeoutMs, signal, { request = pinnedFe
           }
           for (const cookie of setCookies) session.jar.setCookieSync(cookie, currentUrl, { ignoreError: true });
         } catch (error) {
-          try {
-            await response.body?.cancel();
-          } catch {}
+          await discardBody(response);
           throw error;
         }
       }
       if (REDIRECT_STATUSES.has(response.status)) {
         // Drain the redirect response body so the socket isn't held until GC.
-        try {
-          await response.body?.cancel();
-        } catch {}
+        await discardBody(response);
         if (hops >= MAX_REDIRECTS) {
           throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
         }
@@ -448,9 +362,7 @@ export async function fetchDocument(url, timeoutMs, signal, { request = pinnedFe
       try {
         assertDocumentResponse(response.status, response.headers, currentUrl);
       } catch (error) {
-        try {
-          await response.body?.cancel();
-        } catch {}
+        await discardBody(response);
         throw error;
       }
       return {

package/src/runtime/web-search/lib/package-version.mjs

@@ -0,0 +1,10 @@
+import { readFileSync } from 'node:fs';
+
+/** The installed package version, for the MCP server identity and the fetch User-Agent. */
+export const PACKAGE_VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(new URL('../../../../package.json', import.meta.url), 'utf8')).version || '0.0.1';
+  } catch {
+    return '0.0.1';
+  }
+})();