mixdog 0.9.0 → 0.9.2

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

@@ -36,6 +36,11 @@ import {
 import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
 import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX } from './arg-guard.mjs';
 
+// Default surrounding-lines window applied by output_mode:'content_with_context'
+// when the caller does not pass an explicit -A/-B/-C/context. Sized to cover a
+// typical function/block so a match arrives readable without a follow-up read.
+const GREP_AUTO_CONTEXT_LINES = 25;
+
 const MIXDOG_GREP_CASE_HINT_PROBE = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_GREP_CASE_HINT_PROBE || ''));
 
 function expandLegacyEscapedAlternationPattern(rawPattern) {
@@ -353,18 +358,23 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         .map(canonicalizeGlobSlashes)
         .filter((g) => !isRedundantAllFilesGlob(g)));
 
-    const ALLOWED_OUTPUT_MODES = new Set(['files_with_matches', 'content', 'count']);
+    const ALLOWED_OUTPUT_MODES = new Set(['files_with_matches', 'content', 'content_with_context', 'count']);
     const rawOutputMode = typeof args.output_mode === 'string' ? args.output_mode.trim() : '';
     if (rawOutputMode && !ALLOWED_OUTPUT_MODES.has(rawOutputMode)) {
         return `Error: invalid output_mode ${JSON.stringify(args.output_mode)}; expected one of ${[...ALLOWED_OUTPUT_MODES].join(', ')}`;
     }
+    // `content_with_context` is a convenience alias for `content` that auto-applies
+    // a generous surrounding-lines window, so the model can read a match in place
+    // without following up with `read`. It maps to content mode; the default
+    // context is applied below unless the caller passed an explicit -A/-B/-C/context.
+    const wantAutoContext = rawOutputMode === 'content_with_context';
     // Default to `content` when output_mode is omitted. A pattern is always
     // present here (the no-pattern case returned above), so this is a content
     // search — it should return the matching lines WITH line numbers, not just
     // filenames. Filename-only was forcing callers to re-grep for the actual
     // coordinates (the explorer over-iteration root cause). `files_with_matches`
     // is now opt-in; pure filename discovery belongs to `glob`.
