mixdog 0.9.151 → 0.9.152

package/src/runtime/agent/orchestrator/tools/builtin/find-search-budget.test.mjs

@@ -22,7 +22,7 @@ test('server setup is not charged to the search budget', () => {
   assert.equal(_searchRemainingMsForTest(deadline, startedAt, 0, 9_000), 1);
 });
 
-test('a fuzzy deadline recovers a real candidate through one targeted path scan', async () => {
+test('a fuzzy deadline returns promptly without starting another filesystem walk', async () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-find-budget-'));
   try {
     writeFileSync(join(root, 'anchor.txt'), 'anchor\n');
@@ -30,28 +30,19 @@ test('a fuzzy deadline recovers a real candidate through one targeted path scan'
       new Error('native fuzzy search timed out after 1500ms.'),
       { code: 'NATIVE_SEARCH_TIMEOUT' },
     );
-    let targetedEnumerationCalls = 0;
-    let targetedArgs = null;
     const telemetry = {};
     const out = String(await runWithLocalSearchTelemetry(telemetry, () => executeFuzzyFindTool(
       { query: 'needle-that-never-ranks', path: '.', head_limit: 5 },
       root,
       {
         __tryServeFuzzySearch: async () => { throw timeout; },
-        __runRg: async (args) => {
-          targetedEnumerationCalls += 1;
-          targetedArgs = args;
-          return 'src/needle-that-never-ranks.ts\n';
-        },
       },
     )));
     assert.ok(!/^Error[\s:[]/.test(out.trimStart()), `must not surface as a tool failure:\n${out}`);
-    assert.match(out, /src\/needle-that-never-ranks\.ts/);
-    assert.match(out, /targeted path matches shown/);
-    assert.equal(targetedEnumerationCalls, 1);
-    assert.ok(targetedArgs.includes('--iglob'), `expected a targeted --iglob scan: ${JSON.stringify(targetedArgs)}`);
+    assert.match(out, /no fuzzy match yet/);
+    assert.match(out, /inventory is still building/);
     assert.equal(telemetry.native_fuzzy_partials, 1);
-    assert.equal(telemetry.native_fuzzy_targeted_hits, 1);
+    assert.equal(telemetry.native_fuzzy_targeted_hits, undefined);
     assert.equal(telemetry.native_fuzzy_errors, undefined);
   } finally {
     rmSync(root, { recursive: true, force: true });
@@ -76,7 +67,6 @@ test('a served partial still reports its ranked matches', async () => {
           scanErrors: 0,
           walkErrorDetails: [],
         }),
-        __runRg: async () => '',
       },
     ));
     assert.match(out, /src\/alpha\.ts/);
@@ -85,3 +75,29 @@ test('a served partial still reports its ranked matches', async () => {
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+test('an empty served partial is returned without another filesystem walk', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-find-empty-partial-'));
+  try {
+    const out = String(await executeFuzzyFindTool(
+      { query: 'missing', path: '.', head_limit: 5 },
+      root,
+      {
+        __tryServeFuzzySearch: async () => ({
+          matches: [],
+          hasMore: false,
+          totalMatches: 0,
+          totalSeen: 1,
+          complete: false,
+          partial: true,
+          timeout: true,
+          scanErrors: 0,
+          walkErrorDetails: [],
+        }),
+      },
+    ));
+    assert.match(out, /inventory is still building/);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/runtime/agent/orchestrator/tools/builtin/git-command-policy.mjs

@@ -11,6 +11,12 @@ const ALWAYS_READ = new Set([
 ]);
 
 const SHELL_OPERATOR_CHARS = '|&;<>()';
+const OPERATION_ALIASES = new Map([
+    ['--version', 'version'],
+    ['-v', 'version'],
+    ['--help', 'help'],
+    ['-h', 'help'],
+]);
 
 function atTokenBoundary(char) {
     return char === undefined || /\s/.test(char);
@@ -61,19 +67,23 @@ export function gitActionOf(operation, args) {
 
 export function gitPlanIsReadOnly(plan) {
     const { operation, args } = plan;
+    if (args.some((value) => value === '--output' || value.startsWith('--output='))) return false;
     if (operation === 'fsck' && args.includes('--lost-found')) return false;
     if (ALWAYS_READ.has(operation)) return true;
-    if (operation === 'reflog') return !['delete', 'expire'].includes(gitActionOf(operation, args));
+    if (operation === 'reflog') return ['show', 'list', 'exists'].includes(gitActionOf(operation, args));
     if (operation === 'stash') return ['list', 'show'].includes(gitActionOf(operation, args));
     if (operation === 'worktree') return gitActionOf(operation, args) === 'list';
-    if (operation === 'remote') return args.length === 0 || args.includes('-v') || ['get-url', 'show'].includes(gitActionOf(operation, args));
+    if (operation === 'remote') return ['list', 'get-url', 'show'].includes(gitActionOf(operation, args));
     if (operation === 'clean') return args.some((value) => value === '-n' || value === '--dry-run' || /^-[^-]*n/.test(value));
     if (operation === 'bundle') return ['list-heads', 'verify'].includes(gitActionOf(operation, args));
     if (operation === 'notes') return ['', 'list', 'show'].includes(gitActionOf(operation, args));
     if (operation === 'replace') return args.length === 0 || args.includes('--list');
     if (operation === 'sparse-checkout') return gitActionOf(operation, args) === 'list';
     if (operation === 'submodule') return ['', 'status', 'summary'].includes(gitActionOf(operation, args));
-    if (operation === 'symbolic-ref') return args.filter((value) => !value.startsWith('-')).length <= 1;
+    if (operation === 'symbolic-ref') {
+        if (args.some((value) => value === '-d' || value === '--delete')) return false;
+        return args.filter((value) => !value.startsWith('-')).length <= 1;
+    }
     if (operation === 'hash-object') return !args.includes('-w') && !args.includes('--stdin-paths');
     if (operation === 'branch' || operation === 'tag') {
         return args.length === 0 || args.some((value) => ['--list', '-l', '-a', '--all', '-r', '--remotes'].includes(value));
@@ -112,7 +122,8 @@ function parsedGitOperation(command) {
         }
         break;
     }
-    const operation = String(tokens[index] || '').toLowerCase();
+    const rawOperation = String(tokens[index] || '').toLowerCase();
+    const operation = OPERATION_ALIASES.get(rawOperation) ?? rawOperation;
     return operation ? { operation, args: tokens.slice(index + 1) } : null;
 }
 

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

@@ -208,13 +208,19 @@ function parseCommand(command, workDir) {
     const rawOperation = String(tokens[index] || '').toLowerCase();
     const operation = OPERATION_ALIASES.get(rawOperation) ?? rawOperation;
     if (!operation) throw new Error('git requires a subcommand');
+    const args = tokens.slice(index + 1);
+    if (args.includes('--help')
+        || (operation === 'help' && args.some((value) => !value.startsWith('-')))
+        || (operation === 'help' && args.some((value) => ['-w', '--web', '-m', '--man', '-i', '--info'].includes(value)))) {
+        throw new Error('git manual help can open an external viewer; use the subcommand -h form for terminal usage');
+    }
     if (GUI_OPERATIONS.has(operation)) {
         throw new Error(`git ${operation} opens an interactive GUI and would never return here; use its non-interactive form (diff, merge, add -p)`);
     }
     if (SERVER_OPERATIONS.has(operation)) {
         throw new Error(`git ${operation} is a long-running server; start it with the shell tool so it becomes a background task`);
     }
-    return { command: String(command), cwd, globalArgs, operation, args: tokens.slice(index + 1) };
+    return { command: String(command), cwd, globalArgs, operation, args };
 }
 
 async function runProcess(program, argv, { cwd, signal, maxBytes = MAX_CAPTURE_BYTES } = {}) {
@@ -327,12 +333,25 @@ function semanticExit(plan, result) {
         if (result.exitCode === 0) return { exists: true };
         return result.exitCode === 1 || result.exitCode === 128 ? { exists: false } : null;
     }
+    if (operation === 'reflog' && actionOf(operation, args) === 'exists') {
+        if (result.exitCode === 0) return { exists: true };
+        return result.exitCode === 1 ? { exists: false } : null;
+    }
+    if ((operation === 'show-ref' && args.includes('--verify') && args.includes('--quiet'))
+        || (operation === 'rev-parse' && args.includes('--verify') && args.includes('--quiet'))) {
+        if (result.exitCode === 0) return { exists: true };
+        return result.exitCode === 1 ? { exists: false } : null;
+    }
+    if (operation === 'merge-base' && args.includes('--is-ancestor')) {
+        if (result.exitCode === 0) return { ancestor: true };
+        return result.exitCode === 1 ? { ancestor: false } : null;
+    }
     if (!['diff', 'diff-files', 'diff-index', 'diff-tree'].includes(operation)) return null;
     if (args.includes('--check')) {
         if (result.exitCode === 0) return { problems: false };
         return result.exitCode === 1 || result.exitCode === 2 ? { problems: true } : null;
     }
-    if (args.some((value) => value === '--exit-code' || value === '--quiet')) {
+    if (args.some((value) => value === '--exit-code' || value === '--quiet' || value === '--no-index')) {
         if (result.exitCode === 0) return { changed: false };
         return result.exitCode === 1 ? { changed: true } : null;
     }
@@ -379,8 +398,40 @@ function hasOutputFormat(args) {
     return args.some((value) => /^(?:--format|--pretty)(?:=|$)/.test(value) || value === '--oneline');
 }
 
+function hasPatchOutput(args) {
+    return args.some((value) => ['-p', '-u', '--patch', '--binary'].includes(value)
+        || /^-U\d*$/.test(value)
+        || /^--(?:patch|unified|word-diff|color-words)(?:=|$)/.test(value));
+}
+
+function needsTextDiffOutput(args) {
+    return args.some((value) => [
+        '-s', '--no-patch', '--raw', '--patch-with-raw', '--patch-with-stat',
+        '--numstat', '--shortstat', '--summary', '--compact-summary',
+        '--name-only', '--name-status', '--check', '--cumulative',
+        '--no-prefix', '--default-prefix',
+    ].includes(value)
+        || /^--(?:stat|dirstat|dirstat-by-file)(?:-|=|$)/.test(value)
+        || /^--(?:line-prefix|src-prefix|dst-prefix|output-indicator-(?:new|old|context))(?:=|$)/.test(value)
+        || /^--submodule(?:=|$)/.test(value)
+        || /^--(?:word-diff|color-words)(?:=|$)/.test(value));
+}
+
+function hasDiffPresentation(args) {
+    return hasPatchOutput(args) || needsTextDiffOutput(args);
+}
+
+function hasSpecialHistoryPresentation(args) {
+    return hasDiffPresentation(args) || args.some((value) => [
+        '-g', '--graph', '--source', '--show-signature', '--show-notes',
+        '--notes', '--no-notes', '--walk-reflogs', '--left-right',
+        '--cherry-mark', '--boundary', '--parents', '--children',
+    ].includes(value)
+        || /^--(?:decorate|decorate-refs|decorate-refs-exclude|show-notes|notes|date)(?:=|$)/.test(value));
+}
+
 function hasLogLimit(args) {
-    return args.some((value) => /^-\d+$/.test(value) || value === '-n' || value === '--max-count' || value.startsWith('--max-count='));
+    return args.some((value) => /^-(?:n)?\d+$/.test(value) || value === '-n' || value === '--max-count' || value.startsWith('--max-count='));
 }
 
 function prepare(plan, limit) {
@@ -390,22 +441,26 @@ function prepare(plan, limit) {
         return { argv: ['status', '--porcelain=v1', '-b', '--untracked-files=normal'], format: 'status', action: 'list' };
     }
     if (['diff', 'diff-files', 'diff-index', 'diff-tree'].includes(operation)) {
-        // `--check` prints whitespace diagnostics, not a patch: compacting it as
-        // a diff would drop the very lines that are the answer.
-        const format = args.includes('--check') ? 'text' : 'diff';
+        // Plumbing diff commands default to raw records, and presentation flags
+        // can replace or prefix patch markers. Only compact a standard patch.
+        const patch = !needsTextDiffOutput(args) && (operation === 'diff' || hasPatchOutput(args));
+        const format = patch ? 'diff' : 'text';
         return { argv: [operation, '--no-ext-diff', '--no-color', ...args], format, action: 'list' };
     }
-    if (operation === 'log' && !hasOutputFormat(args)) {
+    if (operation === 'log') {
         const limitArgs = hasLogLimit(args) ? [] : [`-n${limit}`];
-        return {
-            argv: ['log', ...limitArgs, '--date=iso-strict', '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%b%x1e', ...args],
-            format: 'log',
-            action: 'list',
-        };
+        if (!hasOutputFormat(args) && !hasSpecialHistoryPresentation(args)) {
+            return {
+                argv: ['log', ...limitArgs, '--date=iso-strict', '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%b%x1e', ...args],
+                format: 'log',
+                action: 'list',
+            };
+        }
+        return { argv: ['log', ...limitArgs, '--no-color', ...args], format: 'text', action: 'list' };
     }
     if (operation === 'show') {
         const blob = args.some((value) => !value.startsWith('-') && value.includes(':'));
-        const explicit = hasOutputFormat(args) || args.some((value) => /^(?:--stat|--numstat|--shortstat|--name-only|--name-status)$/.test(value));
+        const explicit = hasOutputFormat(args) || hasSpecialHistoryPresentation(args);
         if (!blob && !explicit) {
             return { argv: ['show', '--no-color', '--format=%x1e%H%x1f%h%x1f%an%x1f%aI%x1f%s%n', ...args], format: 'show', action: 'list' };
         }
@@ -417,10 +472,13 @@ function prepare(plan, limit) {
             action: 'list',
         };
     }
-    if (operation === 'reflog' && isReadOnly(plan) && !args.some((value) => value.startsWith('--format'))) {
+    if (operation === 'reflog' && isReadOnly(plan) && actionOf(operation, args) === 'show') {
         const action = actionOf(operation, args);
         const rest = action === 'show' && args[0] === 'show' ? args.slice(1) : args;
         const limitArgs = hasLogLimit(rest) ? [] : [`-n${limit}`];
+        if (rest.some((value) => value.startsWith('--format'))) {
+            return { argv: ['reflog', 'show', ...limitArgs, ...rest], format: 'text', action: 'show' };
+        }
         return {
             argv: ['reflog', 'show', ...limitArgs, '--date=iso-strict', '--format=%gD%x00%H%x00%gs', ...rest],
             format: 'reflog',
@@ -915,4 +973,4 @@ export async function executeGitTool(input, workDir, options = {}) {
     })), { signal });
 }
 
-export const _gitCommandInternals = { creationTarget, failureText, foldProgressFrames, localizeConfigPlan, parseCommand };
+export const _gitCommandInternals = { creationTarget, failureText, foldProgressFrames, localizeConfigPlan, parseCommand, prepare };

package/src/runtime/agent/orchestrator/tools/builtin/git-command-tool.test.mjs

@@ -11,7 +11,7 @@ import {
     GIT_TOOL_DEF,
     _gitCommandInternals,
 } from './git-command-tool.mjs';
-import { commandHasShellSyntax } from './git-command-policy.mjs';
+import { commandHasShellSyntax, gitCommandMutates } from './git-command-policy.mjs';
 
 function parseOk(result) {
     assert.doesNotMatch(String(result), /^Error:/, String(result));
@@ -163,6 +163,11 @@ test('git tool answers semantic exits and keeps literal operator characters', as
     // diff reports through the exit code for --quiet and --check.
     assert.equal(parseOk(await git(repo, 'diff --quiet')).changed, false);
     assert.equal(parseOk(await git(repo, 'diff --check')).problems, false);
+    assert.equal(parseOk(await git(repo, 'reflog exists HEAD')).exists, true);
+    assert.equal(parseOk(await git(repo, 'reflog exists refs/heads/missing')).exists, false);
+    assert.equal(parseOk(await git(repo, 'show-ref --verify --quiet refs/heads/missing')).exists, false);
+    assert.equal(parseOk(await git(repo, 'rev-parse --verify --quiet refs/heads/missing')).exists, false);
+    assert.equal(parseOk(await git(repo, 'merge-base --is-ancestor HEAD HEAD')).ancestor, true);
     writeFileSync(join(repo, 'base.txt'), 'base\ntrailing   \n');
     assert.equal(parseOk(await git(repo, 'diff --quiet')).changed, true);
     const check = parseOk(await git(repo, 'diff --check'));
@@ -170,6 +175,73 @@ test('git tool answers semantic exits and keeps literal operator characters', as
     assert.match(JSON.stringify(check), /trailing whitespace/);
 });
 
+test('git preserves non-patch diff and history presentations', async (t) => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-git-presentations-'));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    const repo = join(root, 'repo');
+    parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
+    parseOk(await git(repo, 'config user.name "Mixdog Test"'));
+    parseOk(await git(repo, 'config user.email mixdog@example.invalid'));
+    writeFileSync(join(repo, 'base.txt'), 'base\n');
+    parseOk(await git(repo, 'add -- base.txt'));
+    parseOk(await git(repo, 'commit -m base'));
+    writeFileSync(join(repo, 'base.txt'), 'changed\n');
+
+    for (const command of [
+        'diff --stat -- base.txt',
+        'diff --raw -- base.txt',
+        'diff --numstat -- base.txt',
+        'diff --name-only -- base.txt',
+        'diff --name-status -- base.txt',
+        'diff-files -- base.txt',
+        'diff-index HEAD -- base.txt',
+    ]) {
+        const result = parseOk(await git(repo, command));
+        assert.match(JSON.stringify(result), /base\.txt/, command);
+    }
+
+    parseOk(await git(repo, 'add -- base.txt'));
+    parseOk(await git(repo, 'commit -m changed'));
+    assert.match(JSON.stringify(parseOk(await git(repo, 'diff-tree --no-commit-id HEAD^ HEAD -- base.txt'))), /base\.txt/);
+    for (const command of ['log --stat -1', 'log --raw -1', 'log -p -1', 'show --raw HEAD']) {
+        const result = parseOk(await git(repo, command));
+        assert.equal(result.commits, undefined, command);
+        assert.match(JSON.stringify(result), /base\.txt/, command);
+    }
+    assert.match(JSON.stringify(parseOk(await git(repo, 'reflog list'))), /refs\/heads\//);
+});
+
+test('git policy distinguishes probes from output and ref mutations', () => {
+    for (const command of [
+        'git --version',
+        'git remote -v',
+        'git reflog exists HEAD',
+        'git symbolic-ref HEAD',
+    ]) {
+        assert.equal(gitCommandMutates({ command }), false, command);
+    }
+    for (const command of [
+        'git remote -v update',
+        'git reflog delete HEAD@{0}',
+        'git symbolic-ref --delete HEAD',
+        'git diff --output=outside.patch',
+    ]) {
+        assert.equal(gitCommandMutates({ command }), true, command);
+    }
+});
+
+test('git plans patch, plumbing, and custom history output without over-reading', () => {
+    const plan = (operation, args, limit = 7) => _gitCommandInternals.prepare({ operation, args }, limit);
+    assert.equal(plan('diff', []).format, 'diff');
+    assert.equal(plan('diff', ['--stat']).format, 'text');
+    assert.equal(plan('diff-files', []).format, 'text');
+    assert.equal(plan('diff-files', ['-p']).format, 'diff');
+    assert.deepEqual(plan('log', ['--oneline']).argv.slice(0, 3), ['log', '-n7', '--no-color']);
+    assert.deepEqual(plan('log', ['--stat']).argv.slice(0, 3), ['log', '-n7', '--no-color']);
+    assert.equal(plan('reflog', ['list']).argv[0], 'reflog');
+    assert.notEqual(plan('reflog', ['list']).argv[1], 'show');
+});
+
 test('git failure detail folds progress frames and keeps the fatal tail', () => {
     const { failureText, foldProgressFrames } = _gitCommandInternals;
     assert.equal(
@@ -238,7 +310,7 @@ test('git forwards unknown subcommands to git instead of pre-rejecting them', as
     t.after(() => rmSync(root, { recursive: true, force: true }));
     const repo = join(root, 'repo');
     parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
-    for (const command of ['git filter-repo --version', 'git fast-export --help']) {
+    for (const command of ['git filter-repo --version', 'git fast-export --no-data HEAD']) {
         assert.doesNotMatch(String(await executeGitTool({ command }, repo)), /unsupported git subcommand/);
     }
 });
@@ -254,6 +326,8 @@ test('git refuses only non-returning subcommands and routes servers to shell', a
     parseOk(await executeGitTool({ command: `git init ${quote(repo)}` }, root));
     assert.match(String(await executeGitTool({ command: 'git mergetool' }, repo)), /interactive GUI/i);
     assert.match(String(await executeGitTool({ command: 'git daemon --export-all' }, repo)), /shell tool/i);
+    assert.match(String(await executeGitTool({ command: 'git fast-export --help' }, repo)), /external viewer/i);
+    assert.match(String(await executeGitTool({ command: 'git help fast-export' }, repo)), /external viewer/i);
     assert.match(String(await executeGitTool({ command: 'git' }, repo)), /requires a subcommand/i);
 });