ucn 5.2.0 → 5.2.1

package/core/verify.js

@@ -8,6 +8,7 @@
 const { detectLanguage, getParser, getLanguageAdapter, safeParse, langTraits } = require('../languages');
 const { sameNode } = require('../languages/utils');
 const { escapeRegExp, codeUnitCompare, NON_CALLABLE_TYPES } = require('./shared');
+const { findAccessorReferences } = require('./accessors');
 
 function codeUnitColumnForByteColumn(line, byteColumn) {
     if (!Number.isInteger(byteColumn) || byteColumn < 0) return null;
@@ -2084,6 +2085,7 @@ function plan(index, name, options = {}) {
     let newSignature = currentSignature;
     let operation = null;
     let changes = [];
+    const reviewItems = [];
     let unchangedSites = 0;
 
     if (options.addParam) {
@@ -2361,7 +2363,7 @@ function plan(index, name, options = {}) {
         // tests; the import/reference sweep must not silently hide them via
         // usages()' navigation-oriented default test exclusion.
         const usages = index.usages(name, {
-            codeOnly: true,
+            codeOnly: false,
             includeTests: true,
             internalEvidence: true,
         });
@@ -3166,6 +3168,75 @@ function plan(index, name, options = {}) {
                 }
             }
         }
+
+        // Property/getter/setter renames must cover their normal consumption
+        // form: attribute reads and writes. Reuse impact's receiver-evidence
+        // query so a typed field is edited mechanically and an unresolved
+        // receiver is surfaced for review instead of silently omitted.
+        const accessorReferences = findAccessorReferences(index, name, def, {
+            includeTests: true,
+        });
+        if (accessorReferences) {
+            const confirmedByLine = new Map();
+            for (const ref of accessorReferences.confirmed) {
+                const key = `${ref.absoluteFile}\0${ref.line}`;
+                if (!confirmedByLine.has(key)) confirmedByLine.set(key, []);
+                confirmedByLine.get(key).push(ref);
+            }
+            for (const refs of confirmedByLine.values()) {
+                const ref = refs[0];
+                const columns = refs.map(item => item.column)
+                    .filter(Number.isInteger);
+                const edit = renameIdentifierTokens(index, ref.absoluteFile,
+                    ref.line, name, options.renameTo,
+                    columns.length === refs.length ? columns : null);
+                if (edit.renamed === edit.source) continue;
+                const concrete = {
+                    file: ref.file,
+                    line: ref.line,
+                    expression: edit.source,
+                    suggestion: `Update property access: ${edit.renamed}`,
+                    newExpression: edit.renamed,
+                    editKind: 'reference',
+                };
+                const existing = changes.find(change =>
+                    change.file === ref.file && change.line === ref.line &&
+                    !change.needsReview);
+                if (existing) Object.assign(existing, concrete);
+                else changes.push(concrete);
+            }
+            for (const ref of accessorReferences.unverified) {
+                changes.push({
+                    file: ref.file,
+                    line: ref.line,
+                    expression: ref.expression,
+                    suggestion: `Verify this property access resolves to ${name} on ` +
+                        `${accessorReferences.owner} before renaming`,
+                    needsReview: true,
+                    editKind: 'reference',
+                });
+            }
+        }
+
+        // String/comment occurrences in indexed source can encode guards,
+        // reflection keys, protocol names, snapshots, or documentation. AST
+        // identifier replacement must never rewrite them automatically, but a
+        // complete plan must list them as explicit review work.
+        for (const textRef of usages.filter(usage => usage.usageType === 'text')) {
+            const rel = textRef.relativePath || textRef.file;
+            if (reviewItems.some(item =>
+                item.file === rel && item.line === textRef.line)) continue;
+            reviewItems.push({
+                file: rel,
+                line: textRef.line,
+                expression: (textRef.content || '').trim(),
+                suggestion: `Review comment/string dependency on "${name}"; ` +
+                    'rename manually only if its contract changes',
+                needsReview: true,
+                textDependency: true,
+                editKind: 'text-reference',
+            });
+        }
     }
 
     // Every operation changes the selected declaration. Historically `plan`
@@ -3222,7 +3293,9 @@ function plan(index, name, options = {}) {
         imports: changes.filter(change => change.editKind === 'import').length,
         exports: changes.filter(change => change.editKind === 'export').length,
         references: changes.filter(change => change.editKind === 'reference').length,
-        reviewRequired: changes.filter(change => change.needsReview).length,
+        textReferences: reviewItems.length,
+        reviewRequired: changes.filter(change => change.needsReview).length +
+            reviewItems.length,
     };
 
     return {
@@ -3243,9 +3316,11 @@ function plan(index, name, options = {}) {
             params: newParams.map(p => formatPlanParamName(p)).filter(Boolean)
         },
         totalChanges: changes.length,
-        filesAffected: new Set(changes.map(c => c.file)).size,
+        filesAffected: new Set([...changes, ...reviewItems].map(c => c.file)).size,
         changeSummary,
         changes,
+        reviewItems,
+        totalReviewItems: reviewItems.length,
         ...(unchangedSites > 0 && { unchangedSites }),
         // v4 tiered contract: sites that MAY also need this change but lack
         // binding/receiver evidence — review manually before refactoring.
@@ -3253,6 +3328,13 @@ function plan(index, name, options = {}) {
         unverifiedSites: planUnverified,
         account: planAccount,
         scopeWarning: impactScopeWarning,
+        ...(options.renameTo && {
+            outsideIndexedSource: {
+                scope: 'indexed-source-files',
+                excluded: ['documentation', 'configuration', 'generated files', 'unsupported languages'],
+                action: `Search non-source project files for the exact spelling "${name}" before applying the rename.`,
+            },
+        }),
         ...(resolved.warnings.length > 0 && { warnings: resolved.warnings }),
     };
     } finally { index._endOp(); }

package/languages/c-family.js

@@ -513,27 +513,18 @@ function conditionalRecoverySources(code) {
 }
 
 function treeStructureScore(tree) {
-    let declarations = 0;
-    let calls = 0;
     const declarationTypes = new Set([
         'function_definition', 'class_specifier', 'struct_specifier',
         'union_specifier', 'enum_specifier', 'type_definition',
     ]);
-    const cursor = tree.walk();
-    let entered = true;
-    while (entered) {
-        const type = cursor.nodeType;
-        if (declarationTypes.has(type)) declarations++;
-        else if (type === 'call_expression') calls++;
-        if (cursor.gotoFirstChild()) continue;
-        while (!cursor.gotoNextSibling()) {
-            if (!cursor.gotoParent()) {
-                entered = false;
-                break;
-            }
-        }
-    }
-    cursor.delete?.();
+    // `descendantsOfType` performs the filtering in tree-sitter's native
+    // cursor. Recovery can score the same large source under as many as 14
+    // bounded preprocessor views; walking every node through the JS bridge
+    // made scoring alone a material part of cold C/C++ build CPU. The native
+    // query returns the exact same node sets and therefore preserves the
+    // recovery ordering contract while avoiding thousands of wrapper calls.
+    const declarations = tree.rootNode.descendantsOfType([...declarationTypes]).length;
+    const calls = tree.rootNode.descendantsOfType('call_expression').length;
     return declarations * 1000 + calls;
 }
 

package/languages/csharp.js

@@ -293,7 +293,7 @@ function propertyMember(node, lines) {
         endLine,
         indent,
         modifiers: modifiersOf(node),
-        memberType: 'field',
+        memberType: 'property',
         fieldType: typeNode?.text || null,
     };
 }
