gitnexus 1.4.7 → 1.4.9

package/dist/core/ingestion/named-bindings/rust.js

@@ -0,0 +1,64 @@
+export function extractRustNamedBindings(importNode) {
+    // use_declaration may contain use_as_clause at any depth
+    if (importNode.type !== 'use_declaration')
+        return undefined;
+    const bindings = [];
+    collectRustBindings(importNode, bindings);
+    return bindings.length > 0 ? bindings : undefined;
+}
+function collectRustBindings(node, bindings) {
+    if (node.type === 'use_as_clause') {
+        // First identifier = exported name, second identifier = local alias
+        const idents = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                idents.push(child.text);
+            // For scoped_identifier, extract the last segment
+            if (child?.type === 'scoped_identifier') {
+                const nameNode = child.childForFieldName?.('name');
+                if (nameNode)
+                    idents.push(nameNode.text);
+            }
+        }
+        if (idents.length === 2) {
+            bindings.push({ local: idents[1], exported: idents[0] });
+        }
+        return;
+    }
+    // Terminal identifier in a use_list: use crate::models::{User, Repo}
+    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
+        bindings.push({ local: node.text, exported: node.text });
+        return;
+    }
+    // Skip scoped_identifier that serves as path prefix in scoped_use_list
+    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
+    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
+        return; // path prefix — the use_list sibling handles the actual symbols
+    }
+    // Terminal scoped_identifier: use crate::models::User;
+    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
+    if (node.type === 'scoped_identifier') {
+        let hasDeeper = false;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
+                hasDeeper = true;
+                break;
+            }
+        }
+        if (!hasDeeper) {
+            const nameNode = node.childForFieldName?.('name');
+            if (nameNode) {
+                bindings.push({ local: nameNode.text, exported: nameNode.text });
+            }
+            return;
+        }
+    }
+    // Recurse into children
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            collectRustBindings(child, bindings);
+    }
+}

package/dist/core/ingestion/named-bindings/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Named binding types — shared across all per-language binding extractors.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+/** A single named import binding: local name in the importing file and exported name from the source.
+ *  When `isModuleAlias` is true, the binding represents a Python `import X as Y` module alias
+ *  and is routed to moduleAliasMap instead of namedImportMap during import processing. */
+export interface NamedBinding {
+    local: string;
+    exported: string;
+    isModuleAlias?: boolean;
+}
+/** Per-language named binding extractor -- optional (returns undefined if language has no named imports). */
+export type NamedBindingExtractorFn = (importNode: SyntaxNode) => NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/types.js

