ucn 3.7.35 → 3.7.36

package/core/project.js

@@ -1705,12 +1705,21 @@ class ProjectIndex {
 
     /**
      * Extract type names from a function definition
-     * Finds all word-like type identifiers from param types and return type,
-     * then filters to only those that exist in the project symbol table.
+     * Finds all word-like type identifiers from param types, return type,
+     * class membership, and function body — filters to project-defined types only.
      */
     extractTypeNames(def) {
+        const TYPE_KINDS = ['type', 'interface', 'class', 'struct'];
         const types = new Set();
-        // Collect all type annotation strings
+
+        const addIfType = (name) => {
+            const syms = this.symbols.get(name);
+            if (syms && syms.some(s => TYPE_KINDS.includes(s.type))) {
+                types.add(name);
+            }
+        };
+
+        // 1. From param and return type annotations
         const typeStrings = [];
         if (def.paramsStructured) {
             for (const param of def.paramsStructured) {
@@ -1718,17 +1727,30 @@ class ProjectIndex {
             }
         }
         if (def.returnType) typeStrings.push(def.returnType);
-
-        // Extract all word-like identifiers from type annotations
-        // Handles: Dict[str, Any], Optional[QuoteData], str | None, List[int], CustomType
         for (const ts of typeStrings) {
             const matches = ts.match(/\b([A-Za-z_]\w*)\b/g);
             if (matches) {
-                for (const m of matches) {
-                    // Only include names that exist as type/interface/class/struct in the symbol table
-                    const syms = this.symbols.get(m);
-                    if (syms && syms.some(s => ['type', 'interface', 'class', 'struct'].includes(s.type))) {
-                        types.add(m);
+                for (const m of matches) addIfType(m);
+            }
+        }
+
+        // 2. From the class the method belongs to
+        if (def.className) addIfType(def.className);
+
+        // 3. From function body — scan for project-defined type references
+        //    (constructors, type annotations, isinstance checks)
+        if (types.size === 0) {
+            const code = this.extractCode(def);
+            if (code) {
+                // Find capitalized identifiers that match project types
+                const bodyMatches = code.match(/\b([A-Z][A-Za-z0-9_]*)\b/g);
+                if (bodyMatches) {
+                    const seen = new Set();
+                    for (const m of bodyMatches) {
+                        if (!seen.has(m)) {
+                            seen.add(m);
+                            addIfType(m);
+                        }
                     }
                 }
             }
@@ -2917,12 +2939,16 @@ class ProjectIndex {
         // Get type definitions if requested
         let types = [];
         if (options.withTypes) {
-            const typeNames = this.extractTypeNames(primary);
-            for (const typeName of typeNames) {
+            const TYPE_KINDS = ['type', 'interface', 'class', 'struct'];
+            const seen = new Set();
+
+            const addType = (typeName) => {
+                if (seen.has(typeName)) return;
+                seen.add(typeName);
                 const typeSymbols = this.symbols.get(typeName);
                 if (typeSymbols) {
                     for (const sym of typeSymbols) {
-                        if (['type', 'interface', 'class', 'struct'].includes(sym.type)) {
+                        if (TYPE_KINDS.includes(sym.type)) {
                             types.push({
                                 name: sym.name,
                                 type: sym.type,
@@ -2932,6 +2958,18 @@ class ProjectIndex {
                         }
                     }
                 }
+            };
+
+            // From signature annotations
+            const typeNames = this.extractTypeNames(primary);
+            for (const typeName of typeNames) addType(typeName);
+
+            // From callee signatures — types used by functions this function calls
+            if (allCallees) {
+                for (const callee of allCallees) {
+                    const calleeTypeNames = this.extractTypeNames(callee);
+                    for (const tn of calleeTypeNames) addType(tn);
+                }
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.7.35",
+  "version": "3.7.36",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Universal Code Navigator — AST-based call graph analysis for AI agents. Find callers, trace impact, detect dead code across JS/TS, Python, Go, Rust, Java, and HTML. CLI, MCP server, and agent skill.",
   "main": "index.js",