gitnexus 1.6.11-rc.21 → 1.6.11-rc.23

package/dist/core/ingestion/pipeline-phases/spring-auto-configuration.js

@@ -15,6 +15,7 @@ import path from 'node:path';
 import { generateId } from '../../../lib/utils.js';
 import { logger } from '../../logger.js';
 import { SPRING_AUTO_CONFIGURATION_FACTORY_REASON, SPRING_AUTO_CONFIGURATION_IMPORT_REASON, SPRING_AUTO_CONFIGURATION_SYNTHETIC_DESCRIPTION, } from '../frameworks/spring/auto-configuration.js';
+import { importSpringActuatorRuntime, MAX_RUNTIME_RECORDS, } from '../frameworks/spring/actuator-runtime.js';
 import { isDev } from '../utils/env.js';
 import { getPhaseOutput } from './types.js';
 const MAX_SPRING_METADATA_BYTES = 2 * 1024 * 1024;
@@ -246,10 +247,17 @@ export const springAutoConfigurationPhase = {
             logger.debug(`Spring auto-configuration: skipped ${ambiguousQualifiedNames.size} ambiguous FQN(s) ` +
                 `because classpath precedence is unknown: ${[...ambiguousQualifiedNames].sort().join(', ')}`);
         }
+        const actuatorRuntime = ctx.options?.springActuatorPath === undefined
+            ? undefined
+            : await importSpringActuatorRuntime(ctx.graph, ctx.repoPath, ctx.options.springActuatorPath);
+        if (actuatorRuntime !== undefined && actuatorRuntime.truncatedEndpoints.length > 0) {
+            logger.warn(`Spring Actuator runtime import reached the ${MAX_RUNTIME_RECORDS.toLocaleString('en-US')}-record limit for: ${actuatorRuntime.truncatedEndpoints.join(', ')}. Runtime evidence is incomplete.`);
+        }
         return {
             metadataFiles,
             autoConfigurations,
             ambiguousAutoConfigurations: ambiguousQualifiedNames.size,
+            ...(actuatorRuntime === undefined ? {} : { actuatorRuntime }),
         };
     },
 };

package/dist/core/ingestion/pipeline.d.ts

@@ -31,6 +31,14 @@ export interface PipelineOptions {
      * Community/Process rows can be kept instead of wipe+rewrite.
      */
     skipDerivedGraphPhases?: boolean;
+    /**
+     * Explicit local Spring Boot Actuator snapshot input. Accepts a directory
+     * containing endpoint-named JSON files or a JSON bundle keyed by endpoint.
+     * Undefined keeps runtime enrichment completely disabled.
+     */
+    springActuatorPath?: string;
+    /** Repo-relative Actuator inputs retained only for a cleanup scan. */
+    springActuatorScanExclusions?: readonly string[];
     /** Per-advice Spring AOP candidate inspection cap. `0` disables this cap. */
     springAopMaxCandidateInspectionsPerAdvice?: number;
     /** Aggregate Spring AOP candidate inspection cap for one analysis. `0` disables this cap. */

package/dist/core/ingestion/route-extractors/constant-resolver.d.ts

@@ -62,7 +62,23 @@ export interface ModuleConstants {
     readonly literals: Map<string, string>;
     readonly exprs: Map<string, readonly Operand[]>;
     readonly imports: Map<string, ImportBinding>;
+    /**
+     * On-demand (wildcard) import specifiers whose bound member names could not
+     * be enumerated at extract time — Java `import static a.b.C.*;`, Python
+     * `from m import *`. The agnostic fold never reads this (it has no way to
+     * enumerate a target module's exports); a language binding materializes the
+     * promised bindings from a repo-wide map after extraction — see
+     * `expandJavaWildcardStaticImports` in the Java binding — so they resolve
+     * through the plain `imports` path with no special cases in the fold.
+     */
+    readonly wildcardImports?: readonly string[];
 }
+/**
+ * Declaration keys a language extractor found but could not fold. Java and
+ * Kotlin both use this metadata to keep lower-priority imports from replacing
+ * a real local declaration; other producers simply return the empty set.
+ */
+export declare function unfoldableDeclarationsOf(mc: ModuleConstants | undefined): ReadonlySet<string>;
 /** Repo-wide map: unique file key (e.g. `app/constants.py`) → that file's
  * {@link ModuleConstants}. */
 export type RepoConstants = ReadonlyMap<string, ModuleConstants>;

package/dist/core/ingestion/route-extractors/constant-resolver.js

@@ -32,6 +32,16 @@ const MAX_RESOLVE_DEPTH = 8;
  * so we floor to `null` (skip) instead (#2393). The depth cap bounds recursion but
  * NOT output size, which grows multiplicatively; this bounds the output. */
 export const MAX_FOLD_LENGTH = 8192;
+const NO_UNFOLDABLE_DECLARATIONS = new Set();
+/**
+ * Declaration keys a language extractor found but could not fold. Java and
+ * Kotlin both use this metadata to keep lower-priority imports from replacing
+ * a real local declaration; other producers simply return the empty set.
+ */
+export function unfoldableDeclarationsOf(mc) {
+    const declarations = mc?.unfoldableDeclarations;
+    return declarations instanceof Set ? declarations : NO_UNFOLDABLE_DECLARATIONS;
+}
 /**
  * Fold an operand list to its concatenated literal, or `null` if any operand is
  * unresolvable (an unknown name, a non-string term, a cycle, or a depth overrun).

package/dist/core/ingestion/route-extractors/java-const-resolver.d.ts

@@ -42,6 +42,10 @@
 import type Parser from 'tree-sitter';
 import { type ImportResolver, type ModuleConstants, type Operand, type RepoConstants } from './constant-resolver.js';
 export type { ImportBinding, ModuleConstants, Operand, RepoConstants, } from './constant-resolver.js';
+export interface JavaModuleConstants extends ModuleConstants {
+    /** Declaration keys whose initializer exists but cannot be folded. */
+    readonly unfoldableDeclarations: ReadonlySet<string>;
+}
 export declare function isJavaConstantFile(source: string): boolean;
 /**
  * The Java {@link ImportResolver}: map a fully-qualified import specifier to
@@ -96,7 +100,7 @@ export declare function parseJavaConstOperands(node: Parser.SyntaxNode | null |
  * Last-wins in source order; a non-foldable rebind (`X = compute()`) drops X
  * to unresolvable rather than keeping a stale literal.
  */
-export declare function extractJavaModuleConstants(tree: Parser.Tree): ModuleConstants;
+export declare function extractJavaModuleConstants(tree: Parser.Tree): JavaModuleConstants;
 /**
  * Resolve a single Java constant referenced in `fileKey` to its literal string
  * value, folding `+` concatenation and following import chains via
@@ -112,3 +116,25 @@ export declare function resolveJavaConstant(fileKey: string, name: string, repo:
  * `fileKey`, or null when any piece is unresolvable (skip floor).
  */
 export declare function foldJavaOperands(fileKey: string, operands: readonly Operand[], repo: RepoConstants): string | null;
+/**
+ * Constant-defining file keys used by Java import resolution.
+ *
+ * Build once per repo pass. Recomputing this set for every wildcard-importing
+ * controller makes expansion quadratic in controller count.
+ */
+export declare function buildJavaConstantKeys(repo: RepoConstants): ReadonlySet<string>;
+export interface JavaConstantIndex {
+    readonly keys: ReadonlySet<string>;
+    /** Every resolvable path suffix as a dotted module name; null means ambiguous. */
+    readonly byModule: ReadonlyMap<string, string | null>;
+    /** Direct members by constant-defining file, built once for all importers. */
+    readonly membersByFile: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/**
+ * Build all Java import suffixes once, turning repeated wildcard target lookup
+ * from O(importers × constant files) into O(path segments + importers).
+ */
+export declare function buildJavaConstantIndex(repo: RepoConstants): JavaConstantIndex;
+export declare function expandJavaWildcardStaticImports(mc: ModuleConstants, _fileKey: string, repo: RepoConstants, index?: JavaConstantIndex): ModuleConstants;
+/** Prepare every Java constants entry with one shared suffix index. */
+export declare function prepareJavaRouteConstants(repo: RepoConstants): JavaConstantIndex;

package/dist/core/ingestion/route-extractors/java-const-resolver.js

@@ -40,7 +40,7 @@
  * the import is ambiguous and returns null (skip floor), never a wrong path.
  */
 import { unquoteSpringLiteral } from './spring-shared.js';
-import { MAX_FOLD_LENGTH, } from './constant-resolver.js';
+import { MAX_FOLD_LENGTH, unfoldableDeclarationsOf, } from './constant-resolver.js';
 /**
  * Cheap content gate: can this Java file DEFINE a string constant that a route
  * annotation might reference?
@@ -121,10 +121,15 @@ export const resolveJavaImport = (_importingFileKey, moduleSpec, repoKeys) => {
     // trimming the last segment when the direct hit fails covers both shapes.
     const asPath = moduleSpec.replace(/\./g, '/');
     const classFile = `${asPath}.java`;
+    // Compare in POSIX space: on Windows the repo keys can carry backslash
+    // separators, which would otherwise never match a '/'-joined class file
+    // (observed as 675 calls with zero hits on a backslash-keyed repo).
+    const toPosix = (p) => p.replace(/\\/g, '/');
     // Exact package-path suffix match, unique or nothing.
     let hit = null;
     for (const key of repoKeys) {
-        if (key === classFile || key.endsWith(`/${classFile}`)) {
+        const posixKey = toPosix(key);
+        if (posixKey === classFile || posixKey.endsWith(`/${classFile}`)) {
             if (hit !== null)
                 return null; // 2+ modules carry this FQN — unresolvable
             hit = key;
@@ -251,25 +256,48 @@ export function extractJavaModuleConstants(tree) {
     const literals = new Map();
     const exprs = new Map();
     const imports = new Map();
+    const unfoldableDeclarations = new Set();
+    // On-demand static imports (`import static a.b.C.*`) — expanded post-map
+    // by expandJavaWildcardStaticImports below.
+    const wildcardImports = [];
     // Pass 1: imports (both shapes).
     const walkImports = (node) => {
         if (node.type === 'import_declaration') {
             // import a.b.C;  |  import static a.b.C;  |  import static a.b.C.F;
+            // import static a.b.C.*;  — asterisk is a sibling of scoped_identifier
+            // (tree-sitter-java), not the last path segment. Same detection as
+            // import-decomposer.ts (`static-wildcard`).
             const isStatic = node.children.some((c) => c.type === 'static' && c.text === 'static');
-            const scoped = node.children.find((c) => c.type === 'scoped_identifier');
+            const isWildcard = node.children.some((c) => c.type === 'asterisk');
+            const scoped = node.children.find((c) => c.type === 'scoped_identifier') ??
+                node.children.find((c) => c.type === 'identifier');
             if (scoped) {
                 const text = scoped.text;
-                const lastDot = text.lastIndexOf('.');
-                const fqn = text.slice(0, lastDot);
-                const name = text.slice(lastDot + 1);
-                if (isStatic) {
-                    // import static a.b.C.F → local F from module a.b.C, original F.
-                    imports.set(name, { module: fqn, originalName: name });
+                if (isStatic && isWildcard) {
+                    // Class FQN only — members are materialized post-map.
+                    if (text.length > 0 && !wildcardImports.includes(text)) {
+                        wildcardImports.push(text);
+                    }
                 }
                 else {
-                    // import a.b.C → module IS the class FQN; originalName is the class
-                    // simple name. resolveJavaImport maps `a.b.C` → `a/b/C.java`.
-                    imports.set(name, { module: text, originalName: name });
+                    const lastDot = text.lastIndexOf('.');
+                    const fqn = text.slice(0, lastDot);
+                    const name = text.slice(lastDot + 1);
+                    if (isStatic) {
+                        // Preserve the declaring type in the target lookup. Constants from
+                        // multiple types share one file-level map, so a bare `F` could
+                        // otherwise resolve to a sibling type's flattened field.
+                        const declaringClass = fqn.slice(fqn.lastIndexOf('.') + 1);
+                        imports.set(name, {
+                            module: fqn,
+                            originalName: `${declaringClass}.${name}`,
+                        });
+                    }
+                    else {
+                        // import a.b.C → module IS the class FQN; originalName is the class
+                        // simple name. resolveJavaImport maps `a.b.C` → `a/b/C.java`.
+                        imports.set(name, { module: text, originalName: name });
+                    }
                 }
             }
         }
@@ -328,6 +356,7 @@ export function extractJavaModuleConstants(tree) {
                 if (operands === null) {
                     literals.delete(name);
                     exprs.delete(name);
+                    unfoldableDeclarations.add(name);
                     // …and the static IMPORT of the same simple name. A local
                     // `static final String` shadows `import static a.b.C.PATH` inside
                     // that class (JLS 6.4.1), so the correct answer for a non-foldable
@@ -348,9 +377,13 @@ export function extractJavaModuleConstants(tree) {
                     if (qname) {
                         literals.delete(qname);
                         exprs.delete(qname);
+                        unfoldableDeclarations.add(qname);
                     }
                     continue;
                 }
+                unfoldableDeclarations.delete(name);
+                if (qname)
+                    unfoldableDeclarations.delete(qname);
                 const literalValue = operands.length === 1 && operands[0].kind === 'literal'
                     ? operands[0].value
                     : null;
@@ -419,7 +452,13 @@ export function extractJavaModuleConstants(tree) {
         }
     };
     walkTypes(tree.rootNode, false);
-    return { literals, exprs, imports: imports };
+    return {
+        literals,
+        exprs,
+        imports: imports,
+        wildcardImports,
+        unfoldableDeclarations,
+    };
 }
 function newFoldState(repo) {
     const constantKeys = new Set();
@@ -524,6 +563,8 @@ function computeJavaFold(fileKey, name, state, depth) {
     const expr = mc.exprs.get(name);
     if (expr !== undefined)
         return foldOperands(fileKey, expr, state, depth + 1);
+    if (unfoldableDeclarationsOf(mc).has(name))
+        return null;
     const imp = mc.imports.get(name);
     if (imp !== undefined) {
         const targetFile = resolveJavaImport(fileKey, imp.module, constantKeys);
@@ -567,3 +608,110 @@ export function foldJavaOperands(fileKey, operands, repo) {
     const out = foldOperands(fileKey, operands, newFoldState(repo), 0);
     return out === '' ? null : out;
 }
+/**
+ * Constant-defining file keys used by Java import resolution.
+ *
+ * Build once per repo pass. Recomputing this set for every wildcard-importing
+ * controller makes expansion quadratic in controller count.
+ */
+export function buildJavaConstantKeys(repo) {
+    const repoKeys = new Set();
+    for (const [key, target] of repo) {
+        if (target.literals.size > 0 || target.exprs.size > 0)
+            repoKeys.add(key);
+    }
+    return repoKeys;
+}
+/** Direct static members owned by `classSimple`, excluding nested-type members. */
+function directJavaMembers(target, classSimple) {
+    const members = new Set();
+    const prefix = `${classSimple}.`;
+    for (const map of [target.literals, target.exprs]) {
+        for (const key of map.keys()) {
+            if (!key.startsWith(prefix))
+                continue;
+            const member = key.slice(prefix.length);
+            if (member.length > 0 && !member.includes('.'))
+                members.add(member);
+        }
+    }
+    return members;
+}
+/**
+ * Build all Java import suffixes once, turning repeated wildcard target lookup
+ * from O(importers × constant files) into O(path segments + importers).
+ */
+export function buildJavaConstantIndex(repo) {
+    const keys = buildJavaConstantKeys(repo);
+    const byModule = new Map();
+    const membersByFile = new Map();
+    for (const key of keys) {
+        const normalized = key.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (!normalized.endsWith('.java'))
+            continue;
+        const segments = normalized.slice(0, -'.java'.length).split('/');
+        const classSimple = segments[segments.length - 1];
+        const constants = repo.get(key);
+        if (constants)
+            membersByFile.set(key, directJavaMembers(constants, classSimple));
+        for (let start = 0; start < segments.length; start++) {
+            const moduleName = segments.slice(start).join('.');
+            const existing = byModule.get(moduleName);
+            if (existing === undefined)
+                byModule.set(moduleName, key);
+            else if (existing !== key)
+                byModule.set(moduleName, null);
+        }
+    }
+    return { keys, byModule, membersByFile };
+}
+export function expandJavaWildcardStaticImports(mc, _fileKey, repo, index = buildJavaConstantIndex(repo)) {
+    const wildcards = mc.wildcardImports;
+    if (!wildcards || wildcards.length === 0)
+        return mc;
+    // Resolve targets against constant-DEFINING files only. Ingestion's harvest
+    // also admits import-only files; measuring uniqueness over every key made
+    // a duplicate empty FQN floor ingestion to skip while group still folded
+    // (#2980 R4).
+    const explicitImports = new Set(mc.imports.keys());
+    const pending = new Map();
+    for (const fqn of wildcards) {
+        const targetKey = index.byModule.get(fqn) ?? null;
+        if (targetKey === null)
+            continue;
+        const classSimple = fqn.slice(fqn.lastIndexOf('.') + 1);
+        const members = index.membersByFile.get(targetKey);
+        if (!members)
+            continue;
+        for (const name of members) {
+            // Same-file declarations and explicit imports have higher precedence
+            // than on-demand imports. An unfoldable declaration must remain a skip,
+            // not be resurrected from a wildcard target.
+            if (mc.literals.has(name) ||
+                mc.exprs.has(name) ||
+                unfoldableDeclarationsOf(mc).has(name) ||
+                explicitImports.has(name)) {
+                continue;
+            }
+            const binding = { module: fqn, originalName: `${classSimple}.${name}` };
+            const previous = pending.get(name);
+            if (previous === undefined)
+                pending.set(name, binding);
+            else if (previous !== null && previous.module !== fqn)
+                pending.set(name, null);
+        }
+    }
+    for (const [name, binding] of pending) {
+        if (binding !== null)
+            mc.imports.set(name, binding);
+    }
+    return mc;
+}
+/** Prepare every Java constants entry with one shared suffix index. */
+export function prepareJavaRouteConstants(repo) {
+    const index = buildJavaConstantIndex(repo);
+    for (const [fileKey, mc] of repo) {
+        expandJavaWildcardStaticImports(mc, fileKey, repo, index);
+    }
+    return index;
+}

package/dist/core/ingestion/route-extractors/kotlin-const-resolver.d.ts

@@ -95,6 +95,7 @@
  *   @PostMapping(ApiPaths.ORDERS)                      // qualified
  *   @PostMapping(com.example.app.api.ApiPaths.ORDERS)  // FQN-qualified
  *   @PostMapping(ORDERS)                               // single-name import
+ *   @PostMapping(ORDERS) after import com.example.api.* // package-star import
  *   @PostMapping(ApiPaths.BASE + "/orders")            // inline concat
  *
  * Which ANNOTATIONS count as routes is a separate question this module has no
@@ -136,6 +137,7 @@
 import type Parser from 'tree-sitter';
 import { type ModuleConstants, type Operand, type RepoConstants } from './constant-resolver.js';
 export type { ImportBinding, ModuleConstants, Operand, RepoConstants, } from './constant-resolver.js';
+export { unfoldableDeclarationsOf } from './constant-resolver.js';
 /**
  * What {@link extractKotlinModuleConstants} returns: the agnostic
  * {@link ModuleConstants} plus the one piece of per-file metadata JVM import
@@ -162,12 +164,9 @@ export interface KotlinModuleConstants extends ModuleConstants {
     readonly packageName: string;
     /** Declaration keys whose initializer cannot be folded. */
     readonly unfoldableDeclarations: ReadonlySet<string>;
+    /** Top-level properties and types that shadow lower-priority star imports. */
+    readonly topLevelDeclarations: ReadonlySet<string>;
 }
-/**
- * Kotlin declaration keys known to exist but not fold, or an empty set when
- * `mc` came from another language binding.
- */
-export declare function unfoldableDeclarationsOf(mc: ModuleConstants | undefined): ReadonlySet<string>;
 /**
  * The name a backtick-quoted Kotlin identifier denotes: `` `api` `` → `api`.
  *
@@ -294,9 +293,9 @@ export declare function resolveKotlinImportWithIndex(rawModuleSpec: string, inde
  */
 export declare function parseKotlinConstOperands(node: Parser.SyntaxNode | null | undefined, depth?: number): Operand[] | null;
 /**
- * Extract the declared package, file-level string constants and import bindings
- * of one parsed Kotlin file into the {@link KotlinModuleConstants} shape the
- * resolver consumes.
+ * Extract the declared package, file-level string constants, named imports and
+ * package-star import scopes of one parsed Kotlin file into the
+ * {@link KotlinModuleConstants} shape the resolver consumes.
  *
  * Constants come from the three carriers Kotlin allows a caller to reach without
  * an instance: file top level, `object` members, and `companion object` members.