ucn 3.8.23 → 3.8.25

package/core/check.js

@@ -0,0 +1,200 @@
+/**
+ * core/check.js — Pre-commit summary command.
+ *
+ * Composes diff-impact + verify + affected-tests into a single output.
+ * Tells the caller, in one shot:
+ *   - which functions changed
+ *   - which call sites might break (signature drift)
+ *   - which tests are likely affected
+ *   - which new functions look orphaned
+ */
+
+'use strict';
+
+const { diffImpact } = require('./analysis');
+
+/**
+ * Run the pre-commit check.
+ *
+ * @param {object} index - ProjectIndex
+ * @param {object} options - { base, staged, file, limit }
+ * @returns {object}
+ */
+function check(index, options = {}) {
+    let dr;
+    try {
+        dr = diffImpact(index, {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            file: options.file,
+        });
+    } catch (e) {
+        // Not a git repo, or git command failed — treat as empty
+        return {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            empty: true,
+            reason: e && e.message ? e.message : 'diff failed',
+        };
+    }
+
+    // diffImpact returns { base, functions, newFunctions, deletedFunctions }
+    const modified = (dr && Array.isArray(dr.functions)) ? dr.functions : [];
+    const added    = (dr && Array.isArray(dr.newFunctions)) ? dr.newFunctions : [];
+    const deleted  = (dr && Array.isArray(dr.deletedFunctions)) ? dr.deletedFunctions : [];
+
+    const allChanged = [
+        ...modified.map(f => ({ ...f, _kind: 'modified' })),
+        ...added.map(f => ({ ...f, _kind: 'added' })),
+    ];
+
+    if (!dr || (modified.length === 0 && added.length === 0 && deleted.length === 0)) {
+        return {
+            base: options.base || 'HEAD',
+            staged: !!options.staged,
+            empty: true,
+            reason: dr && dr.error ? dr.error : 'no changes detected',
+        };
+    }
+
+    const limit = options.limit && options.limit > 0 ? options.limit : null;
+    const changed = limit ? allChanged.slice(0, limit) : allChanged;
+
+    const items = [];
+    const reachable = computeReachableSet(index);
+
+    // For each changed function, run verify and gather caller summary
+    for (const fn of changed) {
+        const filePath = fn.relativePath || fn.file || '';
+        let verifyResult = null;
+        try {
+            verifyResult = index.verify(fn.name, { file: filePath });
+        } catch (e) {
+            verifyResult = null;
+        }
+        // Note: verify() returns `mismatches` as a COUNT and `mismatchDetails` as the array.
+        const mismatches = verifyResult && Array.isArray(verifyResult.mismatchDetails)
+            ? verifyResult.mismatchDetails
+            : [];
+
+        // For modified functions, the existing diffImpact result has `callers` already
+        let callers = Array.isArray(fn.callers) ? fn.callers : [];
+        if (callers.length === 0 && fn._kind === 'added') {
+            try {
+                callers = index.findCallers(fn.name, { includeMethods: true, includeUncertain: false }) || [];
+            } catch (e) { /* skip */ }
+        }
+
+        const item = {
+            name: fn.name,
+            file: filePath,
+            line: fn.startLine || fn.line,
+            kind: fn._kind,
+            callerCount: callers.length,
+            signatureMismatches: mismatches.length,
+            ...(mismatches.length > 0 && { mismatches: mismatches.slice(0, 5) }),
+        };
+
+        // Orphan = newly added with zero callers AND not detected as an entry point.
+        // (A new helper called by another new helper is still NOT orphan; reachability
+        //  is rebuilt as the user iterates, and false positives here cause noise.)
+        if (item.kind === 'added' && callers.length === 0) {
+            // Check entry points: if the symbol is a known entry-point pattern, not orphan
+            let isEntry = false;
+            try {
+                const ep = require('./entrypoints');
+                if (typeof ep.detectEntrypoints === 'function') {
+                    const eps = ep.detectEntrypoints(index) || [];
+                    isEntry = eps.some(e => e.name === fn.name && (e.file === filePath || e.relativePath === filePath));
+                }
+            } catch (e) { /* skip */ }
+            item.orphan = !isEntry;
+        }
+
+        items.push(item);
+    }
+
+    // Surface deleted functions inline — they don't have line/file but still matter
+    for (const d of deleted) {
+        items.push({
+            name: d.name || '(unnamed)',
+            file: d.relativePath || d.file || '',
+            line: d.startLine || 0,
+            kind: 'deleted',
+            callerCount: 0,
+            signatureMismatches: 0,
+        });
+    }
+
+    // Affected tests (top-level summary, capped)
+    let testFiles = [];
+    let testCount = 0;
+    for (const fn of changed.slice(0, 10)) {
+        try {
+            const t = index.affectedTests(fn.name, { depth: 2 });
+            if (t && t.testFiles) {
+                for (const tf of t.testFiles) {
+                    if (!testFiles.find(x => x.file === tf.file)) {
+                        testFiles.push(tf);
+                        testCount += tf.testCount || 0;
+                    }
+                }
+            }
+        } catch (e) { /* skip */ }
+    }
+
+    // Action items
+    const actions = [];
+    for (const it of items) {
+        if (it.signatureMismatches > 0) {
+            actions.push({
+                severity: 'warn',
+                kind: 'signature_drift',
+                message: `${it.name}: ${it.signatureMismatches} call site(s) need updating`,
+            });
+        }
+        if (it.orphan) {
+            actions.push({
+                severity: 'warn',
+                kind: 'orphan_new',
+                message: `${it.name} is new but has no callers and is not an entry point`,
+            });
+        }
+    }
+    if (testFiles.length > 0) {
+        const filesList = testFiles.slice(0, 5).map(t => t.file).join(' ');
+        actions.push({
+            severity: 'info',
+            kind: 'tests_to_run',
+            message: `Run tests: ${filesList}`,
+        });
+    }
+
+    return {
+        base: options.base || 'HEAD',
+        staged: !!options.staged,
+        changed: items,
+        totalChanged: allChanged.length + deleted.length,
+        truncated: !!(limit && allChanged.length > limit),
+        testFiles,
+        totalTestFiles: testFiles.length,
+        totalTests: testCount,
+        actions,
+    };
+}
+
+function symbolKey(file, line) {
+    return `${file}:${line}`;
+}
+
+function computeReachableSet(index) {
+    try {
+        const ep = require('./entrypoints');
+        if (typeof ep.computeReachability === 'function') {
+            return ep.computeReachability(index);
+        }
+    } catch (e) { /* fall through */ }
+    return null;
+}
+
+module.exports = { check };

package/core/discovery.js

@@ -393,43 +393,68 @@ function findProjectRoot(startDir) {
     return path.resolve(startDir);
 }
 
+// All file extensions for languages UCN supports as code analysis (excludes .rb/.php/.c/.cpp etc.
+// which are extensions UCN scans but doesn't analyze). When build manifests can't tell us
+// what's in a project, we scan all of these — the file extension alone determines language.
+const ALL_SUPPORTED_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'py', 'go', 'java', 'rs', 'html', 'htm'];
+
+// Build-manifest hints: when present, we know the project has files of that language
+// regardless of whether sources are visible at the time of scan. Used as hints, not gates —
+// any source file extension is included whether or not its manifest is present.
+const MANIFEST_HINTS = {
+    'package.json':      ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'html', 'htm'],
+    'pyproject.toml':    ['py'],
+    'setup.py':          ['py'],
+    'requirements.txt':  ['py'],
+    'go.mod':            ['go'],
+    'Cargo.toml':        ['rs'],
+    'pom.xml':           ['java'],
+    'build.gradle':      ['java'],
+    'build.gradle.kts':  ['java'],
+};
+
 /**
- * Auto-detect the glob pattern for a project based on its type
- * Checks both project root and immediate subdirectories for config files
+ * Auto-detect the glob pattern for a project.
+ *
+ * Discovery rule: build manifests are HINTS, not gates. We always scan ALL supported
+ * language extensions (JS/TS/Python/Go/Rust/Java/HTML). Manifests only inform metadata
+ * (e.g., flagging a project as "has Go") and never exclude files.
+ *
+ * This means a polyglot project with only `package.json` still discovers .py/.go/.rs
+ * files — language is determined by extension, not by manifest presence.
+ *
+ * Manifests are still useful for:
+ *   - Project root detection (see findProjectRoot / PROJECT_MARKERS)
+ *   - Conditional ignores (vendor/target/Pods/etc. — see CONDITIONAL_IGNORES)
+ *   - Language hints in stats output
  */
 function detectProjectPattern(projectRoot) {
-    const extensions = [];
-
-    // Helper to check for config files in a directory
-    const checkDir = (dir) => {
-        if (fs.existsSync(path.join(dir, 'package.json'))) {
-            extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'html', 'htm');
-        }
-
-        if (fs.existsSync(path.join(dir, 'pyproject.toml')) ||
-            fs.existsSync(path.join(dir, 'setup.py')) ||
-            fs.existsSync(path.join(dir, 'requirements.txt'))) {
-            extensions.push('py');
-        }
-
-        if (fs.existsSync(path.join(dir, 'go.mod'))) {
-            extensions.push('go');
-        }
+    // Always scan all supported language extensions. Build manifests no longer gate
+    // language inclusion — file extension alone determines what gets analyzed.
+    return `**/*.{${ALL_SUPPORTED_EXTENSIONS.join(',')}}`;
+}
 
