ucn 3.1.3 → 3.1.5

package/cli/index.js

@@ -960,7 +960,8 @@ function runProjectCommand(rootDir, command, arg) {
 
         case 'graph': {
             requireArg(arg, 'Usage: ucn . graph <file>');
-            const graphResult = index.graph(arg, { direction: 'both', maxDepth: flags.depth ?? 5 });
+            const graphDepth = flags.depth ?? 2;  // Default to 2 for cleaner output
+            const graphResult = index.graph(arg, { direction: 'both', maxDepth: graphDepth });
             if (graphResult.nodes.length === 0) {
                 console.log(`File not found: ${arg}`);
             } else {
@@ -970,7 +971,7 @@ function runProjectCommand(rootDir, command, arg) {
                         nodes: r.nodes.map(n => ({ file: n.relativePath, depth: n.depth })),
                         edges: r.edges.map(e => ({ from: path.relative(index.root, e.from), to: path.relative(index.root, e.to) }))
                     }, null, 2),
-                    r => { printGraph(r, index.root); }
+                    r => { printGraph(r, index.root, graphDepth); }
                 );
             }
             break;
@@ -1801,12 +1802,15 @@ function printStats(stats) {
     }
 }
 
-function printGraph(graph, root) {
+function printGraph(graph, root, maxDepth = 2) {
     const rootRelPath = path.relative(root, graph.root);
     console.log(`Dependency graph for ${rootRelPath}`);
     console.log('═'.repeat(60));
 
     const printed = new Set();
+    const maxChildren = 8;  // Limit children per node
+    let truncatedNodes = 0;
+    let depthLimited = false;
 
     function printNode(file, indent = 0) {
         const fileEntry = graph.nodes.find(n => n.file === file);
@@ -1819,15 +1823,43 @@ function printGraph(graph, root) {
         }
         printed.add(file);
 
+        // Depth limiting
+        if (indent > maxDepth) {
+            depthLimited = true;
+            console.log(`${prefix}${relPath} ...`);
+            return;
+        }
+
         console.log(`${prefix}${relPath}`);
 
         const edges = graph.edges.filter(e => e.from === file);
-        for (const edge of edges) {
+
+        // Limit children
+        const displayEdges = edges.slice(0, maxChildren);
+        const hiddenCount = edges.length - displayEdges.length;
+
+        for (const edge of displayEdges) {
             printNode(edge.to, indent + 1);
         }
+
+        if (hiddenCount > 0) {
+            truncatedNodes += hiddenCount;
+            console.log(`${'  '.repeat(indent)}└── ... and ${hiddenCount} more`);
+        }
     }
 
     printNode(graph.root);
+
+    // Print helpful note about expanding
+    if (depthLimited || truncatedNodes > 0) {
+        console.log('\n' + '─'.repeat(60));
+        if (depthLimited) {
+            console.log(`Depth limited to ${maxDepth}. Use --depth=N for deeper graph.`);
+        }
+        if (truncatedNodes > 0) {
+            console.log(`${truncatedNodes} nodes hidden. Graph has ${graph.nodes.length} total files.`);
+        }
+    }
 }
 
 function printSearchResults(results, term) {

package/core/discovery.js

@@ -332,31 +332,51 @@ function findProjectRoot(startDir) {
 
 /**
  * Auto-detect the glob pattern for a project based on its type
+ * Checks both project root and immediate subdirectories for config files
  */
 function detectProjectPattern(projectRoot) {
     const extensions = [];
 
-    if (fs.existsSync(path.join(projectRoot, 'package.json'))) {
-        extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs');
-    }
+    // Helper to check for config files in a directory
+    const checkDir = (dir) => {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs');
+        }
 
-    if (fs.existsSync(path.join(projectRoot, 'pyproject.toml')) ||
-        fs.existsSync(path.join(projectRoot, 'setup.py')) ||
-        fs.existsSync(path.join(projectRoot, 'requirements.txt'))) {
-        extensions.push('py');
-    }
+        if (fs.existsSync(path.join(dir, 'pyproject.toml')) ||
+            fs.existsSync(path.join(dir, 'setup.py')) ||
+            fs.existsSync(path.join(dir, 'requirements.txt'))) {
+            extensions.push('py');
+        }
 
-    if (fs.existsSync(path.join(projectRoot, 'go.mod'))) {
-        extensions.push('go');
-    }
+        if (fs.existsSync(path.join(dir, 'go.mod'))) {
+            extensions.push('go');
+        }
 
-    if (fs.existsSync(path.join(projectRoot, 'Cargo.toml'))) {
-        extensions.push('rs');
-    }
+        if (fs.existsSync(path.join(dir, 'Cargo.toml'))) {
+            extensions.push('rs');
+        }
 
-    if (fs.existsSync(path.join(projectRoot, 'pom.xml')) ||
-        fs.existsSync(path.join(projectRoot, 'build.gradle'))) {
-        extensions.push('java', 'kt');
+        if (fs.existsSync(path.join(dir, 'pom.xml')) ||
+            fs.existsSync(path.join(dir, 'build.gradle'))) {
+            extensions.push('java', 'kt');
+        }
+    };
+
+    // Check project root
+    checkDir(projectRoot);
+
+    // Also check immediate subdirectories for multi-language projects (e.g., web/, frontend/, server/)
+    try {
+        const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.') &&
+                !EXCLUDED_DIRS.has(entry.name)) {
+                checkDir(path.join(projectRoot, entry.name));
+            }
+        }
+    } catch (e) {
+        // Ignore errors reading directory
     }
 
     if (extensions.length > 0) {

package/core/project.js

@@ -1010,11 +1010,37 @@ class ProjectIndex {
             }
 
             // Look up each callee in the symbol table
+            // For methods, prefer callees from: 1) same file, 2) same package, 3) same receiver type
             const result = [];
+            const defDir = path.dirname(def.file);
+            const defReceiver = def.receiver;
+
             for (const [calleeName, count] of callees) {
                 const symbols = this.symbols.get(calleeName);
                 if (symbols && symbols.length > 0) {
-                    const callee = symbols[0];
+                    let callee = symbols[0];
+
+                    // If multiple definitions, try to find the best match
+                    if (symbols.length > 1) {
+                        // Priority 1: Same file
+                        const sameFile = symbols.find(s => s.file === def.file);
+                        if (sameFile) {
+                            callee = sameFile;
+                        } else {
+                            // Priority 2: Same directory (package)
+                            const sameDir = symbols.find(s => path.dirname(s.file) === defDir);
+                            if (sameDir) {
+                                callee = sameDir;
+                            } else if (defReceiver) {
+                                // Priority 3: Same receiver type (for methods)
+                                const sameReceiver = symbols.find(s => s.receiver === defReceiver);
+                                if (sameReceiver) {
+                                    callee = sameReceiver;
+                                }
+                            }
+                        }
+                    }
+
                     result.push({
                         ...callee,
                         callCount: count,
@@ -2137,23 +2163,15 @@ class ProjectIndex {
 
         const def = definitions[0];
         const visited = new Set();
+        const defDir = path.dirname(def.file);
 
-        const buildTree = (funcName, currentDepth, dir) => {
-            if (currentDepth > maxDepth || visited.has(funcName)) {
+        const buildTree = (funcDef, currentDepth, dir) => {
+            const funcName = funcDef.name;
+            if (currentDepth > maxDepth || visited.has(`${funcDef.file}:${funcDef.startLine}`)) {
                 return null;
             }
-            visited.add(funcName);
-
-            const funcDefs = this.symbols.get(funcName);
-            if (!funcDefs || funcDefs.length === 0) {
-                return {
-                    name: funcName,
-                    external: true,
-                    children: []
-                };
-            }
+            visited.add(`${funcDef.file}:${funcDef.startLine}`);
 
-            const funcDef = funcDefs[0];
             const node = {
                 name: funcName,
                 file: funcDef.relativePath,
@@ -2165,7 +2183,8 @@ class ProjectIndex {
             if (dir === 'down' || dir === 'both') {
                 const callees = this.findCallees(funcDef);
                 for (const callee of callees.slice(0, 10)) {  // Limit children
-                    const childTree = buildTree(callee.name, currentDepth + 1, 'down');
+                    // callee already has the best-matched definition from findCallees
+                    const childTree = buildTree(callee, currentDepth + 1, 'down');
                     if (childTree) {
                         node.children.push({
                             ...childTree,
@@ -2179,7 +2198,7 @@ class ProjectIndex {
             return node;
         };
 
-        const tree = buildTree(name, 0, direction);
+        const tree = buildTree(def, 0, direction);
 
         // Also get callers if direction is 'up' or 'both'
         let callers = [];

package/languages/javascript.js

@@ -812,6 +812,50 @@ function findCallsInCode(code, parser) {
             return true;
         }
 
+        // Handle JSX component usage: <Component /> or <Component>...</Component>
+        // Only track PascalCase names (React components), not lowercase (HTML elements)
+        if (node.type === 'jsx_self_closing_element' || node.type === 'jsx_opening_element') {
+            // First named child is the element name
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child.type === 'identifier') {
+                    const name = child.text;
+                    // React components start with uppercase
+                    if (name && /^[A-Z]/.test(name)) {
+                        const enclosingFunction = getCurrentEnclosingFunction();
+                        calls.push({
+                            name: name,
+                            line: node.startPosition.row + 1,
+                            isMethod: false,
+                            isJsxComponent: true,
+                            enclosingFunction
+                        });
+                    }
+                    break;
+                }
+                // Handle namespaced components: <Foo.Bar />
+                if (child.type === 'member_expression' || child.type === 'nested_identifier') {
+                    const text = child.text;
+                    // Get the last part after the dot
+                    const parts = text.split('.');
+                    const componentName = parts[parts.length - 1];
+                    if (componentName && /^[A-Z]/.test(componentName)) {
+                        const enclosingFunction = getCurrentEnclosingFunction();
+                        calls.push({
+                            name: componentName,
+                            line: node.startPosition.row + 1,
+                            isMethod: true,
+                            receiver: parts.slice(0, -1).join('.'),
+                            isJsxComponent: true,
+                            enclosingFunction
+                        });
+                    }
+                    break;
+                }
+            }
+            return true;
+        }
+
         return true;
     }, {
         onLeave: (node) => {
@@ -1338,6 +1382,10 @@ function findUsagesInCode(code, name, parser) {
                     usageType = 'reference';
                 }
             }
+            // JSX component usage: <Component /> or <Component>...</Component>
+            else if (parent.type === 'jsx_self_closing_element' || parent.type === 'jsx_opening_element') {
+                usageType = 'call';  // Treat JSX component usage as a "call"
+            }
         }
 
         usages.push({ line, column, usageType });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.1.3",
+  "version": "3.1.5",
   "description": "Code navigation built by AI, for AI. Reduces context usage when working with large codebases.",
   "main": "index.js",
   "bin": {

package/test/parser.test.js

@@ -4497,6 +4497,88 @@ function main() {
         }
     });
 
+    it('should prefer same-file callees for Go methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-callee-disambig-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/test
+go 1.21
+`);
+
+            // Two files with same method name 'helper'
+            fs.writeFileSync(path.join(tmpDir, 'service_a.go'), `package main
+
+type ServiceA struct{}
+
+func (s *ServiceA) Process() {
+    s.helper()
+}
+
+func (s *ServiceA) helper() {}
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'service_b.go'), `package main
+
+type ServiceB struct{}
+
+func (s *ServiceB) Process() {
+    s.helper()
+}
+
+func (s *ServiceB) helper() {}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Get callees for ServiceA.Process - should find ServiceA.helper, not ServiceB.helper
+            const defs = index.symbols.get('Process') || [];
+            const serviceAProcess = defs.find(d => d.relativePath.includes('service_a.go'));
+            assert.ok(serviceAProcess, 'Should find ServiceA.Process');
+
+            const callees = index.findCallees(serviceAProcess);
+            assert.ok(callees.length >= 1, 'Should find at least 1 callee');
+
+            const helperCallee = callees.find(c => c.name === 'helper');
+            assert.ok(helperCallee, 'Should find helper callee');
+            assert.ok(helperCallee.relativePath.includes('service_a.go'),
+                'helper callee should be from service_a.go, not service_b.go');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should detect JSX component usage as calls', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-jsx-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'package.json'), `{"name": "test"}`);
+
+            fs.writeFileSync(path.join(tmpDir, 'Page.tsx'), `
+function EnvironmentsPage() {
+  return <div>Hello</div>;
+}
+
+function App() {
+  return <EnvironmentsPage />;
+}
+
+export { App, EnvironmentsPage };
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.tsx', { quiet: true });
+
+            const usages = index.usages('EnvironmentsPage', { codeOnly: true });
+            const calls = usages.filter(u => u.usageType === 'call' && !u.isDefinition);
+
+            // Should find JSX usage as a call
+            assert.ok(calls.length >= 1, 'Should find at least 1 JSX component usage');
+            assert.ok(calls.some(c => c.content && c.content.includes('<EnvironmentsPage')),
+                'Should detect <EnvironmentsPage /> as a call');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
     it('should detect Rust method calls in usages', () => {
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-rust-method-'));
         try {