sdl-mcp 0.9.2 → 0.9.3

package/dist/indexer/adapter/c.js

@@ -96,14 +96,14 @@ class CAdapter {
         for (const symbol of extractedSymbols) {
             symbolMap.set(symbol.name, symbol);
         }
-        const callQuery = createQuery("c", `
-      (call_expression
-        function: (identifier) @callee)
-
-      (call_expression
-        function: (field_expression
-          argument: (_) @obj
-          field: (field_identifier) @field))
+        const callQuery = createQuery("c", `
+      (call_expression
+        function: (identifier) @callee)
+
+      (call_expression
+        function: (field_expression
+          argument: (_) @obj
+          field: (field_identifier) @field))
     `);
         if (!callQuery) {
             return [];

package/dist/indexer/adapter/kotlin.js

@@ -494,30 +494,30 @@ function extractCalls(tree, extractedSymbols) {
     for (const symbol of extractedSymbols) {
         symbolMap.set(symbol.name, symbol);
     }
-    const callQuery = createQuery("kotlin", `
-    (call_expression
-      (simple_identifier) @callee)
-
-    (call_expression
-      (navigation_expression
-        (simple_identifier) @recv
-        (navigation_suffix
-          (simple_identifier) @attr)))
-
-    (call_expression
-      (navigation_expression
-        (this_expression) @recv
-        (navigation_suffix
-          (simple_identifier) @attr)))
-
-    (call_expression
-      (navigation_expression
-        (navigation_expression
-          (simple_identifier) @recv
-          (navigation_suffix
-            (simple_identifier) @attr1))
-        (navigation_suffix
-          (simple_identifier) @attr2)))
+    const callQuery = createQuery("kotlin", `
+    (call_expression
+      (simple_identifier) @callee)
+
+    (call_expression
+      (navigation_expression
+        (simple_identifier) @recv
+        (navigation_suffix
+          (simple_identifier) @attr)))
+
+    (call_expression
+      (navigation_expression
+        (this_expression) @recv
+        (navigation_suffix
+          (simple_identifier) @attr)))
+
+    (call_expression
+      (navigation_expression
+        (navigation_expression
+          (simple_identifier) @recv
+          (navigation_suffix
+            (simple_identifier) @attr1))
+        (navigation_suffix
+          (simple_identifier) @attr2)))
   `);
     if (!callQuery) {
         return [];

package/dist/indexer/adapter/php.js

@@ -452,26 +452,26 @@ function extractRange(node) {
 }
 function extractImports(tree) {
     const imports = [];
-    const importQuery = createQuery("php", `
-    (namespace_use_declaration
-      (namespace_use_clause
-        (qualified_name) @import_name))
-
-    (namespace_use_declaration
-      (namespace_use_clause
-        (name) @import_name))
-
-    (include_expression
-      (string) @include_path)
-
-    (include_once_expression
-      (string) @include_path)
-
-    (require_expression
-      (string) @include_path)
-
-    (require_once_expression
-      (string) @include_path)
+    const importQuery = createQuery("php", `
+    (namespace_use_declaration
+      (namespace_use_clause
+        (qualified_name) @import_name))
+
+    (namespace_use_declaration
+      (namespace_use_clause
+        (name) @import_name))
+
+    (include_expression
+      (string) @include_path)
+
+    (include_once_expression
+      (string) @include_path)
+
+    (require_expression
+      (string) @include_path)
+
+    (require_once_expression
+      (string) @include_path)
   `);
     if (!importQuery) {
         return [];
@@ -548,27 +548,27 @@ function extractCalls(tree, extractedSymbols) {
     for (const symbol of extractedSymbols) {
         symbolMap.set(symbol.name, symbol);
     }
-    const callQuery = createQuery("php", `(function_call_expression
-      (name) @callee)
-
-    (function_call_expression
-      (variable_name) @var_callee)
-
-    (member_call_expression
-      object: (variable_name) @recv
-      name: (name) @attr)
-
-    (member_call_expression
-      object: (variable_name) @recv
-      name: (variable_name) @var_attr)
-
-    (scoped_call_expression
-      (name) @scope
-      (name) @static_callee)
-
-    (scoped_call_expression
-      (qualified_name) @qualified_scope
-      (name) @static_callee)
+    const callQuery = createQuery("php", `(function_call_expression
+      (name) @callee)
+
+    (function_call_expression
+      (variable_name) @var_callee)
+
+    (member_call_expression
+      object: (variable_name) @recv
+      name: (name) @attr)
+
+    (member_call_expression
+      object: (variable_name) @recv
+      name: (variable_name) @var_attr)
+
+    (scoped_call_expression
+      (name) @scope
+      (name) @static_callee)
+
+    (scoped_call_expression
+      (qualified_name) @qualified_scope
+      (name) @static_callee)
   `);
     if (!callQuery) {
         return [];

package/dist/indexer/adapter/python.js

@@ -256,23 +256,23 @@ function extractRange(node) {
 }
 function extractImports(tree) {
     const imports = [];
-    const importQuery = createQuery("python", `
-    (import_statement
-      name: (dotted_name) @import_name)
-
-    (import_statement
-      name: (aliased_import
-        name: (dotted_name) @import_name))
-
-    (import_from_statement
-      module_name: (dotted_name) @module_name)
-
-    (import_from_statement
-      module_name: (relative_import) @relative_import)
-
-    (import_from_statement
-      module_name: (relative_import
-        (dotted_name) @module_name))
+    const importQuery = createQuery("python", `
+    (import_statement
+      name: (dotted_name) @import_name)
+
+    (import_statement
+      name: (aliased_import
+        name: (dotted_name) @import_name))
+
+    (import_from_statement
+      module_name: (dotted_name) @module_name)
+
+    (import_from_statement
+      module_name: (relative_import) @relative_import)
+
+    (import_from_statement
+      module_name: (relative_import
+        (dotted_name) @module_name))
   `);
     if (!importQuery) {
         return [];
@@ -375,13 +375,13 @@ function extractCalls(tree, extractedSymbols) {
     for (const symbol of extractedSymbols) {
         symbolMap.set(symbol.name, symbol);
     }
-    const callQuery = createQuery("python", `(call
-      function: (identifier) @callee)
-
-    (call
-      function: (attribute
-        object: (_) @recv
-        attribute: (identifier) @attr))
+    const callQuery = createQuery("python", `(call
+      function: (identifier) @callee)
+
+    (call
+      function: (attribute
+        object: (_) @recv
+        attribute: (identifier) @attr))
   `);
     if (!callQuery) {
         return [];
@@ -449,16 +449,16 @@ function extractCalls(tree, extractedSymbols) {
     return calls;
 }
 function extractDecoratorCalls(tree, _extractedSymbols, symbolMap, calls, seenCallNodes) {
-    const decoratorQuery = createQuery("python", `
-    (decorator
-      (call
-        function: (identifier) @callee))
-
-    (decorator
-      (call
-        function: (attribute
-          object: (_) @recv
-          attribute: (identifier) @attr)))
+    const decoratorQuery = createQuery("python", `
+    (decorator
+      (call
+        function: (identifier) @callee))
+
+    (decorator
+      (call
+        function: (attribute
+          object: (_) @recv
+          attribute: (identifier) @attr)))
     `);
     if (!decoratorQuery)
         return;

package/dist/indexer/adapter/rust.js

@@ -557,24 +557,24 @@ function extractCalls(tree, extractedSymbols) {
         symbolMap.set(symbol.name, symbol);
         symbolMap.set(symbol.nodeId, symbol);
     }
-    const callQuery = createQuery("rust", `
-
-(call_expression
-  function: (identifier) @callee) @call
-
-(call_expression
-  function: (scoped_identifier
-    path: (identifier) @type
-    name: (identifier) @name)) @call
-
-(call_expression
-  function: (field_expression
-    value: (_) @recv
-    field: (field_identifier) @field)) @call
-
-(macro_invocation
-  macro: (identifier) @macro) @macro_call
-
+    const callQuery = createQuery("rust", `
+
+(call_expression
+  function: (identifier) @callee) @call
+
+(call_expression
+  function: (scoped_identifier
+    path: (identifier) @type
+    name: (identifier) @name)) @call
+
+(call_expression
+  function: (field_expression
+    value: (_) @recv
+    field: (field_identifier) @field)) @call
+
+(macro_invocation
+  macro: (identifier) @macro) @macro_call
+
 `);
     if (!callQuery) {
         return [];

package/dist/indexer/treesitter/extractCalls.js

@@ -86,93 +86,93 @@ export function extractCalls(tree, extractedSymbols) {
         }
     }
     // --- Standard call queries ---
-    const functionQuery = `
-    (call_expression
-      function: (identifier) @callee
-      arguments: (_) @args
-    ) @call
+    const functionQuery = `
+    (call_expression
+      function: (identifier) @callee
+      arguments: (_) @args
+    ) @call
   `;
-    const memberCallQuery = `
-    (call_expression
-      function: (member_expression
-        object: (_) @obj
-        property: (property_identifier) @prop
-      )
-      arguments: (_) @args
-    ) @call
+    const memberCallQuery = `
+    (call_expression
+      function: (member_expression
+        object: (_) @obj
+        property: (property_identifier) @prop
+      )
+      arguments: (_) @args
+    ) @call
   `;
-    const newExpressionQuery = `
-    (new_expression
-      constructor: (identifier) @callee
-      arguments: (_) @args
-    ) @call
+    const newExpressionQuery = `
+    (new_expression
+      constructor: (identifier) @callee
+      arguments: (_) @args
+    ) @call
   `;
-    const newMemberExpressionQuery = `
-    (new_expression
-      constructor: (member_expression
-        object: (_) @obj
-        property: (property_identifier) @prop
-      )
-      arguments: (_) @args
-    ) @call
+    const newMemberExpressionQuery = `
+    (new_expression
+      constructor: (member_expression
+        object: (_) @obj
+        property: (property_identifier) @prop
+      )
+      arguments: (_) @args
+    ) @call
   `;
-    const superCallQuery = `
-    (call_expression
-      function: (super) @callee
-    ) @call
+    const superCallQuery = `
+    (call_expression
+      function: (super) @callee
+    ) @call
   `;
     // --- 36-1.1: Computed property call detection ---
     // Matches: obj[methodName]() or obj["method"]()
-    const computedCallQuery = `
-    (call_expression
-      function: (subscript_expression
-        object: (_) @obj
-        index: (_) @index
-      )
-      arguments: (_) @args
-    ) @call
+    const computedCallQuery = `
+    (call_expression
+      function: (subscript_expression
+        object: (_) @obj
+        index: (_) @index
+      )
+      arguments: (_) @args
+    ) @call
   `;
     // --- 36-1.4: Tagged template string detection ---
     // Matches: tag`template` or obj.method`template`
-    const taggedTemplateQuery = `
-    (call_expression
-      function: (identifier) @callee
-      arguments: (template_string)
-    ) @call
+    const taggedTemplateQuery = `
+    (call_expression
+      function: (identifier) @callee
+      arguments: (template_string)
+    ) @call
   `;
-    const taggedTemplateMemberQuery = `
-    (call_expression
-      function: (member_expression
-        object: (_) @obj
-        property: (property_identifier) @prop
-      )
-      arguments: (template_string)
-    ) @call
+    const taggedTemplateMemberQuery = `
+    (call_expression
+      function: (member_expression
+        object: (_) @obj
+        property: (property_identifier) @prop
+      )
+      arguments: (template_string)
+    ) @call
   `;
     // Note: tagged_template_expression doesn't exist in tree-sitter-typescript 0.23.x
     // Tagged templates are parsed as call_expression with template_string arguments
     // The taggedTemplateQuery and taggedTemplateMemberQuery above already handle these cases
     // --- 36-1.7: Optional chaining call detection ---
     // Note: In tree-sitter-typescript 0.23.x, optional_chain is a sibling of object/property
-    const optionalChainedCallQuery = `
-    (call_expression
-      function: (member_expression
-        object: (_) @obj
-        (optional_chain)
-        property: (property_identifier) @prop
-      )
-      arguments: (_) @args
-    ) @call
+    const optionalChainedCallQuery = `
+    (call_expression
+      function: (member_expression
+        object: (_) @obj
+        (optional_chain)
+        property: (property_identifier) @prop
+      )
+      arguments: (_) @args
+    ) @call
   `;
-    const optionalChainedNewQuery = `
-    (new_expression
-      constructor: (member_expression
-        object: (_) @obj
-        (optional_chain)
-        property: (property_identifier) @prop
-      )
-      arguments: (_) @args
-    ) @call
+    const optionalChainedNewQuery = `
+    (new_expression
+      constructor: (member_expression
+        object: (_) @obj
+        (optional_chain)
+        property: (property_identifier) @prop
+      )
+      arguments: (_) @args
+    ) @call
   `;
     // Collect all matches
     const standardMatches = [

package/dist/indexer/treesitter/extractImports.js

@@ -8,12 +8,12 @@ const BUILTIN_MODULES = new Set([...builtinModules, "test"].flatMap((moduleName)
 }));
 export function extractImports(tree) {
     const imports = [];
-    const importQuery = createQuery("typescript", `
-    (import_statement 
-      source: (string (string_fragment) @specifier))
-
-    (export_statement
-      source: (string (string_fragment) @specifier))
+    const importQuery = createQuery("typescript", `
+    (import_statement 
+      source: (string (string_fragment) @specifier))
+
+    (export_statement
+      source: (string (string_fragment) @specifier))
   `);
     if (!importQuery) {
         return [];

package/dist/server.js

@@ -99,7 +99,7 @@ export class MCPServer {
                             })),
                         },
                     };
-                    process.stderr.write(`[sdl-mcp] Tool ${request.params.name} validation error: ${JSON.stringify(validationError)}
+                    process.stderr.write(`[sdl-mcp] Tool ${request.params.name} validation error: ${JSON.stringify(validationError)}
 `);
                     logToolCall({
                         tool: request.params.name,
@@ -197,7 +197,7 @@ export class MCPServer {
                             await hook(request.params.name, parseResult.data, finalResult, toolContext);
                         }
                         catch (err) {
-                            process.stderr.write(`[sdl-mcp] Post-dispatch hook failed for tool ${request.params.name}: ${err instanceof Error ? err.message : String(err)}
+                            process.stderr.write(`[sdl-mcp] Post-dispatch hook failed for tool ${request.params.name}: ${err instanceof Error ? err.message : String(err)}
 `);
                         }
                     }