ucn 3.4.3 → 3.4.5

package/README.md

@@ -134,6 +134,27 @@ EXTERNAL:
   fs, path, crypto
 ```
 
+## Workflows
+
+**Investigating a bug:**
+```bash
+ucn about problematic_function          # Understand it fully
+ucn trace problematic_function --depth=2  # See what it calls
+```
+
+**Before modifying a function:**
+```bash
+ucn impact the_function                 # Who will break?
+ucn smart the_function                  # See it + its helpers
+# ... make your changes ...
+ucn verify the_function                 # Did all call sites survive?
+```
+
+**Periodic cleanup:**
+```bash
+ucn deadcode --exclude=test             # What can be deleted?
+ucn toc                                 # Project overview
+```
 ## Supported Languages
 
 JavaScript, TypeScript, Python, Go, Rust, Java
@@ -144,9 +165,88 @@ JavaScript, TypeScript, Python, Go, Rust, Java
 npm install -g ucn
 ```
 
-### Claude Code (optional)
+### MCP Server
+
+UCN includes a built-in [MCP](https://modelcontextprotocol.io) server, so any MCP-compatible AI client can use it as a tool.
+
+**Claude Code** (`~/.claude/mcp-config.json`):
+```json
+{
+  "mcpServers": {
+    "ucn": {
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+**Claude Desktop** (macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "ucn": {
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+**Cursor** (`~/.cursor/mcp.json` or `.cursor/mcp.json` in project):
+```json
+{
+  "mcpServers": {
+    "ucn": {
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+**Windsurf** (`~/.codeium/windsurf/mcp_config.json`):
+```json
+{
+  "mcpServers": {
+    "ucn": {
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+**VS Code Copilot** (`.vscode/mcp.json`):
+```json
+{
+  "servers": {
+    "ucn": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+**Zed** (Settings > `settings.json`):
+```json
+{
+  "context_servers": {
+    "ucn": {
+      "command": "npx",
+      "args": ["-y", "ucn", "--mcp"]
+    }
+  }
+}
+```
+
+The MCP server exposes 27 tools: `ucn_about`, `ucn_context`, `ucn_impact`, `ucn_smart`, `ucn_trace`, `ucn_find`, `ucn_usages`, `ucn_toc`, `ucn_deadcode`, `ucn_fn`, `ucn_class`, `ucn_verify`, `ucn_imports`, `ucn_exporters`, `ucn_tests`, `ucn_related`, `ucn_graph`, `ucn_file_exports`, `ucn_search`, `ucn_plan`, `ucn_typedef`, `ucn_stacktrace`, `ucn_example`, `ucn_expand`, `ucn_lines`, `ucn_api`, `ucn_stats`.
 
-To use UCN as a skill in Claude Code:
+### Claude Code Skill (alternative)
+
+To use UCN as a skill in Claude Code (alternative to MCP):
 
 ```bash
 mkdir -p ~/.claude/skills
@@ -257,6 +357,7 @@ Common Flags:
   --clear-cache       Clear cache before running
   --no-follow-symlinks  Don't follow symbolic links
   -i, --interactive   Keep index in memory for multiple queries
+  --mcp               Start as MCP server (stdio transport)
 
 Quick Start:
   ucn toc                             # See project structure (compact)
@@ -267,28 +368,6 @@ Quick Start:
   ucn --interactive                   # Multiple queries
 ```
 
-## Workflows
-
-**Investigating a bug:**
-```bash
-ucn about problematic_function          # Understand it fully
-ucn trace problematic_function --depth=2  # See what it calls
-```
-
-**Before modifying a function:**
-```bash
-ucn impact the_function                 # Who will break?
-ucn smart the_function                  # See it + its helpers
-# ... make your changes ...
-ucn verify the_function                 # Did all call sites survive?
-```
-
-**Periodic cleanup:**
-```bash
-ucn deadcode --exclude=test             # What can be deleted?
-ucn toc                                 # Project overview
-```
-
 ## License
 
 MIT

package/cli/index.js

@@ -22,6 +22,10 @@ const output = require('../core/output');
 
 const rawArgs = process.argv.slice(2);
 
+// MCP server mode — launch server and skip CLI
+if (rawArgs.includes('--mcp')) {
+    require('../mcp/server.js');
+} else {
 // Support -- to separate flags from positional arguments
 const doubleDashIdx = rawArgs.indexOf('--');
 const args = doubleDashIdx === -1 ? rawArgs : rawArgs.slice(0, doubleDashIdx);
@@ -78,7 +82,7 @@ if (fileArgIdx !== -1 && args[fileArgIdx + 1]) {
 
 // Known flags for validation
 const knownFlags = new Set([
-    '--help', '-h',
+    '--help', '-h', '--mcp',
     '--json', '--verbose', '--no-quiet', '--quiet',
     '--code-only', '--with-types', '--top-level', '--exact',
     '--no-cache', '--clear-cache', '--include-tests',
@@ -2542,3 +2546,5 @@ if (flags.interactive) {
 } else {
     main();
 }
+
+} // end of --mcp else block

package/core/discovery.js

@@ -298,7 +298,8 @@ function shouldIgnore(name, ignores, parentDir) {
     }
 
     // Check conditional ignores (only if parentDir provided)
-    if (parentDir && CONDITIONAL_IGNORES[name]) {
+    // Use Array.isArray to avoid matching Object.prototype properties (e.g. dir named "constructor")
+    if (parentDir && Array.isArray(CONDITIONAL_IGNORES[name])) {
         const markers = CONDITIONAL_IGNORES[name];
         for (const marker of markers) {
             if (fs.existsSync(path.join(parentDir, marker))) {

package/core/project.js

@@ -1021,8 +1021,8 @@ class ProjectIndex {
                             const matchesDef = definitions.some(d => d.className === targetClass);
                             if (!matchesDef) continue;
                             // Falls through to add as caller
-                        } else if (fileEntry.language === 'python' && ['self', 'cls'].includes(call.receiver)) {
-                            // self.method() / cls.method() — resolve to same-class method
+                        } else if (['self', 'cls', 'this'].includes(call.receiver)) {
+                            // self.method() / cls.method() / this.method() — resolve to same-class method
                             const callerSymbol = this.findEnclosingFunction(filePath, call.line, true);
                             if (!callerSymbol?.className) continue;
                             // Check if any definition of searched function belongs to caller's class
@@ -1030,8 +1030,6 @@ class ProjectIndex {
                             if (!matchesDef) continue;
                             // Falls through to add as caller
                         } else {
-                            // Always skip this/self/cls calls (internal state access, not function calls)
-                            if (['this', 'self', 'cls'].includes(call.receiver)) 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;
@@ -1143,14 +1141,14 @@ class ProjectIndex {
 
                 // Smart method call handling:
                 // - Go: include all method calls (Go doesn't use this/self/cls)
-                // - Python self.method(): resolve to same-class method (handled below)
+                // - self/this.method(): resolve to same-class method (handled below)
                 // - Python self.attr.method(): resolve via selfAttribute (handled below)
                 // - Other languages: skip method calls unless explicitly requested
                 if (call.isMethod) {
                     if (call.selfAttribute && language === 'python') {
                         // Will be resolved in second pass below
-                    } else if (language === 'python' && ['self', 'cls'].includes(call.receiver)) {
-                        // self.method() / cls.method() — resolve to same-class method below
+                    } else if (['self', 'cls', 'this'].includes(call.receiver)) {
+                        // self.method() / cls.method() / this.method() — resolve to same-class method below
                     } else if (language !== 'go' && !options.includeMethods) {
                         continue;
                     }
@@ -1166,8 +1164,8 @@ class ProjectIndex {
                     continue;
                 }
 
-                // Collect Python self.method() calls for same-class resolution
-                if (language === 'python' && call.isMethod && ['self', 'cls'].includes(call.receiver)) {
+                // Collect self/this.method() calls for same-class resolution
+                if (call.isMethod && ['self', 'cls', 'this'].includes(call.receiver)) {
                     if (!selfMethodCalls) selfMethodCalls = [];
                     selfMethodCalls.push(call);
                     continue;
@@ -1255,7 +1253,7 @@ class ProjectIndex {
                 }
             }
 
-            // Third pass: resolve Python self.method() calls to same-class methods
+            // Third pass: resolve self/this.method() calls to same-class methods
             if (selfMethodCalls && def.className) {
                 for (const call of selfMethodCalls) {
                     const symbols = this.symbols.get(call.name);
@@ -1590,7 +1588,7 @@ class ProjectIndex {
         const fileEntry = this.files.get(filePath);
         if (!fileEntry) return null;
 
-        const nonCallableTypes = new Set(['class', 'struct', 'interface', 'type', 'state']);
+        const nonCallableTypes = new Set(['class', 'struct', 'interface', 'type', 'state', 'impl']);
         for (const symbol of fileEntry.symbols) {
             if (!nonCallableTypes.has(symbol.type) &&
                 symbol.startLine <= lineNum &&

package/languages/java.js

@@ -567,7 +567,7 @@ function findCallsInCode(code, parser) {
                     name: nameNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: !!objNode,
-                    receiver: objNode?.type === 'identifier' ? objNode.text : undefined,
+                    receiver: (objNode?.type === 'identifier' || objNode?.type === 'this') ? objNode.text : undefined,
                     enclosingFunction
                 });
             }

package/languages/rust.js

@@ -622,7 +622,7 @@ function findCallsInCode(code, parser) {
                         name: fieldNode.text,
                         line: node.startPosition.row + 1,
                         isMethod: true,
-                        receiver: valueNode?.type === 'identifier' ? valueNode.text : undefined,
+                        receiver: (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined,
                         enclosingFunction
                     });
                 }