@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/entry-point-scoring.js

@@ -0,0 +1,317 @@
+// code-mapper/src/core/ingestion/entry-point-scoring.ts
+/** @file entry-point-scoring.ts @description Scores functions as entry point candidates using call ratio, export status, name patterns, and framework detection */
+import { detectFrameworkFromPath } from './framework-detection.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+// Entry point naming patterns by language
+const ENTRY_POINT_PATTERNS = {
+    // Universal patterns
+    '*': [
+        /^(main|init|bootstrap|start|run|setup|configure)$/i,
+        /^handle[A-Z]/, // handleLogin, handleSubmit
+        /^on[A-Z]/, // onClick, onSubmit
+        /Handler$/, // RequestHandler
+        /Controller$/, // UserController
+        /^process[A-Z]/, // processPayment
+        /^execute[A-Z]/, // executeQuery
+        /^perform[A-Z]/, // performAction
+        /^dispatch[A-Z]/, // dispatchEvent
+        /^trigger[A-Z]/, // triggerAction
+        /^fire[A-Z]/, // fireEvent
+        /^emit[A-Z]/, // emitEvent
+    ],
+    // JavaScript/TypeScript
+    [SupportedLanguages.JavaScript]: [
+        /^use[A-Z]/, // React hooks (useEffect, etc.)
+    ],
+    [SupportedLanguages.TypeScript]: [
+        /^use[A-Z]/, // React hooks
+    ],
+    // Python
+    [SupportedLanguages.Python]: [
+        /^app$/, // Flask/FastAPI app
+        /^(get|post|put|delete|patch)_/i, // REST conventions
+        /^api_/, // API functions
+        /^view_/, // Django views
+    ],
+    // Java
+    [SupportedLanguages.Java]: [
+        /^do[A-Z]/, // doGet, doPost (Servlets)
+        /^create[A-Z]/, // Factory patterns
+        /^build[A-Z]/, // Builder patterns
+        /Service$/, // UserService
+    ],
+    // C#
+    [SupportedLanguages.CSharp]: [
+        /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
+        /Action$/, // MVC actions
+        /^On[A-Z]/, // Event handlers / Blazor lifecycle
+        /Async$/, // Async entry points
+        /^Configure$/, // Startup.Configure
+        /^ConfigureServices$/, // Startup.ConfigureServices
+        /^Handle$/, // MediatR / generic handler
+        /^Execute$/, // Command pattern
+        /^Invoke$/, // Middleware Invoke
+        /^Map[A-Z]/, // Minimal API MapGet, MapPost
+        /Service$/, // Service classes
+        /^Seed/, // Database seeding
+    ],
+    // Go
+    [SupportedLanguages.Go]: [
+        /Handler$/, // http.Handler pattern
+        /^Serve/, // ServeHTTP
+        /^New[A-Z]/, // Constructor pattern (returns new instance)
+        /^Make[A-Z]/, // Make functions
+    ],
+    // Rust
+    [SupportedLanguages.Rust]: [
+        /^(get|post|put|delete)_handler$/i,
+        /^handle_/, // handle_request
+        /^new$/, // Constructor pattern
+        /^run$/, // run entry point
+        /^spawn/, // Async spawn
+    ],
+    // C - explicit main() boost plus common C entry point conventions
+    [SupportedLanguages.C]: [
+        /^main$/, // THE entry point
+        /^init_/, // init_server, init_client
+        /_init$/, // module_init, server_init
+        /^start_/, // start_server
+        /_start$/, // thread_start
+        /^run_/, // run_loop
+        /_run$/, // event_run
+        /^stop_/, // stop_server
+        /_stop$/, // service_stop
+        /^open_/, // open_connection
+        /_open$/, // file_open
+        /^close_/, // close_connection
+        /_close$/, // socket_close
+        /^create_/, // create_session
+        /_create$/, // object_create
+        /^destroy_/, // destroy_session
+        /_destroy$/, // object_destroy
+        /^handle_/, // handle_request
+        /_handler$/, // signal_handler
+        /_callback$/, // event_callback
+        /^cmd_/, // tmux: cmd_new_window, cmd_attach_session
+        /^server_/, // server_start, server_loop
+        /^client_/, // client_connect
+        /^session_/, // session_create
+        /^window_/, // window_resize (tmux)
+        /^key_/, // key_press
+        /^input_/, // input_parse
+        /^output_/, // output_write
+        /^notify_/, // notify_client
+        /^control_/, // control_start
+    ],
+    // C++ - same as C plus OOP/template patterns
+    [SupportedLanguages.CPlusPlus]: [
+        /^main$/, // THE entry point
+        /^init_/,
+        /_init$/,
+        /^Create[A-Z]/, // Factory patterns
+        /^create_/,
+        /^Run$/, // Run methods
+        /^run$/,
+        /^Start$/, // Start methods
+        /^start$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^OnEvent/, // Event callbacks
+        /^on_/,
+        /::Run$/, // Class::Run
+        /::Start$/, // Class::Start
+        /::Init$/, // Class::Init
+        /::Execute$/, // Class::Execute
+    ],
+    // Swift / iOS
+    [SupportedLanguages.Swift]: [
+        /^viewDidLoad$/, // UIKit lifecycle
+        /^viewWillAppear$/, // UIKit lifecycle
+        /^viewDidAppear$/, // UIKit lifecycle
+        /^viewWillDisappear$/, // UIKit lifecycle
+        /^viewDidDisappear$/, // UIKit lifecycle
+        /^application\(/, // AppDelegate methods
+        /^scene\(/, // SceneDelegate methods
+        /^body$/, // SwiftUI View.body
+        /Coordinator$/, // Coordinator pattern
+        /^sceneDidBecomeActive$/, // SceneDelegate lifecycle
+        /^sceneWillResignActive$/, // SceneDelegate lifecycle
+        /^didFinishLaunchingWithOptions$/, // AppDelegate
+        /ViewController$/, // ViewController classes
+        /^configure[A-Z]/, // Configuration methods
+        /^setup[A-Z]/, // Setup methods
+        /^makeBody$/, // SwiftUI ViewModifier
+    ],
+    // PHP / Laravel
+    [SupportedLanguages.PHP]: [
+        /Controller$/, // UserController (class name convention)
+        /^handle$/, // Job::handle(), Listener::handle()
+        /^execute$/, // Command::execute()
+        /^boot$/, // ServiceProvider::boot()
+        /^register$/, // ServiceProvider::register()
+        /^__invoke$/, // Invokable controllers/actions
+        /^(index|show|store|update|destroy|create|edit)$/, // RESTful resource methods
+        /^(get|post|put|delete|patch)[A-Z]/, // Explicit HTTP method actions
+        /^run$/, // Command/Job run()
+        /^fire$/, // Event fire()
+        /^dispatch$/, // Dispatchable jobs
+        /Service$/, // UserService (Service layer)
+        /Repository$/, // UserRepository (Repository pattern)
+        /^find$/, // Repository::find()
+        /^findAll$/, // Repository::findAll()
+        /^save$/, // Repository::save()
+        /^delete$/, // Repository::delete()
+    ],
+    // Ruby
+    [SupportedLanguages.Ruby]: [
+        /^call$/, // Service objects (MyService.call)
+        /^perform$/, // Background jobs (Sidekiq, ActiveJob)
+        /^execute$/, // Command pattern
+    ],
+};
+// Pre-computed merged patterns (universal + language-specific)
+const MERGED_ENTRY_POINT_PATTERNS = {};
+const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
+for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
+    if (lang === '*')
+        continue;
+    MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
+}
+// Utility/helper patterns that get penalized in scoring (not entry points)
+const UTILITY_PATTERNS = [
+    /^(get|set|is|has|can|should|will|did)[A-Z]/, // Accessors/predicates
+    /^_/, // Private by convention
+    /^(format|parse|validate|convert|transform)/i, // Transformation utilities
+    /^(log|debug|error|warn|info)$/i, // Logging
+    /^(to|from)[A-Z]/, // Conversions
+    /^(encode|decode)/i, // Encoding utilities
+    /^(serialize|deserialize)/i, // Serialization
+    /^(clone|copy|deep)/i, // Cloning utilities
+    /^(merge|extend|assign)/i, // Object utilities
+    /^(filter|map|reduce|sort|find)/i, // Collection utilities (standalone)
+    /Helper$/,
+    /Util$/,
+    /Utils$/,
+    /^utils?$/i,
+    /^helpers?$/i,
+];
+/**
+ * Calculate an entry point score for a function/method
+ *
+ * Score = baseScore * exportMultiplier * nameMultiplier * frameworkMultiplier
+ *
+ * @param name - Function/method name
+ * @param language - Programming language
+ * @param isExported - Whether the function is exported/public
+ * @param callerCount - Number of callers
+ * @param calleeCount - Number of callees
+ * @returns Score and reasons explaining the score
+ */
+export function calculateEntryPointScore(name, language, isExported, callerCount, calleeCount, filePath = '' // Optional for backwards compatibility
+) {
+    const reasons = [];
+    // Must have outgoing calls to be an entry point
+    if (calleeCount === 0) {
+        return { score: 0, reasons: ['no-outgoing-calls'] };
+    }
+    // Base score: call ratio (high = calls many, called by few)
+    const baseScore = calleeCount / (callerCount + 1);
+    reasons.push(`base:${baseScore.toFixed(2)}`);
+    // Export bonus
+    const exportMultiplier = isExported ? 2.0 : 1.0;
+    if (isExported) {
+        reasons.push('exported');
+    }
+    // Name pattern scoring: check negative patterns first
+    let nameMultiplier = 1.0;
+    if (UTILITY_PATTERNS.some(p => p.test(name))) {
+        nameMultiplier = 0.3;
+        reasons.push('utility-pattern');
+    }
+    else {
+        // Check positive entry point patterns
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
+        if (allPatterns.some(p => p.test(name))) {
+            nameMultiplier = 1.5;
+            reasons.push('entry-pattern');
+        }
+    }
+    // Framework detection bonus
+    let frameworkMultiplier = 1.0;
+    if (filePath) {
+        const frameworkHint = detectFrameworkFromPath(filePath);
+        if (frameworkHint) {
+            frameworkMultiplier = frameworkHint.entryPointMultiplier;
+            reasons.push(`framework:${frameworkHint.reason}`);
+        }
+    }
+    // Final score
+    const finalScore = baseScore * exportMultiplier * nameMultiplier * frameworkMultiplier;
+    return {
+        score: finalScore,
+        reasons,
+    };
+}
+/** Check if a file path is a test file (excluded from entry points) */
+export function isTestFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (
+    // JavaScript/TypeScript test patterns
+    p.includes('.test.') ||
+        p.includes('.spec.') ||
+        p.includes('__tests__/') ||
+        p.includes('__mocks__/') ||
+        // Generic test folders
+        p.includes('/test/') ||
+        p.includes('/tests/') ||
+        p.includes('/testing/') ||
+        // Python test patterns
+        p.endsWith('_test.py') ||
+        p.includes('/test_') ||
+        // Go test patterns
+        p.endsWith('_test.go') ||
+        // Java test patterns
+        p.includes('/src/test/') ||
+        // Rust test patterns (inline tests are different, but test files)
+        p.includes('/tests/') ||
+        // Swift/iOS test patterns
+        p.endsWith('tests.swift') ||
+        p.endsWith('test.swift') ||
+        p.includes('uitests/') ||
+        // C# test patterns
+        p.endsWith('tests.cs') ||
+        p.endsWith('test.cs') ||
+        p.includes('.tests/') ||
+        p.includes('.test/') ||
+        p.includes('.integrationtests/') ||
+        p.includes('.unittests/') ||
+        p.includes('/testproject/') ||
+        // PHP/Laravel test patterns
+        p.endsWith('test.php') ||
+        p.endsWith('spec.php') ||
+        p.includes('/tests/feature/') ||
+        p.includes('/tests/unit/') ||
+        // Ruby test patterns
+        p.endsWith('_spec.rb') ||
+        p.endsWith('_test.rb') ||
+        p.includes('/spec/') ||
+        p.includes('/test/fixtures/'));
+}
+/** Check if a file path is a utility/helper file (lower entry point priority) */
+export function isUtilityFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (p.includes('/utils/') ||
+        p.includes('/util/') ||
+        p.includes('/helpers/') ||
+        p.includes('/helper/') ||
+        p.includes('/common/') ||
+        p.includes('/shared/') ||
+        p.includes('/lib/') ||
+        p.endsWith('/utils.ts') ||
+        p.endsWith('/utils.js') ||
+        p.endsWith('/helpers.ts') ||
+        p.endsWith('/helpers.js') ||
+        p.endsWith('_utils.py') ||
+        p.endsWith('_helpers.py'));
+}

package/dist/core/ingestion/export-detection.d.ts

@@ -0,0 +1,11 @@
+/** @file export-detection.ts @description Per-language detection of whether a symbol is exported/public, pure function safe for worker threads */
+import { SyntaxNode } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Check if a tree-sitter node is exported/public in its language
+ *
+ * @param node - The tree-sitter AST node
+ * @param name - The symbol name
+ * @param language - The programming language
+ */
+export declare const isNodeExported: (node: SyntaxNode, name: string, language: SupportedLanguages) => boolean;

package/dist/core/ingestion/export-detection.js

@@ -0,0 +1,203 @@
+// code-mapper/src/core/ingestion/export-detection.ts
+/** @file export-detection.ts @description Per-language detection of whether a symbol is exported/public, pure function safe for worker threads */
+import { findSiblingChild } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+// Per-language export checkers
+// JS/TS: walk ancestors looking for export_statement or export_specifier
+const tsExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        const type = current.type;
+        if (type === 'export_statement' ||
+            type === 'export_specifier' ||
+            (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) {
+            return true;
+        }
+        // Fallback: check if node text starts with 'export '
+        if (current.text?.startsWith('export ')) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// Python: public if no leading underscore (convention)
+const pythonExportChecker = (_node, name) => !name.startsWith('_');
+// Java: check for 'public' modifier (sibling of name node)
+const javaExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const parent = current.parent;
+            for (let i = 0; i < parent.childCount; i++) {
+                const child = parent.child(i);
+                if (child?.type === 'modifiers' && child.text?.includes('public')) {
+                    return true;
+                }
+            }
+            if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
+                if (parent.text?.trimStart().startsWith('public')) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// C# declaration node types for sibling modifier scanning
+const CSHARP_DECL_TYPES = new Set([
+    'method_declaration', 'local_function_statement', 'constructor_declaration',
+    'class_declaration', 'interface_declaration', 'struct_declaration',
+    'enum_declaration', 'record_declaration', 'record_struct_declaration',
+    'record_class_declaration', 'delegate_declaration',
+    'property_declaration', 'field_declaration', 'event_declaration',
+    'namespace_declaration', 'file_scoped_namespace_declaration',
+]);
+// C#: walk up to declaration node, scan children for 'public' modifier
+const csharpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (CSHARP_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'modifier' && child.text === 'public')
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// Go: uppercase first letter = exported
+const goExportChecker = (_node, name) => {
+    if (name.length === 0)
+        return false;
+    const first = name[0];
+    return first === first.toUpperCase() && first !== first.toLowerCase();
+};
+// Rust declaration node types for visibility_modifier scanning
+const RUST_DECL_TYPES = new Set([
+    'function_item', 'struct_item', 'enum_item', 'trait_item', 'impl_item',
+    'union_item', 'type_item', 'const_item', 'static_item', 'mod_item',
+    'use_declaration', 'associated_type', 'function_signature_item',
+]);
+// Rust: walk up to declaration node, scan children for 'pub' visibility_modifier
+const rustExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (RUST_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub'))
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// Kotlin: default visibility is public; check for private/internal/protected modifiers
+const kotlinExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
+            if (visMod) {
+                const text = visMod.text;
+                if (text === 'private' || text === 'internal' || text === 'protected')
+                    return false;
+                if (text === 'public')
+                    return true;
+            }
+        }
+        current = current.parent;
+    }
+    // No visibility modifier = public in Kotlin
+    return true;
+};
+// C/C++: non-static functions have external linkage (exported by default)
+// C++ anonymous namespaces also give internal linkage
+const cCppExportChecker = (node, _name) => {
+    let cur = node;
+    while (cur) {
+        if (cur.type === 'function_definition' || cur.type === 'declaration') {
+            // Check for 'static' storage class specifier as a direct child node
+            for (let i = 0; i < cur.childCount; i++) {
+                const child = cur.child(i);
+                if (child?.type === 'storage_class_specifier' && child.text === 'static')
+                    return false;
+            }
+        }
+        // C++ anonymous namespace = internal linkage
+        if (cur.type === 'namespace_definition') {
+            const hasName = cur.childForFieldName?.('name');
+            if (!hasName)
+                return false;
+        }
+        cur = cur.parent;
+    }
+    return true;
+};
+// PHP: check for visibility modifier or top-level scope
+const phpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'interface_declaration' ||
+            current.type === 'trait_declaration' ||
+            current.type === 'enum_declaration') {
+            return true;
+        }
+        if (current.type === 'visibility_modifier') {
+            return current.text === 'public';
+        }
+        current = current.parent;
+    }
+    // Top-level functions are globally accessible in PHP
+    return true;
+};
+// Swift: check for 'public' or 'open' access modifiers
+const swiftExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
+            const text = current.text || '';
+            if (text.includes('public') || text.includes('open'))
+                return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// Exhaustive dispatch table covering all SupportedLanguages
+const exportCheckers = {
+    [SupportedLanguages.JavaScript]: tsExportChecker,
+    [SupportedLanguages.TypeScript]: tsExportChecker,
+    [SupportedLanguages.Python]: pythonExportChecker,
+    [SupportedLanguages.Java]: javaExportChecker,
+    [SupportedLanguages.CSharp]: csharpExportChecker,
+    [SupportedLanguages.Go]: goExportChecker,
+    [SupportedLanguages.Rust]: rustExportChecker,
+    [SupportedLanguages.Kotlin]: kotlinExportChecker,
+    [SupportedLanguages.C]: cCppExportChecker,
+    [SupportedLanguages.CPlusPlus]: cCppExportChecker,
+    [SupportedLanguages.PHP]: phpExportChecker,
+    [SupportedLanguages.Swift]: swiftExportChecker,
+    [SupportedLanguages.Ruby]: (_node, _name) => true,
+};
+/**
+ * Check if a tree-sitter node is exported/public in its language
+ *
+ * @param node - The tree-sitter AST node
+ * @param name - The symbol name
+ * @param language - The programming language
+ */
+export const isNodeExported = (node, name, language) => {
+    const checker = exportCheckers[language];
+    if (!checker)
+        return false;
+    return checker(node, name);
+};

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -0,0 +1,18 @@
+/** @file filesystem-walker.ts @description Scans repository files with ignore filtering and batched concurrent reads */
+export interface FileEntry {
+    path: string;
+    content: string;
+}
+export interface ScannedFile {
+    path: string;
+    size: number;
+}
+export interface FilePath {
+    path: string;
+}
+/** Scan repository: stat files to get paths + sizes, no content loaded (~10MB for 100K files) */
+export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<ScannedFile[]>;
+/** Read file contents for a set of relative paths, returning a Map for O(1) lookup */
+export declare const readFileContents: (repoPath: string, relativePaths: string[]) => Promise<Map<string, string>>;
+/** Legacy API: scans and reads everything into memory (sequential fallback only) */
+export declare const walkRepository: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<FileEntry[]>;

