mixdog 0.9.9 → 0.9.11

package/src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs

@@ -1,12 +1,14 @@
 import { readdirSync } from 'fs';
 import { basename, relative } from 'path';
 import {
+    coerceReadFamilyPathArg,
     extractGlobBaseDirectory,
     hasGlobMagic,
     normalizeInputPath,
     normalizeOutputPath,
     resolveAgainstCwd,
 } from './path-utils.mjs';
+import { tryReadFamilyEnoentRedirect } from './search-path-diagnostics.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
 import { isUncPath, isWindowsDevicePath, hasUnsafeWin32Component } from './device-paths.mjs';
 import {
@@ -37,6 +39,19 @@ const LIST_WALK_TIMEOUT_MS = 20_000;
 const LIST_ABSOLUTE_CAP = 50_000;
 
 /** undefined / invalid / negative → defaultCap; 0 = no page cap (absolute caps still apply). */
+async function readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, rerunTool) {
+    const redirected = await tryReadFamilyEnoentRedirect({
+        workDir,
+        resolvedPath: fullPath,
+        requestedPath: inputPath,
+        errCode: err?.code,
+        options,
+        rerun: (target, opts) => rerunTool({ ...args, path: target }, workDir, opts),
+    });
+    if (redirected) return redirected;
+    return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+}
+
 function normalizeListHeadLimit(raw, defaultCap) {
     if (raw === undefined || raw === null || raw === '') return defaultCap;
     const n = Number(raw);
@@ -60,6 +75,7 @@ function listGuardPath(p) {
 }
 
 export async function executeListTool(args, workDir, options = {}) {
+    args.path = coerceReadFamilyPathArg(args.path, workDir);
     if (Array.isArray(args.path)) {
         const list = [...new Set(args.path.map((p) => (typeof p === 'string' ? p.trim() : '')).filter((p) => p.length > 0))];
         const capped = list.length > 10;
@@ -120,7 +136,9 @@ export async function executeListTool(args, workDir, options = {}) {
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
     let st;
     try { st = getCachedReadOnlyStat(fullPath); }
-    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    catch (err) {
+        return await readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, executeListTool);
+    }
     if (!st.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
 
     const rows = [];
@@ -251,7 +269,9 @@ export async function executeTreeTool(args, workDir, options = {}) {
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
     let st;
     try { st = getCachedReadOnlyStat(fullPath); }
-    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    catch (err) {
+        return await readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, executeListTool);
+    }
     if (!st.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
     const lines = [`${normalizeOutputPath(fullPath)}/`];
     const prefixStack = [''];
@@ -407,6 +427,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
 }
 
 export async function executeFindFilesTool(args, workDir, options = {}) {
+    args.path = coerceReadFamilyPathArg(args.path, workDir);
     args.path = normalizeInputPath(args.path);
     let inputPath = args.path || '.';
     let namePattern = typeof args.name === 'string' ? args.name : null;
@@ -511,7 +532,9 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
     let rootStat;
     try { rootStat = getCachedReadOnlyStat(fullPath); }
-    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    catch (err) {
+        return await readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, executeFindFilesTool);
+    }
     if (!rootStat.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
 
     const matches = [];

package/src/runtime/agent/orchestrator/tools/builtin/path-utils.mjs

@@ -1,6 +1,6 @@
 import { homedir } from 'os';
 import { isAbsolute, relative, resolve } from 'path';
-import { realpathSync } from 'node:fs';
+import { realpathSync, statSync } from 'node:fs';
 import { isWSL } from '../../../../shared/wsl.mjs';
 
 // Restore the on-disk casing of a path (win32 only). rg relativizes candidate
@@ -237,3 +237,31 @@ export function coerceShapeFlex(value) {
     }
     return value;
 }
+
+// JSON-stringified path arrays (path:"[]") and empty arrays mean "search cwd".
+// Bracket-shaped strings that exist on disk (e.g. a literal `[x]` directory) are
+// left untouched — JSON reinterpretation only runs after a stat miss.
+export function coerceReadFamilyPathArg(path, workDir = null) {
+    if (path === undefined || path === null || path === '') return path;
+    if (typeof path === 'string' && typeof workDir === 'string' && workDir) {
+        const trimmed = path.trim();
+        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            try {
+                const resolved = resolveAgainstCwd(normalizeInputPath(trimmed), workDir);
+                statSync(resolved);
+                return path;
+            } catch { /* not a literal bracket path — allow JSON coercion */ }
+        }
+    }
+    const coerced = coerceShapeFlex(path);
+    if (!Array.isArray(coerced)) return coerced;
+    const list = coerced
+        // Region objects ({path,offset,limit}) must pass through untouched —
+        // read's batch dispatcher consumes them. Only strings are trimmed.
+        .map((p) => (typeof p === 'string' ? p.trim() : p))
+        .filter((p) => (typeof p === 'string' ? p.length > 0 : (p && typeof p === 'object')));
+    if (list.length === 0) return '.';
+    // Collapse to scalar only for a lone string; a lone region object must
+    // stay an array so read's object-batch dispatcher handles it.
+    return list.length === 1 && typeof list[0] === 'string' ? list[0] : list;
+}

package/src/runtime/agent/orchestrator/tools/builtin/read-single-tool.mjs

@@ -3,7 +3,7 @@ import * as fsPromises from 'fs/promises';
 import { readFile } from 'fs/promises';
 import { extname } from 'path';
 import { normalizeInputPath } from './path-utils.mjs';
-import { findFileByBasename, findBySuffixStrip } from './path-diagnostics.mjs';
+import { buildNotFoundHint, tryReadFamilyEnoentRedirect } from './search-path-diagnostics.mjs';
 import { getReadSnapshot } from './read-snapshot-runtime.mjs';
 import { snapshotCoversFullFile, statMatchesSnapshot } from './snapshot-helpers.mjs';
 import { formatBinaryReadPreview } from './binary-file.mjs';
@@ -202,24 +202,25 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     }
     if (!st) {
         const err = _statErr;
+        const redirected = await tryReadFamilyEnoentRedirect({
+            workDir,
+            resolvedPath: fullPath,
+            requestedPath: filePath,
+            errCode: err?.code,
+            options,
+            rerun: (target, opts) => executeSingleReadTool(
+                { ...args, path: target },
+                workDir,
+                readStateScope,
+                opts,
+                helpers,
+            ),
+        });
+        if (redirected) return redirected;
         const similar = findSimilarFile(fullPath);
         let hint = similar ? ` Did you mean "${normalizeOutputPath(similar)}"?` : '';
-        // Right-name / wrong-directory miss: findSimilarFile only checks the
-        // same dir. Locate the basename elsewhere in the tree and name the real
-        // path(s) directly — the route a model would otherwise reconstruct with
-        // a grep/glob storm.
         if (!similar) {
-            // Hallucinated absolute-prefix recovery first: no directory walk,
-            // stats directly (finds vendor/ paths the basename BFS skips).
-            const suffixHit = findBySuffixStrip(workDir, fullPath);
-            if (suffixHit) {
-                hint = ` Not found at this path; the same filename exists at: "${normalizeOutputPath(suffixHit)}". Read that path directly.`;
-            } else {
-                const elsewhere = findFileByBasename(workDir, fullPath);
-                if (elsewhere.length) {
-                    hint = ` Not found at this path; the same filename exists at: ${elsewhere.map((p) => `"${normalizeOutputPath(p)}"`).join(', ')}. Read that path directly.`;
-                }
-            }
+            hint = buildNotFoundHint(workDir, fullPath, 'Read', err?.code);
         }
         const _rawMsg = err instanceof Error ? err.message : String(err);
         const _safeMsg = normalizeErrorMessage(_rawMsg, workDir);

package/src/runtime/agent/orchestrator/tools/builtin/read-tool.mjs

@@ -5,6 +5,7 @@ import { readEntryCoalescedDiskWindow } from './read-batch.mjs';
 import { readPathStringGuardError } from './read-open.mjs';
 import { parseReadLineNumberArg } from './read-args.mjs';
 import { assertPathsReachable } from './fs-reachability.mjs';
+import { coerceReadFamilyPathArg } from './path-utils.mjs';
 
 function hasLineCoordinate(path) {
     return typeof path === 'string' && /(?:#L\d+|:\d+(?:-\d+)?(?::|$))/i.test(path);
@@ -109,7 +110,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             args.offset = Math.trunc(ccOffset) - 1;
         }
     }
-    args.path = coerceShapeFlex(args.path);
+    args.path = coerceReadFamilyPathArg(args.path, workDir);
     // Reachability preflight up front (all shapes) — before readPathStringGuardError /
     // image stat, all of which can touch sync FS.
     {

package/src/runtime/agent/orchestrator/tools/builtin/search-builders.mjs

@@ -30,6 +30,7 @@ export function buildGrepCacheKey(parts) {
         fileType,
         onlyMatching,
         pcre2,
+        withFilename,
     } = parts;
     return [
         'grep',
@@ -48,6 +49,7 @@ export function buildGrepCacheKey(parts) {
         onlyMatching ? 'o1' : 'o0',
         Array.isArray(fileType) ? fileType.join('\x01') : (fileType || ''),
         pcre2 ? 'p1' : 'p0',
+        withFilename ? 'H1' : 'H0',
     ].join('|');
 }
 
@@ -67,6 +69,7 @@ export function buildGrepRgArgs(parts) {
         onlyMatching,
         fixedStrings = false,
         pcre2 = false,
+        withFilename = false,
     } = parts;
     // `--hidden`: search dotfiles/dot-dirs (.github, .mixdog) that
     // rg skips by default. The DEFAULT_IGNORE_GLOBS below still exclude .git and
@@ -78,6 +81,7 @@ export function buildGrepRgArgs(parts) {
         rgArgs.push('--count');
     } else {
         rgArgs.push('--no-heading');
+        if (withFilename) rgArgs.push('-H');
         if (showLineNumbers) rgArgs.push('--line-number');
         if (beforeN !== null) rgArgs.push('-B', String(beforeN));
         if (afterN !== null) rgArgs.push('-A', String(afterN));

package/src/runtime/agent/orchestrator/tools/builtin/search-path-diagnostics.mjs

@@ -64,12 +64,38 @@ export function stripEmbeddedPathQuotes(p) {
 // not-found codes: EACCES/EPERM etc. keep their real failure semantics and
 // must not trigger same-basename guidance or the BFS scan.
 const NOT_FOUND_CODES = new Set(['ENOENT', 'ENOTDIR']);
+export function resolveUniqueEnoentRedirect(workDir, missingPath, errCode = 'ENOENT') {
+    if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return null;
+    const suffixHit = findBySuffixStrip(workDir, missingPath);
+    if (suffixHit) return suffixHit;
+    const elsewhere = findFileByBasename(workDir, missingPath);
+    if (elsewhere.length === 1) return elsewhere[0];
+    return null;
+}
+
+export function redirectedFromPrefix(requestedPath) {
+    return `[redirected from ${normalizeOutputPath(requestedPath)}]\n`;
+}
+
+export async function tryReadFamilyEnoentRedirect({
+    workDir,
+    resolvedPath,
+    requestedPath,
+    errCode,
+    options,
+    rerun,
+}) {
+    if (options?._enoentRedirectFrom) return null;
+    const target = resolveUniqueEnoentRedirect(workDir, resolvedPath, errCode);
+    if (!target) return null;
+    const body = await rerun(target, { ...options, _enoentRedirectFrom: resolvedPath });
+    const shown = requestedPath ?? resolvedPath;
+    return redirectedFromPrefix(shown) + body;
+}
+
 export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'ENOENT') {
     if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return '';
-    const suffixHit = findBySuffixStrip(workDir, missingPath);
-    if (suffixHit) {
-        return ` Not found at this path; the same filename exists at: "${normalizeOutputPath(suffixHit)}". ${actionVerb} that path directly.`;
-    }
+    if (resolveUniqueEnoentRedirect(workDir, missingPath, errCode)) return '';
     const elsewhere = findFileByBasename(workDir, missingPath);
     if (elsewhere.length) {
         return ` Not found at this path; the same filename exists at: ${elsewhere.map((p) => `"${normalizeOutputPath(p)}"`).join(', ')}. ${actionVerb} that path directly.`;