ucn 3.0.0 → 3.1.0

package/README.md

@@ -38,13 +38,8 @@ JavaScript, TypeScript, Python, Go, Rust, Java
 
 ## Install
 
-Not published to npm yet. Install from source:
-
 ```bash
-git clone https://github.com/mleoca/ucn.git
-cd ucn
-npm install
-npm link  # makes 'ucn' available globally
+npm install -g ucn
 ```
 
 ### Claude Code (optional)
@@ -53,6 +48,12 @@ To use UCN as a skill in Claude Code:
 
 ```bash
 mkdir -p ~/.claude/skills
+
+# If installed via npm:
+cp -r "$(npm root -g)/ucn/.claude/skills/ucn" ~/.claude/skills/
+
+# If cloned from git:
+git clone https://github.com/mleoca/ucn.git
 cp -r ucn/.claude/skills/ucn ~/.claude/skills/
 ```
 
@@ -62,6 +63,12 @@ To use UCN as a skill in OpenAI Codex:
 
 ```bash
 mkdir -p ~/.agents/skills
+
+# If installed via npm:
+cp -r "$(npm root -g)/ucn/.claude/skills/ucn" ~/.agents/skills/
+
+# If cloned from git:
+git clone https://github.com/mleoca/ucn.git
 cp -r ucn/.claude/skills/ucn ~/.agents/skills/
 ```
 

package/cli/index.js