package/dist/core/ingestion/filesystem-walker.js

@@ -0,0 +1,64 @@
+// code-mapper/src/core/ingestion/filesystem-walker.ts
+/** @file filesystem-walker.ts @description Scans repository files with ignore filtering and batched concurrent reads */
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+import { createIgnoreFilter } from '../../config/ignore-service.js';
+const READ_CONCURRENCY = 32;
+/** Scan repository: stat files to get paths + sizes, no content loaded (~10MB for 100K files) */
+export const walkRepositoryPaths = async (repoPath, onProgress) => {
+    const ignoreFilter = await createIgnoreFilter(repoPath);
+    const filtered = await glob('**/*', {
+        cwd: repoPath,
+        nodir: true,
+        dot: false,
+        ignore: ignoreFilter,
+    });
+    const entries = [];
+    let processed = 0;
+    for (let start = 0; start < filtered.length; start += READ_CONCURRENCY) {
+        const batch = filtered.slice(start, start + READ_CONCURRENCY);
+        const results = await Promise.allSettled(batch.map(async (relativePath) => {
+            const fullPath = path.join(repoPath, relativePath);
+            const stat = await fs.stat(fullPath);
+            return { path: relativePath.replace(/\\/g, '/'), size: stat.size };
+        }));
+        for (const result of results) {
+            processed++;
+            if (result.status === 'fulfilled' && result.value !== null) {
+                entries.push(result.value);
+                onProgress?.(processed, filtered.length, result.value.path);
+            }
+            else {
+                onProgress?.(processed, filtered.length, batch[results.indexOf(result)]);
+            }
+        }
+    }
+    return entries;
+};
+/** Read file contents for a set of relative paths, returning a Map for O(1) lookup */
+export const readFileContents = async (repoPath, relativePaths) => {
+    const contents = new Map();
+    for (let start = 0; start < relativePaths.length; start += READ_CONCURRENCY) {
+        const batch = relativePaths.slice(start, start + READ_CONCURRENCY);
+        const results = await Promise.allSettled(batch.map(async (relativePath) => {
+            const fullPath = path.join(repoPath, relativePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            return { path: relativePath, content };
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                contents.set(result.value.path, result.value.content);
+            }
+        }
+    }
+    return contents;
+};
+/** Legacy API: scans and reads everything into memory (sequential fallback only) */
+export const walkRepository = async (repoPath, onProgress) => {
+    const scanned = await walkRepositoryPaths(repoPath, onProgress);
+    const contents = await readFileContents(repoPath, scanned.map(f => f.path));
+    return scanned
+        .filter(f => contents.has(f.path))
+        .map(f => ({ path: f.path, content: contents.get(f.path) }));
+};

package/dist/core/ingestion/framework-detection.d.ts

@@ -0,0 +1,42 @@
+/** @file framework-detection.ts @description Detects frameworks from file path patterns and AST definition text (decorators/annotations/attributes), returning entry point multipliers for process scoring. Returns null for unknown frameworks, yielding a 1.0 multiplier (no bonus, no penalty) */
+export interface FrameworkHint {
+    framework: string;
+    entryPointMultiplier: number;
+    reason: string;
+}
+/** Detect framework from file path conventions, returning an entry point multiplier or null */
+export declare function detectFrameworkFromPath(filePath: string): FrameworkHint | null;
+export declare const FRAMEWORK_AST_PATTERNS: {
+    nestjs: string[];
+    express: string[];
+    fastapi: string[];
+    flask: string[];
+    spring: string[];
+    jaxrs: string[];
+    aspnet: string[];
+    signalr: string[];
+    blazor: string[];
+    efcore: string[];
+    'go-http': string[];
+    laravel: string[];
+    actix: string[];
+    axum: string[];
+    rocket: string[];
+    uikit: string[];
+    swiftui: string[];
+    combine: string[];
+    'nestjs-di': string[];
+    'angular-di': string[];
+    'spring-di': string[];
+    'dagger-di': string[];
+    'aspnet-di': string[];
+    'python-di': string[];
+};
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Detect framework entry points from AST definition text (decorators/annotations/attributes)
+ * @param language - Source language
+ * @param definitionText - AST node text (callers should slice to ~300 chars)
+ * @returns FrameworkHint or null if no known pattern matches
+ */
+export declare function detectFrameworkFromAST(language: SupportedLanguages, definitionText: string): FrameworkHint | null;