@@ -0,0 +1,6 @@
+/**
+ * Named binding types — shared across all per-language binding extractors.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+export {};

package/dist/core/ingestion/named-bindings/typescript.d.ts

@@ -0,0 +1,3 @@
+import { type SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractTsNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/typescript.js

@@ -0,0 +1,58 @@
+import { findChild } from '../utils/ast-helpers.js';
+export function extractTsNamedBindings(importNode) {
+    // import_statement > import_clause > named_imports > import_specifier*
+    const importClause = findChild(importNode, 'import_clause');
+    if (importClause) {
+        const namedImports = findChild(importClause, 'named_imports');
+        if (!namedImports)
+            return undefined; // default import, namespace import, or side-effect
+        const bindings = [];
+        for (let i = 0; i < namedImports.namedChildCount; i++) {
+            const specifier = namedImports.namedChild(i);
+            if (specifier?.type !== 'import_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // import { Foo as Bar } → exported='Foo', local='Bar'
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
+    const exportClause = findChild(importNode, 'export_clause');
+    if (exportClause) {
+        const bindings = [];
+        for (let i = 0; i < exportClause.namedChildCount; i++) {
+            const specifier = exportClause.namedChild(i);
+            if (specifier?.type !== 'export_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                // export { User } from './base' → re-exports User as User
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // export { Repo as Repository } from './models' → name=Repo, alias=Repository
+                // For re-exports, the first id is the source name, second is what's exported
+                // When another file imports { Repository }, they get Repo from the source
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    return undefined;
+}

package/dist/core/ingestion/parsing-processor.d.ts

@@ -2,7 +2,7 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { SymbolTable } from './symbol-table.js';
 import { ASTCache } from './ast-cache.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
+import type { ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileConstructorBindings, FileTypeEnvBindings, ExtractedORMQuery } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
@@ -10,9 +10,13 @@ export interface WorkerExtractedData {
     assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
+    fetchCalls: ExtractedFetchCall[];
+    decoratorRoutes: ExtractedDecoratorRoute[];
+    toolDefs: ExtractedToolDef[];
+    ormQueries: ExtractedORMQuery[];
     constructorBindings: FileConstructorBindings[];
+    typeEnvBindings: FileTypeEnvBindings[];
 }
-export { isNodeExported } from './export-detection.js';
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

package/dist/core/ingestion/parsing-processor.js

@@ -1,17 +1,13 @@
 import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
-import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
-import { extractPropertyDeclaredType } from './type-extractors/shared.js';
-import { isNodeExported } from './export-detection.js';
+import { getLanguageFromFilename } from './utils/language-detection.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
-import { typeConfigs } from './type-extractors/index.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
-// isNodeExported imported from ./export-detection.js (shared module)
-// Re-export for backward compatibility with any external consumers
-export { isNodeExported } from './export-detection.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -24,7 +20,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             parseableFiles.push({ path: file.path, content: file.content });
     }
     if (parseableFiles.length === 0)
-        return { imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [] };
+        return { imports: [], calls: [], assignments: [], heritage: [], routes: [], fetchCalls: [], decoratorRoutes: [], toolDefs: [], ormQueries: [], constructorBindings: [], typeEnvBindings: [] };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -36,7 +32,12 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allAssignments = [];
     const allHeritage = [];
     const allRoutes = [];
+    const allFetchCalls = [];
+    const allDecoratorRoutes = [];
+    const allToolDefs = [];
+    const allORMQueries = [];
     const allConstructorBindings = [];
+    const allTypeEnvBindings = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -51,6 +52,8 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         for (const sym of result.symbols) {
             symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
                 parameterCount: sym.parameterCount,
+                requiredParameterCount: sym.requiredParameterCount,
+                parameterTypes: sym.parameterTypes,
                 returnType: sym.returnType,
                 declaredType: sym.declaredType,
                 ownerId: sym.ownerId,
@@ -61,7 +64,13 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         allAssignments.push(...result.assignments);
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
+        allFetchCalls.push(...result.fetchCalls);
+        allDecoratorRoutes.push(...result.decoratorRoutes);
+        allToolDefs.push(...result.toolDefs);
+        if (result.ormQueries)
+            allORMQueries.push(...result.ormQueries);
         allConstructorBindings.push(...result.constructorBindings);
+        allTypeEnvBindings.push(...result.typeEnvBindings);
     }
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
@@ -78,17 +87,75 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
+    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, fetchCalls: allFetchCalls, decoratorRoutes: allDecoratorRoutes, toolDefs: allToolDefs, ormQueries: allORMQueries, constructorBindings: allConstructorBindings, typeEnvBindings: allTypeEnvBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
 // ============================================================================
+// Inline caches to avoid repeated parent-walks per node (same pattern as parse-worker.ts).
+// Keyed by tree-sitter node reference — cleared at the start of each file.
+const classIdCache = new Map();
+const exportCache = new Map();
+const cachedFindEnclosingClassId = (node, filePath) => {
+    const cached = classIdCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = findEnclosingClassId(node, filePath);
+    classIdCache.set(node, result);
+    return result;
+};
+const cachedExportCheck = (checker, node, name) => {
+    const cached = exportCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = checker(node, name);
+    exportCache.set(node, result);
+    return result;
+};
+// FieldExtractor cache for sequential path — same pattern as parse-worker.ts
+const seqFieldInfoCache = new Map();
+function seqFindEnclosingClassNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+/** Minimal no-op SymbolTable stub for FieldExtractorContext (sequential path has a real
+ *  SymbolTable, but it's incomplete at this stage — use the stub for safety). */
+const NOOP_SYMBOL_TABLE_SEQ = {
+    lookupExactAll: () => [],
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+};
+function seqGetFieldInfo(classNode, provider, context) {
+    if (!provider.fieldExtractor)
+        return undefined;
+    const cacheKey = classNode.startIndex;
+    let cached = seqFieldInfoCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const extracted = provider.fieldExtractor.extract(classNode, context);
+    if (!extracted?.fields?.length)
+        return undefined;
+    cached = new Map();
+    for (const field of extracted.fields)
+        cached.set(field.name, field);
+    seqFieldInfoCache.set(cacheKey, cached);
+    return cached;
+}
 const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
     const skippedLanguages = new Map();
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        // Reset memoization before each new file (node refs are per-tree)
+        classIdCache.clear();
+        exportCache.clear();
+        seqFieldInfoCache.clear();
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -118,7 +185,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             continue;
         }
         astCache.set(file.path, tree);
