ucn 3.8.16 → 3.8.17

package/.claude/skills/ucn/SKILL.md

@@ -157,11 +157,11 @@ ucn [target] <command> [name] [--flags]
 
 | Flag | When to use it |
 |------|---------------|
-| `--class-name=X` | Scope to specific class (e.g., `--class-name=Repository` for method `save`) |
+| `--class-name=X` | Scope to specific class (e.g., `--class-name=Repository` for method `save`). Works with `fn`, `about`, `context`, `impact`, `tests`, `example`, `typedef`, `verify`, `plan` |
 | `--file=<pattern>` | Disambiguate when a name exists in multiple files (e.g., `--file=api`) |
 | `--exclude=test,mock` | Focus on production code only |
 | `--in=src/core` | Limit search to a subdirectory |
-| `--depth=N` | Control tree depth for `trace` and `graph` (default 3). Also expands all children — no breadth limit |
+| `--depth=N` | Control tree depth for `trace`, `graph`, and detail level for `find` (default 3). Also expands all children — no breadth limit |
 | `--all` | Expand truncated sections in `about`, `trace`, `graph`, `related` |
 | `--include-tests` | Include test files in results (excluded by default) |
 | `--include-methods` | Include `obj.method()` calls in `context`/`smart` (only direct calls shown by default) |

package/cli/index.js

@@ -658,7 +658,7 @@ function runProjectCommand(rootDir, command, arg) {
 
         case 'class': {
             requireArg(arg, 'Usage: ucn . class <name>');
-            const { ok, result, error, note } = execute(index, 'class', { name: arg, file: flags.file, all: flags.all, maxLines: flags.maxLines, className: flags.className });
+            const { ok, result, error, note } = execute(index, 'class', { name: arg, file: flags.file, all: flags.all, maxLines: flags.maxLines });
             if (!ok) fail(error);
             if (note) console.error(note);
             printOutput(result, output.formatClassResultJson, output.formatClassResult);
@@ -703,7 +703,7 @@ function runProjectCommand(rootDir, command, arg) {
             const { ok, result, error } = execute(index, 'fileExports', { file: filePath });
             if (!ok) fail(error);
             printOutput(result,
-                output.formatFileExportsJson,
+                r => output.formatFileExportsJson(r, filePath),
                 r => output.formatFileExports(r, filePath)
             );
             break;

package/core/output/graph.js

@@ -120,14 +120,14 @@ function formatFileExports(exports, filePath) {
     return lines.join('\n');
 }
 
-function formatFileExportsJson(result) {
+function formatFileExportsJson(result, filePath) {
     if (!result) return JSON.stringify({ found: false });
+    // result is an array of exported symbols from index.fileExports()
     return JSON.stringify({
-        meta: { command: 'fileExports', file: result.file },
+        meta: { command: 'fileExports', file: filePath || (Array.isArray(result) ? result[0]?.file : result.file) },
         data: {
-            file: result.file,
-            exports: result.exports || [],
-            reExports: result.reExports || [],
+            file: filePath || (Array.isArray(result) ? result[0]?.file : result.file),
+            exports: Array.isArray(result) ? result : (result.exports || []),
         },
     }, null, 2);
 }

package/core/registry.js

@@ -116,7 +116,7 @@ const FLAG_APPLICABILITY = {
     entrypoints:  ['file', 'exclude', 'includeTests', 'limit', 'type', 'framework'],
     // Extracting code
     fn:           ['file', 'className', 'all'],
-    class:        ['file', 'className', 'all', 'maxLines'],
+    class:        ['file', 'all', 'maxLines'],
     lines:        ['file', 'range'],
     expand:       [],
     // File dependencies

package/core/search.js

@@ -845,11 +845,15 @@ function tests(index, nameOrFile, options = {}) {
     const callPattern = new RegExp(escapeRegExp(searchTerm) + '\\s*\\(');
     const strPattern = new RegExp("['\"`]" + escapeRegExp(searchTerm) + "['\"`]");
 
-    // When className is provided, build a pattern to scope matches.
-    // We require the test file to also reference the class name (import, instantiation, or receiver).
+    // When className is provided, build patterns for match-level scoping.
     const classNameFilter = options.className
         ? new RegExp('\\b' + escapeRegExp(options.className) + '\\b')
         : null;
+    // Match-level class scoping: for calls, check receiver or nearby context;
+    // e.g., "new ClassName().method()" or "instance.method()" where instance is typed.
+    const classReceiverPattern = options.className
+        ? new RegExp('\\b' + escapeRegExp(options.className) + '\\s*[\\.\\(]')
+        : null;
 
     for (const { path: testPath, entry } of testFiles) {
         try {
@@ -880,6 +884,40 @@ function tests(index, nameOrFile, options = {}) {
                         }
                     }
 
+                    // Match-level className scoping: for call matches,
+                    // the class name must appear on the SAME line as receiver
+                    // (e.g., "new ClassName().method()" or "className.method()").
+                    if (classReceiverPattern && matchType === 'call') {
+                        if (!classNameFilter.test(line)) return; // skip — different receiver
+                    }
+
+                    // For reference matches, check same line or ±1 line.
+                    if (classReceiverPattern && matchType === 'reference') {
+                        let classNearby = classNameFilter.test(line);
+                        if (!classNearby && idx > 0) classNearby = classNameFilter.test(lines[idx - 1]);
+                        if (!classNearby && idx + 1 < lines.length) classNearby = classNameFilter.test(lines[idx + 1]);
+                        if (!classNearby) return; // skip this match
+                    }
+
+                    // For test-case matches with className, keep if the test
+                    // description mentions the class or the test body (next few
+                    // lines) references the class as a receiver.
+                    if (classNameFilter && matchType === 'test-case') {
+                        let classInContext = classNameFilter.test(line);
+                        if (!classInContext) {
+                            // Look forward into the test body for class usage
+                            for (let d = 1; d <= 5 && !classInContext; d++) {
+                                if (idx + d < lines.length) {
+                                    const bodyLine = lines[idx + d];
+                                    // Stop at next test-case boundary
+                                    if (/\b(describe|it|test|spec)\s*\(/.test(bodyLine)) break;
+                                    if (classNameFilter.test(bodyLine)) classInContext = true;
+                                }
+                            }
+                        }
+                        if (!classInContext) return; // skip test-case not related to this class
+                    }
+
                     matches.push({
                         line: idx + 1,
                         content: line.trim(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.8.16",
+  "version": "3.8.17",
   "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",