ucn 3.2.0 → 3.3.0

package/languages/go.js

@@ -11,7 +11,11 @@ const {
     parseStructuredParams,
     extractGoDocstring
 } = require('./utils');
-const { PARSE_OPTIONS } = require('./index');
+const { PARSE_OPTIONS, safeParse } = require('./index');
+
+function parseTree(parser, code) {
+    return safeParse(parser, code, undefined, PARSE_OPTIONS);
+}
 
 /**
  * Extract return type from Go function/method
@@ -49,7 +53,7 @@ function extractReceiver(receiverNode) {
  * Find all functions in Go code using tree-sitter
  */
 function findFunctions(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const functions = [];
     const processedRanges = new Set();
 
@@ -146,7 +150,7 @@ function extractTypeParams(node) {
  * Find all types (structs, interfaces) in Go code using tree-sitter
  */
 function findClasses(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const types = [];
     const processedRanges = new Set();
 
@@ -235,7 +239,7 @@ function extractStructFields(structNode, code) {
  * Find state objects (constants) in Go code
  */
 function findStateObjects(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const objects = [];
 
     const statePattern = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|Default[A-Z][a-zA-Z]*|[A-Z][a-zA-Z]*(?:Config|Settings|Options))$/;
@@ -320,7 +324,7 @@ function parse(code, parser) {
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string}>}
  */
 function findCallsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
 
@@ -368,6 +372,7 @@ function findCallsInCode(code, parser) {
             if (!funcNode) return true;
 
             const enclosingFunction = getCurrentEnclosingFunction();
+            let uncertain = false;
 
             if (funcNode.type === 'identifier') {
                 // Direct call: foo()
@@ -375,7 +380,8 @@ function findCallsInCode(code, parser) {
                     name: funcNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: false,
-                    enclosingFunction
+                    enclosingFunction,
+                    uncertain
                 });
             } else if (funcNode.type === 'selector_expression') {
                 // Method or package call: obj.Method() or pkg.Func()
@@ -388,7 +394,8 @@ function findCallsInCode(code, parser) {
                         line: node.startPosition.row + 1,
                         isMethod: true,
                         receiver: operandNode?.type === 'identifier' ? operandNode.text : undefined,
-                        enclosingFunction
+                        enclosingFunction,
+                        uncertain
                     });
                 }
             }
@@ -414,7 +421,7 @@ function findCallsInCode(code, parser) {
  * @returns {Array<{module: string, names: string[], type: string, line: number}>}
  */
 function findImportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const imports = [];
 
     function processImportSpec(spec) {
@@ -422,6 +429,7 @@ function findImportsInCode(code, parser) {
         let modulePath = null;
         let alias = null;
         let importType = 'import';
+        let dynamic = false;
 
         for (let i = 0; i < spec.namedChildCount; i++) {
             const child = spec.namedChild(i);
@@ -433,9 +441,11 @@ function findImportsInCode(code, parser) {
             } else if (child.type === 'blank_identifier') {
                 alias = '_';
                 importType = 'side-effect';
+                dynamic = true; // treat side-effect imports as dynamic for completeness signals
             } else if (child.type === 'dot') {
                 alias = '.';
                 importType = 'dot-import';
+                dynamic = true;
             }
         }
 
@@ -446,6 +456,7 @@ function findImportsInCode(code, parser) {
                 module: modulePath,
                 names: [pkgName],
                 type: importType,
+                dynamic,
                 line
             });
         }
@@ -483,7 +494,7 @@ function findImportsInCode(code, parser) {
  * @returns {Array<{name: string, type: string, line: number}>}
  */
 function findExportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const exports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -563,7 +574,7 @@ function findExportsInCode(code, parser) {
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
 function findUsagesInCode(code, name, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {

package/languages/java.js

@@ -11,7 +11,11 @@ const {
     parseStructuredParams,
     extractJavaDocstring
 } = require('./utils');
-const { PARSE_OPTIONS } = require('./index');
+const { PARSE_OPTIONS, safeParse } = require('./index');
+
+function parseTree(parser, code) {
+    return safeParse(parser, code, undefined, PARSE_OPTIONS);
+}
 
 /**
  * Extract Java parameters
@@ -99,7 +103,7 @@ function extractGenerics(node) {
  * Find all methods/constructors in Java code using tree-sitter
  */
 function findFunctions(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const functions = [];
     const processedRanges = new Set();
 
@@ -150,6 +154,12 @@ function findFunctions(code, parser) {
             if (processedRanges.has(rangeKey)) return true;
             processedRanges.add(rangeKey);
 
+            // Skip constructors 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 constructor
+            }
+
             const nameNode = node.childForFieldName('name');
             const paramsNode = node.childForFieldName('parameters');
 
@@ -186,7 +196,7 @@ function findFunctions(code, parser) {
  * Find all classes, interfaces, enums, records in Java code
  */
 function findClasses(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const classes = [];
     const processedRanges = new Set();
 
@@ -209,6 +219,10 @@ function findClasses(code, parser) {
                 const extendsInfo = extractExtends(node);
                 const implementsInfo = extractImplements(node);
 
+                // Check if this is a nested/inner class
+                let parentNode = node.parent;
+                const isNested = parentNode && parentNode.type === 'class_body';
+
                 classes.push({
                     name: nameNode.text,
                     startLine,
@@ -216,6 +230,7 @@ function findClasses(code, parser) {
                     type: 'class',
                     members,
                     modifiers,
+                    ...(isNested && { isNested: true }),
                     ...(docstring && { docstring }),
                     ...(generics && { generics }),
                     ...(annotations.length > 0 && { annotations }),
@@ -223,7 +238,8 @@ function findClasses(code, parser) {
                     ...(implementsInfo.length > 0 && { implements: implementsInfo })
                 });
             }
-            return false;  // Don't traverse into class body
+            // Continue traversal to find inner classes, but members are already extracted
+            return true;
         }
 
         // Interface declarations
@@ -438,7 +454,7 @@ function extractClassMembers(classNode, code) {
  * Find state objects (static final constants) in Java code
  */
 function findStateObjects(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const objects = [];
 
     const statePattern = /^([A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:CONFIG|SETTINGS|OPTIONS))$/;
@@ -495,7 +511,7 @@ function parse(code, parser) {
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string, isConstructor?: boolean}>}
  */
 function findCallsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
 
@@ -602,7 +618,7 @@ function findCallsInCode(code, parser) {
  * @returns {Array<{module: string, names: string[], type: string, line: number}>}
  */
 function findImportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const imports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -648,7 +664,7 @@ function findImportsInCode(code, parser) {
  * @returns {Array<{name: string, type: string, line: number}>}
  */
 function findExportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const exports = [];
 
     function isPublic(node) {
@@ -728,7 +744,7 @@ function findExportsInCode(code, parser) {
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
 function findUsagesInCode(code, name, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {

package/languages/javascript.js

@@ -12,7 +12,12 @@ const {
     parseStructuredParams,
     extractJSDocstring
 } = require('./utils');
-const { PARSE_OPTIONS } = require('./index');
+const { PARSE_OPTIONS, safeParse } = require('./index');
+
+// Helper to consistently parse with buffer retries
+function parseTree(parser, code) {
+    return safeParse(parser, code, undefined, PARSE_OPTIONS);
+}
 
 /**
  * Extract return type annotation from JS/TS function
@@ -88,7 +93,7 @@ function extractModifiers(text) {
  * @returns {Array}
  */
 function findFunctions(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const functions = [];
     const processedRanges = new Set();
 
@@ -327,7 +332,7 @@ function findFunctions(code, parser) {
  * @returns {Array}
  */
 function findClasses(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const classes = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -581,7 +586,7 @@ function extractClassMembers(classNode, code) {
  * Find state objects (CONFIG, constants, etc.)
  */
 function findStateObjects(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const objects = [];
 
     const statePattern = /^(CONFIG|[A-Z][a-zA-Z]*(?:State|Store|Context|Options|Settings)|[A-Z][A-Z_]+|Entities|Input)$/;
@@ -655,7 +660,7 @@ function parse(code, parser) {
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string, isConstructor?: boolean}>}
  */
 function findCallsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
 
@@ -718,6 +723,9 @@ function findCallsInCode(code, parser) {
             if (!funcNode) return true;
 
             const enclosingFunction = getCurrentEnclosingFunction();
+            let uncertain = false;
+            // optional chaining implies possible non-call
+            if (node.type === 'call_expression' && node.text.includes('?.')) uncertain = true;
 
             if (funcNode.type === 'identifier') {
                 // Direct call: foo()
@@ -725,7 +733,8 @@ function findCallsInCode(code, parser) {
                     name: funcNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: false,
-                    enclosingFunction
+                    enclosingFunction,
+                    uncertain
                 });
             } else if (funcNode.type === 'member_expression') {
                 // Method call: obj.foo() or foo.call/apply/bind()
@@ -755,7 +764,8 @@ function findCallsInCode(code, parser) {
                                     line: node.startPosition.row + 1,
                                     isMethod: true,
                                     receiver: innerObj?.text,
-                                    enclosingFunction
+                                    enclosingFunction,
+                                    uncertain
                                 });
                             }
                         }
@@ -773,7 +783,8 @@ function findCallsInCode(code, parser) {
                             line: node.startPosition.row + 1,
                             isMethod: true,
                             receiver,
-                            enclosingFunction
+                            enclosingFunction,
+                            uncertain
                         });
                     }
                 }
@@ -877,7 +888,7 @@ function findCallsInCode(code, parser) {
  * @returns {Array<{line: number, context: string, pattern: string}>}
  */
 function findCallbackUsages(code, name, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -974,7 +985,7 @@ function findCallbackUsages(code, name, parser) {
  * @returns {Array<{name: string, from: string, line: number}>}
  */
 function findReExports(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const reExports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -1026,7 +1037,7 @@ function findReExports(code, parser) {
  * @returns {Array<{module: string, names: string[], type: string, line: number}>}
  */
 function findImportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const imports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -1091,35 +1102,41 @@ function findImportsInCode(code, parser) {
                 const argsNode = node.childForFieldName('arguments');
                 if (argsNode && argsNode.namedChildCount > 0) {
                     const firstArg = argsNode.namedChild(0);
+                    const line = node.startPosition.row + 1;
+                    const names = [];
+                    let modulePath = null;
+                    let dynamic = false;
+
                     if (firstArg && firstArg.type === 'string') {
-                        const modulePath = firstArg.text.slice(1, -1);
-                        const line = node.startPosition.row + 1;
-                        const names = [];
+                        modulePath = firstArg.text.slice(1, -1);
+                    } else {
+                        dynamic = true;
+                        modulePath = firstArg ? firstArg.text : null;
+                    }
 
-                        // Check parent for variable name
-                        let parent = node.parent;
-                        if (parent && parent.type === 'variable_declarator') {
-                            const nameNode = parent.childForFieldName('name');
-                            if (nameNode) {
-                                if (nameNode.type === 'identifier') {
-                                    names.push(nameNode.text);
-                                } else if (nameNode.type === 'object_pattern') {
-                                    // Destructuring: const { a, b } = require('x')
-                                    for (let i = 0; i < nameNode.namedChildCount; i++) {
-                                        const prop = nameNode.namedChild(i);
-                                        if (prop.type === 'shorthand_property_identifier_pattern') {
-                                            names.push(prop.text);
-                                        } else if (prop.type === 'pair_pattern') {
-                                            const key = prop.childForFieldName('key');
-                                            if (key) names.push(key.text);
-                                        }
+                    // Check parent for variable name
+                    let parent = node.parent;
+                    if (parent && parent.type === 'variable_declarator') {
+                        const nameNode = parent.childForFieldName('name');
+                        if (nameNode) {
+                            if (nameNode.type === 'identifier') {
+                                names.push(nameNode.text);
+                            } else if (nameNode.type === 'object_pattern') {
+                                // Destructuring: const { a, b } = require('x')
+                                for (let i = 0; i < nameNode.namedChildCount; i++) {
+                                    const prop = nameNode.namedChild(i);
+                                    if (prop.type === 'shorthand_property_identifier_pattern') {
+                                        names.push(prop.text);
+                                    } else if (prop.type === 'pair_pattern') {
+                                        const key = prop.childForFieldName('key');
+                                        if (key) names.push(key.text);
                                     }
                                 }
                             }
                         }
-
-                        imports.push({ module: modulePath, names, type: 'require', line });
                     }
+
+                    imports.push({ module: modulePath, names, type: 'require', line, dynamic });
                 }
             }
 
@@ -1128,10 +1145,12 @@ function findImportsInCode(code, parser) {
                 const argsNode = node.childForFieldName('arguments');
                 if (argsNode && argsNode.namedChildCount > 0) {
                     const firstArg = argsNode.namedChild(0);
+                    const line = node.startPosition.row + 1;
                     if (firstArg && firstArg.type === 'string') {
                         const modulePath = firstArg.text.slice(1, -1);
-                        const line = node.startPosition.row + 1;
-                        imports.push({ module: modulePath, names: [], type: 'dynamic', line });
+                        imports.push({ module: modulePath, names: [], type: 'dynamic', line, dynamic: false });
+                    } else {
+                        imports.push({ module: firstArg ? firstArg.text : null, names: [], type: 'dynamic', line, dynamic: true });
                     }
                 }
             }
@@ -1151,7 +1170,7 @@ function findImportsInCode(code, parser) {
  * @returns {Array<{name: string, type: string, line: number, source?: string}>}
  */
 function findExportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const exports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -1288,7 +1307,7 @@ function findExportsInCode(code, parser) {
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
 function findUsagesInCode(code, name, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {

package/languages/python.js

@@ -11,7 +11,11 @@ const {
     parseStructuredParams,
     extractPythonDocstring
 } = require('./utils');
-const { PARSE_OPTIONS } = require('./index');
+const { PARSE_OPTIONS, safeParse } = require('./index');
+
+function parseTree(parser, code) {
+    return safeParse(parser, code, undefined, PARSE_OPTIONS);
+}
 
 /**
  * Extract return type annotation from Python function
@@ -62,7 +66,7 @@ function extractPythonParams(paramsNode) {
  * Find all functions in Python code using tree-sitter
  */
 function findFunctions(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const functions = [];
     const processedRanges = new Set();
 
@@ -159,7 +163,7 @@ function extractDecorators(node) {
  * Find all classes in Python code using tree-sitter
  */
 function findClasses(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const classes = [];
     const processedRanges = new Set();
 
@@ -312,7 +316,7 @@ function extractClassMembers(classNode, code) {
  * Find state objects (constants) in Python code
  */
 function findStateObjects(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const objects = [];
 
     const statePattern = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:Config|Settings|Options|State|Store|Context))$/;
@@ -365,7 +369,7 @@ function parse(code, parser) {
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string}>}
  */
 function findCallsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
 
@@ -409,6 +413,7 @@ function findCallsInCode(code, parser) {
             if (!funcNode) return true;
 
             const enclosingFunction = getCurrentEnclosingFunction();
+            let uncertain = false;
 
             if (funcNode.type === 'identifier') {
                 // Direct call: foo()
@@ -416,7 +421,8 @@ function findCallsInCode(code, parser) {
                     name: funcNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: false,
-                    enclosingFunction
+                    enclosingFunction,
+                    uncertain
                 });
             } else if (funcNode.type === 'attribute') {
                 // Method/attribute call: obj.foo()
@@ -429,7 +435,8 @@ function findCallsInCode(code, parser) {
                         line: node.startPosition.row + 1,
                         isMethod: true,
                         receiver: objNode?.type === 'identifier' ? objNode.text : undefined,
-                        enclosingFunction
+                        enclosingFunction,
+                        uncertain
                     });
                 }
             }
@@ -455,7 +462,7 @@ function findCallsInCode(code, parser) {
  * @returns {Array<{module: string, names: string[], type: string, line: number}>}
  */
 function findImportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const imports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -526,6 +533,28 @@ function findImportsInCode(code, parser) {
             return true;
         }
 
+        // Dynamic imports via importlib/import_module or __import__
+        if (node.type === 'call') {
+            const funcNode = node.childForFieldName('function');
+            const argsNode = node.childForFieldName('arguments');
+            if (funcNode && argsNode && argsNode.namedChildCount > 0) {
+                const funcName = funcNode.text;
+                const firstArg = argsNode.namedChild(0);
+                if ((funcName === 'importlib.import_module' || funcName === '__import__') && firstArg) {
+                    const line = node.startPosition.row + 1;
+                    const isLiteral = firstArg.type === 'string';
+                    imports.push({
+                        module: isLiteral ? firstArg.text.replace(/^['"]|['"]$/g, '') : firstArg.text,
+                        names: [],
+                        type: 'dynamic',
+                        line,
+                        dynamic: !isLiteral
+                    });
+                }
+            }
+            return true;
+        }
+
         return true;
     });
 
@@ -540,7 +569,7 @@ function findImportsInCode(code, parser) {
  * @returns {Array<{name: string, type: string, line: number}>}
  */
 function findExportsInCode(code, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const exports = [];
 
     traverseTree(tree.rootNode, (node) => {
@@ -590,7 +619,7 @@ function findExportsInCode(code, parser) {
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
 function findUsagesInCode(code, name, parser) {
-    const tree = parser.parse(code, undefined, PARSE_OPTIONS);
+    const tree = parseTree(parser, code);
     const usages = [];
 
     traverseTree(tree.rootNode, (node) => {