-        const queryString = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryString = provider.treeSitterQueries;
         if (!queryString) {
             continue;
         }
@@ -133,82 +201,21 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
+        // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor)
+        const typeEnv = provider.fieldExtractor ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder }) : null;
         matches.forEach(match => {
             const captureMap = {};
             match.captures.forEach(c => {
                 captureMap[c.name] = c.node;
             });
-            if (captureMap['import']) {
+            const nodeLabel = getLabelFromCaptures(captureMap, provider);
+            if (!nodeLabel)
                 return;
-            }
-            if (captureMap['call']) {
-                return;
-            }
             const nameNode = captureMap['name'];
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && !captureMap['definition.constructor'])
+            if (!nameNode && nodeLabel !== 'Constructor')
                 return;
             const nodeName = nameNode ? nameNode.text : 'init';
-            let nodeLabel = 'CodeElement';
-            if (captureMap['definition.function']) {
-                // C/C++: @definition.function is broad and also matches inline class methods (inside
-                // a class/struct body). Those are already captured by @definition.method, so skip
-                // the duplicate Function entry to prevent double-indexing in globalIndex.
-                if (language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C) {
-                    let ancestor = captureMap['definition.function']?.parent;
-                    while (ancestor) {
-                        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier') {
-                            break;
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                    if (ancestor)
-                        return; // inside a class body — handled by @definition.method
-                }
-                nodeLabel = 'Function';
-            }
-            else if (captureMap['definition.class'])
-                nodeLabel = 'Class';
-            else if (captureMap['definition.interface'])
-                nodeLabel = 'Interface';
-            else if (captureMap['definition.method'])
-                nodeLabel = 'Method';
-            else if (captureMap['definition.struct'])
-                nodeLabel = 'Struct';
-            else if (captureMap['definition.enum'])
-                nodeLabel = 'Enum';
-            else if (captureMap['definition.namespace'])
-                nodeLabel = 'Namespace';
-            else if (captureMap['definition.module'])
-                nodeLabel = 'Module';
-            else if (captureMap['definition.trait'])
-                nodeLabel = 'Trait';
-            else if (captureMap['definition.impl'])
-                nodeLabel = 'Impl';
-            else if (captureMap['definition.type'])
-                nodeLabel = 'TypeAlias';
-            else if (captureMap['definition.const'])
-                nodeLabel = 'Const';
-            else if (captureMap['definition.static'])
-                nodeLabel = 'Static';
-            else if (captureMap['definition.typedef'])
-                nodeLabel = 'Typedef';
-            else if (captureMap['definition.macro'])
-                nodeLabel = 'Macro';
-            else if (captureMap['definition.union'])
-                nodeLabel = 'Union';
-            else if (captureMap['definition.property'])
-                nodeLabel = 'Property';
-            else if (captureMap['definition.record'])
-                nodeLabel = 'Record';
-            else if (captureMap['definition.delegate'])
-                nodeLabel = 'Delegate';
-            else if (captureMap['definition.annotation'])
-                nodeLabel = 'Annotation';
-            else if (captureMap['definition.constructor'])
-                nodeLabel = 'Constructor';
-            else if (captureMap['definition.template'])
-                nodeLabel = 'Template';
             const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
             const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
@@ -223,7 +230,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
             // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
             if (methodSig && (!methodSig.returnType || methodSig.returnType === 'array' || methodSig.returnType === 'iterable') && definitionNode) {
-                const tc = typeConfigs[language];
+                const tc = provider.typeConfig;
                 if (tc?.extractReturnType) {
                     const docReturn = tc.extractReturnType(definitionNode);
                     if (docReturn)
@@ -239,13 +246,15 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine,
                     endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
                     language: language,
-                    isExported: isNodeExported(nameNode || definitionNodeForRange, nodeName, language),
+                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
                     ...(frameworkHint ? {
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
                     ...(methodSig ? {
                         parameterCount: methodSig.parameterCount,
+                        ...(methodSig.requiredParameterCount !== undefined ? { requiredParameterCount: methodSig.requiredParameterCount } : {}),
+                        ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
                         returnType: methodSig.returnType,
                     } : {}),
                 },
@@ -254,13 +263,44 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
             // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
             const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
-            const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
-            // Extract declared type for Property nodes (field/property type annotations)
-            const declaredType = (nodeLabel === 'Property' && definitionNode)
-                ? extractPropertyDeclaredType(definitionNode)
-                : undefined;
+            const enclosingClassId = needsOwner ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
+            // Extract declared type and field metadata for Property nodes
+            let declaredType;
+            let seqVisibility;
+            let seqIsStatic;
+            let seqIsReadonly;
+            if (nodeLabel === 'Property' && definitionNode) {
+                // FieldExtractor is the single source of truth when available
+                if (provider.fieldExtractor && typeEnv) {
+                    const classNode = seqFindEnclosingClassNode(definitionNode);
+                    if (classNode) {
+                        const fieldMap = seqGetFieldInfo(classNode, provider, {
+                            typeEnv, symbolTable: NOOP_SYMBOL_TABLE_SEQ, filePath: file.path, language,
+                        });
+                        const info = fieldMap?.get(nodeName);
+                        if (info) {
+                            declaredType = info.type ?? undefined;
+                            seqVisibility = info.visibility;
+                            seqIsStatic = info.isStatic;
+                            seqIsReadonly = info.isReadonly;
+                        }
+                    }
+                }
+                // All 14 languages register a FieldExtractor — no fallback needed.
+            }
+            // Apply field metadata to the graph node retroactively
+            if (seqVisibility !== undefined)
+                node.properties.visibility = seqVisibility;
+            if (seqIsStatic !== undefined)
+                node.properties.isStatic = seqIsStatic;
+            if (seqIsReadonly !== undefined)
+                node.properties.isReadonly = seqIsReadonly;
+            if (declaredType !== undefined)
+                node.properties.declaredType = declaredType;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
                 parameterCount: methodSig?.parameterCount,
+                requiredParameterCount: methodSig?.requiredParameterCount,
+                parameterTypes: methodSig?.parameterTypes,
                 returnType: methodSig?.returnType,
                 declaredType,
                 ownerId: enclosingClassId ?? undefined,

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

@@ -1,6 +1,16 @@
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+/** A group of files with no mutual dependencies, safe to process in parallel. */
+type IndependentFileGroup = readonly string[];
+/** Kahn's algorithm: returns files grouped by topological level.
+ *  Files in the same level have no mutual dependencies — safe to process in parallel.
+ *  Files in cycles are returned as a final group (no cross-cycle propagation). */
+export declare function topologicalLevelSort(importMap: ReadonlyMap<string, ReadonlySet<string>>): {
+    levels: readonly IndependentFileGroup[];
+    cycleCount: number;
+};
 export interface PipelineOptions {
     /** Skip MRO, community detection, and process extraction for faster test runs. */
     skipGraphPhases?: boolean;
 }
 export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions) => Promise<PipelineResult>;
+export {};