@liendev/parser 0.39.0

package/dist/dependency-analyzer.d.ts

@@ -0,0 +1,79 @@
+import type { CodeChunk } from './types.js';
+import type { RiskLevel } from './insights/types.js';
+/**
+ * Risk level thresholds for dependent count.
+ * Based on impact analysis: more dependents = higher risk of breaking changes.
+ */
+export declare const DEPENDENT_COUNT_THRESHOLDS: {
+    readonly LOW: 5;
+    readonly MEDIUM: 15;
+    readonly HIGH: 30;
+};
+/**
+ * Complexity thresholds for risk assessment.
+ * Based on cyclomatic complexity: higher complexity = harder to change safely.
+ */
+export declare const COMPLEXITY_THRESHOLDS: {
+    readonly HIGH_COMPLEXITY_DEPENDENT: 10;
+    readonly CRITICAL_AVG: 15;
+    readonly CRITICAL_MAX: 25;
+    readonly HIGH_AVG: 10;
+    readonly HIGH_MAX: 20;
+    readonly MEDIUM_AVG: 6;
+    readonly MEDIUM_MAX: 15;
+};
+export interface FileComplexityInfo {
+    filepath: string;
+    avgComplexity: number;
+    maxComplexity: number;
+    complexityScore: number;
+    chunksWithComplexity: number;
+}
+export interface DependencyAnalysisResult {
+    dependents: Array<{
+        filepath: string;
+        isTestFile: boolean;
+    }>;
+    dependentCount: number;
+    riskLevel: RiskLevel;
+    complexityMetrics?: {
+        averageComplexity: number;
+        maxComplexity: number;
+        filesWithComplexityData: number;
+        highComplexityDependents: Array<{
+            filepath: string;
+            maxComplexity: number;
+            avgComplexity: number;
+        }>;
+        complexityRiskBoost: RiskLevel;
+    };
+}
+/**
+ * Check if a single chunk imports from the given source path.
+ * Checks both `importedSymbols` keys and raw `imports` array.
+ */
+export declare function chunkImportsFrom(chunk: CodeChunk, sourcePath: string, normalizePathCached: (path: string) => string): boolean;
+/**
+ * Group chunks by their normalized file path.
+ */
+export declare function groupChunksByNormalizedPath(chunks: CodeChunk[], normalizePathCached: (path: string) => string): Map<string, CodeChunk[]>;
+/**
+ * Check if a file (given its chunks) is a re-exporter from a source path.
+ * A re-exporter has both imports from the source and exports.
+ */
+export declare function fileIsReExporter(chunks: CodeChunk[], sourcePath: string, normalizePathCached: (path: string) => string): boolean;
+/**
+ * Find transitive dependents through re-export chains using BFS.
+ * Bounded to MAX_REEXPORT_DEPTH.
+ */
+export declare function findTransitiveDependents(reExporterPaths: string[], importIndex: Map<string, CodeChunk[]>, normalizedTarget: string, normalizePathCached: (path: string) => string, allChunksByFile: Map<string, CodeChunk[]>, existingFiles: Set<string>): CodeChunk[];
+/**
+ * Analyzes dependencies for a given file by finding all chunks that import it.
+ *
+ * @param targetFilepath - The file to analyze dependencies for
+ * @param allChunks - All chunks from the vector database
+ * @param workspaceRoot - The workspace root directory
+ * @returns Dependency analysis including dependents, count, and risk level
+ */
+export declare function analyzeDependencies(targetFilepath: string, allChunks: CodeChunk[], workspaceRoot: string): DependencyAnalysisResult;
+//# sourceMappingURL=dependency-analyzer.d.ts.map

package/dist/dependency-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-analyzer.d.ts","sourceRoot":"","sources":["../src/dependency-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;CAQxB,CAAC;AAEX,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC,CAAC;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,SAAS,CAAC;IACrB,iBAAiB,CAAC,EAAE;QAClB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,aAAa,EAAE,MAAM,CAAC;QACtB,uBAAuB,EAAE,MAAM,CAAC;QAChC,wBAAwB,EAAE,KAAK,CAAC;YAC9B,QAAQ,EAAE,MAAM,CAAC;YACjB,aAAa,EAAE,MAAM,CAAC;YACtB,aAAa,EAAE,MAAM,CAAC;SACvB,CAAC,CAAC;QACH,mBAAmB,EAAE,SAAS,CAAC;KAChC,CAAC;CACH;AAoPD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC5C,OAAO,CAcT;AASD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,EAAE,EACnB,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC5C,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAY1B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC5C,OAAO,CAaT;AAsDD;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,MAAM,EAAE,EACzB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EACrC,gBAAgB,EAAE,MAAM,EACxB,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAC7C,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,EACzC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,SAAS,EAAE,CA+Bb;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,SAAS,EAAE,EACtB,aAAa,EAAE,MAAM,GACpB,wBAAwB,CAqE1B"}

package/dist/dependency-analyzer.js

@@ -0,0 +1,408 @@
+import { normalizePath, getCanonicalPath, matchesFile, isTestFile } from './utils/path-matching.js';
+import { RISK_ORDER } from './insights/types.js';
+/**
+ * Risk level thresholds for dependent count.
+ * Based on impact analysis: more dependents = higher risk of breaking changes.
+ */
+export const DEPENDENT_COUNT_THRESHOLDS = {
+    LOW: 5, // Few dependents, safe to change
+    MEDIUM: 15, // Moderate impact, review dependents
+    HIGH: 30, // High impact, careful planning needed
+};
+/**
+ * Complexity thresholds for risk assessment.
+ * Based on cyclomatic complexity: higher complexity = harder to change safely.
+ */
+export const COMPLEXITY_THRESHOLDS = {
+    HIGH_COMPLEXITY_DEPENDENT: 10, // Individual file is complex
+    CRITICAL_AVG: 15, // Average complexity indicates systemic complexity
+    CRITICAL_MAX: 25, // Peak complexity indicates hotspot
+    HIGH_AVG: 10, // Moderately complex on average
+    HIGH_MAX: 20, // Some complex functions exist
+    MEDIUM_AVG: 6, // Slightly above simple code
+    MEDIUM_MAX: 15, // Occasional branching
+};
+/**
+ * Creates a cached path normalizer to avoid repeated string operations.
+ *
+ * @param workspaceRoot - The workspace root directory for path normalization
+ * @returns A function that normalizes and caches file paths
+ */
+function createPathNormalizer(workspaceRoot) {
+    const cache = new Map();
+    return (path) => {
+        const cached = cache.get(path);
+        if (cached !== undefined)
+            return cached;
+        const normalized = normalizePath(path, workspaceRoot);
+        cache.set(path, normalized);
+        return normalized;
+    };
+}
+/**
+ * Builds an index mapping normalized import paths to chunks that import them.
+ * Enables O(1) lookup instead of O(n*m) iteration.
+ *
+ * @param chunks - All chunks from the vector database
+ * @param normalizePathCached - Cached path normalization function
+ * @returns Map of normalized import paths to chunks that import them
+ */
+function buildImportIndex(chunks, normalizePathCached) {
+    const importIndex = new Map();
+    for (const chunk of chunks) {
+        const imports = chunk.metadata.imports || [];
+        for (const imp of imports) {
+            const normalizedImport = normalizePathCached(imp);
+            let chunkList = importIndex.get(normalizedImport);
+            if (!chunkList) {
+                chunkList = [];
+                importIndex.set(normalizedImport, chunkList);
+            }
+            chunkList.push(chunk);
+        }
+    }
+    return importIndex;
+}
+/**
+ * Finds all chunks that import the target file using index + fuzzy matching.
+ *
+ * @param normalizedTarget - The normalized path of the target file
+ * @param importIndex - Index mapping import paths to chunks
+ * @returns Array of chunks that import the target file (deduplicated)
+ */
+function findDependentChunks(normalizedTarget, importIndex) {
+    const dependentChunks = [];
+    const seenChunkIds = new Set();
+    const addChunk = (chunk) => {
+        const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+        if (!seenChunkIds.has(chunkId)) {
+            dependentChunks.push(chunk);
+            seenChunkIds.add(chunkId);
+        }
+    };
+    // Direct index lookup (fastest path)
+    const directMatches = importIndex.get(normalizedTarget);
+    if (directMatches) {
+        for (const chunk of directMatches) {
+            addChunk(chunk);
+        }
+    }
+    // Fuzzy match for relative imports and path variations
+    // Note: This is O(M) where M = unique import paths. For large codebases with many
+    // violations, consider caching fuzzy match results at a higher level.
+    for (const [normalizedImport, chunks] of importIndex.entries()) {
+        if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+            for (const chunk of chunks) {
+                addChunk(chunk);
+            }
+        }
+    }
+    return dependentChunks;
+}
+/**
+ * Groups chunks by their canonical file path.
+ *
+ * @param chunks - Array of chunks to group
+ * @param workspaceRoot - The workspace root directory
+ * @returns Map of canonical file paths to their chunks
+ */
+function groupChunksByFile(chunks, workspaceRoot) {
+    const chunksByFile = new Map();
+    for (const chunk of chunks) {
+        const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+        let existing = chunksByFile.get(canonical);
+        if (!existing) {
+            existing = [];
+            chunksByFile.set(canonical, existing);
+        }
+        existing.push(chunk);
+    }
+    return chunksByFile;
+}
+/**
+ * Calculates complexity metrics for each file based on its chunks.
+ *
+ * @param chunksByFile - Map of file paths to their chunks
+ * @returns Array of complexity info for files with complexity data
+ */
+function calculateFileComplexities(chunksByFile) {
+    const fileComplexities = [];
+    for (const [filepath, chunks] of chunksByFile.entries()) {
+        const complexities = chunks
+            .map(c => c.metadata.complexity)
+            .filter((c) => typeof c === 'number' && c > 0);
+        if (complexities.length > 0) {
+            const sum = complexities.reduce((a, b) => a + b, 0);
+            const avg = sum / complexities.length;
+            const max = Math.max(...complexities);
+            fileComplexities.push({
+                filepath,
+                avgComplexity: Math.round(avg * 10) / 10,
+                maxComplexity: max,
+                complexityScore: sum,
+                chunksWithComplexity: complexities.length,
+            });
+        }
+    }
+    return fileComplexities;
+}
+/**
+ * Calculates overall complexity metrics from per-file data.
+ *
+ * @param fileComplexities - Array of per-file complexity info
+ * @returns Aggregated complexity metrics, or undefined if no data
+ */
+function calculateOverallComplexityMetrics(fileComplexities) {
+    if (fileComplexities.length === 0) {
+        return undefined;
+    }
+    const allAvgs = fileComplexities.map(f => f.avgComplexity);
+    const allMaxes = fileComplexities.map(f => f.maxComplexity);
+    const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
+    const globalMax = Math.max(...allMaxes);
+    // Identify high-complexity dependents (top 5)
+    const highComplexityDependents = fileComplexities
+        .filter(f => f.maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_COMPLEXITY_DEPENDENT)
+        .sort((a, b) => b.maxComplexity - a.maxComplexity)
+        .slice(0, 5)
+        .map(f => ({
+        filepath: f.filepath,
+        maxComplexity: f.maxComplexity,
+        avgComplexity: f.avgComplexity,
+    }));
+    // Calculate complexity-based risk boost
+    const complexityRiskBoost = calculateComplexityRiskBoost(totalAvg, globalMax);
+    return {
+        averageComplexity: Math.round(totalAvg * 10) / 10,
+        maxComplexity: globalMax,
+        filesWithComplexityData: fileComplexities.length,
+        highComplexityDependents,
+        complexityRiskBoost,
+    };
+}
+/**
+ * Determines risk level based on complexity thresholds.
+ *
+ * @param avgComplexity - Average complexity across all files
+ * @param maxComplexity - Maximum complexity found in any file
+ * @returns Risk level based on complexity thresholds
+ */
+function calculateComplexityRiskBoost(avgComplexity, maxComplexity) {
+    if (avgComplexity > COMPLEXITY_THRESHOLDS.CRITICAL_AVG ||
+        maxComplexity > COMPLEXITY_THRESHOLDS.CRITICAL_MAX) {
+        return 'critical';
+    }
+    if (avgComplexity > COMPLEXITY_THRESHOLDS.HIGH_AVG ||
+        maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_MAX) {
+        return 'high';
+    }
+    if (avgComplexity > COMPLEXITY_THRESHOLDS.MEDIUM_AVG ||
+        maxComplexity > COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
+        return 'medium';
+    }
+    return 'low';
+}
+/**
+ * Calculates risk level based on dependent count.
+ *
+ * @param count - Number of dependent files
+ * @returns Risk level based on dependent count thresholds
+ */
+function calculateRiskLevelFromCount(count) {
+    if (count <= DEPENDENT_COUNT_THRESHOLDS.LOW) {
+        return 'low';
+    }
+    if (count <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM) {
+        return 'medium';
+    }
+    if (count <= DEPENDENT_COUNT_THRESHOLDS.HIGH) {
+        return 'high';
+    }
+    return 'critical';
+}
+/**
+ * Maximum depth for following re-export chains.
+ * Covers real-world barrel chains (A → barrel → barrel → consumer)
+ * without risk of runaway traversal.
+ */
+const MAX_REEXPORT_DEPTH = 3;
+/**
+ * Check if a single chunk imports from the given source path.
+ * Checks both `importedSymbols` keys and raw `imports` array.
+ */
+export function chunkImportsFrom(chunk, sourcePath, normalizePathCached) {
+    const importedSymbols = chunk.metadata.importedSymbols;
+    if (importedSymbols && typeof importedSymbols === 'object') {
+        for (const importPath of Object.keys(importedSymbols)) {
+            if (matchesFile(normalizePathCached(importPath), sourcePath))
+                return true;
+        }
+    }
+    const imports = chunk.metadata.imports || [];
+    for (const imp of imports) {
+        if (matchesFile(normalizePathCached(imp), sourcePath))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a chunk has any exports.
+ */
+function chunkHasExports(chunk) {
+    return chunk.metadata.exports != null && chunk.metadata.exports.length > 0;
+}
+/**
+ * Group chunks by their normalized file path.
+ */
+export function groupChunksByNormalizedPath(chunks, normalizePathCached) {
+    const grouped = new Map();
+    for (const chunk of chunks) {
+        const canonical = normalizePathCached(chunk.metadata.file);
+        let list = grouped.get(canonical);
+        if (!list) {
+            list = [];
+            grouped.set(canonical, list);
+        }
+        list.push(chunk);
+    }
+    return grouped;
+}
+/**
+ * Check if a file (given its chunks) is a re-exporter from a source path.
+ * A re-exporter has both imports from the source and exports.
+ */
+export function fileIsReExporter(chunks, sourcePath, normalizePathCached) {
+    let importsFromSource = false;
+    let hasExports = false;
+    for (const chunk of chunks) {
+        if (!importsFromSource && chunkImportsFrom(chunk, sourcePath, normalizePathCached)) {
+            importsFromSource = true;
+        }
+        if (!hasExports && chunkHasExports(chunk)) {
+            hasExports = true;
+        }
+        if (importsFromSource && hasExports)
+            return true;
+    }
+    return false;
+}
+/**
+ * Build a list of files that re-export from the target file.
+ *
+ * A re-exporter is a file where a symbol appears in both
+ * `importedSymbols[targetPath]` (or raw `imports`) AND `exports`.
+ */
+function buildReExportGraph(allChunksByFile, normalizedTarget, normalizePathCached) {
+    const reExporters = [];
+    for (const [filepath, chunks] of allChunksByFile.entries()) {
+        if (matchesFile(filepath, normalizedTarget))
+            continue;
+        if (fileIsReExporter(chunks, normalizedTarget, normalizePathCached)) {
+            reExporters.push(filepath);
+        }
+    }
+    return reExporters;
+}
+/**
+ * Process a single dependent chunk during BFS traversal.
+ * Returns the chunk if it's a new dependent, or null if already visited.
+ * If the chunk's file is itself a re-exporter, adds it to the BFS queue.
+ */
+function processTransitiveChunk(chunk, reExporterPath, depth, visited, allChunksByFile, normalizePathCached, queue) {
+    const chunkFile = normalizePathCached(chunk.metadata.file);
+    if (visited.has(chunkFile))
+        return null;
+    visited.add(chunkFile);
+    if (depth < MAX_REEXPORT_DEPTH) {
+        const fileChunks = allChunksByFile.get(chunkFile) || [];
+        if (fileIsReExporter(fileChunks, reExporterPath, normalizePathCached)) {
+            queue.push([chunkFile, depth + 1]);
+        }
+    }
+    return chunk;
+}
+/**
+ * Find transitive dependents through re-export chains using BFS.
+ * Bounded to MAX_REEXPORT_DEPTH.
+ */
+export function findTransitiveDependents(reExporterPaths, importIndex, normalizedTarget, normalizePathCached, allChunksByFile, existingFiles) {
+    const transitiveChunks = [];
+    const visited = new Set([normalizedTarget, ...existingFiles]);
+    const queue = [];
+    for (const rePath of reExporterPaths) {
+        if (!visited.has(rePath)) {
+            queue.push([rePath, 1]);
+            visited.add(rePath);
+        }
+    }
+    while (queue.length > 0) {
+        const [reExporterPath, depth] = queue.shift();
+        const dependentChunks = findDependentChunks(reExporterPath, importIndex);
+        for (const chunk of dependentChunks) {
+            const result = processTransitiveChunk(chunk, reExporterPath, depth, visited, allChunksByFile, normalizePathCached, queue);
+            if (result)
+                transitiveChunks.push(result);
+        }
+    }
+    return transitiveChunks;
+}
+/**
+ * Analyzes dependencies for a given file by finding all chunks that import it.
+ *
+ * @param targetFilepath - The file to analyze dependencies for
+ * @param allChunks - All chunks from the vector database
+ * @param workspaceRoot - The workspace root directory
+ * @returns Dependency analysis including dependents, count, and risk level
+ */
+export function analyzeDependencies(targetFilepath, allChunks, workspaceRoot) {
+    // Create cached path normalizer
+    const normalizePathCached = createPathNormalizer(workspaceRoot);
+    // Build import index for efficient lookup
+    const importIndex = buildImportIndex(allChunks, normalizePathCached);
+    // Find all dependent chunks
+    const normalizedTarget = normalizePathCached(targetFilepath);
+    const dependentChunks = findDependentChunks(normalizedTarget, importIndex);
+    // Group by file for analysis
+    const chunksByFile = groupChunksByFile(dependentChunks, workspaceRoot);
+    // Find transitive dependents through re-export chains (barrel files)
+    const allChunksByFile = groupChunksByNormalizedPath(allChunks, normalizePathCached);
+    const reExporterPaths = buildReExportGraph(allChunksByFile, normalizedTarget, normalizePathCached);
+    if (reExporterPaths.length > 0) {
+        const existingFiles = new Set(chunksByFile.keys());
+        const transitiveChunks = findTransitiveDependents(reExporterPaths, importIndex, normalizedTarget, normalizePathCached, allChunksByFile, existingFiles);
+        if (transitiveChunks.length > 0) {
+            const transitiveByFile = groupChunksByFile(transitiveChunks, workspaceRoot);
+            for (const [fp, chunks] of transitiveByFile.entries()) {
+                if (chunksByFile.has(fp)) {
+                    chunksByFile.get(fp).push(...chunks);
+                }
+                else {
+                    chunksByFile.set(fp, chunks);
+                }
+            }
+        }
+    }
+    // Calculate complexity metrics
+    const fileComplexities = calculateFileComplexities(chunksByFile);
+    const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
+    // Build dependents list
+    const dependents = Array.from(chunksByFile.keys()).map(filepath => ({
+        filepath,
+        isTestFile: isTestFile(filepath),
+    }));
+    // Calculate risk level
+    let riskLevel = calculateRiskLevelFromCount(dependents.length);
+    // Boost risk level if complexity warrants it
+    if (complexityMetrics?.complexityRiskBoost) {
+        if (RISK_ORDER[complexityMetrics.complexityRiskBoost] > RISK_ORDER[riskLevel]) {
+            riskLevel = complexityMetrics.complexityRiskBoost;
+        }
+    }
+    return {
+        dependents,
+        dependentCount: dependents.length,
+        riskLevel,
+        complexityMetrics,
+    };
+}
+//# sourceMappingURL=dependency-analyzer.js.map

package/dist/dependency-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-analyzer.js","sourceRoot":"","sources":["../src/dependency-analyzer.ts"],"names":[],"mappings":"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"}

package/dist/ecosystem-presets.d.ts

@@ -0,0 +1,32 @@
+/**
+ * An ecosystem preset defines marker files and exclude patterns
+ * for a specific development ecosystem.
+ */
+export interface EcosystemPreset {
+    name: string;
+    markerFiles: string[];
+    excludePatterns: string[];
+}
+/**
+ * Predefined ecosystem presets.
+ * Each preset checks for marker files and provides exclude patterns
+ * for common build artifacts, caches, and generated files.
+ */
+export declare const ECOSYSTEM_PRESETS: EcosystemPreset[];
+/**
+ * Detect which ecosystems are present in a project by checking for marker files.
+ * Checks rootDir and immediate subdirectories (depth 1) for monorepo support.
+ *
+ * @param rootDir - Project root directory
+ * @returns Array of matched ecosystem names
+ */
+export declare function detectEcosystems(rootDir: string): Promise<string[]>;
+/**
+ * Get merged exclude patterns for the given ecosystem names.
+ * Returns a deduplicated array of exclude patterns.
+ *
+ * @param ecosystemNames - Array of ecosystem names (e.g. ['nodejs', 'python'])
+ * @returns Deduplicated exclude patterns
+ */
+export declare function getEcosystemExcludePatterns(ecosystemNames: string[]): string[];
+//# sourceMappingURL=ecosystem-presets.d.ts.map

package/dist/ecosystem-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecosystem-presets.d.ts","sourceRoot":"","sources":["../src/ecosystem-presets.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,EAwM9C,CAAC;AAgFF;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkBzE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAa9E"}