@@ -1550,6 +1550,66 @@ function printBestExample(index, name) {
 }
 
 function printContext(ctx, options = {}) {
+    // Handle struct/interface types differently
+    if (ctx.type && ['struct', 'interface', 'type'].includes(ctx.type)) {
+        console.log(`Context for ${ctx.type} ${ctx.name}:`);
+        console.log('═'.repeat(60));
+
+        // Display warnings if any
+        if (ctx.warnings && ctx.warnings.length > 0) {
+            console.log('\n⚠️  WARNINGS:');
+            for (const w of ctx.warnings) {
+                console.log(`  ${w.message}`);
+            }
+        }
+
+        const expandable = [];
+        let itemNum = 1;
+
+        // Show methods for structs/interfaces
+        const methods = ctx.methods || [];
+        console.log(`\nMETHODS (${methods.length}):`);
+        for (const m of methods) {
+            const receiver = m.receiver ? `(${m.receiver}) ` : '';
+            const params = m.params || '...';
+            const returnType = m.returnType ? `: ${m.returnType}` : '';
+            console.log(`  [${itemNum}] ${receiver}${m.name}(${params})${returnType}`);
+            console.log(`    ${m.file}:${m.line}`);
+            expandable.push({
+                num: itemNum++,
+                type: 'method',
+                name: m.name,
+                relativePath: m.file,
+                startLine: m.line
+            });
+        }
+
+        // Show callers (type references/usages)
+        const callers = ctx.callers || [];
+        console.log(`\nUSAGES (${callers.length}):`);
+        for (const c of callers) {
+            const callerName = c.callerName || '(module level)';
+            const displayName = c.callerName ? ` [${callerName}]` : '';
+            console.log(`  [${itemNum}] ${c.relativePath}:${c.line}${displayName}`);
+            expandable.push({
+                num: itemNum++,
+                type: 'usage',
+                name: callerName,
+                file: c.callerFile || c.file,
+                relativePath: c.relativePath,
+                line: c.line,
+                startLine: c.callerStartLine || c.line,
+                endLine: c.callerEndLine || c.line
+            });
+            console.log(`    ${c.content.trim()}`);
+        }
+
+        console.log(`\nUse "ucn . expand <N>" to see code for item N`);
+        lastContextExpandable = expandable;
+        return;
+    }
+
+    // Standard function/method context
     console.log(`Context for ${ctx.function}:`);
     console.log('═'.repeat(60));
 
@@ -1565,8 +1625,9 @@ function printContext(ctx, options = {}) {
     const expandable = [];
     let itemNum = 1;
 
-    console.log(`\nCALLERS (${ctx.callers.length}):`);
-    for (const c of ctx.callers) {
+    const callers = ctx.callers || [];
+    console.log(`\nCALLERS (${callers.length}):`);
+    for (const c of callers) {
         // All callers are numbered for expand command
         const callerName = c.callerName || '(module level)';
         const displayName = c.callerName ? ` [${callerName}]` : '';
@@ -1584,8 +1645,9 @@ function printContext(ctx, options = {}) {
         console.log(`    ${c.content.trim()}`);
     }
 
-    console.log(`\nCALLEES (${ctx.callees.length}):`);
-    for (const c of ctx.callees) {
+    const callees = ctx.callees || [];
+    console.log(`\nCALLEES (${callees.length}):`);
+    for (const c of callees) {
         const weight = c.weight && c.weight !== 'normal' ? ` [${c.weight}]` : '';
         console.log(`  [${itemNum}] ${c.name}${weight} - ${c.relativePath}:${c.startLine}`);
         expandable.push({

package/core/output.js

@@ -307,25 +307,59 @@ function formatUsagesJson(usages, name) {
  * Format context (callers + callees) as JSON
  */
 function formatContextJson(context) {
+    // Handle struct/interface types differently
+    if (context.type && ['struct', 'interface', 'type'].includes(context.type)) {
+        const callers = context.callers || [];
+        const methods = context.methods || [];
+        return JSON.stringify({
+            type: context.type,
+            name: context.name,
+            file: context.file,
+            startLine: context.startLine,
+            endLine: context.endLine,
+            methodCount: methods.length,
+            usageCount: callers.length,
+            methods: methods.map(m => ({
+                name: m.name,
+                file: m.file,
+                line: m.line,
+                params: m.params,
+                returnType: m.returnType,
+                receiver: m.receiver
+            })),
+            usages: callers.map(c => ({
+                file: c.relativePath || c.file,
+                line: c.line,
+                expression: c.content,
+                callerName: c.callerName
+            })),
+            ...(context.warnings && { warnings: context.warnings })
+        }, null, 2);
+    }
+
+    // Standard function/method context
+    const callers = context.callers || [];
+    const callees = context.callees || [];
     return JSON.stringify({
         function: context.function,
         file: context.file,
-        callerCount: context.callers.length,
-        calleeCount: context.callees.length,
-        callers: context.callers.map(c => ({
+        callerCount: callers.length,
+        calleeCount: callees.length,
+        callers: callers.map(c => ({
             file: c.relativePath || c.file,
             line: c.line,
             expression: c.content,  // FULL expression
             callerName: c.callerName
         })),
-        callees: context.callees.map(c => ({
+        callees: callees.map(c => ({
             name: c.name,
             type: c.type,
             file: c.relativePath || c.file,
             line: c.startLine,
             params: c.params,  // FULL params
             weight: c.weight || 'normal'  // Dependency weight: core, setup, utility
-        }))
+        })),
+        ...(context.warnings && { warnings: context.warnings })
     }, null, 2);
 }
 

package/core/project.js

@@ -166,7 +166,11 @@ class ProjectIndex {
                 ...(item.extends && { extends: item.extends }),
                 ...(item.implements && { implements: item.implements }),
                 ...(item.indent !== undefined && { indent: item.indent }),
-                ...(item.isNested && { isNested: item.isNested })
+                ...(item.isNested && { isNested: item.isNested }),
+                ...(item.isMethod && { isMethod: item.isMethod }),
+                ...(item.receiver && { receiver: item.receiver }),
+                ...(item.className && { className: item.className }),
+                ...(item.memberType && { memberType: item.memberType })
             };
             fileEntry.symbols.push(symbol);
 
@@ -649,6 +653,55 @@ class ProjectIndex {
         return usages;
     }
 
+    /**
+     * Find methods that belong to a class/struct/type
+     * Works for:
+     * - Go: methods with receiver field (e.g., receiver: "*TypeName")
+     * - Python/Java: methods with className field
+     * - Rust: impl methods with receiver field
+     * @param {string} typeName - The class/struct/interface name
+     * @returns {Array} Methods belonging to this type
+     */
+    findMethodsForType(typeName) {
+        const methods = [];
+        // Match both "TypeName" and "*TypeName" receivers (for Go/Rust pointer receivers)
+        const baseTypeName = typeName.replace(/^\*/, '');
+
+        for (const [name, symbols] of this.symbols) {
+            for (const symbol of symbols) {
+                // Skip non-method types (fields, properties, etc.)
+                if (symbol.type === 'field' || symbol.type === 'property') {
+                    continue;
+                }
+
+                // Check Go/Rust-style receiver (e.g., func (r *Router) Method())
+                if (symbol.isMethod && symbol.receiver) {
+                    const receiverBase = symbol.receiver.replace(/^\*/, '');
+                    if (receiverBase === baseTypeName) {
+                        methods.push(symbol);
+                        continue;
+                    }
+                }
+
+                // Check Python/Java/JS-style className (class members)
+                // Must be a method type, not just any symbol with className
+                if (symbol.className === baseTypeName &&
+                    (symbol.isMethod || symbol.type === 'method' || symbol.type === 'constructor')) {
+                    methods.push(symbol);
+                    continue;
+                }
+            }
+        }
+
+        // Sort by file then line
+        methods.sort((a, b) => {
+            if (a.relativePath !== b.relativePath) return a.relativePath.localeCompare(b.relativePath);
+            return a.startLine - b.startLine;
+        });
+
+        return methods;
+    }
+
     /**
      * Get context for a symbol (callers + callees)
      */
@@ -658,7 +711,53 @@ class ProjectIndex {
             return { function: name, file: null, callers: [], callees: [] };
         }
 
-        const def = definitions[0];  // Use first definition
+        // Prefer class/struct/interface definitions over functions/methods/constructors
+        // This ensures context('ClassName') finds the class, not a constructor with same name
+        const typeOrder = ['class', 'struct', 'interface', 'type', 'impl'];
+        let def = definitions[0];
+        for (const d of definitions) {
+            if (typeOrder.includes(d.type)) {
+                def = d;
+                break;
+            }
+        }
+
+        // Special handling for class/struct/interface types
+        if (['class', 'struct', 'interface', 'type'].includes(def.type)) {
+            const methods = this.findMethodsForType(name);
+
+            const result = {
+                type: def.type,
+                name: name,
+                file: def.relativePath,
+                startLine: def.startLine,
+                endLine: def.endLine,
+                methods: methods.map(m => ({
+                    name: m.name,
+                    file: m.relativePath,
+                    line: m.startLine,
+                    params: m.params,
+                    returnType: m.returnType,
+                    receiver: m.receiver
+                })),
+                // Also include places where the type is used in function parameters/returns
+                callers: this.findCallers(name, { includeMethods: options.includeMethods })
+            };
+
+            if (definitions.length > 1) {
+                result.warnings = [{
+                    type: 'ambiguous',
+                    message: `Found ${definitions.length} definitions for "${name}". Using ${def.relativePath}:${def.startLine}. Use --file to disambiguate.`,
+                    alternatives: definitions.slice(1).map(d => ({
+                        file: d.relativePath,
+                        line: d.startLine
+                    }))
+                }];
+            }
+
+            return result;
+        }
+
         const callers = this.findCallers(name, { includeMethods: options.includeMethods });
         const callees = this.findCallees(def, { includeMethods: options.includeMethods });
 
@@ -787,8 +886,9 @@ class ProjectIndex {
                     if (call.isMethod) {
                         // Always skip this/self/cls calls (internal state access, not function calls)
                         if (['this', 'self', 'cls'].includes(call.receiver)) continue;
-                        // Skip other method calls unless explicitly requested
-                        if (!options.includeMethods) continue;
+                        // Go doesn't use this/self/cls - always include Go method calls
+                        // For other languages, skip method calls unless explicitly requested
+                        if (fileEntry.language !== 'go' && !options.includeMethods) continue;
                     }
 
                     // Skip definition lines
@@ -1594,7 +1694,14 @@ class ProjectIndex {
         for (const [name, symbols] of this.symbols) {
             for (const symbol of symbols) {
                 // Skip non-function/class types
-                if (!['function', 'class', 'method'].includes(symbol.type)) {
+                // Include various method types from different languages:
+                // - function: standalone functions
+                // - class, struct, interface: type definitions (skip them in deadcode)
+                // - method: class methods
+                // - static, public, abstract: Java method modifiers used as types
+                // - constructor: constructors
+                const callableTypes = ['function', 'method', 'static', 'public', 'abstract', 'constructor'];
+                if (!callableTypes.includes(symbol.type)) {
                     continue;
                 }
 
@@ -1605,11 +1712,33 @@ class ProjectIndex {
 
                 // Check if exported
                 const fileEntry = this.files.get(symbol.file);
+                const lang = fileEntry?.language;
+                const mods = symbol.modifiers || [];
+
+                // Language-specific entry points (called by runtime, no AST-visible callers)
+                // Go: main() and init() are called by runtime
+                const isGoEntryPoint = lang === 'go' && (name === 'main' || name === 'init');
+
+                // Java: public static void main(String[] args) is the entry point
+                const isJavaEntryPoint = lang === 'java' && name === 'main' &&
+                    mods.includes('public') && mods.includes('static');
+
+                // Python: Magic/dunder methods are called by the interpreter, not user code
+                const isPythonMagicMethod = lang === 'python' && /^__\w+__$/.test(name);
+
+                // Rust: main() is entry point, #[test] functions are called by test runner
+                const isRustEntryPoint = lang === 'rust' &&
+                    (name === 'main' || mods.includes('test'));
+
+                const isEntryPoint = isGoEntryPoint || isJavaEntryPoint ||
+                    isPythonMagicMethod || isRustEntryPoint;
+
                 const isExported = fileEntry && (
                     fileEntry.exports.includes(name) ||
-                    (symbol.modifiers && symbol.modifiers.includes('export')) ||
-                    (symbol.modifiers && symbol.modifiers.includes('public')) ||
-                    (fileEntry.language === 'go' && /^[A-Z]/.test(name))
+                    mods.includes('export') ||
+                    mods.includes('public') ||
+                    (lang === 'go' && /^[A-Z]/.test(name)) ||
+                    isEntryPoint
                 );
 
                 // Skip exported unless requested
@@ -3130,7 +3259,7 @@ class ProjectIndex {
         }
 
         const cacheData = {
-            version: 2,  // Bump version for new cache format
+            version: 4,  // v4: className, memberType, isMethod for all languages
             root: this.root,
             buildTime: this.buildTime,
             timestamp: Date.now(),
@@ -3163,8 +3292,10 @@ class ProjectIndex {
         try {
             const cacheData = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
 
-            // Check version compatibility (support v1 and v2)
-            if (cacheData.version !== 1 && cacheData.version !== 2) {
+            // Check version compatibility
+            // v4 adds className, memberType, isMethod for all languages
+            // Only accept exactly version 4 (or future versions handled explicitly)
+            if (cacheData.version !== 4) {
                 return false;
             }
 

package/languages/java.js

@@ -111,6 +111,12 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
+            // Skip methods inside a class body (they're extracted as class members)
+            let parent = node.parent;
+            if (parent && parent.type === 'class_body') {
+                return true;  // Skip - this is a class method
+            }
+
             const nameNode = node.childForFieldName('name');
             const paramsNode = node.childForFieldName('parameters');
 
@@ -393,6 +399,7 @@ function extractClassMembers(classNode, code) {
                     endLine,
                     memberType,
                     modifiers,
+                    isMethod: true,  // Mark as method for context() lookups
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring })
                 });
@@ -417,6 +424,7 @@ function extractClassMembers(classNode, code) {
                     endLine,
                     memberType: 'constructor',
                     modifiers,
+                    isMethod: true,  // Mark as method for context() lookups
                     ...(docstring && { docstring })
                 });
             }

package/languages/javascript.js

@@ -531,6 +531,7 @@ function extractClassMembers(classNode, code) {
                     memberType,
                     isAsync,
                     isGenerator: isGen,
+                    isMethod: true,  // Mark as method for context() lookups
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring })
                 });
@@ -557,6 +558,7 @@ function extractClassMembers(classNode, code) {
                         endLine,
                         memberType: name.startsWith('#') ? 'private' : 'field',
                         isArrow: true,
+                        isMethod: true,  // Arrow fields are callable like methods
                         ...(returnType && { returnType })
                     });
                 } else {
@@ -565,6 +567,7 @@ function extractClassMembers(classNode, code) {
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private field' : 'field'
+                        // Not a method - regular field
                     });
                 }
             }

package/languages/python.js

@@ -73,6 +73,20 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
+            // Skip functions that are inside a class (they're extracted as class members)
+            let parent = node.parent;
+            // Handle decorated_definition wrapper
+            if (parent && parent.type === 'decorated_definition') {
+                parent = parent.parent;
+            }
+            // Check if parent is a class body (block inside class_definition)
+            if (parent && parent.type === 'block') {
+                const grandparent = parent.parent;
+                if (grandparent && grandparent.type === 'class_definition') {
+                    return true;  // Skip - this is a class method
+                }
+            }
+
             const nameNode = node.childForFieldName('name');
             const paramsNode = node.childForFieldName('parameters');
 
@@ -282,6 +296,7 @@ function extractClassMembers(classNode, code) {
                     endLine,
                     memberType,
                     isAsync,
+                    isMethod: true,  // Mark as method for context() lookups
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators })

package/languages/rust.js

@@ -51,6 +51,39 @@ function extractVisibility(text) {
     return null;
 }
 
+/**
+ * Extract attributes from a function node (e.g., #[test], #[tokio::main])
+ * @param {Node} node - AST node
+ * @param {string} code - Source code
+ * @returns {string[]} Array of attribute names
+ */
+function extractAttributes(node, code) {
+    const attributes = [];
+    const lines = code.split('\n');
+
+    // Look at lines before the function for attributes
+    const startLine = node.startPosition.row;
+    for (let i = startLine - 1; i >= 0 && i >= startLine - 5; i--) {
+        const line = lines[i]?.trim();
+        if (!line) continue;
+        if (line.startsWith('#[')) {
+            // Extract attribute name (e.g., #[test] -> test, #[tokio::main] -> tokio::main)
+            const match = line.match(/#\[([^\]]+)\]/);
+            if (match) {
+                const attrContent = match[1];
+                // Get just the attribute name (without arguments)
+                const attrName = attrContent.split('(')[0].trim();
+                attributes.push(attrName);
+            }
+        } else if (!line.startsWith('//')) {
+            // Stop at non-comment, non-attribute lines
+            break;
+        }
+    }
+
+    return attributes;
+}
+
 /**
  * Find all functions in Rust code using tree-sitter
  */
@@ -66,6 +99,19 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
+            // Skip functions inside impl blocks (they're extracted as impl members)
+            let parent = node.parent;
+            if (parent && (parent.type === 'impl_item' || parent.type === 'declaration_list')) {
+                // declaration_list is the body of an impl block
+                const grandparent = parent.parent;
+                if (grandparent && grandparent.type === 'impl_item') {
+                    return true;  // Skip - this is an impl method
+                }
+                if (parent.type === 'impl_item') {
+                    return true;  // Skip - this is an impl method
+                }
+            }
+
             const nameNode = node.childForFieldName('name');
             const paramsNode = node.childForFieldName('parameters');
 
@@ -81,12 +127,17 @@ function findFunctions(code, parser) {
                 const returnType = extractReturnType(node);
                 const docstring = extractRustDocstring(code, startLine);
                 const generics = extractGenerics(node);
+                const attributes = extractAttributes(node, code);
 
                 const modifiers = [];
                 if (visibility) modifiers.push(visibility);
                 if (isAsync) modifiers.push('async');
                 if (isUnsafe) modifiers.push('unsafe');
                 if (isConst) modifiers.push('const');
+                // Add attributes like #[test] to modifiers
+                for (const attr of attributes) {
+                    modifiers.push(attr);
+                }
 
                 functions.push({
                     name: nameNode.text,
@@ -228,7 +279,7 @@ function findClasses(code, parser) {
                 type: 'impl',
                 traitName: implInfo.traitName,
                 typeName: implInfo.typeName,
-                members: extractImplMembers(node, code),
+                members: extractImplMembers(node, code, implInfo.typeName),
                 modifiers: [],
                 ...(docstring && { docstring })
             });
@@ -390,8 +441,11 @@ function extractImplInfo(implNode) {
 
 /**
  * Extract impl block members (functions)
+ * @param {Node} implNode - The impl block AST node
+ * @param {string} code - Source code
+ * @param {string} [typeName] - The type this impl is for (e.g., "MyStruct")
  */
-function extractImplMembers(implNode, code) {
+function extractImplMembers(implNode, code, typeName) {
     const members = [];
     const bodyNode = implNode.childForFieldName('body');
     if (!bodyNode) return members;
@@ -411,6 +465,9 @@ function extractImplMembers(implNode, code) {
                 const docstring = extractRustDocstring(code, startLine);
                 const visibility = extractVisibility(text);
 
+                // Check if this is a method (has self parameter) or associated function
+                const hasSelf = paramsNode && paramsNode.text.includes('self');
+
                 members.push({
                     name: nameNode.text,
                     params: extractRustParams(paramsNode),
@@ -419,6 +476,8 @@ function extractImplMembers(implNode, code) {
                     endLine,
                     memberType: visibility ? 'public' : 'method',
                     isAsync: firstLine.includes('async '),
+                    isMethod: true,  // Mark as method for context() lookups
+                    ...(typeName && { receiver: typeName }),  // Track which type this impl is for
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring })
                 });

package/package.json

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

package/test/parser.test.js

@@ -3557,7 +3557,7 @@ function helper() { return 42; }
 
             // Verify cache file has callsCache
             const cacheData = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
-            assert.strictEqual(cacheData.version, 2, 'Cache version should be 2');
+            assert.strictEqual(cacheData.version, 4, 'Cache version should be 4 (className, memberType, isMethod for all languages)');
             assert.ok(Array.isArray(cacheData.callsCache), 'Cache should have callsCache array');
             assert.ok(cacheData.callsCache.length > 0, 'callsCache should have entries');
 
@@ -3657,5 +3657,647 @@ function helper() { return 42; }
     });
 });
 
+// ============================================================================
+// REGRESSION TESTS: Go-specific bug fixes (2026-02)
+// ============================================================================
+
+describe('Regression: Go entry points not flagged as deadcode', () => {
+    it('should NOT report main() as dead code in Go', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-main-'));
+        try {
+            // Create a Go project with main and init functions
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), 'module example.com/test\n\ngo 1.21\n');
+            fs.writeFileSync(path.join(tmpDir, 'main.go'), `package main
+
+func main() {
+    run()
+}
+
+func init() {
+    setup()
+}
+
+func run() {
+    println("running")
+}
+
+func setup() {
+    println("setup")
+}
+
+func unusedHelper() {
+    println("unused")
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            const deadcode = index.deadcode();
+            const deadNames = deadcode.map(d => d.name);
+
+            // main and init should NOT be reported as dead
+            assert.ok(!deadNames.includes('main'), 'main() should not be flagged as dead code');
+            assert.ok(!deadNames.includes('init'), 'init() should not be flagged as dead code');
+
+            // run and setup are called, so not dead
+            assert.ok(!deadNames.includes('run'), 'run() is called by main, not dead');
+            assert.ok(!deadNames.includes('setup'), 'setup() is called by init, not dead');
+
+            // unusedHelper should be flagged as dead
+            assert.ok(deadNames.includes('unusedHelper'), 'unusedHelper() should be flagged as dead code');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Go method calls included in findCallers', () => {
+    it('should find Go method call sites without --include-methods flag', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-methods-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), 'module example.com/test\n\ngo 1.21\n');
+            fs.writeFileSync(path.join(tmpDir, 'server.go'), `package main
+
+type Server struct {
+    port int
+}
+
+func (s *Server) Start() {
+    s.listen()
+}
+
+func (s *Server) listen() {
+    println("listening on", s.port)
+}
+
+func main() {
+    srv := &Server{port: 8080}
+    srv.Start()
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Find callers of Start method - should find the call in main
+            const callers = index.findCallers('Start');
+
+            assert.strictEqual(callers.length, 1, 'Should find 1 caller for Start method');
+            assert.strictEqual(callers[0].callerName, 'main', 'Caller should be main function');
+            assert.ok(callers[0].content.includes('srv.Start()'), 'Should capture the method call');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should still filter this/self/cls in non-Go languages', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-py-self-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'app.py'), `class Server:
+    def __init__(self, port):
+        self.port = port
+
+    def start(self):
+        self.listen()
+
+    def listen(self):
+        print(f"listening on {self.port}")
+
+def main():
+    srv = Server(8080)
+    srv.start()
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.py', { quiet: true });
+
+            // self.listen() should be filtered out (self call)
+            // but srv.start() should be included (external call)
+            const listenCallers = index.findCallers('listen');
+            // self.listen() is internal, so it depends on implementation
+            // At minimum, without --include-methods, non-self calls should not show
+
+            const startCallers = index.findCallers('start');
+            // srv.start() is a method call with receiver 'srv', which is not this/self/cls
+            // But since it's Python (not Go), it should be filtered unless --include-methods
+            assert.strictEqual(startCallers.length, 0, 'Python method calls should be filtered by default');
+
+            // With --include-methods, should find the call
+            const startCallersIncluded = index.findCallers('start', { includeMethods: true });
+            assert.strictEqual(startCallersIncluded.length, 1, 'With includeMethods, should find srv.start()');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: context for structs shows methods', () => {
+    it('should return methods for Go struct types', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-struct-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), 'module example.com/test\n\ngo 1.21\n');
+            fs.writeFileSync(path.join(tmpDir, 'types.go'), `package main
+
+type User struct {
+    Name  string
+    Email string
+}
+
+func (u *User) Validate() bool {
+    return u.Name != "" && u.Email != ""
+}
+
+func (u *User) String() string {
+    return u.Name + " <" + u.Email + ">"
+}
+
+func (u User) IsEmpty() bool {
+    return u.Name == "" && u.Email == ""
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            const ctx = index.context('User');
+
+            // Should identify as struct type
+            assert.strictEqual(ctx.type, 'struct', 'User should be identified as struct');
+            assert.strictEqual(ctx.name, 'User', 'Should return correct name');
+
+            // Should have methods
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 3, 'User struct should have 3 methods');
+
+            const methodNames = ctx.methods.map(m => m.name);
+            assert.ok(methodNames.includes('Validate'), 'Should include Validate method');
+            assert.ok(methodNames.includes('String'), 'Should include String method');
+            assert.ok(methodNames.includes('IsEmpty'), 'Should include IsEmpty method');
+
+            // Methods should have receiver info
+            const validateMethod = ctx.methods.find(m => m.name === 'Validate');
+            assert.strictEqual(validateMethod.receiver, '*User', 'Validate has pointer receiver');
+
+            const isEmptyMethod = ctx.methods.find(m => m.name === 'IsEmpty');
+            assert.strictEqual(isEmptyMethod.receiver, 'User', 'IsEmpty has value receiver');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should return empty methods for struct with no methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-struct-empty-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), 'module example.com/test\n\ngo 1.21\n');
+            fs.writeFileSync(path.join(tmpDir, 'types.go'), `package main
+
+type Config struct {
+    Port int
+    Host string
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            const ctx = index.context('Config');
+
+            assert.strictEqual(ctx.type, 'struct', 'Config should be identified as struct');
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 0, 'Config struct should have 0 methods');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: receiver field preserved in Go method symbols', () => {
+    it('should store receiver info for Go methods in symbol index', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-receiver-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), 'module example.com/test\n\ngo 1.21\n');
+            fs.writeFileSync(path.join(tmpDir, 'handler.go'), `package main
+
+type Handler struct{}
+
+func (h *Handler) ServeHTTP(w, r) {
+    h.handleRequest(w, r)
+}
+
+func (h *Handler) handleRequest(w, r) {
+    println("handling")
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Check that receiver is preserved in symbols
+            const serveHTTP = index.symbols.get('ServeHTTP');
+            assert.ok(serveHTTP, 'ServeHTTP should be indexed');
+            assert.strictEqual(serveHTTP.length, 1, 'Should have one definition');
+            assert.strictEqual(serveHTTP[0].receiver, '*Handler', 'Receiver should be *Handler');
+            assert.strictEqual(serveHTTP[0].isMethod, true, 'Should be marked as method');
+
+            const handleRequest = index.symbols.get('handleRequest');
+            assert.ok(handleRequest, 'handleRequest should be indexed');
+            assert.strictEqual(handleRequest[0].receiver, '*Handler', 'Receiver should be *Handler');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+// ============================================================================
+// REGRESSION TESTS: Multi-language class/method handling (2026-02)
+// ============================================================================
+
+describe('Regression: Python class methods in context', () => {
+    it('should show methods for Python classes via className', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-py-class-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'user.py'), `class User:
+    def __init__(self, name):
+        self.name = name
+
+    def greet(self):
+        return f"Hello {self.name}"
+
+    def validate(self):
+        return len(self.name) > 0
+
+    @staticmethod
+    def create(name):
+        return User(name)
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.py', { quiet: true });
+
+            const ctx = index.context('User');
+
+            // Should identify as class
+            assert.strictEqual(ctx.type, 'class', 'User should be identified as class');
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 4, 'User class should have 4 methods');
+
+            const methodNames = ctx.methods.map(m => m.name);
+            assert.ok(methodNames.includes('__init__'), 'Should include __init__');
+            assert.ok(methodNames.includes('greet'), 'Should include greet');
+            assert.ok(methodNames.includes('validate'), 'Should include validate');
+            assert.ok(methodNames.includes('create'), 'Should include create');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Java class methods in context', () => {
+    it('should show methods for Java classes via className', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-java-class-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'User.java'), `public class User {
+    private String name;
+
+    public User(String name) {
+        this.name = name;
+    }
+
+    public String greet() {
+        return "Hello " + this.name;
+    }
+
+    public boolean validate() {
+        return this.name != null && this.name.length() > 0;
+    }
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.java', { quiet: true });
+
+            const ctx = index.context('User');
+
+            // Should identify as class
+            assert.strictEqual(ctx.type, 'class', 'User should be identified as class');
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 3, 'User class should have 3 methods (constructor + 2 methods)');
+
+            const methodNames = ctx.methods.map(m => m.name);
+            assert.ok(methodNames.includes('User'), 'Should include constructor User');
+            assert.ok(methodNames.includes('greet'), 'Should include greet');
+            assert.ok(methodNames.includes('validate'), 'Should include validate');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Rust impl methods in context', () => {
+    it('should show impl methods for Rust structs via receiver', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-rust-impl-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'Cargo.toml'), `[package]
+name = "test"
+version = "0.1.0"
+`);
+            fs.writeFileSync(path.join(tmpDir, 'lib.rs'), `pub struct User {
+    name: String,
+}
+
+impl User {
+    pub fn new(name: String) -> Self {
+        User { name }
+    }
+
+    pub fn greet(&self) -> String {
+        format!("Hello {}", self.name)
+    }
+
+    fn validate(&self) -> bool {
+        !self.name.is_empty()
+    }
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.rs', { quiet: true });
+
+            const ctx = index.context('User');
+
+            // Should identify as struct
+            assert.strictEqual(ctx.type, 'struct', 'User should be identified as struct');
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 3, 'User impl should have 3 methods');
+
+            const methodNames = ctx.methods.map(m => m.name);
+            assert.ok(methodNames.includes('new'), 'Should include new');
+            assert.ok(methodNames.includes('greet'), 'Should include greet');
+            assert.ok(methodNames.includes('validate'), 'Should include validate');
+
+            // Methods should have receiver info pointing to User
+            const greetMethod = ctx.methods.find(m => m.name === 'greet');
+            assert.strictEqual(greetMethod.receiver, 'User', 'greet should have User as receiver');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: JavaScript class methods in context', () => {
+    it('should show methods for JS classes via className', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-js-class-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'user.js'), `class User {
+    constructor(name) {
+        this.name = name;
+    }
+
+    greet() {
+        return 'Hello ' + this.name;
+    }
+
+    static create(name) {
+        return new User(name);
+    }
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.js', { quiet: true });
+
+            const ctx = index.context('User');
+
+            // Should identify as class
+            assert.strictEqual(ctx.type, 'class', 'User should be identified as class');
+            assert.ok(ctx.methods, 'Should have methods array');
+            assert.strictEqual(ctx.methods.length, 3, 'User class should have 3 methods');
+
+            const methodNames = ctx.methods.map(m => m.name);
+            assert.ok(methodNames.includes('constructor'), 'Should include constructor');
+            assert.ok(methodNames.includes('greet'), 'Should include greet');
+            assert.ok(methodNames.includes('create'), 'Should include create');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Java main() not flagged as deadcode', () => {
+    it('should NOT report public static main as dead code in Java', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-java-main-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'App.java'), `public class App {
+    public static void main(String[] args) {
+        System.out.println("Hello");
+        helper();
+    }
+
+    private static void helper() {
+        System.out.println("Helper");
+    }
+
+    private static void unusedMethod() {
+        System.out.println("Unused");
+    }
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.java', { quiet: true });
+
+            const deadcode = index.deadcode();
+            const deadNames = deadcode.map(d => d.name);
+
+            // main should NOT be flagged as dead code (entry point)
+            assert.ok(!deadNames.includes('main'), 'main() should not be flagged as dead code');
+
+            // helper is called by main, so not dead
+            assert.ok(!deadNames.includes('helper'), 'helper() is called by main, not dead');
+
+            // unusedMethod should be flagged as dead
+            assert.ok(deadNames.includes('unusedMethod'), 'unusedMethod() should be flagged as dead code');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Python magic methods not flagged as deadcode', () => {
+    it('should NOT report __init__, __call__, __enter__, __exit__ as dead code', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-py-magic-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'context.py'), `class MyContext:
+    def __init__(self):
+        self.count = 0
+
+    def __enter__(self):
+        self.count += 1
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.count -= 1
+        return False
+
+    def __call__(self, x):
+        return x * 2
+
+    def unused_method(self):
+        pass
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.py', { quiet: true });
+
+            const deadcode = index.deadcode();
+            const deadNames = deadcode.map(d => d.name);
+
+            // Magic methods should NOT be flagged as dead code
+            assert.ok(!deadNames.includes('__init__'), '__init__ should not be flagged as dead code');
+            assert.ok(!deadNames.includes('__enter__'), '__enter__ should not be flagged as dead code');
+            assert.ok(!deadNames.includes('__exit__'), '__exit__ should not be flagged as dead code');
+            assert.ok(!deadNames.includes('__call__'), '__call__ should not be flagged as dead code');
+
+            // unused_method should be flagged as dead
+            assert.ok(deadNames.includes('unused_method'), 'unused_method() should be flagged as dead code');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: Rust main and #[test] not flagged as deadcode', () => {
+    it('should NOT report main() or #[test] functions as dead code in Rust', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-rust-main-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'Cargo.toml'), `[package]
+name = "test"
+version = "0.1.0"
+`);
+            fs.writeFileSync(path.join(tmpDir, 'main.rs'), `fn main() {
+    helper();
+}
+
+fn helper() {
+    println!("Helper");
+}
+
+fn unused_fn() {
+    println!("Unused");
+}
+
+#[test]
+fn test_something() {
+    assert!(true);
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.rs', { quiet: true });
+
+            const deadcode = index.deadcode();
+            const deadNames = deadcode.map(d => d.name);
+
+            // main should NOT be flagged as dead code (entry point)
+            assert.ok(!deadNames.includes('main'), 'main() should not be flagged as dead code');
+
+            // test_something should NOT be flagged (has #[test] attribute)
+            assert.ok(!deadNames.includes('test_something'), '#[test] function should not be flagged as dead code');
+
+            // helper is called by main
+            assert.ok(!deadNames.includes('helper'), 'helper() is called by main, not dead');
+
+            // unused_fn should be flagged as dead
+            assert.ok(deadNames.includes('unused_fn'), 'unused_fn() should be flagged as dead code');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('Regression: className field preserved in symbol index', () => {
+    it('should store className for Python class methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-classname-py-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'models.py'), `class User:
+    def save(self):
+        pass
+
+class Product:
+    def save(self):
+        pass
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.py', { quiet: true });
+
+            // Both save methods should have className field
+            const saveMethods = index.symbols.get('save');
+            assert.ok(saveMethods, 'save methods should be indexed');
+            assert.strictEqual(saveMethods.length, 2, 'Should have 2 save methods');
+
+            const classNames = saveMethods.map(m => m.className).sort();
+            assert.deepStrictEqual(classNames, ['Product', 'User'], 'Should have User and Product as classNames');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should store className for Java class methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-classname-java-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'Models.java'), `class User {
+    public void save() {}
+}
+
+class Product {
+    public void save() {}
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.java', { quiet: true });
+
+            // Both save methods should have className field
+            const saveMethods = index.symbols.get('save');
+            assert.ok(saveMethods, 'save methods should be indexed');
+            assert.strictEqual(saveMethods.length, 2, 'Should have 2 save methods');
+
+            const classNames = saveMethods.map(m => m.className).sort();
+            assert.deepStrictEqual(classNames, ['Product', 'User'], 'Should have User and Product as classNames');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+
+    it('should store className for JavaScript class methods', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-classname-js-'));
+        try {
+            fs.writeFileSync(path.join(tmpDir, 'models.js'), `class User {
+    save() {}
+}
+
+class Product {
+    save() {}
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.js', { quiet: true });
+
+            // Both save methods should have className field
+            const saveMethods = index.symbols.get('save');
+            assert.ok(saveMethods, 'save methods should be indexed');
+            assert.strictEqual(saveMethods.length, 2, 'Should have 2 save methods');
+
+            const classNames = saveMethods.map(m => m.className).sort();
+            assert.deepStrictEqual(classNames, ['Product', 'User'], 'Should have User and Product as classNames');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+
 console.log('UCN v3 Test Suite');
 console.log('Run with: node --test test/parser.test.js');