fix: capture suggestion alongside unknownEntries for "did you mean?" hints

The hint is now stored at determination time rather than re-computed
in the error loop (where it was always undefined). When both kebab-case
and camelCase forms are provided (e.g. source-root + sourceRoot), the
duplicate is now rejected with a "did you mean?" suggestion instead of
being silently ignored.

Agent-Logs-Url: https://github.com/advanced-security/codeql-development-mcp-server/sessions/02a09bd4-39e4-4e83-968e-8562405a9f4c

Co-authored-by: data-douser <70299490+data-douser@users.noreply.github.com>

Author: Copilot

server/dist/codeql-development-mcp-server.js

@@ -188611,14 +188611,12 @@ function buildEnhancedToolSchema(shape) {
         const suggestion = suggestPropertyName(key, knownKeys);
         if (suggestion && !(suggestion in data) && !(suggestion in normalized)) {
           normalized[suggestion] = value;
-        } else if (suggestion && (suggestion in data || suggestion in normalized)) {
         } else {
-          unknownEntries.push({ key, value });
+          unknownEntries.push({ key, hint: suggestion });
         }
       }
     }
-    for (const { key } of unknownEntries) {
-      const hint = suggestPropertyName(key, knownKeys);
+    for (const { key, hint } of unknownEntries) {
       const message = hint ? `unknown property '${key}' \u2014 did you mean '${hint}'?` : `unknown property '${key}'`;
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,

server/dist/codeql-development-mcp-server.js.map

@@ -78,7 +78,7 @@ export function buildEnhancedToolSchema(
     .passthrough()
     .transform((data, ctx) => {
       const normalized: Record<string, unknown> = {};
-      const unknownEntries: Array<{ key: string; value: unknown }> = [];
+      const unknownEntries: Array<{ key: string; hint?: string }> = [];
 
       for (const [key, value] of Object.entries(data)) {
         if (knownKeys.has(key)) {
@@ -90,18 +90,17 @@ export function buildEnhancedToolSchema(
           if (suggestion && !(suggestion in data) && !(suggestion in normalized)) {
             // Silently normalize to the canonical kebab-case key
             normalized[suggestion] = value;
-          } else if (suggestion && (suggestion in data || suggestion in normalized)) {
-            // Both forms provided — prefer the canonical (kebab-case) key,
-            // silently ignore the alias
           } else {
-            unknownEntries.push({ key, value });
+            // Either no suggestion (truly unknown) or the canonical key is
+            // already present.  Capture the suggestion so the error message
+            // can include a "did you mean?" hint.
+            unknownEntries.push({ key, hint: suggestion });
           }
         }
       }
 
-      // Report truly unknown properties with "did you mean?" hints
-      for (const { key } of unknownEntries) {
-        const hint = suggestPropertyName(key, knownKeys);
+      // Report unknown / duplicate properties with "did you mean?" hints
+      for (const { key, hint } of unknownEntries) {
         const message = hint
           ? `unknown property '${key}' — did you mean '${hint}'?`
           : `unknown property '${key}'`;

server/src/lib/param-normalization.ts

@@ -167,17 +167,21 @@ describe('buildEnhancedToolSchema', () => {
     }
   });
 
-  it('should prefer kebab-case when both forms are provided', () => {
+  it('should reject duplicate when both kebab-case and camelCase forms are provided', () => {
     const schema = buildEnhancedToolSchema(shape);
     const result = schema.safeParse({
       database: '/path/to/db',
       'source-root': '/canonical/path',
       sourceRoot: '/alias/path',
     });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data['source-root']).toBe('/canonical/path');
-      expect(result.data).not.toHaveProperty('sourceRoot');
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const messages = result.error.issues.map((i) => i.message);
+      expect(messages).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining("unknown property 'sourceRoot' — did you mean 'source-root'?"),
+        ]),
+      );
     }
   });