@@ -1312,6 +1312,7 @@ function findImportsInCode(code, parser) {
 function findUsagesInCode(code, name, parser, existingTree) {
     const tree = existingTree || parseTree(parser, code);
     const usages = [];
+    const variableTypesByScope = buildVariableTypes(tree, parser);
     visitNameNodes(tree, code, name, node => {
         if (!IDENTIFIER_NODES.has(node.type) || node.text !== name) return;
         let usageType = 'reference';
@@ -1320,6 +1321,8 @@ function findUsagesInCode(code, name, parser, existingTree) {
             if ((parent.type === 'method_declaration' ||
                 parent.type === 'constructor_declaration' ||
                 TYPE_DECLARATIONS.has(parent.type) ||
+                parent.type === 'property_declaration' ||
+                parent.type === 'event_declaration' ||
                 parent.type === 'parameter' ||
                 parent.type === 'variable_declarator') &&
                 (sameNode(parent.childForFieldName('name'), node))) {
@@ -1330,6 +1333,28 @@ function findUsagesInCode(code, name, parser, existingTree) {
             } else if (parent.type === 'using_directive') {
                 usageType = 'import';
             }
+            if (parent.type === 'member_access_expression' &&
+                sameNode(parent.childForFieldName('name'), node)) {
+                const receiverNode = parent.childForFieldName('expression') ||
+                    parent.namedChild(0);
+                const receiver = receiverNode?.text;
+                const scopeTypes = variableTypesByScope.get(variableScopeKey(node)) ||
+                    variableTypesByScope.get('global');
+                const declared = receiverNode?.type === 'identifier'
+                    ? normalizeReceiverType(scopeTypes?.get(receiver)) : null;
+                const sameClass = ['this', 'base'].includes(receiver)
+                    ? enclosingClassName(node) : null;
+                usages.push({
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                    usageType,
+                    ...(receiver && { receiver }),
+                    ...((declared?.name || sameClass) && {
+                        receiverType: declared?.name || sameClass,
+                    }),
+                });
+                return true;
+            }
         }
         usages.push({
             line: node.startPosition.row + 1,

package/languages/javascript.js

@@ -3844,7 +3844,7 @@ function findUsagesInCode(code, name, parser, tree) {
                     usageType = 'reference';
                 }
                 // Track receiver for member expressions (obj.name → receiver = 'obj')
-                if (object && object.type === 'identifier') {
+                if (object && ['identifier', 'this', 'super'].includes(object.type)) {
                     usages.push({ line, column, usageType, receiver: object.text });
                     return true;
                 }

package/languages/python.js

@@ -2468,10 +2468,24 @@ function findImportsInCode(code, parser) {
     const imports = [];
     let importAliases = null;  // {original, local}[] — tracks renamed imports
 
+    // Imports nested in a function/lambda do not execute during ordinary
+    // module initialization. Preserve that AST fact so dependency-cycle
+    // reporting can distinguish an eager import loop from a deliberate lazy
+    // edge without deleting either edge from the graph.
+    const isDeferredImport = (node) => {
+        for (let parent = node.parent; parent; parent = parent.parent) {
+            if (parent.type === 'function_definition' || parent.type === 'lambda') {
+                return true;
+            }
+        }
+        return false;
+    };
+
     traverseTreeCached(tree.rootNode, (node) => {
         // import statement: import os, import sys as system
         if (node.type === 'import_statement') {
             const line = node.startPosition.row + 1;
+            const deferred = isDeferredImport(node);
 
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
@@ -2487,20 +2501,23 @@ function findImportsInCode(code, parser) {
                             module: parts[0],
                             names: [parts[0]],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                         imports.push({
                             module: child.text,
                             names: [],
                             type: 'import-submodule',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                     } else {
                         imports.push({
                             module: child.text,
                             names: [child.text],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                     }
                 } else if (child.type === 'aliased_import') {
@@ -2512,7 +2529,8 @@ function findImportsInCode(code, parser) {
                             module: nameNode.text,
                             names: [aliasNode ? aliasNode.text : nameNode.text.split('.').pop()],
                             type: 'import',
-                            line
+                            line,
+                            ...(deferred && { deferred: true })
                         });
                         if (aliasNode && aliasNode.text !== nameNode.text) {
                             if (!importAliases) importAliases = [];
@@ -2527,6 +2545,7 @@ function findImportsInCode(code, parser) {
         // from ... import statement
         if (node.type === 'import_from_statement') {
             const line = node.startPosition.row + 1;
+            const deferred = isDeferredImport(node);
             let modulePath = '';
             const names = [];
 
@@ -2559,7 +2578,8 @@ function findImportsInCode(code, parser) {
                     module: modulePath,
                     names,
                     type: isRelative ? 'relative' : 'from',
-                    line
+                    line,
+                    ...(deferred && { deferred: true })
                 });
             }
             return true;
@@ -2574,13 +2594,15 @@ function findImportsInCode(code, parser) {
                 const firstArg = argsNode.namedChild(0);
                 if ((funcName === 'importlib.import_module' || funcName === '__import__') && firstArg) {
                     const line = node.startPosition.row + 1;
+                    const deferred = isDeferredImport(node);
                     const isLiteral = firstArg.type === 'string';
                     imports.push({
                         module: isLiteral ? firstArg.text.replace(/^['"]|['"]$/g, '') : firstArg.text,
                         names: [],
                         type: 'dynamic',
                         line,
-                        dynamic: !isLiteral
+                        dynamic: !isLiteral,
+                        ...(deferred && { deferred: true })
                     });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Auditable AST code intelligence for AI agents: 18 task-oriented commands through one MCP tool, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java, C, C++, C#, and HTML.",
   "main": "index.js",