gitnexus 1.6.12-rc.36 → 1.6.12-rc.38

package/dist/mcp/local/local-backend.js

@@ -55,6 +55,7 @@ import { stalenessPayload, } from '../../core/staleness-status.js';
 import { logger } from '../../core/logger.js';
 import { isLocalEmbeddingRuntimeBlockerMessage, isMissingLocalEmbeddingStackMessage, } from '../../core/embeddings/runtime-support.js';
 import { LIST_REPOS_DEFAULT_LIMIT, LIST_REPOS_MAX_LIMIT, EXPLAIN_DEFAULT_LIMIT, EXPLAIN_MAX_LIMIT, PDG_QUERY_DEFAULT_LIMIT, PDG_QUERY_MAX_LIMIT, } from '../tools.js';
+import { foldNumericToolArgumentAliases } from '../tool-arguments.js';
 import { findImportCycles, IMPORT_CYCLE_LIMIT } from '../../core/graph/import-cycles.js';
 import { decodeTaintPath } from '../../core/ingestion/taint/path-codec.js';
 import { decodeReachingDefReason } from '../../core/ingestion/cfg/reaching-def-reason-codec.js';
@@ -154,10 +155,8 @@ const TOOL_STRING_ALIASES = {
 function normalizeToolParams(method, params) {
     const input = params && typeof params === 'object' ? params : {};
     const definitions = TOOL_STRING_ALIASES[method];
-    if (!definitions)
-        return { params: input };
     const normalized = { ...input };
-    for (const { canonical, aliases } of definitions) {
+    for (const { canonical, aliases } of definitions ?? []) {
         const keys = [canonical, ...aliases];
         const supplied = [];
         for (const key of keys) {
@@ -191,12 +190,15 @@ function normalizeToolParams(method, params) {
         if (supplied.length > 0)
             normalized[canonical] = supplied[0].value;
     }
+    const folded = foldNumericToolArgumentAliases(method, normalized);
+    if ('error' in folded)
+        return folded;
     if (method === 'impact' &&
-        typeof normalized.target !== 'string' &&
-        (typeof normalized.target_uid !== 'string' || !normalized.target_uid.trim())) {
+        typeof folded.params.target !== 'string' &&
+        (typeof folded.params.target_uid !== 'string' || !folded.params.target_uid.trim())) {
         return { error: 'MCP impact requires target, name, symbol, or target_uid.' };
     }
-    return { params: normalized };
+    return { params: folded.params };
 }
 // AI context generation is CLI-only (gitnexus analyze)
 // import { generateAIContextFiles } from '../../cli/ai-context.js';

package/dist/mcp/server.js

@@ -20,6 +20,7 @@ import { getResourceDefinitions, getResourceTemplates, readResource } from './re
 import { assertMcpReadOnlyResource, assertMcpReadOnlyToolCall, filterMcpReadOnlyResourceContent, MCP_READ_ONLY_TOOLS, readOnlyResourceTemplateAllowed, resolveMcpReadOnlyMode, toolForReadOnlyMcp, } from './read-only-policy.js';
 import { createMcpRepositoryPolicy, McpRepositoryPolicy, mcpRepositoryPolicyConfigured, } from './repository-policy.js';
 import { applyMcpMaxTokens, resolveMcpMaxTokens, withoutMcpBudgetArg } from './output-budget.js';
+import { assertKnownMcpToolArguments, schemaSourceToolName } from './tool-arguments.js';
 /**
  * Next-step hints appended to tool responses.
  *
@@ -164,6 +165,12 @@ export function createMCPServer(backend, options = {}) {
         try {
             const typedArgs = args;
             assertMcpReadOnlyToolCall(name, typedArgs, readOnly);
+            const schemaSource = schemaSourceToolName(name);
+            const advertisedTool = GITNEXUS_TOOLS.find((tool) => tool.name === schemaSource);
+            if (advertisedTool) {
+                const listed = toolForReadOnlyMcp(repositoryPolicy.toolForMcp(advertisedTool), readOnly);
+                assertKnownMcpToolArguments(name, typedArgs, listed.inputSchema.properties);
+            }
             maxTokens = resolveMcpMaxTokens(name, typedArgs);
             const result = await scopedBackend.callTool(name, withoutMcpBudgetArg(typedArgs));
             const resultText = typeof result === 'string' ? result : JSON.stringify(result, null, 2);

package/dist/mcp/tool-arguments.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP tool-argument contract (#3261).
+ *
+ * `tools/list` advertises `inputSchema`; `tools/call` used to forward any JSON
+ * object. A misspelled or CLI-taught key (`depth` instead of `maxDepth`) then
+ * produced a well-formed answer computed from the server default — no error,
+ * no warning. This module is the single dispatch-time check that the keys a
+ * caller sent are ones the advertised schema (or an unpublished handler alias)
+ * actually reads.
+ */
+/** Legacy MCP names that reuse another tool's advertised schema. */
+export declare const LEGACY_TOOL_SCHEMA_SOURCE: Readonly<Record<string, string>>;
+/**
+ * Keys the handler still reads but that must NOT appear in `inputSchema`
+ * (#2175: advertising `query` makes Claude Code drop the argument).
+ */
+export declare const UNPUBLISHED_TOOL_ARGUMENT_ALIASES: Readonly<Record<string, readonly string[]>>;
+export interface NumericArgumentAlias {
+    canonical: string;
+    aliases: readonly string[];
+}
+/**
+ * Numeric aliases that the backend folds onto the advertised canonical key.
+ * `depth` is the CLI flag name for `maxDepth` on impact and trace.
+ */
+export declare const TOOL_NUMERIC_ARGUMENT_ALIASES: Readonly<Record<string, readonly NumericArgumentAlias[]>>;
+export declare function schemaSourceToolName(toolName: string): string;
+export declare function advertisedToolPropertyNames(toolName: string): string[] | undefined;
+export declare function suggestKnownToolArgument(unknownKey: string, knownKeys: readonly string[]): string | undefined;
+/**
+ * Reject top-level tool arguments that are neither advertised nor an
+ * unpublished handler alias. `advertisedProperties` should be the schema the
+ * caller actually saw (`tools/list` after read-only / repository-policy
+ * scrubbing). When it is omitted, the canonical `GITNEXUS_TOOLS` schema is
+ * used. Tools with no schema (legacy `overview`) are left unchecked.
+ */
+export declare function assertKnownMcpToolArguments(toolName: string, args: Record<string, unknown> | undefined, advertisedProperties?: Record<string, unknown>): void;
+/**
+ * Fold numeric aliases onto their canonical key (e.g. `depth` → `maxDepth`).
+ * Conflicting values error; a single agreed value is written to the canonical
+ * key and the alias keys are removed so every downstream reader sees one name.
+ */
+export declare function foldNumericToolArgumentAliases(toolName: string, params: Record<string, unknown>): {
+    params: Record<string, unknown>;
+} | {
+    error: string;
+};

package/dist/mcp/tool-arguments.js

@@ -0,0 +1,147 @@
+/**
+ * MCP tool-argument contract (#3261).
+ *
+ * `tools/list` advertises `inputSchema`; `tools/call` used to forward any JSON
+ * object. A misspelled or CLI-taught key (`depth` instead of `maxDepth`) then
+ * produced a well-formed answer computed from the server default — no error,
+ * no warning. This module is the single dispatch-time check that the keys a
+ * caller sent are ones the advertised schema (or an unpublished handler alias)
+ * actually reads.
+ */
+import { GITNEXUS_TOOLS } from './tools.js';
+/** Legacy MCP names that reuse another tool's advertised schema. */
+export const LEGACY_TOOL_SCHEMA_SOURCE = {
+    search: 'query',
+    explore: 'context',
+};
+/**
+ * Keys the handler still reads but that must NOT appear in `inputSchema`
+ * (#2175: advertising `query` makes Claude Code drop the argument).
+ */
+export const UNPUBLISHED_TOOL_ARGUMENT_ALIASES = {
+    query: ['query'],
+    cypher: ['query'],
+    // Group-mode context still reads `target` as the symbol name; local
+    // `name` is the advertised key. Advertising `target` would collide with
+    // impact's target vocabulary and is not in tools/list. Legacy `search`
+    // and `explore` inherit via schemaSourceToolName.
+    context: ['target'],
+};
+/**
+ * Numeric aliases that the backend folds onto the advertised canonical key.
+ * `depth` is the CLI flag name for `maxDepth` on impact and trace.
+ */
+export const TOOL_NUMERIC_ARGUMENT_ALIASES = {
+    impact: [{ canonical: 'maxDepth', aliases: ['depth'] }],
+    trace: [{ canonical: 'maxDepth', aliases: ['depth'] }],
+};
+export function schemaSourceToolName(toolName) {
+    return LEGACY_TOOL_SCHEMA_SOURCE[toolName] ?? toolName;
+}
+export function advertisedToolPropertyNames(toolName) {
+    const source = schemaSourceToolName(toolName);
+    const tool = GITNEXUS_TOOLS.find((entry) => entry.name === source);
+    if (!tool)
+        return undefined;
+    return Object.keys(tool.inputSchema.properties);
+}
+function normalizeArgumentKey(key) {
+    return key.toLowerCase().replace(/_/gu, '');
+}
+export function suggestKnownToolArgument(unknownKey, knownKeys) {
+    const needle = normalizeArgumentKey(unknownKey);
+    if (!needle)
+        return undefined;
+    const exact = knownKeys.find((key) => normalizeArgumentKey(key) === needle);
+    if (exact)
+        return exact;
+    const contained = knownKeys.filter((key) => {
+        const normalized = normalizeArgumentKey(key);
+        return normalized.includes(needle) || needle.includes(normalized);
+    });
+    return contained.length === 1 ? contained[0] : undefined;
+}
+function formatUnknownArgumentError(toolName, unknownKeys, advertisedKeys) {
+    const quoted = unknownKeys.map((key) => `"${key}"`).join(', ');
+    const noun = unknownKeys.length === 1 ? 'argument' : 'arguments';
+    const verb = unknownKeys.length === 1 ? 'does' : 'do';
+    const suggestion = unknownKeys.length === 1 ? suggestKnownToolArgument(unknownKeys[0], advertisedKeys) : undefined;
+    if (suggestion) {
+        return `Unknown ${noun} ${quoted} for tool "${toolName}". Did you mean "${suggestion}"?`;
+    }
+    return (`Unknown ${noun} ${quoted} for tool "${toolName}". ` +
+        `The advertised inputSchema ${verb} not include ${unknownKeys.length === 1 ? 'this key' : 'these keys'}.`);
+}
+/**
+ * Reject top-level tool arguments that are neither advertised nor an
+ * unpublished handler alias. `advertisedProperties` should be the schema the
+ * caller actually saw (`tools/list` after read-only / repository-policy
+ * scrubbing). When it is omitted, the canonical `GITNEXUS_TOOLS` schema is
+ * used. Tools with no schema (legacy `overview`) are left unchecked.
+ */
+export function assertKnownMcpToolArguments(toolName, args, advertisedProperties) {
+    if (!args)
+        return;
+    const propertyNames = advertisedProperties !== undefined
+        ? Object.keys(advertisedProperties)
+        : advertisedToolPropertyNames(toolName);
+    if (!propertyNames)
+        return;
+    const unpublished = UNPUBLISHED_TOOL_ARGUMENT_ALIASES[toolName] ??
+        UNPUBLISHED_TOOL_ARGUMENT_ALIASES[schemaSourceToolName(toolName)] ??
+        [];
+    const allowed = new Set([...propertyNames, ...unpublished]);
+    const unknownKeys = Object.keys(args).filter((key) => !allowed.has(key));
+    if (unknownKeys.length === 0)
+        return;
+    throw new Error(formatUnknownArgumentError(toolName, unknownKeys, propertyNames));
+}
+/**
+ * Fold numeric aliases onto their canonical key (e.g. `depth` → `maxDepth`).
+ * Conflicting values error; a single agreed value is written to the canonical
+ * key and the alias keys are removed so every downstream reader sees one name.
+ */
+export function foldNumericToolArgumentAliases(toolName, params) {
+    const definitions = TOOL_NUMERIC_ARGUMENT_ALIASES[toolName];
+    if (!definitions)
+        return { params };
+    const normalized = { ...params };
+    for (const { canonical, aliases } of definitions) {
+        const keys = [canonical, ...aliases];
+        const supplied = [];
+        for (const key of keys) {
+            if (!Object.prototype.hasOwnProperty.call(normalized, key))
+                continue;
+            const value = normalized[key];
+            if (value === undefined)
+                continue;
+            if (typeof value !== 'number') {
+                return { error: `MCP parameter ${toolName}.${key} must be a number.` };
+            }
+            // #2279: some MCP adapters materialize an omitted optional number as 0,
+            // and a coerced missing value arrives as NaN. Treat both sentinels as
+            // absent so they cannot conflict with a real maxDepth or fold onto
+            // `params.maxDepth || 3`. The handlers already map a non-positive or
+            // non-integer maxDepth to their default; erroring here turned that
+            // contract into an error payload instead.
+            if (value === 0 || Number.isNaN(value))
+                continue;
+            supplied.push({ key, value });
+        }
+        const distinctValues = new Set(supplied.map(({ value }) => value));
+        if (distinctValues.size > 1) {
+            return {
+                error: `Conflicting MCP parameters for ${toolName}.${canonical}: ${supplied
+                    .map(({ key }) => key)
+                    .join(', ')} must agree.`,
+            };
+        }
+        // Drop every source key, then write back the single agreed value (if any),
+        // so a sentinel 0/NaN never survives on the canonical key.
+        for (const key of keys)
+            delete normalized[key];
+        if (supplied.length > 0)
+            normalized[canonical] = supplied[0].value;
+    }
+    return { params: normalized };
+}

package/dist/mcp/tools.d.ts

@@ -24,6 +24,7 @@ export interface ToolDefinition {
             minLength?: number;
         }>;
         required: string[];
+        additionalProperties?: false;
     };
 }
 /**

package/dist/mcp/tools.js

@@ -526,6 +526,12 @@ SERVICE: optional monorepo path prefix (case-sensitive path segments). When "rep
                     minimum: 1,
                     maximum: IMPACT_MAX_DEPTH,
                 },
+                depth: {
+                    type: 'number',
+                    description: 'Compatibility alias for maxDepth (CLI --depth). Values must agree when both are present. Literal 0 is an omitted-value compatibility sentinel.',
+                    minimum: 0,
+                    maximum: IMPACT_MAX_DEPTH,
+                },
                 crossDepth: {
                     type: 'number',
                     description: 'Cross-repository hop depth via contract bridge (default: 1; values above server maximum are clamped)',
@@ -865,6 +871,12 @@ DESTINATION TRACE (cross-repo): for an "@groupName" trace, OMIT to/to_uid/to_fil
                     minimum: 1,
                     maximum: 30,
                 },
+                depth: {
+                    type: 'number',
+                    description: 'Compatibility alias for maxDepth (CLI --depth). Values must agree when both are present. Literal 0 is an omitted-value compatibility sentinel.',
+                    minimum: 0,
+                    maximum: 30,
+                },
                 includeTests: {
                     type: 'boolean',
                     description: 'Include test-file symbols in traversal (default: false)',
@@ -922,6 +934,16 @@ export const REPO_SCOPED_TOOLS = new Set([
     'trace',
 ]);
 for (const tool of GITNEXUS_TOOLS) {
+    // Advertises a closed schema; tools/call still fail-closes on the scrubbed key list.
+    // The unpublished handler aliases in tool-arguments.ts stay off this schema on
+    // purpose (#2175), and closing it strands no caller: every alias has an
+    // advertised counterpart reaching the same handler — `query` → `search_query`
+    // on query, `query` → `statement` on cypher, and `target` → `name` on group
+    // context, which local-backend maps to the group target (the group name comes
+    // from `repo: "@group"`, not from `name`; see test/unit/mcp/group-repo-routing).
+    // A schema-validating client therefore has a valid call for every tool, and
+    // advertising the aliases instead would re-break Claude Code on `query`.
+    tool.inputSchema.additionalProperties = false;
     if (!REPO_SCOPED_TOOLS.has(tool.name))
         continue;
     if (tool.inputSchema.properties.branch)

package/dist/storage/git.js

@@ -903,12 +903,16 @@ export function parseDiffHunksResult(diffOutput) {
     // `+++` after the first `@@` of a file is hunk body (`+` plus source text
     // that itself starts `++ …`), not another file header.
     let inHunk = false;
+    // A deleted file has no new-side coordinates. Its indexed symbols still use
+    // the pre-delete file, so map those hunks with the old-side range instead.
+    let currentFileDeleted = false;
     for (const line of diffOutput.split('\n')) {
         if (line.startsWith(DIFF_GIT_PREFIX)) {
             // Drop the previous file first: an unparsed header must not leave
             // `current` live for a later `@@` / quoted `+++` to steal.
             current = null;
             inHunk = false;
+            currentFileDeleted = false;
             const filePath = filePathFromGitHeader(line);
             if (filePath) {
                 current = { filePath, hunks: [] };
@@ -929,6 +933,9 @@ export function parseDiffHunksResult(diffOutput) {
                 files.push(current);
             }
         }
+        else if (!inHunk && line === '+++ /dev/null') {
+            currentFileDeleted = true;
+        }
         else if (!inHunk && line.startsWith('+++ ')) {
             const filePath = pathFromPlusPlusPlus(line);
             if (!filePath)
@@ -940,10 +947,12 @@ export function parseDiffHunksResult(diffOutput) {
         }
         else if (line.startsWith('@@') && current) {
             inHunk = true;
-            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            const match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
             if (match) {
-                const start = parseInt(match[1], 10);
-                const count = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+                const sideOffset = currentFileDeleted ? 1 : 3;
+                const start = parseInt(match[sideOffset], 10);
+                const rawCount = match[sideOffset + 1];
+                const count = rawCount !== undefined ? parseInt(rawCount, 10) : 1;
                 if (count > 0) {
                     current.hunks.push({ startLine: start, endLine: start + count - 1 });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.36",
+  "version": "1.6.12-rc.38",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",