-        if (fs.existsSync(path.join(dir, 'Cargo.toml'))) {
-            extensions.push('rs');
-        }
+/**
+ * Detect which manifest hints are present in a project root or immediate subdirectories.
+ * Returns array of detected language extension hints. Used purely informationally —
+ * not as a gate on which files get scanned.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {string[]} Array of language extension strings (e.g., ['js', 'py', 'go'])
+ */
+function detectManifestHints(projectRoot) {
+    const hints = new Set();
 
-        if (fs.existsSync(path.join(dir, 'pom.xml')) ||
-            fs.existsSync(path.join(dir, 'build.gradle'))) {
-            extensions.push('java');
+    const checkDir = (dir) => {
+        for (const [marker, exts] of Object.entries(MANIFEST_HINTS)) {
+            if (fs.existsSync(path.join(dir, marker))) {
+                for (const ext of exts) hints.add(ext);
+            }
         }
     };
 
-    // Check project root
     checkDir(projectRoot);
 
-    // Also check immediate subdirectories for multi-language projects (e.g., web/, frontend/, server/)
     try {
         const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
         for (const entry of entries) {
@@ -442,12 +467,7 @@ function detectProjectPattern(projectRoot) {
         // Ignore errors reading directory
     }
 
-    if (extensions.length > 0) {
-        const unique = [...new Set(extensions)];
-        return `**/*.{${unique.join(',')}}`;
-    }
-
-    return '**/*.{js,jsx,ts,tsx,py,go,java,rs,rb,php,c,cpp,h,hpp,html,htm}';
+    return [...hints];
 }
 
 /**
@@ -541,11 +561,14 @@ module.exports = {
     shouldIgnore,
     findProjectRoot,
     detectProjectPattern,
+    detectManifestHints,
     getFileStats,
     isTestFile,
     findTestFileFor,
     parseGitignore,
     DEFAULT_IGNORES,
     PROJECT_MARKERS,
-    TEST_PATTERNS
+    TEST_PATTERNS,
+    ALL_SUPPORTED_EXTENSIONS,
+    MANIFEST_HINTS
 };