ucn 3.8.13 → 3.8.15

package/core/verify.js

@@ -6,7 +6,7 @@
  */
 
 const path = require('path');
-const { detectLanguage, getParser, getLanguageModule, safeParse } = require('../languages');
+const { detectLanguage, getParser, getLanguageModule, safeParse, langTraits } = require('../languages');
 const { escapeRegExp } = require('./shared');
 const { extractImports } = require('./imports');
 
@@ -164,8 +164,9 @@ function identifyCallPatterns(callSites, funcName) {
         if (new RegExp('\\.' + escapeRegExp(funcName) + '\\s*\\(').test(expr)) patterns.chainedCalls++;
 
         if (site.args && site.args.length > 0) {
+            const literalPattern = /^[\d'"{\[]/; // eslint-disable-line no-useless-escape
             const hasLiteral = site.args.some(a =>
-                /^[\d'"{\[]/.test(a) || a === 'true' || a === 'false' || a === 'null'
+                literalPattern.test(a) || a === 'true' || a === 'false' || a === 'null'
             );
             if (hasLiteral) patterns.constantArgs++;
             if (site.hasVariable) patterns.variableArgs++;
@@ -194,11 +195,9 @@ function verify(index, name, options = {}) {
     const fileEntry = index.files.get(def.file);
     const lang = fileEntry?.language;
     let params = def.paramsStructured || [];
-    if ((lang === 'python' || lang === 'rust') && params.length > 0) {
-        const firstName = params[0].name;
-        if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self' || firstName === 'mut self') {
-            params = params.slice(1);
-        }
+    const selfParams = langTraits(lang)?.selfParam;
+    if (selfParams && params.length > 0 && selfParams.includes(params[0].name)) {
+        params = params.slice(1);
     }
     const hasRest = params.some(p => p.rest);
     // Rest params don't count toward expected/min — they accept 0+ extra args
@@ -345,7 +344,7 @@ function verify(index, name, options = {}) {
                 const importedNames = getImportedNames(call.file);
                 if (!importedNames.has(callReceiver)) continue;
                 // Receiver matches target module and is imported — keep it
-            } else if (callReceiver && defLang === 'go') {
+            } else if (callReceiver && langTraits(defLang)?.hasReceiverPackageCalls) {
                 // Go: receiver is package alias (last segment of import path, e.g., "controller"
                 // from "k8s.io/.../pkg/controller"), not the filename ("controller_utils").
                 // Check if receiver matches the directory name of the target file.
@@ -588,11 +587,9 @@ function plan(index, name, options = {}) {
         const fileEntry = index.files.get(def.file);
         const lang = fileEntry?.language;
         let selfOffset = 0;
-        if ((lang === 'python' || lang === 'rust') && currentParams.length > 0) {
-            const firstName = currentParams[0].name;
-            if (firstName === 'self' || firstName === 'cls' || firstName === '&self' || firstName === '&mut self' || firstName === 'mut self') {
-                selfOffset = 1;
-            }
+        const planSelfParams = langTraits(lang)?.selfParam;
+        if (planSelfParams && currentParams.length > 0 && planSelfParams.includes(currentParams[0].name)) {
+            selfOffset = 1;
         }
         const callerArgIndex = paramIndex - selfOffset;
 

package/eslint.config.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const js = require('@eslint/js');
+
+module.exports = [
+    js.configs.recommended,
+    {
+        languageOptions: {
+            ecmaVersion: 2020,
+            sourceType: 'commonjs',
+            globals: {
+                // Node.js globals
+                require: 'readonly',
+                module: 'readonly',
+                exports: 'readonly',
+                __dirname: 'readonly',
+                __filename: 'readonly',
+                process: 'readonly',
+                console: 'readonly',
+                Buffer: 'readonly',
+                setTimeout: 'readonly',
+                setInterval: 'readonly',
+                clearTimeout: 'readonly',
+                clearInterval: 'readonly',
+                setImmediate: 'readonly',
+                URL: 'readonly',
+                URLSearchParams: 'readonly',
+                TextEncoder: 'readonly',
+                TextDecoder: 'readonly',
+            },
+        },
+        rules: {
+            'no-undef': 'error',
+            'no-unused-vars': ['warn', { args: 'none', caughtErrors: 'none' }],
+            'no-redeclare': 'error',
+            'eqeqeq': ['warn', 'smart'],
+            'no-constant-condition': ['error', { checkLoops: false }],
+        },
+    },
+    {
+        ignores: ['node_modules/', 'test/', '.ucn-cache/', 'demo/'],
+    },
+];

package/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "checkJs": false,
+    "module": "commonjs",
+    "target": "es2020",
+    "baseUrl": "."
+  },
+  "include": ["core/**/*.js", "cli/**/*.js", "mcp/**/*.js", "languages/**/*.js"],
+  "exclude": ["node_modules"]
+}

package/languages/go.js

@@ -1124,8 +1124,15 @@ function findImportsInCode(code, parser) {
         }
 
         if (modulePath) {
-            // Package name is last segment of path
-            const pkgName = alias || modulePath.split('/').pop();
+            // Package name is last segment of path, skipping Go version suffixes (v2, v3, etc.)
+            let pkgName = alias;
+            if (!pkgName) {
+                const parts = modulePath.split('/');
+                // Go convention: if last segment matches /^v\d+$/, use the previous segment
+                // e.g., k8s.io/klog/v2 → klog, github.com/foo/bar/v3 → bar
+                const last = parts[parts.length - 1];
+                pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+            }
             imports.push({
                 module: modulePath,
                 names: [pkgName],
@@ -1345,6 +1352,17 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Check if a symbol is a Go-convention entry point.
+ * These are invoked by the Go runtime or test runner, not user code.
+ */
+function isEntryPoint(symbol) {
+    const { name } = symbol;
+    if (name === 'main' || name === 'init') return true;
+    if (/^(Test|Benchmark|Example|Fuzz)[A-Z_]/.test(name)) return true;
+    return false;
+}
+
 module.exports = {
     findFunctions,
     findClasses,
@@ -1353,5 +1371,6 @@ module.exports = {
     findImportsInCode,
     findExportsInCode,
     findUsagesInCode,
+    isEntryPoint,
     parse
 };

package/languages/html.js

@@ -311,6 +311,13 @@ function findUsagesInCode(code, name, parser) {
     return jsUsages.concat(handlerUsages);
 }
 
+/**
+ * HTML has no entry points of its own.
+ */
+function isEntryPoint() {
+    return false;
+}
+
 module.exports = {
     parse,
     findFunctions,
@@ -322,6 +329,7 @@ module.exports = {
     findImportsInCode,
     findExportsInCode,
     findUsagesInCode,
+    isEntryPoint,
     // Exported for testing
     extractScriptBlocks,
     buildVirtualJSContent,

package/languages/index.js

@@ -12,55 +12,133 @@ let TreeSitter = null;
 // Cached parser instances
 const parsers = {};
 
+// Shared trait presets for languages with the same type-system characteristics
+const STRUCTURAL_TRAITS = {
+    typeSystem: 'structural',
+    methodCallInclusion: 'explicit',
+    packageScope: 'file',
+    hasReceiverPackageCalls: false,
+    exportVisibility: 'keyword',
+    hasDynamicImports: true,
+    testDirs: [],
+};
+const NOMINAL_TRAITS = {
+    typeSystem: 'nominal',
+    methodCallInclusion: 'auto',
+    packageScope: 'file',
+    hasReceiverPackageCalls: false,
+    exportVisibility: 'keyword',
+    hasDynamicImports: true,
+    testDirs: [],
+};
+
 // Language configurations
 const LANGUAGES = {
     javascript: {
         name: 'javascript',
         extensions: ['.js', '.jsx', '.mjs', '.cjs'],
         treeSitterLang: 'javascript',
-        module: () => require('./javascript')
+        module: () => require('./javascript'),
+        treeSitterModule: () => require('tree-sitter-javascript'),
+        traits: {
+            ...STRUCTURAL_TRAITS,
+            selfParam: ['this'],
+            testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
+            testDirs: ['__tests__'],
+        },
     },
     typescript: {
         name: 'typescript',
         extensions: ['.ts'],
         treeSitterLang: 'typescript',
-        module: () => require('./javascript')  // Same module, different parser
+        module: () => require('./javascript'),  // Same module, different parser
+        treeSitterModule: () => require('tree-sitter-typescript').typescript,
+        traits: {
+            ...STRUCTURAL_TRAITS,
+            selfParam: ['this'],
+            testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
+            testDirs: ['__tests__'],
+        },
     },
     tsx: {
         name: 'tsx',
         extensions: ['.tsx'],
         treeSitterLang: 'tsx',
-        module: () => require('./javascript')
+        module: () => require('./javascript'),
+        treeSitterModule: () => require('tree-sitter-typescript').tsx,
+        traits: {
+            ...STRUCTURAL_TRAITS,
+            selfParam: ['this'],
+            testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`, `${base}.test.ts`, `${base}.test.js`, `${base}.spec.ts`, `${base}.spec.js`],
+            testDirs: ['__tests__'],
+        },
     },
     python: {
         name: 'python',
         extensions: ['.py', '.pyi'],
         treeSitterLang: 'python',
-        module: () => require('./python')
+        module: () => require('./python'),
+        treeSitterModule: () => require('tree-sitter-python'),
+        traits: {
+            ...STRUCTURAL_TRAITS,
+            selfParam: ['self', 'cls'],
+            testFileCandidates: (base, ext) => [`test_${base}.py`, `${base}_test.py`],
+            testDirs: ['tests'],
+        },
     },
     go: {
         name: 'go',
         extensions: ['.go'],
         treeSitterLang: 'go',
-        module: () => require('./go')
+        module: () => require('./go'),
+        treeSitterModule: () => require('tree-sitter-go'),
+        traits: {
+            ...NOMINAL_TRAITS,
+            selfParam: null,
+            packageScope: 'directory',
+            hasReceiverPackageCalls: true,
+            exportVisibility: 'capitalization',
+            hasDynamicImports: false,
+            testFileCandidates: (base, ext) => [`${base}_test.go`],
+        },
     },
     rust: {
         name: 'rust',
         extensions: ['.rs'],
         treeSitterLang: 'rust',
-        module: () => require('./rust')
+        module: () => require('./rust'),
+        treeSitterModule: () => require('tree-sitter-rust'),
+        traits: {
+            ...NOMINAL_TRAITS,
+            selfParam: ['self', '&self', '&mut self', 'mut self'],
+            hasDynamicImports: false,
+            testFileCandidates: (base, ext) => [`${base}_test.rs`],
+            testDirs: ['tests'],
+        },
     },
     java: {
         name: 'java',
         extensions: ['.java'],
         treeSitterLang: 'java',
-        module: () => require('./java')
+        module: () => require('./java'),
+        treeSitterModule: () => require('tree-sitter-java'),
+        traits: {
+            ...NOMINAL_TRAITS,
+            selfParam: ['this'],
+            testFileCandidates: (base, ext) => [`${base}Test.java`, `${base}Tests.java`, `${base}TestCase.java`],
+        },
     },
     html: {
         name: 'html',
         extensions: ['.html', '.htm'],
         treeSitterLang: 'html',
-        module: () => require('./html')
+        module: () => require('./html'),
+        treeSitterModule: () => require('tree-sitter-html'),
+        traits: {
+            ...STRUCTURAL_TRAITS,
+            selfParam: ['this'],
+            testFileCandidates: (base, ext) => [`${base}.test${ext}`, `${base}.spec${ext}`],
+        },
     }
 };
 
@@ -83,7 +161,8 @@ function loadTreeSitter() {
         } catch (e) {
             throw new Error(
                 'tree-sitter is required but not installed.\n' +
-                'Install with: npm install'
+                'Install with: npm install',
+                { cause: e }
             );
         }
     }
@@ -107,41 +186,14 @@ function getParser(language) {
     }
 
     try {
-        let lang;
-        switch (language) {
-            case 'javascript':
-                lang = require('tree-sitter-javascript');
-                break;
-            case 'typescript':
-                lang = require('tree-sitter-typescript').typescript;
-                break;
-            case 'tsx':
-                lang = require('tree-sitter-typescript').tsx;
-                break;
-            case 'python':
-                lang = require('tree-sitter-python');
-                break;
-            case 'go':
-                lang = require('tree-sitter-go');
-                break;
-            case 'java':
-                lang = require('tree-sitter-java');
-                break;
-            case 'rust':
-                lang = require('tree-sitter-rust');
-                break;
-            case 'html':
-                lang = require('tree-sitter-html');
-                break;
-            default:
-                throw new Error(`No tree-sitter grammar for: ${language}`);
-        }
+        const lang = config.treeSitterModule();
         parser.setLanguage(lang);
     } catch (e) {
         throw new Error(
-            `Failed to load tree-sitter-${language}.\n` +
+            `Failed to load tree-sitter grammar for ${language}.\n` +
             `Install with: npm install tree-sitter-${language}\n` +
-            `Original error: ${e.message}`
+            `Original error: ${e.message}`,
+            { cause: e }
         );
     }
 
@@ -282,6 +334,15 @@ function safeParse(parser, content, oldTree = undefined, options = {}) {
     throw lastError;
 }
 
+/**
+ * Get trait object for a language.
+ * @param {string} language - Language name (e.g. 'go', 'python')
+ * @returns {object|undefined} Trait object or undefined if unknown language
+ */
+function langTraits(language) {
+    return LANGUAGES[language]?.traits;
+}
+
 module.exports = {
     detectLanguage,
     getParser,
@@ -293,6 +354,7 @@ module.exports = {
     PARSE_OPTIONS,
     getParseOptions,
     safeParse,
+    langTraits,
     DEFAULT_BUFFER_SIZE,
     MAX_BUFFER_SIZE
 };

package/languages/java.js

@@ -1173,6 +1173,18 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Check if a symbol is a Java-convention entry point.
+ * These are invoked by the JVM runtime, test runners, or required by type system.
+ */
+function isEntryPoint(symbol) {
+    const m = symbol.modifiers || [];
+    if (symbol.name === 'main' && m.includes('public') && m.includes('static')) return true;
+    if (m.includes('test')) return true;
+    if (m.includes('override')) return true;
+    return false;
+}
+
 module.exports = {
     findFunctions,
     findClasses,
@@ -1181,5 +1193,6 @@ module.exports = {
     findImportsInCode,
     findExportsInCode,
     findUsagesInCode,
+    isEntryPoint,
     parse
 };

package/languages/javascript.js

@@ -1776,7 +1776,7 @@ function findImportsInCode(code, parser) {
                     const firstArg = argsNode.namedChild(0);
                     const line = node.startPosition.row + 1;
                     const names = [];
-                    let modulePath = null;
+                    let modulePath;
                     let dynamic = false;
 
                     if (firstArg && firstArg.type === 'string') {
@@ -2141,6 +2141,21 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+const _JS_LIFECYCLE_METHODS = new Set([
+    'render', 'componentDidMount', 'componentDidUpdate', 'componentWillUnmount',
+    'getDerivedStateFromProps', 'getDerivedStateFromError', 'componentDidCatch',
+    'getSnapshotBeforeUpdate', 'shouldComponentUpdate',
+    'connectedCallback', 'disconnectedCallback', 'attributeChangedCallback', 'adoptedCallback'
+]);
+
+/**
+ * Check if a symbol is a JS/TS-convention entry point.
+ * These are framework lifecycle methods invoked by React or Web Components.
+ */
+function isEntryPoint(symbol) {
+    return !!(symbol.isMethod && _JS_LIFECYCLE_METHODS.has(symbol.name));
+}
+
 module.exports = {
     findFunctions,
     findClasses,
@@ -2151,5 +2166,6 @@ module.exports = {
     findImportsInCode,
     findExportsInCode,
     findUsagesInCode,
+    isEntryPoint,
     parse
 };

package/languages/python.js

@@ -1198,6 +1198,19 @@ function extractConstructorName(node) {
     return null;
 }
 
+/**
+ * Check if a symbol is a Python-convention entry point.
+ * These are invoked by the Python runtime, test runners, or frameworks.
+ */
+function isEntryPoint(symbol) {
+    const { name } = symbol;
+    if (/^__\w+__$/.test(name)) return true;
+    if (/^test_/.test(name)) return true;
+    if (/^(setUp|tearDown)(Class|Module)?$/.test(name)) return true;
+    if (/^pytest_/.test(name)) return true;
+    return false;
+}
+
 module.exports = {
     findFunctions,
     findClasses,
@@ -1207,5 +1220,6 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     findInstanceAttributeTypes,
+    isEntryPoint,
     parse
 };

package/languages/rust.js

@@ -1459,6 +1459,18 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Check if a symbol is a Rust-convention entry point.
+ * These are invoked by the Rust runtime, test harness, or required by trait contracts.
+ */
+function isEntryPoint(symbol) {
+    const m = symbol.modifiers || [];
+    if (symbol.name === 'main') return true;
+    if (m.includes('test') || m.includes('bench')) return true;
+    if (symbol.isMethod && symbol.className && symbol.traitImpl) return true;
+    return false;
+}
+
 module.exports = {
     findFunctions,
     findClasses,
@@ -1467,5 +1479,6 @@ module.exports = {
     findImportsInCode,
     findExportsInCode,
     findUsagesInCode,
+    isEntryPoint,
     parse
 };

package/languages/utils.js

@@ -372,7 +372,7 @@ function extractRustDocstring(codeOrLines, startLine) {
             commentStart--;
         }
         // Return first line of comment block
-        const firstLine = lines[commentStart].trim().replace(/^\/\/[\/!]\s?/, '');
+        const firstLine = lines[commentStart].trim().replace(/^\/\/[/!]\s?/, '');
         if (firstLine) return firstLine;
     }
     return null;