mixdog 0.9.147 → 0.9.149

package/src/runtime/agent/orchestrator/tools/code-graph/text-mask.mjs

@@ -61,6 +61,90 @@ function _maskJsRegexLiteral(src, out, start) {
   return j;
 }
 
+// Interpolation dialect of a string literal, decided when the literal opens:
+//   'dollar-brace' — `${expr}`  (JS/TS backticks, kotlin "…")
+//   'brace'        — `{expr}`   (python f-strings, C# $"…", `{{` = literal)
+//   'bash'         — `$(cmd)` / `${var}` inside double quotes
+// null = the whole literal is opaque text. Without this only JS backticks had
+// their interpolations analysed, so calls inside python/C#/kotlin/bash
+// interpolation were masked away entirely.
+function _stringLiteralPrefix(src, quoteIndex, allowed) {
+  let k = quoteIndex - 1;
+  let prefix = '';
+  while (k >= 0 && allowed.test(src[k]) && prefix.length < 2) {
+    prefix = src[k] + prefix;
+    k -= 1;
+  }
+  // A prefix glued to a longer identifier is not a string prefix.
+  if (prefix && k >= 0 && _isWordChar(src[k])) return '';
+  return prefix;
+}
+
+function _stringInterpKind(lang, delim, src, quoteIndex) {
+  const triple = delim === '"""' || delim === "'''";
+  if (delim === '`') return _isJsLike(lang) ? 'dollar-brace' : null;
+  // Kotlin templates work the same in "…" and in """…""" raw strings.
+  if (lang === 'kotlin' && (delim === '"' || triple)) return 'dollar-brace';
+  if (lang === 'bash' && delim === '"') return 'bash';
+  if (lang === 'python' && (triple || delim === '"' || delim === '\'')) {
+    const prefix = _stringLiteralPrefix(src, quoteIndex, /[fFrRbBuU]/);
+    return /[fF]/.test(prefix) ? 'brace' : null;
+  }
+  if (lang === 'csharp' && (delim === '"' || triple)) {
+    const prefix = _stringLiteralPrefix(src, quoteIndex, /[$@]/);
+    return prefix.includes('$') ? 'brace' : null;
+  }
+  return null;
+}
+
+// Interpolation handling shared by single- and triple-quoted frames. Returns
+// the next index when it consumed bytes, or -1 when the character is ordinary
+// string text.
+function _handleInterpolationInString(src, out, i, frame, stack) {
+  const kind = frame?.interp;
+  if (!kind) return -1;
+  if (kind === 'brace' && src[i] === '{' && src[i + 1] === '{') {
+    // `{{` is an escaped literal brace inside an f-string / $"…".
+    if (src[i] !== '\n') out[i] = ' ';
+    if (src[i + 1] !== '\n') out[i + 1] = ' ';
+    return i + 2;
+  }
+  const opened = _interpolationOpenerAt(src, i, kind);
+  if (opened) {
+    // Enter interpolation: the expression bytes stay intact.
+    stack.push({ kind: 'interp', depth: 1, open: opened.open, close: opened.close });
+    return i + opened.length;
+  }
+  // Bare `$name` (kotlin template, bash expansion) is a real reference, so its
+  // identifier bytes stay visible; only the `$` is masked. JS template literals
+  // have no bare form — `$foo` there is literal text.
+  if ((kind === 'bash' || (kind === 'dollar-brace' && frame.lang === 'kotlin'))
+      && src[i] === '$' && _isWordStartChar(src[i + 1])) {
+    if (src[i] !== '\n') out[i] = ' ';
+    let j = i + 1;
+    while (j < src.length && _isWordChar(src[j])) j += 1;
+    return j;
+  }
+  return -1;
+}
+
+// Interpolation opener at `i` for a frame of the given dialect.
+function _interpolationOpenerAt(src, i, kind) {
+  if (kind === 'dollar-brace') {
+    return src.startsWith('${', i) ? { length: 2, open: '{', close: '}' } : null;
+  }
+  if (kind === 'brace') {
+    // `{{` is an escaped literal brace — handled by the caller.
+    if (src[i] !== '{' || src[i + 1] === '{') return null;
+    return { length: 1, open: '{', close: '}' };
+  }
+  if (kind === 'bash') {
+    if (src.startsWith('$(', i)) return { length: 2, open: '(', close: ')' };
+    if (src.startsWith('${', i)) return { length: 2, open: '{', close: '}' };
+  }
+  return null;
+}
+
 export function _maskNonCodeText(text, lang) {
   const src = String(text || '');
   const out = src.split('');
@@ -69,9 +153,11 @@ export function _maskNonCodeText(text, lang) {
   // Stack of scanner frames. Top describes current state:
   //   { kind: 'string', delim }       — inside single-line string literal (mask body)
   //   { kind: 'triple', delim }       — inside triple-quote string (mask body)
-  //   { kind: 'interp', braceDepth }  — inside backtick `${...}` interpolation
-  //                                     (code mode; bytes preserved so callers
-  //                                     analysis can see fn-calls inside)
+  //   { kind: 'interp', depth, open, close }
+  //                                   — inside a string interpolation
+  //                                     (`${…}`, f-string `{…}`, bash `$( … )`;
+  //                                     code mode, bytes preserved so caller
+  //                                     analysis sees fn-calls inside)
   // Empty stack = top-level code.
   const stack = [];
   const top = () => (stack.length ? stack[stack.length - 1] : null);
@@ -104,6 +190,13 @@ export function _maskNonCodeText(text, lang) {
         prevToken = 'value';
         continue;
       }
+      // Triple-quoted literals interpolate too (python f"""…""", kotlin """…""").
+      const nextIndex = _handleInterpolationInString(src, out, i, t, stack);
+      if (nextIndex >= 0) {
+        i = nextIndex;
+        prevToken = 'expr';
+        continue;
+      }
       if (src[i] !== '\n') out[i] = ' ';
       i++;
       continue;
@@ -127,12 +220,13 @@ export function _maskNonCodeText(text, lang) {
     }
     if (t && t.kind === 'string') {
       const d = t.delim;
-      if (d === '`' && src.startsWith('${', i)) {
-        // Enter interpolation. `${` itself is code-relevant — leave bytes intact.
-        stack.push({ kind: 'interp', braceDepth: 1 });
-        i += 2;
-        prevToken = 'expr';
-        continue;
+      {
+        const nextIndex = _handleInterpolationInString(src, out, i, t, stack);
+        if (nextIndex >= 0) {
+          i = nextIndex;
+          prevToken = 'expr';
+          continue;
+        }
       }
       // In bash single-quotes `'...'`, backslash is literal (no escape) — the
       // string closes at the first `'`. Skip the escape consumption there so
@@ -165,23 +259,19 @@ export function _maskNonCodeText(text, lang) {
       continue;
     }
     if (t && t.kind === 'interp') {
-      // Code mode inside `${...}`. Bytes preserved; track brace depth and
-      // nested constructs so masking resumes once interpolation closes.
-      if (src[i] === '{') {
-        t.braceDepth++;
+      // Code mode inside the interpolation. Bytes preserved; track the frame's
+      // own delimiter depth so masking resumes once the expression closes.
+      if (src[i] === t.open) {
+        t.depth++;
         prevToken = 'expr';
         i++;
         continue;
       }
-      if (src[i] === '}') {
-        t.braceDepth--;
+      if (src[i] === t.close) {
+        t.depth--;
         i++;
-        if (t.braceDepth === 0) {
-          stack.pop();
-          prevToken = 'value';
-        } else {
-          prevToken = 'value';
-        }
+        if (t.depth === 0) stack.pop();
+        prevToken = 'value';
         continue;
       }
       if (_supportsSlashComments(lang) && src.startsWith('/*', i)) {
@@ -205,7 +295,7 @@ export function _maskNonCodeText(text, lang) {
       }
       if (src[i] === '"' || (_supportsSingleQuoteStrings(lang) && src[i] === '\'') || (_supportsBacktickStrings(lang) && src[i] === '`')) {
         if (src[i] !== '\n') out[i] = ' ';
-        stack.push({ kind: 'string', delim: src[i], lang });
+        stack.push({ kind: 'string', delim: src[i], lang, interp: _stringInterpKind(lang, src[i], src, i) });
         i++;
         continue;
       }
@@ -298,7 +388,7 @@ export function _maskNonCodeText(text, lang) {
       if (i + 1 < out.length) out[i + 1] = ' ';
       if (i + 2 < out.length) out[i + 2] = ' ';
       i += 3;
-      stack.push({ kind: 'triple', delim: "'''" });
+      stack.push({ kind: 'triple', delim: "'''", lang, interp: _stringInterpKind(lang, "'''", src, i - 3) });
       continue;
     }
     if (_supportsTripleDoubleQuoteStrings(lang) && src.startsWith('"""', i)) {
@@ -306,7 +396,7 @@ export function _maskNonCodeText(text, lang) {
       if (i + 1 < out.length) out[i + 1] = ' ';
       if (i + 2 < out.length) out[i + 2] = ' ';
       i += 3;
-      stack.push({ kind: 'triple', delim: '"""' });
+      stack.push({ kind: 'triple', delim: '"""', lang, interp: _stringInterpKind(lang, '"""', src, i - 3) });
       continue;
     }
     if (src[i] === '/' && _isJsLike(lang) && prevToken === 'expr') {
@@ -316,7 +406,7 @@ export function _maskNonCodeText(text, lang) {
     }
     if (src[i] === '"' || (_supportsSingleQuoteStrings(lang) && src[i] === '\'') || (_supportsBacktickStrings(lang) && src[i] === '`')) {
       if (src[i] !== '\n') out[i] = ' ';
-      stack.push({ kind: 'string', delim: src[i], lang });
+      stack.push({ kind: 'string', delim: src[i], lang, interp: _stringInterpKind(lang, src[i], src, i) });
       i++;
       continue;
     }

package/src/runtime/agent/orchestrator/tools/code-graph/text-span-mask.test.mjs

@@ -0,0 +1,268 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { _inferSpanEndByIndent } from './span.mjs';
+import { _maskNonCodeText } from './text-mask.mjs';
+import { _atJsRegexPosition, _extractCallees, _jsBraceKindAt } from './search.mjs';
+
+test('indentation span inference keeps a multiline arrow signature whole', () => {
+    const lines = [
+        'const handler = (',
+        '  a,',
+        '  b,',
+        ') => {',
+        '  return a + b;',
+        '};',
+    ];
+    assert.equal(_inferSpanEndByIndent(lines, 1), 6);
+});
+
+test('indentation span inference still ends at a plain matching closer', () => {
+    const lines = [
+        'const rows = [',
+        '  1,',
+        '  2,',
+        '];',
+        'const other = 3;',
+    ];
+    assert.equal(_inferSpanEndByIndent(lines, 1), 4);
+});
+
+test('python f-string interpolation keeps its call visible', () => {
+    const masked = _maskNonCodeText('x = f"total {compute_total(rows)} done"\n', 'python');
+    assert.match(masked, /compute_total\(rows\)/);
+    assert.doesNotMatch(masked, /done/);
+});
+
+test('C# interpolated string exposes the call and keeps {{ }} literal', () => {
+    const masked = _maskNonCodeText('var s = $"{Compute(x)} {{literal}}";\n', 'csharp');
+    assert.match(masked, /Compute\(x\)/);
+    assert.doesNotMatch(masked, /literal/);
+});
+
+test('kotlin string template exposes the call', () => {
+    const masked = _maskNonCodeText('val s = "n=${computeTotal(rows)}"\n', 'kotlin');
+    assert.match(masked, /computeTotal\(rows\)/);
+});
+
+test('bash command substitution inside double quotes stays code', () => {
+    const masked = _maskNonCodeText('echo "value $(compute_total rows) done"\n', 'bash');
+    assert.match(masked, /compute_total rows/);
+    assert.doesNotMatch(masked, /value/);
+});
+
+test('a plain python string is still fully masked', () => {
+    const masked = _maskNonCodeText('x = "total {compute_total(rows)} done"\n', 'python');
+    assert.doesNotMatch(masked, /compute_total/);
+});
+
+test('a python triple-quoted f-string interpolates', () => {
+    const masked = _maskNonCodeText('x = f"""head {compute(rows)} tail"""\n', 'python');
+    assert.match(masked, /compute\(rows\)/);
+    assert.doesNotMatch(masked, /head/);
+});
+
+test('a kotlin raw string template interpolates', () => {
+    const masked = _maskNonCodeText('val s = """head ${compute(rows)} tail"""\n', 'kotlin');
+    assert.match(masked, /compute\(rows\)/);
+    assert.doesNotMatch(masked, /head/);
+});
+
+test('a kotlin bare $name keeps the identifier but a JS template does not', () => {
+    const kotlin = _maskNonCodeText('val s = "id=$userId done"\n', 'kotlin');
+    assert.match(kotlin, /userId/);
+    assert.doesNotMatch(kotlin, /done/);
+
+    // JS template literals have no bare form: `$userId` is literal text.
+    const js = _maskNonCodeText('const s = `id=$userId`;\n', 'javascript');
+    assert.doesNotMatch(js, /userId/);
+});
+
+test('a non-matching same-indent closer does not end the span', () => {
+    const lines = [
+        'const handler = {',
+        '  run: (',
+        '  ) => 1,',
+        ')',
+        '};',
+    ];
+    assert.equal(_inferSpanEndByIndent(lines, 1), 5);
+});
+
+test('a division after an object literal is not read as a regex', () => {
+    const text = 'function f(){ const x = {} / 2; } outside();';
+    assert.equal(_atJsRegexPosition(text, text.indexOf('/ 2')), false);
+});
+
+test('a statement-position regex after a closing brace is recognized', () => {
+    const text = '}\n/re/.test(x)';
+    assert.equal(_atJsRegexPosition(text, text.indexOf('/re/')), true);
+});
+
+test('a postfix increment before a slash stays division', () => {
+    const text = 'const y = a++ / b;';
+    assert.equal(_atJsRegexPosition(text, text.indexOf('/ b')), false);
+});
+
+test('brace kinds separate object literals from blocks', () => {
+    assert.equal(_jsBraceKindAt('const x = {}', 10), 'object');
+    assert.equal(_jsBraceKindAt('call({})', 5), 'object');
+    assert.equal(_jsBraceKindAt('return {}', 7), 'object');
+    // Property value: the scanner passes the ENCLOSING brace kind, which is
+    // what separates `{ key: {…} }` from a labeled block.
+    assert.equal(_jsBraceKindAt('const y = { a: {} }', 15, null, 'object'), 'object');
+    // Grammatical position, not a character list: unary `!` and binary `-`.
+    assert.equal(_jsBraceKindAt('!{}', 1), 'object');
+    assert.equal(_jsBraceKindAt('1 - {}', 4), 'object');
+    assert.equal(_jsBraceKindAt('function f() {}', 13), 'block');
+    assert.equal(_jsBraceKindAt('const f = () => {}', 16), 'block');
+    assert.equal(_jsBraceKindAt('if (x) {}', 7), 'block');
+    assert.equal(_jsBraceKindAt('do {} while (x)', 3), 'block');
+    assert.equal(_jsBraceKindAt('if (x) {} else {}', 15), 'block');
+});
+
+test('object-literal divisions after ! and - do not swallow the rest of the file', () => {
+    for (const body of ['!{} / 2;', '1 - {} / 2;']) {
+        const rel = 'probe-op.mjs';
+        const text = `function f(){ ${body} } outside();\n`;
+        const node = {
+            rel,
+            abs: rel,
+            lang: 'javascript',
+            fingerprint: '',
+            symbols: [],
+            topLevelTypes: [],
+            resolvedImports: [],
+            rawImports: [],
+        };
+        const graph = {
+            nodes: new Map([[rel, node]]),
+            reverse: new Map(),
+            _sourceTextCache: new Map([[rel, { fingerprint: '', text }]]),
+            _sourceLinesCache: new Map(),
+            _maskedLinesCache: new Map(),
+        };
+        const rows = _extractCallees(
+            graph,
+            { rel, lang: 'javascript', line: 1, col: 1, declarationLike: true },
+            '.',
+            { callerSymbol: 'f' },
+        );
+        assert.deepEqual(rows.map((row) => row.name), [], `body: ${body}`);
+    }
+});
+
+test('a labeled block is a block, an object property and a ternary are values', () => {
+    assert.equal(_jsBraceKindAt('label: {}', 7, null, 'block'), 'block');
+    assert.equal(_jsBraceKindAt('({ key: {} })', 8, null, 'object'), 'object');
+    assert.equal(_jsBraceKindAt('const v = c ? a : {};', 18, null, 'block'), 'object');
+});
+
+test('a case label with a ternary expression still opens a block', () => {
+    const src = 'switch (v) { case c ? a : b: {} }';
+    assert.equal(_jsBraceKindAt(src, src.indexOf('{}'), null, 'block'), 'block');
+    const plain = 'switch (v) { case 1: {} }';
+    assert.equal(_jsBraceKindAt(plain, plain.indexOf('{}'), null, 'block'), 'block');
+    const ternary = 'const v = c ? a : {};';
+    assert.equal(_jsBraceKindAt(ternary, ternary.indexOf('{}'), null, 'block'), 'object');
+});
+
+test('a case-label block keeps the callee behind it', () => {
+    const rel = 'probe-case.mjs';
+    const text = 'function f(){ switch (v) { case c ? a : b: {} /[}]/.test(x); tail(); } }\n';
+    const node = {
+        rel,
+        abs: rel,
+        lang: 'javascript',
+        fingerprint: '',
+        symbols: [],
+        topLevelTypes: [],
+        resolvedImports: [],
+        rawImports: [],
+    };
+    const graph = {
+        nodes: new Map([[rel, node]]),
+        reverse: new Map(),
+        _sourceTextCache: new Map([[rel, { fingerprint: '', text }]]),
+        _sourceLinesCache: new Map(),
+        _maskedLinesCache: new Map(),
+    };
+
+    const names = _extractCallees(
+        graph,
+        { rel, lang: 'javascript', line: 1, col: 1, declarationLike: true },
+        '.',
+        { callerSymbol: 'f' },
+    ).map((row) => row.name);
+    assert.ok(names.includes('tail'), `expected 'tail' in ${JSON.stringify(names)}`);
+});
+
+test('a labeled block keeps the regex after it and the calls behind it', () => {
+    const rel = 'probe-label.mjs';
+    const text = 'function f(){ label: {} /[}]/.test(x); inside(); }\n';
+    const node = {
+        rel,
+        abs: rel,
+        lang: 'javascript',
+        fingerprint: '',
+        symbols: [],
+        topLevelTypes: [],
+        resolvedImports: [],
+        rawImports: [],
+    };
+    const graph = {
+        nodes: new Map([[rel, node]]),
+        reverse: new Map(),
+        _sourceTextCache: new Map([[rel, { fingerprint: '', text }]]),
+        _sourceLinesCache: new Map(),
+        _maskedLinesCache: new Map(),
+    };
+
+    const rows = _extractCallees(
+        graph,
+        { rel, lang: 'javascript', line: 1, col: 1, declarationLike: true },
+        '.',
+        { callerSymbol: 'f' },
+    );
+    const names = rows.map((row) => row.name);
+    assert.ok(names.includes('test'), `expected 'test' in ${JSON.stringify(names)}`);
+    assert.ok(names.includes('inside'), `expected 'inside' in ${JSON.stringify(names)}`);
+});
+
+test('a multiline object-literal division does not swallow the rest of the file', () => {
+    // Probe: the `/` sits on its own line after `{}`. A line-break heuristic
+    // reads it as a regex, runs past the closing brace and attributes the
+    // following top-level call as a callee of f.
+    const rel = 'probe.mjs';
+    const text = 'function f(){ const x = {}\n/ 2; } outside();\n';
+    const node = {
+        rel,
+        abs: rel,
+        lang: 'javascript',
+        fingerprint: '',
+        symbols: [],
+        topLevelTypes: [],
+        resolvedImports: [],
+        rawImports: [],
+    };
+    const graph = {
+        nodes: new Map([[rel, node]]),
+        reverse: new Map(),
+        _sourceTextCache: new Map([[rel, { fingerprint: '', text }]]),
+        _sourceLinesCache: new Map(),
+        _maskedLinesCache: new Map(),
+    };
+
+    // The discriminator: a bare line break says "regex", the tracked brace
+    // kind says "division". The scanner uses the tracked kind.
+    assert.equal(_atJsRegexPosition(text, text.indexOf('/ 2')), true);
+    assert.equal(_atJsRegexPosition(text, text.indexOf('/ 2'), 'object'), false);
+
+    const rows = _extractCallees(
+        graph,
+        { rel, lang: 'javascript', line: 1, col: 1, declarationLike: true },
+        '.',
+        { callerSymbol: 'f' },
+    );
+    assert.deepEqual(rows.map((row) => row.name), []);
+});

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

@@ -3,12 +3,12 @@ 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: 'Read-only; safe to batch in parallel. Source-file structure, symbol relations, and flow. Exact identifiers route directly to find_symbol/references/callers/callees; symbol-name keywords use symbol_search/search. Text, literals, and regex belong to grep. File modes use files[]; symbol modes use symbols[]. overview and mode:symbols return file summaries. find_symbol returns declaration/body; references returns declaration/usages plus optional body; callers/callees return locations.',
+    description: 'Read-only; safe to batch in parallel. Source-file structure, symbol relations, and flow. mode:symbols with files[] is the cheap direct outline of known source files: declarations with line numbers, no file body. Exact identifiers route directly to find_symbol/references/callers/callees; symbol-name keywords use symbol_search/search. Text, literals, and regex belong to grep. File modes use files[]; symbol modes use symbols[]. find_symbol returns declaration/body; references returns declaration/usages plus optional body; callers/callees return locations.',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'File modes: overview, imports, dependents, related, and impact. symbols with files[] returns an optionally filtered file outline; remaining modes use symbols[].' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Project-relative source path(s); required by file modes, optional to scope symbol modes.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'File modes: overview, imports, dependents, related, and impact. symbols with files[] returns an optionally filtered file outline of those exact files. It needs no prior search; remaining modes use symbols[].' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Source path(s), project-relative or absolute; required by file modes, optional to scope symbol modes.' },
         symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Exact identifiers or symbol-name keywords; batch in one symbols[] call; required by symbol modes, optional filter for mode:symbols.' },
         body: { type: 'boolean', description: 'Include declaration body: find_symbol defaults true; references is opt-in.' },
         limit: { type: 'integer', minimum: 1, maximum: 500, description: 'Maximum results; modes may enforce lower caps.' },