ucn 3.7.5 → 3.7.6

package/languages/java.js

@@ -279,7 +279,7 @@ function findClasses(code, parser) {
                     startLine,
                     endLine,
                     type: 'interface',
-                    members: [],
+                    members: extractClassMembers(node, code),
                     modifiers,
                     ...(docstring && { docstring }),
                     ...(generics && { generics }),
@@ -307,7 +307,7 @@ function findClasses(code, parser) {
                     startLine,
                     endLine,
                     type: 'enum',
-                    members: [],
+                    members: extractEnumConstants(node, code),
                     modifiers,
                     ...(docstring && { docstring }),
                     ...(annotations.length > 0 && { annotations })
@@ -405,6 +405,82 @@ function extractInterfaceExtends(interfaceNode) {
     return [];
 }
 
+/**
+ * Extract enum constants from enum body
+ */
+function extractEnumConstants(enumNode, code) {
+    const constants = [];
+    const bodyNode = enumNode.childForFieldName('body');
+    if (!bodyNode) return constants;
+
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const child = bodyNode.namedChild(i);
+        if (child.type === 'enum_constant') {
+            const nameNode = child.childForFieldName('name');
+            if (nameNode) {
+                const { startLine, endLine } = nodeToLocation(child, code);
+                const argsNode = child.childForFieldName('arguments');
+                constants.push({
+                    name: nameNode.text,
+                    startLine,
+                    endLine,
+                    memberType: 'constant',
+                    ...(argsNode && { params: argsNode.text.slice(1, -1) })
+                });
+            }
+        }
+    }
+
+    // Also extract methods from enum_body_declarations
+    if (bodyNode) {
+        for (let i = 0; i < bodyNode.namedChildCount; i++) {
+            const child = bodyNode.namedChild(i);
+            if (child.type === 'enum_body_declarations') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const member = child.namedChild(j);
+                    if (member.type === 'method_declaration') {
+                        const nameNode = member.childForFieldName('name');
+                        const paramsNode = member.childForFieldName('parameters');
+                        if (nameNode) {
+                            const { startLine, endLine } = nodeToLocation(member, code);
+                            const modifiers = extractModifiers(member);
+                            const returnType = extractReturnType(member);
+                            constants.push({
+                                name: nameNode.text,
+                                params: extractJavaParams(paramsNode),
+                                startLine,
+                                endLine,
+                                memberType: modifiers.includes('static') ? 'static' : 'method',
+                                modifiers,
+                                isMethod: true,
+                                ...(returnType && { returnType })
+                            });
+                        }
+                    } else if (member.type === 'constructor_declaration') {
+                        const nameNode = member.childForFieldName('name');
+                        const paramsNode = member.childForFieldName('parameters');
+                        if (nameNode) {
+                            const { startLine, endLine } = nodeToLocation(member, code);
+                            const modifiers = extractModifiers(member);
+                            constants.push({
+                                name: nameNode.text,
+                                params: extractJavaParams(paramsNode),
+                                startLine,
+                                endLine,
+                                memberType: 'constructor',
+                                modifiers,
+                                isMethod: true
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return constants;
+}
+
 /**
  * Extract class members (methods, constructors)
  */

package/languages/rust.js

@@ -232,7 +232,7 @@ function findClasses(code, parser) {
                     startLine,
                     endLine,
                     type: 'enum',
-                    members: [],
+                    members: extractEnumVariants(node, code),
                     modifiers: visibility ? [visibility] : [],
                     ...(docstring && { docstring }),
                     ...(generics && { generics })
@@ -258,7 +258,7 @@ function findClasses(code, parser) {
                     startLine,
                     endLine,
                     type: 'trait',
-                    members: [],
+                    members: extractTraitMembers(node, code),
                     modifiers: visibility ? [visibility] : [],
                     ...(docstring && { docstring }),
                     ...(generics && { generics })
@@ -443,6 +443,75 @@ function extractImplInfo(implNode) {
     return { name, traitName, typeName };
 }
 
+/**
+ * Extract enum variants
+ */
+function extractEnumVariants(enumNode, code) {
+    const variants = [];
+    const bodyNode = enumNode.childForFieldName('body');
+    if (!bodyNode) return variants;
+
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const child = bodyNode.namedChild(i);
+        if (child.type === 'enum_variant') {
+            const nameNode = child.childForFieldName('name');
+            if (nameNode) {
+                const { startLine, endLine } = nodeToLocation(child, code);
+                // Check for tuple/struct variant data
+                let params = undefined;
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const variantChild = child.namedChild(j);
+                    if (variantChild.type === 'field_declaration_list' || variantChild.type === 'ordered_field_declaration_list') {
+                        params = variantChild.text.slice(1, -1);
+                    }
+                }
+                variants.push({
+                    name: nameNode.text,
+                    startLine,
+                    endLine,
+                    memberType: 'variant',
+                    ...(params !== undefined && { params })
+                });
+            }
+        }
+    }
+    return variants;
+}
+
+/**
+ * Extract trait method signatures
+ */
+function extractTraitMembers(traitNode, code) {
+    const members = [];
+    const bodyNode = traitNode.childForFieldName('body');
+    if (!bodyNode) return members;
+
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const child = bodyNode.namedChild(i);
+        if (child.type === 'function_item' || child.type === 'function_signature_item') {
+            const nameNode = child.childForFieldName('name');
+            if (nameNode) {
+                const { startLine, endLine } = nodeToLocation(child, code);
+                const paramsNode = child.childForFieldName('parameters');
+                const returnType = extractReturnType(child);
+                const hasSelf = paramsNode && paramsNode.text.includes('self');
+
+                members.push({
+                    name: nameNode.text,
+                    startLine,
+                    endLine,
+                    memberType: 'method',
+                    isMethod: true,
+                    ...(paramsNode && { params: extractRustParams(paramsNode) }),
+                    ...(returnType && { returnType }),
+                    ...(hasSelf && { receiver: 'self' })
+                });
+            }
+        }
+    }
+    return members;
+}
+
 /**
  * Extract impl block members (functions)
  * @param {Node} implNode - The impl block AST node

package/mcp/server.js

@@ -34,6 +34,7 @@ const { ProjectIndex } = require('../core/project');
 const { findProjectRoot, isTestFile } = require('../core/discovery');
 const { detectLanguage } = require('../core/parser');
 const output = require('../core/output');
+const { pickBestDefinition, addTestExclusions } = require('../core/shared');
 
 // ============================================================================
 // INDEX CACHE
@@ -98,24 +99,6 @@ function getIndex(projectDir) {
     return index;
 }
 
-function pickBestDefinition(matches) {
-    const typeOrder = new Set(['class', 'struct', 'interface', 'type', 'impl']);
-    const scored = matches.map(m => {
-        let score = 0;
-        const rp = m.relativePath || '';
-        if (typeOrder.has(m.type)) score += 1000;
-        if (isTestFile(rp, detectLanguage(m.file))) score -= 500;
-        if (/^(examples?|docs?|vendor|third[_-]?party|benchmarks?|samples?)\//i.test(rp)) score -= 300;
-        if (/^(lib|src|core|internal|pkg|crates)\//i.test(rp)) score += 200;
-        if (m.startLine && m.endLine) {
-            score += Math.min(m.endLine - m.startLine, 100);
-        }
-        return { match: m, score };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored[0].match;
-}
-
 // ============================================================================
 // SERVER SETUP
 // ============================================================================
@@ -129,13 +112,6 @@ const server = new McpServer({
 // TOOL HELPERS
 // ============================================================================
 
-function addTestExclusions(exclude) {
-    const testPatterns = ['test', 'spec', '__tests__', '__mocks__', 'fixture', 'mock'];
-    const existing = new Set((exclude || []).map(e => e.toLowerCase()));
-    const additions = testPatterns.filter(p => !existing.has(p));
-    return [...(exclude || []), ...additions];
-}
-
 function parseExclude(excludeStr) {
     if (!excludeStr) return [];
     return excludeStr.split(',').map(s => s.trim()).filter(Boolean);
@@ -330,6 +306,7 @@ server.registerTool(
                     file,
                     exclude: parseExclude(exclude)
                 });
+                if (!ctx) return toolResult(`Symbol "${name}" not found.`);
                 const { text, expandable } = output.formatContext(ctx, {
                     expandHint: 'Use expand command with item number to see code for any item.'
                 });
@@ -371,6 +348,7 @@ server.registerTool(
                     includeMethods: include_methods,
                     includeUncertain: include_uncertain || false
                 });
+                if (!result) return toolResult(`Function "${name}" not found.`);
                 return toolResult(output.formatSmart(result));
             }
 
@@ -389,7 +367,9 @@ server.registerTool(
                 const err = requireName(name);
                 if (err) return err;
                 const index = getIndex(project_dir);
-                return toolResult(output.formatExample(index.example(name), name));
+                const exResult = index.example(name);
+                if (!exResult) return toolResult(`No usage examples found for "${name}".`);
+                return toolResult(output.formatExample(exResult, name));
             }
 
             case 'related': {
@@ -397,6 +377,7 @@ server.registerTool(
                 if (err) return err;
                 const index = getIndex(project_dir);
                 const result = index.related(name, { file, top, all: top !== undefined });
+                if (!result) return toolResult(`Symbol "${name}" not found.`);
                 return toolResult(output.formatRelated(result, {
                     showAll: top !== undefined,
                     top,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.7.5",
+  "version": "3.7.6",
   "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",
   "bin": {

package/test/mcp-edge-cases.js

@@ -376,6 +376,34 @@ const tests = [
         args: { command: 'api', project_dir: PROJECT_DIR, file: 'nonexistent.js' },
         assert: (res, text, isError) => (isError && /not found/i.test(text)) || 'Expected file-not-found error message'
     },
+    {
+        category: 'Correctness',
+        tool: 'ucn',
+        desc: 'smart(nonexistent) returns "not found" message',
+        args: { command: 'smart', project_dir: PROJECT_DIR, name: 'zzz_nonexistent_symbol_xyz' },
+        assert: (res, text, isError) => (!isError && /not found/i.test(text)) || 'Expected "not found" message for nonexistent smart target'
+    },
+    {
+        category: 'Correctness',
+        tool: 'ucn',
+        desc: 'context(nonexistent) returns "not found" message',
+        args: { command: 'context', project_dir: PROJECT_DIR, name: 'zzz_nonexistent_symbol_xyz' },
+        assert: (res, text, isError) => (!isError && /not found/i.test(text)) || 'Expected "not found" message for nonexistent context target'
+    },
+    {
+        category: 'Correctness',
+        tool: 'ucn',
+        desc: 'example(nonexistent) returns "no examples" message',
+        args: { command: 'example', project_dir: PROJECT_DIR, name: 'zzz_nonexistent_symbol_xyz' },
+        assert: (res, text, isError) => (!isError && /no .* examples found|not found/i.test(text)) || 'Expected "no examples found" message for nonexistent example target'
+    },
+    {
+        category: 'Correctness',
+        tool: 'ucn',
+        desc: 'related(nonexistent) returns "not found" message',
+        args: { command: 'related', project_dir: PROJECT_DIR, name: 'zzz_nonexistent_symbol_xyz' },
+        assert: (res, text, isError) => (!isError && /not found/i.test(text)) || 'Expected "not found" message for nonexistent related target'
+    },
     {
         category: 'Correctness',
         tool: 'ucn',