ucn 3.8.7 → 3.8.9

package/cli/index.js

@@ -760,7 +760,7 @@ function runProjectCommand(rootDir, command, arg) {
         }
 
         case 'entrypoints': {
-            const { ok, result, error } = execute(index, 'entrypoints', { type: flags.type, framework: flags.framework, file: flags.file });
+            const { ok, result, error } = execute(index, 'entrypoints', { type: flags.type, framework: flags.framework, file: flags.file, exclude: flags.exclude });
             if (!ok) fail(error);
             printOutput(result,
                 output.formatEntrypointsJson,
@@ -1389,7 +1389,7 @@ function executeInteractiveCommand(index, command, arg, iflags = {}, cache = nul
         }
 
         case 'entrypoints': {
-            const { ok, result, error } = execute(index, 'entrypoints', { type: iflags.type, framework: iflags.framework, file: iflags.file });
+            const { ok, result, error } = execute(index, 'entrypoints', { type: iflags.type, framework: iflags.framework, file: iflags.file, exclude: iflags.exclude });
             if (!ok) { console.log(error); return; }
             console.log(output.formatEntrypoints(result));
             break;

package/core/entrypoints.js

@@ -209,15 +209,15 @@ const FRAMEWORK_PATTERNS = [
     // ── Go Framework Patterns ─────────────────────────────────────────
 
     // Cobra CLI framework — RunE, Run, PreRunE etc. assigned to cobra.Command struct fields
-    // Detected via call-pattern: cobra.Command composite literals with function value fields
+    // Detected via composite literal: &cobra.Command{RunE: handler}
     {
         id: 'cobra-command',
         languages: new Set(['go']),
         type: 'cli',
         framework: 'cobra',
-        detection: 'callPattern',
-        receiverPattern: /^cobra$/i,
-        methodPattern: /^Command$/,
+        detection: 'compositePattern',
+        typePattern: /^cobra\.Command$/,
+        fieldPattern: /^(Run|RunE|PreRun|PreRunE|PostRun|PostRunE|PersistentPreRun|PersistentPreRunE|PersistentPostRun|PersistentPostRunE)$/,
     },
 
     // Go goroutine launch — go func() or go handler()
@@ -289,50 +289,77 @@ function matchDecoratorOrModifier(symbol, language) {
  */
 function buildCallbackEntrypointMap(index) {
     const callPatterns = FRAMEWORK_PATTERNS.filter(p => p.detection === 'callPattern');
-    if (callPatterns.length === 0) return new Map();
+    const compositePatterns = FRAMEWORK_PATTERNS.filter(p => p.detection === 'compositePattern');
+    if (callPatterns.length === 0 && compositePatterns.length === 0) return new Map();
 
     const result = new Map(); // name -> info
 
     for (const [filePath, fileEntry] of index.files) {
         const lang = fileEntry.language;
-        const relevantPatterns = callPatterns.filter(p => p.languages.has(lang));
-        if (relevantPatterns.length === 0) continue;
 
         const calls = getCachedCalls(index, filePath);
         if (!calls) continue;
 
-        // Pass 1: find route-registration calls, index by line
-        // Match both method calls (obj.method) and package-qualified calls (pkg.Func)
-        const routeLines = new Map(); // line -> { pattern, call }
-        for (const call of calls) {
-            if (!call.receiver) continue;
-            for (const pattern of relevantPatterns) {
-                if (pattern.receiverPattern.test(call.receiver) &&
-                    pattern.methodPattern.test(call.name)) {
-                    routeLines.set(call.line, { pattern, call });
-                    break;
+        // Pass 1+2: call-pattern detection (e.g., app.GET("/", handler))
+        const relevantCallPatterns = callPatterns.filter(p => p.languages.has(lang));
+        if (relevantCallPatterns.length > 0) {
+            // Pass 1: find route-registration calls, index by line
+            const routeLines = new Map(); // line -> { pattern, call }
+            for (const call of calls) {
+                if (!call.receiver) continue;
+                for (const pattern of relevantCallPatterns) {
+                    if (pattern.receiverPattern.test(call.receiver) &&
+                        pattern.methodPattern.test(call.name)) {
+                        routeLines.set(call.line, { pattern, call });
+                        break;
+                    }
+                }
+            }
+
+            if (routeLines.size > 0) {
+                // Pass 2: find callbacks on route-registration lines
+                for (const call of calls) {
+                    if (!call.isFunctionReference && !call.isPotentialCallback) continue;
+                    const route = routeLines.get(call.line);
+                    if (!route) continue;
+
+                    if (!result.has(call.name)) {
+                        result.set(call.name, {
+                            framework: route.pattern.framework,
+                            type: route.pattern.type,
+                            patternId: route.pattern.id,
+                            method: route.call.name.toUpperCase(),
+                            file: filePath,
+                            line: call.line,
+                        });
+                    }
                 }
             }
         }
 
-        if (routeLines.size === 0) continue;
-
-        // Pass 2: find callbacks on route-registration lines
-        for (const call of calls) {
-            if (!call.isFunctionReference && !call.isPotentialCallback) continue;
-            const route = routeLines.get(call.line);
-            if (!route) continue;
-
-            // This callback is registered as a framework handler
-            if (!result.has(call.name)) {
-                result.set(call.name, {
-                    framework: route.pattern.framework,
-                    type: route.pattern.type,
-                    patternId: route.pattern.id,
-                    method: route.call.name.toUpperCase(),
-                    file: filePath,
-                    line: call.line,
-                });
+        // Pass 3: composite literal patterns (e.g., &cobra.Command{RunE: handler})
+        const relevantCompositePatterns = compositePatterns.filter(p => p.languages.has(lang));
+        if (relevantCompositePatterns.length > 0) {
+            for (const call of calls) {
+                if (!call.compositeType) continue;
+                if (!call.isPotentialCallback && !call.isFunctionReference) continue;
+
+                for (const pattern of relevantCompositePatterns) {
+                    if (pattern.typePattern.test(call.compositeType) &&
+                        pattern.fieldPattern.test(call.fieldName)) {
+                        if (!result.has(call.name)) {
+                            result.set(call.name, {
+                                framework: pattern.framework,
+                                type: pattern.type,
+                                patternId: pattern.id,
+                                method: call.fieldName,
+                                file: filePath,
+                                line: call.line,
+                            });
+                        }
+                        break;
+                    }
+                }
             }
         }
     }
@@ -449,6 +476,15 @@ function detectEntrypoints(index, options = {}) {
         filtered = filtered.filter(e => e.file.includes(options.file));
     }
 
+    if (options.exclude) {
+        const raw = Array.isArray(options.exclude) ? options.exclude : options.exclude.split(',');
+        const patterns = raw.map(s => s.trim()).filter(Boolean);
+        if (patterns.length > 0) {
+            const regexes = patterns.map(p => new RegExp(`(^|[/._-])${p}s?([/._-]|$)`, 'i'));
+            filtered = filtered.filter(e => !regexes.some(r => r.test(e.file)));
+        }
+    }
+
     // Sort by file, then line
     filtered.sort((a, b) => {
         if (a.file !== b.file) return a.file.localeCompare(b.file);

package/core/execute.js

@@ -595,6 +595,7 @@ const HANDLERS = {
             type: p.type,
             framework: p.framework,
             file: p.file,
+            exclude: p.exclude,
         });
         return { ok: true, result };
     },

package/core/output.js

@@ -3122,6 +3122,7 @@ function formatEntrypoints(results, options = {}) {
 
     const typeLabels = {
         http: 'HTTP Routes',
+        cli: 'CLI Handlers',
         di: 'Dependency Injection',
         jobs: 'Job Schedulers',
         test: 'Test Fixtures',

package/languages/go.js

@@ -954,6 +954,31 @@ function findCallsInCode(code, parser, options = {}) {
                 valueNode = valueNode.namedChildCount > 0 ? valueNode.namedChild(0) : null;
             }
             if (valueNode) {
+                // Extract field name (the key) and parent composite literal type
+                let keyNode = node.namedChildCount >= 1 ? node.namedChild(0) : null;
+                if (keyNode && keyNode.type === 'literal_element') {
+                    keyNode = keyNode.namedChildCount > 0 ? keyNode.namedChild(0) : null;
+                }
+                const fieldName = keyNode ? keyNode.text : undefined;
+
+                let compositeType;
+                let compositeLit = node.parent; // literal_value
+                if (compositeLit && compositeLit.type === 'literal_value') {
+                    compositeLit = compositeLit.parent; // composite_literal
+                }
+                if (compositeLit && compositeLit.type === 'composite_literal') {
+                    const typeNode = compositeLit.childForFieldName('type');
+                    if (typeNode) {
+                        if (typeNode.type === 'qualified_type') {
+                            const pkg = typeNode.childForFieldName('package')?.text;
+                            const typeName = typeNode.childForFieldName('name')?.text;
+                            compositeType = pkg && typeName ? `${pkg}.${typeName}` : typeNode.text;
+                        } else if (typeNode.type === 'type_identifier') {
+                            compositeType = typeNode.text;
+                        }
+                    }
+                }
+
                 if (valueNode.type === 'identifier') {
                     const name = valueNode.text;
                     if (!GO_SKIP_IDENTS.has(name) && !GO_BUILTINS.has(name) && !importAliases.has(name) && /^[a-zA-Z]/.test(name)) {
@@ -965,7 +990,9 @@ function findCallsInCode(code, parser, options = {}) {
                             isFunctionReference: true,
                             isPotentialCallback: true,
                             enclosingFunction,
-                            uncertain: false
+                            uncertain: false,
+                            ...(compositeType && { compositeType }),
+                            ...(fieldName && { fieldName }),
                         });
                     }
                 }
@@ -984,7 +1011,28 @@ function findCallsInCode(code, parser, options = {}) {
                             ...(receiverType && { receiverType }),
                             enclosingFunction,
                             isPotentialCallback: true,
-                            uncertain: false
+                            uncertain: false,
+                            ...(compositeType && { compositeType }),
+                            ...(fieldName && { fieldName }),
+                        });
+                    }
+                }
+                // Inline closure: RunE: func(cmd *cobra.Command, args []string) { ... }
+                // Mark the enclosing function as the entry point (the closure itself has no name)
+                if (valueNode.type === 'func_literal' && compositeType && fieldName) {
+                    const enclosing = getCurrentEnclosingFunction();
+                    const enclosingName = typeof enclosing === 'string' ? enclosing : enclosing?.name;
+                    if (enclosingName) {
+                        calls.push({
+                            name: enclosingName,
+                            line: valueNode.startPosition.row + 1,
+                            isMethod: false,
+                            isFunctionReference: false,
+                            isPotentialCallback: true,
+                            enclosingFunction: enclosing,
+                            uncertain: false,
+                            compositeType,
+                            fieldName,
                         });
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.8.7",
+  "version": "3.8.9",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",