-    const outputMode = rawOutputMode || 'content';
+    const outputMode = (rawOutputMode === 'content_with_context') ? 'content' : (rawOutputMode || 'content');
     const headLimitRaw = args.head_limit;
     const headLimitCoerced = coerceNonNegInt(headLimitRaw);
     if (Number.isNaN(headLimitCoerced)) {
@@ -391,6 +401,12 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     let contextN = args['-C'] !== undefined && args['-C'] !== null && args['-C'] !== ''
         ? coerceContext(args['-C'])
         : coerceContext(args.context);
+    // content_with_context: if no explicit context flag was supplied, apply a
+    // generous default so the match arrives with enough surrounding code to
+    // understand it (function-sized) without a separate read.
+    if (wantAutoContext && afterN === null && beforeN === null && contextN === null) {
+        contextN = GREP_AUTO_CONTEXT_LINES;
+    }
     if (contextN !== null && contextN > 0) {
         if (afterN === 0) afterN = null;
         if (beforeN === 0) beforeN = null;

package/src/runtime/agent/orchestrator/tools/builtin/shell-output.mjs

@@ -1,9 +1,10 @@
 import { countSplitLines } from './path-utils.mjs';
+import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
 
-export const SHELL_OUTPUT_MAX_CHARS = 30_000;
+export const SHELL_OUTPUT_MAX_CHARS = TOOL_OUTPUT_MAX_BYTES;
 
 export const SMART_BASH_MAX_LINES = 400;
-export const SMART_BASH_MAX_BYTES = 30_000;
+export const SMART_BASH_MAX_BYTES = TOOL_OUTPUT_MAX_BYTES;
 export const SMART_BASH_HEAD_LINES = 80;
 export const SMART_BASH_TAIL_LINES = 80;
 

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

@@ -0,0 +1,10 @@
+// Single source of truth for the model-facing tool-output byte budget.
+// read / shell / list-tree all truncate their output to this cap so the
+// context cost of any one tool call is bounded and consistent. Override with
+// MIXDOG_TOOL_OUTPUT_MAX_BYTES. Line-based sub-caps (e.g. bash max lines) stay
+// per-tool; this governs only the byte budget.
+function _envInt(name, fallback) {
+    const v = parseInt(process.env[name], 10);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+export const TOOL_OUTPUT_MAX_BYTES = _envInt('MIXDOG_TOOL_OUTPUT_MAX_BYTES', 50 * 1024);

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -277,6 +277,8 @@ const EXTERNAL_TOOL_REDIRECTS = new Map([
     ['strreplace', 'use `apply_patch` with a `*** Update File:` V4A section'],
     ['str_replace', 'use `apply_patch` with a `*** Update File:` V4A section'],
     ['str_replace_editor', 'use `apply_patch` with a `*** Update File:` V4A section'],
+    ['search_replace', 'use `apply_patch` with a `*** Update File:` V4A section'],
+    ['applypatch', 'call the `apply_patch` tool (snake_case) with a V4A patch'],
     ['createfile', 'use `apply_patch` with an `*** Add File:` V4A section'],
     ['create_file', 'use `apply_patch` with an `*** Add File:` V4A section'],
     ['deletefile', 'use `apply_patch` with a `*** Delete File:` V4A section'],
@@ -287,9 +289,15 @@ const EXTERNAL_TOOL_REDIRECTS = new Map([
     ['terminal', 'use the `shell` tool'],
     ['view', 'use the `read` tool'],
     ['cat', 'use the `read` tool'],
+    ['read_file', 'use the `read` tool'],
     ['ls', 'use the `list` tool'],
+    ['list_dir', 'use the `list` tool'],
     ['searchfiles', 'use the `grep` tool'],
+    ['file_search', 'use the `find` or `glob` tool'],
+    ['grep_search', 'use the `grep` tool'],
     ['codebase_search', 'use the `grep` or `code_graph` tool'],
+    ['semanticsearch', 'use the `grep` or `code_graph` tool'],
+    ['semantic_search', 'use the `grep` or `code_graph` tool'],
 ]);
 
 export function canonicalizeBuiltinToolName(name) {
@@ -401,6 +409,55 @@ function capToolOutput(result, options = {}) {
     return `${head}\n... [tool-output truncated: ${Math.round(bytes / 1024)} KB -> ${Math.round(cap / 1024)} KB cap (tool_output_token_limit)] ...\n${tail}`;
 }
 
+const _GREP_SWEEP_NUDGE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_ENABLE_GREP_SWEEP_NUDGE || ''));
+const _GREP_SWEEP_MIN_CALLS = 20;
+const _GREP_SWEEP_MIN_UNIQUE = 16;
+const _grepSweepState = new Map();
+
+function _grepSweepTerms(pattern) {
+    const raw = Array.isArray(pattern) ? pattern.join('|') : String(pattern || '');
+    return [...new Set(raw
+        .split(/[|,\s()"'`[\]{}.*+?^$\\:-]+/g)
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => s.length >= 4))];
+}
+
+function _normalizeSweepPath(value) {
+    return String(value || '.')
+        .replace(/\\/g, '/')
+        .replace(/^([A-Za-z]):/, (_, d) => d.toLowerCase() + ':')
+        .replace(/\/+/g, '/')
+        .replace(/\/$/, '') || '.';
+}
+
+function _grepSweepKey(args = {}) {
+    const path = _normalizeSweepPath(args.path || '.');
+    const glob = Array.isArray(args.glob) ? args.glob.join(',') : String(args.glob || '');
+    const terms = _grepSweepTerms(args.pattern).slice(0, 3).join('|');
+    return `${path}::${glob}::${terms}`;
+}
+
+function _maybeAppendGrepSweepNudge(toolName, args, result, scope) {
+    if (!_GREP_SWEEP_NUDGE_ENABLED || toolName !== 'grep' || typeof result !== 'string') return result;
+    const key = scope || 'global';
+    const now = Date.now();
+    let state = _grepSweepState.get(key);
+    if (!state || now - state.lastTs > 10 * 60_000) {
+        state = { count: 0, unique: new Set(), lastTs: 0, nudged: false };
+        _grepSweepState.set(key, state);
+    }
+    state.count += 1;
+    state.unique.add(_grepSweepKey(args));
+    state.lastTs = now;
+    if (_grepSweepState.size > 256) {
+        const oldest = [..._grepSweepState.entries()].sort((a, b) => (a[1].lastTs || 0) - (b[1].lastTs || 0)).slice(0, 32);
+        for (const [oldKey] of oldest) _grepSweepState.delete(oldKey);
+    }
+    if (state.nudged || state.count < _GREP_SWEEP_MIN_CALLS || state.unique.size < _GREP_SWEEP_MIN_UNIQUE) return result;
+    state.nudged = true;
+    return `${result}\n\n[grep_sweep_hint] Many distinct grep searches were used in this session. Stop rewording search terms; synthesize from existing anchors or switch tools once (code_graph/find/read known regions).`;
+}
+
 export async function executeBuiltinTool(name, args, cwd, options = {}) {
     if (options.abortSignal && !options.signal) {
         options = { ...options, signal: options.abortSignal };
@@ -463,7 +520,8 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
             return formatUnknownBuiltinToolMessage(name, args);
     }
     })();
-    return capToolOutput(_toolResult, options);
+    const _withNudge = _maybeAppendGrepSweepNudge(toolName, args, _toolResult, readStateScope);
+    return capToolOutput(_withNudge, options);
 }
 /**
  * Check if a tool name is a builtin tool.

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -3,14 +3,14 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Code structure: symbols, refs, calls, imports, impact.',
+    description: 'Repo-local code structure/flow lookup, not web: symbols/references/calls/deps before text grep. Batch symbols[].',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'search', 'references', 'callers', 'callees', 'prewarm'], description: 'Operation.' },
-        file: { type: 'string', description: 'Source file.' },
-        symbol: { type: 'string', description: 'Identifier or symbol keyword.' },
-        symbols: { type: 'array', items: { type: 'string' }, description: 'Batch identifiers.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees', 'prewarm'], description: 'Repo-local operation; code flow before text search.' },
+        file: { type: 'string', description: 'Known source file.' },
+        symbol: { type: 'string', description: 'Identifier/keyword; one anchor is enough.' },
+        symbols: { type: 'array', items: { type: 'string' }, description: 'Batch identifiers in one call.' },
         body: { type: 'boolean', description: 'Include body.' },
         language: { type: 'string', description: 'Language hint.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },