cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/finalize-orchestrator.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * `finalizeScopeModel` — turn a workspace's `ParsedFile[]` into a
+ * materialized `ScopeResolutionIndexes` (RFC §3.2 Phase 2; Ring 2 PKG #921).
+ *
+ * Thin integration glue, per issue #884's boundary: all algorithmic logic
+ * lives in `cgraph-shared` (finalize algorithm #915, the four per-file
+ * indexes #913, the method-dispatch materialization #914, the scope tree
+ * #912). This file does three things only:
+ *
+ *   1. Map `ParsedFile[]` → `FinalizeInput` and call shared `finalize()`.
+ *   2. Build the four workspace-wide indexes from the union of per-file
+ *      defs/scopes/modules/qualified-names.
+ *   3. Bundle the results into `ScopeResolutionIndexes` for
+ *      `MutableSemanticModel.attachScopeIndexes(...)`.
+ *
+ * ## What this module is NOT responsible for
+ *
+ *   - Invoking tree-sitter or running AST walks. That's the extractor (#919).
+ *   - Per-language import-target resolution. Hooks are plumbed through
+ *     but default to "unresolved" when no provider supplies them — the
+ *     real adapters land with #922.
+ *   - Populating `ReferenceIndex`. That's the resolution phase (#925).
+ *   - Deciding which language uses registry-primary lookup. That's the
+ *     flag reader (#924).
+ *
+ * ## Empty-input behavior
+ *
+ * When `parsedFiles` is empty (the common case today — no language has
+ * migrated yet), the orchestrator produces a valid but empty bundle: all
+ * indexes are zero-sized, the scope tree is empty, and
+ * `finalize.stats.totalFiles === 0`. This lets downstream consumers
+ * safely consult `model.scopes` without branching on presence.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeScopeModel = finalizeScopeModel;
+const index_js_1 = require("../../../shared/index.js");
+const env_js_1 = require("./utils/env.js");
+const scope_index_store_js_1 = require("../../storage/scope-index-store.js");
+/**
+ * Produce a fully materialized `ScopeResolutionIndexes` from the
+ * workspace's per-file artifacts.
+ *
+ * Pure function (given pure hooks). No I/O, no globals consulted. The
+ * pipeline calls this once per ingestion run and hands the result to
+ * `MutableSemanticModel.attachScopeIndexes`.
+ */
+function finalizeScopeModel(parsedFiles, options = {}) {
+    const hooks = withDefaultHooks(options.hooks ?? {});
+    const workspaceIndex = options.workspaceIndex ?? undefined;
+    // ── Step 1: Shared finalize — runs SCC-aware cross-file link + binding
+    // materialization. Returns linked imports + merged bindings per module
+    // scope + SCC condensation + stats.
+    const finalizeInput = {
+        files: parsedFiles.map(toFinalizeFile),
+        workspaceIndex,
+    };
+    const finalizeOut = (0, index_js_1.finalize)(finalizeInput, hooks);
+    // ── Step 2: Workspace-wide indexes built from the per-file unions.
+    // These are pure aggregations — no algorithm beyond what the builders
+    // in cgraph-shared already encapsulate (first-write-wins, qname
+    // collision buckets, etc.).
+    const allScopes = [];
+    const allDefs = [];
+    const moduleEntries = [];
+    const allReferenceSites = collectReferenceSites(parsedFiles);
+    for (const file of parsedFiles) {
+        for (const s of file.scopes)
+            allScopes.push(s);
+        for (const d of file.localDefs)
+            allDefs.push(d);
+        moduleEntries.push({ filePath: file.filePath, moduleScopeId: file.moduleScope });
+    }
+    // Out-of-core scope index: when enabled, build a TransitionalScopeTree
+    // (validated + fully resident now; sealed to disk by run.ts just before emit so
+    // the heavy Scope.bindings payload is reclaimed). Default off → the in-heap
+    // buildScopeTree result exactly, byte-identical.
+    const scopeTree = (0, env_js_1.parseTruthyEnv)(process.env.CGRAPH_DISK_SCOPE_INDEX)
+        ? new scope_index_store_js_1.TransitionalScopeTree(allScopes)
+        : (0, index_js_1.buildScopeTree)(allScopes);
+    const defs = (0, index_js_1.buildDefIndex)(allDefs);
+    const qualifiedNames = (0, index_js_1.buildQualifiedNameIndex)(allDefs);
+    const moduleScopes = (0, index_js_1.buildModuleScopeIndex)(moduleEntries);
+    // ── Step 3: MethodDispatchIndex. Today we lack per-language MRO
+    // strategies wired into this orchestrator (that belongs with the
+    // MRO bridge, a separate piece of work). Ship an EMPTY index
+    // so the bundle shape is consistent; the callbacks return `[]` for
+    // every owner and `implementsOf` returns `[]`. Populating this
+    // properly is tracked alongside the per-language provider hooks.
+    const methodDispatch = (0, index_js_1.buildMethodDispatchIndex)({
+        owners: [], // empty → no MRO entries; `mroFor(x)` returns the frozen empty array
+        computeMro: () => [],
+        implementsOf: () => [],
+    });
+    return {
+        scopeTree,
+        defs,
+        qualifiedNames,
+        moduleScopes,
+        methodDispatch,
+        imports: finalizeOut.imports,
+        bindings: finalizeOut.bindings,
+        // Empty post-finalize augmentation channel. Populated (if at all)
+        // by language hooks like `populateCsharpNamespaceSiblings` running
+        // AFTER `finalizeScopeModel` returns, before `resolveReferenceSites`
+        // consumes the bundle. Most languages leave it empty.
+        bindingAugmentations: new Map(),
+        workspaceFqnBindings: new Map(),
+        workspaceTypeBindings: new Map(),
+        namespaceFqnBindings: new Map(),
+        namespaceTypeBindings: new Map(),
+        accessibleNamespacesByScope: new Map(),
+        referenceSites: Object.freeze([...allReferenceSites]),
+        sccs: finalizeOut.sccs,
+        stats: finalizeOut.stats,
+    };
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+/** Shape-reduce a `ParsedFile` to the narrower `FinalizeFile` the shared
+ *  algorithm reads. The subset is stable — `FinalizeFile` is a proper
+ *  subset of `ParsedFile`. */
+function toFinalizeFile(file) {
+    return {
+        filePath: file.filePath,
+        moduleScope: file.moduleScope,
+        parsedImports: file.parsedImports,
+        localDefs: file.localDefs,
+    };
+}
+/** Flatten every file's reference sites into one list. Order reflects
+ *  input-file order, then capture order inside each file. Deterministic. */
+function collectReferenceSites(parsedFiles) {
+    const out = [];
+    for (const file of parsedFiles) {
+        for (const site of file.referenceSites)
+            out.push(site);
+    }
+    return out;
+}
+/**
+ * Fill in no-op defaults for any omitted hook. Keeps `finalize()`
+ * behavior well-defined for the zero-provider case today:
+ *
+ *   - `resolveImportTarget: () => null` — every import edge ends up
+ *     `linkStatus: 'unresolved'` (or dynamic-unresolved pass-through).
+ *   - `expandsWildcardTo: () => []` — wildcards don't materialize.
+ *   - `mergeBindings: (existing, incoming) => [...existing, ...incoming]`
+ *     — append without precedence; providers override to implement local-
+ *     shadows-import and similar rules.
+ */
+function withDefaultHooks(partial) {
+    return {
+        resolveImportTarget: partial.resolveImportTarget ?? (() => null),
+        isNamespaceImport: partial.isNamespaceImport,
+        expandsWildcardTo: partial.expandsWildcardTo ?? (() => []),
+        mergeBindings: partial.mergeBindings ??
+            ((existing, incoming) => [...existing, ...incoming]),
+    };
+}

package/dist/core/code/engine/core/ingestion/framework-detection.js

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Framework Detection
+ *
+ * Detects frameworks from:
+ * 1) file path patterns
+ * 2) AST definition text (decorators/annotations/attributes)
+ * and provides entry point multipliers for process scoring.
+ *
+ * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
+ * (no bonus, no penalty) - same behavior as before this feature.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFrameworkFromPath = detectFrameworkFromPath;
+exports.detectFrameworkFromAST = detectFrameworkFromAST;
+const index_js_1 = require("./languages/index.js");
+// ============================================================================
+// PATH-BASED FRAMEWORK DETECTION
+// ============================================================================
+/**
+ * Detect framework from file path patterns
+ *
+ * This provides entry point multipliers based on well-known framework conventions.
+ * Returns null if no framework pattern is detected (falls back to 1.0 multiplier).
+ */
+function detectFrameworkFromPath(filePath) {
+    // Normalize path separators and ensure leading slash for consistent matching
+    const originalPath = filePath.replace(/\\/g, '/');
+    let p = originalPath.toLowerCase();
+    if (!p.startsWith('/')) {
+        p = '/' + p; // Add leading slash so patterns like '/app/' match 'app/...'
+    }
+    const originalPathWithLeadingSlash = originalPath.startsWith('/')
+        ? originalPath
+        : `/${originalPath}`;
+    // ========== JAVASCRIPT / TYPESCRIPT FRAMEWORKS ==========
+    // Next.js - Pages Router (high confidence)
+    if (p.includes('/pages/') && !p.includes('/_') && !p.includes('/api/')) {
+        if (p.endsWith('.tsx') || p.endsWith('.ts') || p.endsWith('.jsx') || p.endsWith('.js')) {
+            return { framework: 'nextjs-pages', entryPointMultiplier: 3.0, reason: 'nextjs-page' };
+        }
+    }
+    // Next.js - App Router (page.tsx files)
+    if (p.includes('/app/') &&
+        (p.endsWith('page.tsx') ||
+            p.endsWith('page.ts') ||
+            p.endsWith('page.jsx') ||
+            p.endsWith('page.js'))) {
+        return { framework: 'nextjs-app', entryPointMultiplier: 3.0, reason: 'nextjs-app-page' };
+    }
+    // Next.js - API Routes
+    if (p.includes('/pages/api/') ||
+        (p.includes('/app/') && p.includes('/api/') && p.endsWith('route.ts'))) {
+        return { framework: 'nextjs-api', entryPointMultiplier: 3.0, reason: 'nextjs-api-route' };
+    }
+    // Next.js - Layout files (moderate - they're entry-ish but not the main entry)
+    if (p.includes('/app/') &&
+        !p.includes('_layout') &&
+        (p.endsWith('layout.tsx') || p.endsWith('layout.ts'))) {
+        return { framework: 'nextjs-app', entryPointMultiplier: 2.0, reason: 'nextjs-layout' };
+    }
+    // Expo Router - screen/layout/api files in app/ directory
+    if (p.includes('/app/') &&
+        (p.endsWith('.tsx') || p.endsWith('.ts') || p.endsWith('.jsx') || p.endsWith('.js'))) {
+        const fn = p.split('/').pop() || '';
+        if (fn.startsWith('_layout')) {
+            return { framework: 'expo-router', entryPointMultiplier: 2.0, reason: 'expo-layout' };
+        }
+        if (fn.startsWith('+') && !fn.startsWith('+api')) {
+            return { framework: 'expo-router', entryPointMultiplier: 1.5, reason: 'expo-special-route' };
+        }
+        if (fn.endsWith('+api.ts') || fn.endsWith('+api.tsx')) {
+            return { framework: 'expo-router', entryPointMultiplier: 3.0, reason: 'expo-api-route' };
+        }
+        return { framework: 'expo-router', entryPointMultiplier: 2.5, reason: 'expo-screen' };
+    }
+    // Prisma schema (ORM data model definition)
+    if (p.includes('/prisma/') && p.endsWith('schema.prisma')) {
+        return { framework: 'prisma', entryPointMultiplier: 1.5, reason: 'prisma-schema' };
+    }
+    // Supabase client files
+    if ((p.includes('/lib/supabase') || p.includes('/utils/supabase') || p.includes('/supabase/')) &&
+        (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'supabase', entryPointMultiplier: 1.5, reason: 'supabase-client' };
+    }
+    // Express / Node.js routes
+    if (p.includes('/routes/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'express', entryPointMultiplier: 2.5, reason: 'routes-folder' };
+    }
+    // Generic controllers (MVC pattern)
+    if (p.includes('/controllers/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'mvc', entryPointMultiplier: 2.5, reason: 'controllers-folder' };
+    }
+    // Generic handlers
+    if (p.includes('/handlers/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'handlers', entryPointMultiplier: 2.5, reason: 'handlers-folder' };
+    }
+    // React components (lower priority - not all are entry points)
+    if ((p.includes('/components/') || p.includes('/views/')) &&
+        (p.endsWith('.tsx') || p.endsWith('.jsx'))) {
+        // Only boost if PascalCase filename (likely a component, not util)
+        const fileName = originalPathWithLeadingSlash.split('/').pop() || '';
+        if (/^[A-Z]/.test(fileName)) {
+            return { framework: 'react', entryPointMultiplier: 1.5, reason: 'react-component' };
+        }
+    }
+    // ========== PYTHON FRAMEWORKS ==========
+    // Django views (high confidence)
+    if (p.endsWith('views.py')) {
+        return { framework: 'django', entryPointMultiplier: 3.0, reason: 'django-views' };
+    }
+    // Django URL configs
+    if (p.endsWith('urls.py')) {
+        return { framework: 'django', entryPointMultiplier: 2.0, reason: 'django-urls' };
+    }
+    // FastAPI / Flask routers
+    if ((p.includes('/routers/') || p.includes('/endpoints/') || p.includes('/routes/')) &&
+        p.endsWith('.py')) {
+        return { framework: 'fastapi', entryPointMultiplier: 2.5, reason: 'api-routers' };
+    }
+    // Python API folder
+    if (p.includes('/api/') && p.endsWith('.py') && !p.endsWith('__init__.py')) {
+        return { framework: 'python-api', entryPointMultiplier: 2.0, reason: 'api-folder' };
+    }
+    // ========== JAVA FRAMEWORKS ==========
+    // Spring Boot controllers
+    if ((p.includes('/controller/') || p.includes('/controllers/')) && p.endsWith('.java')) {
+        return { framework: 'spring', entryPointMultiplier: 3.0, reason: 'spring-controller' };
+    }
+    // Spring Boot - files ending in Controller.java
+    if (p.endsWith('controller.java')) {
+        return { framework: 'spring', entryPointMultiplier: 3.0, reason: 'spring-controller-file' };
+    }
+    // Java service layer (often entry points for business logic)
+    if ((p.includes('/service/') || p.includes('/services/')) && p.endsWith('.java')) {
+        return { framework: 'java-service', entryPointMultiplier: 1.8, reason: 'java-service' };
+    }
+    // ========== KOTLIN FRAMEWORKS ==========
+    // Spring Boot Kotlin controllers
+    if ((p.includes('/controller/') || p.includes('/controllers/')) && p.endsWith('.kt')) {
+        return {
+            framework: 'spring-kotlin',
+            entryPointMultiplier: 3.0,
+            reason: 'spring-kotlin-controller',
+        };
+    }
+    // Spring Boot - files ending in Controller.kt
+    if (p.endsWith('controller.kt')) {
+        return {
+            framework: 'spring-kotlin',
+            entryPointMultiplier: 3.0,
+            reason: 'spring-kotlin-controller-file',
+        };
+    }
+    // Ktor routes
+    if (p.includes('/routes/') && p.endsWith('.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routes' };
+    }
+    // Ktor plugins folder or Routing.kt files
+    if (p.includes('/plugins/') && p.endsWith('.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.0, reason: 'ktor-plugin' };
+    }
+    if (p.endsWith('routing.kt') || p.endsWith('routes.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routing-file' };
+    }
+    // Android Activities, Fragments
+    if ((p.includes('/activity/') || p.includes('/ui/')) && p.endsWith('.kt')) {
+        return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-ui' };
+    }
+    if (p.endsWith('activity.kt') || p.endsWith('fragment.kt')) {
+        return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-component' };
+    }
+    // Kotlin main entry point
+    if (p.endsWith('/main.kt')) {
+        return { framework: 'kotlin', entryPointMultiplier: 3.0, reason: 'kotlin-main' };
+    }
+    // Kotlin Application entry point (common naming)
+    if (p.endsWith('/application.kt')) {
+        return { framework: 'kotlin', entryPointMultiplier: 2.5, reason: 'kotlin-application' };
+    }
+    // ========== C# / .NET FRAMEWORKS ==========
+    // ASP.NET Controllers
+    if (p.includes('/controllers/') && p.endsWith('.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller' };
+    }
+    // ASP.NET - files ending in Controller.cs
+    if (p.endsWith('controller.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller-file' };
+    }
+    // ASP.NET Services
+    if ((p.includes('/services/') || p.includes('/service/')) && p.endsWith('.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 1.8, reason: 'aspnet-service' };
+    }
+    // ASP.NET Middleware
+    if (p.includes('/middleware/') && p.endsWith('.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 2.5, reason: 'aspnet-middleware' };
+    }
+    // SignalR Hubs
+    if (p.includes('/hubs/') && p.endsWith('.cs')) {
+        return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub' };
+    }
+    if (p.endsWith('hub.cs')) {
+        return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub-file' };
+    }
+    // Minimal API / Program.cs / Startup.cs
+    if (p.endsWith('/program.cs') || p.endsWith('/startup.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-entry' };
+    }
+    // Background services / Hosted services
+    if ((p.includes('/backgroundservices/') || p.includes('/hostedservices/')) && p.endsWith('.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 2.0, reason: 'aspnet-background-service' };
+    }
+    // Blazor pages
+    if (p.includes('/pages/') && p.endsWith('.razor')) {
+        return { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-page' };
+    }
+    // ========== GO FRAMEWORKS ==========
+    // Go handlers
+    if ((p.includes('/handlers/') || p.includes('/handler/')) && p.endsWith('.go')) {
+        return { framework: 'go-http', entryPointMultiplier: 2.5, reason: 'go-handlers' };
+    }
+    // Go routes
+    if (p.includes('/routes/') && p.endsWith('.go')) {
+        return { framework: 'go-http', entryPointMultiplier: 2.5, reason: 'go-routes' };
+    }
+    // Go controllers
+    if (p.includes('/controllers/') && p.endsWith('.go')) {
+        return { framework: 'go-mvc', entryPointMultiplier: 2.5, reason: 'go-controller' };
+    }
+    // Go main.go files (THE entry point) — only match main.go, not arbitrary .go files under cmd/
+    if (p.endsWith('/main.go')) {
+        return { framework: 'go', entryPointMultiplier: 3.0, reason: 'go-main' };
+    }
+    // ========== RUST FRAMEWORKS ==========
+    // Rust handlers/routes
+    if ((p.includes('/handlers/') || p.includes('/routes/')) && p.endsWith('.rs')) {
+        return { framework: 'rust-web', entryPointMultiplier: 2.5, reason: 'rust-handlers' };
+    }
+    // Rust main.rs (THE entry point)
+    if (p.endsWith('/main.rs')) {
+        return { framework: 'rust', entryPointMultiplier: 3.0, reason: 'rust-main' };
+    }
+    // Rust bin folder (executables)
+    if (p.includes('/bin/') && p.endsWith('.rs')) {
+        return { framework: 'rust', entryPointMultiplier: 2.5, reason: 'rust-bin' };
+    }
+    // ========== C / C++ ==========
+    // C/C++ main files
+    if (p.endsWith('/main.c') || p.endsWith('/main.cpp') || p.endsWith('/main.cc')) {
+        return { framework: 'c-cpp', entryPointMultiplier: 3.0, reason: 'c-main' };
+    }
+    // C/C++ src folder entry points (if named specifically)
+    if (p.includes('/src/') && (p.endsWith('/app.c') || p.endsWith('/app.cpp'))) {
+        return { framework: 'c-cpp', entryPointMultiplier: 2.5, reason: 'c-app' };
+    }
+    // ========== PHP / LARAVEL FRAMEWORKS ==========
+    // Laravel routes (highest - these ARE the entry point definitions)
+    if (p.includes('/routes/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-routes' };
+    }
+    // Laravel controllers (very high - receive HTTP requests)
+    if ((p.includes('/http/controllers/') || p.includes('/controllers/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller' };
+    }
+    // Laravel controller by file name convention
+    if (p.endsWith('controller.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller-file' };
+    }
+    // Laravel console commands
+    if ((p.includes('/console/commands/') || p.includes('/commands/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-command' };
+    }
+    // Laravel jobs (queue entry points)
+    if (p.includes('/jobs/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-job' };
+    }
+    // Laravel listeners (event-driven entry points)
+    if (p.includes('/listeners/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-listener' };
+    }
+    // Laravel middleware
+    if (p.includes('/http/middleware/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-middleware' };
+    }
+    // Laravel service providers
+    if (p.includes('/providers/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-provider' };
+    }
+    // Laravel policies
+    if (p.includes('/policies/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.0, reason: 'laravel-policy' };
+    }
+    // Laravel models (important but not entry points per se)
+    if (p.includes('/models/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-model' };
+    }
+    // Laravel services (Service Repository pattern)
+    if (p.includes('/services/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-service' };
+    }
+    // Laravel repositories (Service Repository pattern)
+    if (p.includes('/repositories/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
+    }
+    // ========== RUBY ==========
+    // Ruby: bin/ or exe/ (CLI entry points)
+    if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) {
+        return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' };
+    }
+    // Ruby: Rakefile or *.rake (task definitions)
+    if (p.endsWith('/rakefile') || p.endsWith('.rake')) {
+        return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' };
+    }
+    // ========== SWIFT / iOS ==========
+    // iOS App entry points (highest priority)
+    if (p.endsWith('/appdelegate.swift') ||
+        p.endsWith('/scenedelegate.swift') ||
+        p.endsWith('/app.swift')) {
+        return { framework: 'ios', entryPointMultiplier: 3.0, reason: 'ios-app-entry' };
+    }
+    // SwiftUI App entry (@main)
+    if (p.endsWith('app.swift') && p.includes('/sources/')) {
+        return { framework: 'swiftui', entryPointMultiplier: 3.0, reason: 'swiftui-app' };
+    }
+    // UIKit ViewControllers (high priority - screen entry points)
+    if ((p.includes('/viewcontrollers/') || p.includes('/controllers/') || p.includes('/screens/')) &&
+        p.endsWith('.swift')) {
+        return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller' };
+    }
+    // ViewController by filename convention
+    if (p.endsWith('viewcontroller.swift') || p.endsWith('vc.swift')) {
+        return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller-file' };
+    }
+    // Coordinator pattern (navigation entry points)
+    if (p.includes('/coordinators/') && p.endsWith('.swift')) {
+        return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator' };
+    }
+    // Coordinator by filename
+    if (p.endsWith('coordinator.swift')) {
+        return {
+            framework: 'ios-coordinator',
+            entryPointMultiplier: 2.5,
+            reason: 'ios-coordinator-file',
+        };
+    }
+    // SwiftUI Views (moderate - reusable components)
+    if ((p.includes('/views/') || p.includes('/scenes/')) && p.endsWith('.swift')) {
+        return { framework: 'swiftui', entryPointMultiplier: 1.8, reason: 'swiftui-view' };
+    }
+    // Service layer
+    if (p.includes('/services/') && p.endsWith('.swift')) {
+        return { framework: 'ios-service', entryPointMultiplier: 1.8, reason: 'ios-service' };
+    }
+    // Router / navigation
+    if (p.includes('/router/') && p.endsWith('.swift')) {
+        return { framework: 'ios-router', entryPointMultiplier: 2.0, reason: 'ios-router' };
+    }
+    // ========== DART / FLUTTER ==========
+    // Flutter main/app entry points
+    if (p.endsWith('/main.dart') || p.endsWith('/app.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 3.0, reason: 'flutter-main' };
+    }
+    // Flutter screens/pages/views (high priority - route entry points)
+    if ((p.includes('/screens/') || p.includes('/pages/') || p.includes('/views/')) &&
+        p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.5, reason: 'flutter-screen' };
+    }
+    // Flutter routes
+    if (p.includes('/routes/') && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.5, reason: 'flutter-routes' };
+    }
+    // Flutter BLoC / controllers / presentation (state management entry points)
+    if ((p.includes('/bloc/') ||
+        p.includes('/controllers/') ||
+        p.includes('/cubit/') ||
+        p.includes('/presentation/')) &&
+        p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.0, reason: 'flutter-state-management' };
+    }
+    // Flutter services / domain
+    if ((p.includes('/services/') || p.includes('/domain/')) && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 1.8, reason: 'flutter-service' };
+    }
+    // Flutter widgets (reusable components)
+    if (p.includes('/widgets/') && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 1.5, reason: 'flutter-widget' };
+    }
+    // ========== GENERIC PATTERNS ==========
+    // Any language: index files in API folders
+    if (p.includes('/api/') &&
+        (p.endsWith('/index.ts') || p.endsWith('/index.js') || p.endsWith('/__init__.py'))) {
+        return { framework: 'api', entryPointMultiplier: 1.8, reason: 'api-index' };
+    }
+    // No framework detected - return null for graceful fallback (1.0 multiplier)
+    return null;
+}
+// ============================================================================
+// AST-BASED FRAMEWORK DETECTION
+// ============================================================================
+/** Pre-lowercased patterns for O(1) pattern matching at runtime — built from providers. */
+const AST_PATTERNS_LOWERED = Object.fromEntries(Object.entries(index_js_1.providers).map(([lang, provider]) => [
+    lang,
+    (provider.astFrameworkPatterns ?? []).map((cfg) => ({
+        ...cfg,
+        patterns: cfg.patterns.map((p) => p.toLowerCase()),
+    })),
+]));
+/**
+ * Detect framework entry points from AST definition text (decorators/annotations/attributes).
+ * Returns null if no known pattern is found.
+ * Note: callers should slice definitionText to ~300 chars since annotations appear at the start.
+ */
+function detectFrameworkFromAST(language, definitionText) {
+    if (!language || !definitionText)
+        return null;
+    const configs = AST_PATTERNS_LOWERED[language.toLowerCase()];
+    if (!configs || configs.length === 0)
+        return null;
+    const normalized = definitionText.toLowerCase();
+    for (const cfg of configs) {
+        for (const pattern of cfg.patterns) {
+            if (normalized.includes(pattern)) {
+                return {
+                    framework: cfg.framework,
+                    entryPointMultiplier: cfg.entryPointMultiplier,
+                    reason: cfg.reason,
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/frameworks/spring/analysis-features.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_AOP_FEATURE = exports.SPRING_CONDITIONALS_FEATURE = exports.SPRING_BEAN_INVENTORY_FEATURE = void 0;
+const bean_catalog_js_1 = require("./bean-catalog.js");
+/** Durable completeness contract for Java/Kotlin Spring Bean evidence. */
+exports.SPRING_BEAN_INVENTORY_FEATURE = {
+    id: 'spring.bean-inventory',
+    version: 2,
+    appliesTo: (filePaths) => filePaths.some(bean_catalog_js_1.isSpringBeanCandidateSourceFile),
+};
+function isSpringConditionOrAutoConfigurationFile(filePath) {
+    const normalized = `/${filePath.replaceAll('\\', '/')}`.toLowerCase();
+    return (normalized.endsWith('.java') ||
+        normalized.endsWith('.kt') ||
+        normalized.endsWith('.kts') ||
+        normalized.endsWith('/meta-inf/spring.factories') ||
+        normalized.endsWith('/meta-inf/spring/org.springframework.boot.autoconfigure.autoconfiguration.imports'));
+}
+/** Durable completeness contract for conditional and auto-configuration evidence. */
+exports.SPRING_CONDITIONALS_FEATURE = {
+    id: 'spring.conditionals-auto-configuration',
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some(isSpringConditionOrAutoConfigurationFile),
+};
+/**
+ * Candidate-language approximation, not a claim that the file contains AOP.
+ * Kotlin scripts are included because `.kts` is a supported Kotlin input.
+ */
+function isJvmSourceFile(filePath) {
+    const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+    return normalized.endsWith('.java') || normalized.endsWith('.kt') || normalized.endsWith('.kts');
+}
+/** Durable completeness contract for Spring proxy/advice evidence (#2416). */
+exports.SPRING_AOP_FEATURE = {
+    id: 'spring.aop-advice',
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some(isJvmSourceFile),
+};