@liendev/core 0.19.5

package/dist/indexer/chunk-batch-processor.js

@@ -0,0 +1,179 @@
+/**
+ * ChunkBatchProcessor - Handles concurrent chunk accumulation and batch processing.
+ *
+ * Extracted from performFullIndex to:
+ * 1. Encapsulate mutex/lock management complexity
+ * 2. Make the batch processing logic testable
+ * 3. Separate concerns (accumulation vs processing vs coordination)
+ *
+ * Key responsibilities:
+ * - Accumulate chunks from concurrent file processing
+ * - Batch chunks for embedding generation
+ * - Manage concurrent access with mutex pattern
+ * - Process batches through embedding → vectordb pipeline
+ */
+import { EMBEDDING_MICRO_BATCH_SIZE } from '../constants.js';
+/**
+ * Process embeddings in micro-batches to prevent event loop blocking.
+ * Yields to the event loop between batches for UI responsiveness.
+ */
+export async function processEmbeddingMicroBatches(texts, embeddings) {
+    const results = [];
+    for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
+        const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
+        const microResults = await embeddings.embedBatch(microBatch);
+        results.push(...microResults);
+        // Yield to event loop for UI responsiveness
+        await new Promise(resolve => setImmediate(resolve));
+    }
+    return results;
+}
+/**
+ * ChunkBatchProcessor handles the complex concurrent chunk accumulation
+ * and batch processing logic for indexing.
+ *
+ * Usage:
+ * ```typescript
+ * const processor = new ChunkBatchProcessor(vectorDB, embeddings, config, tracker);
+ *
+ * // From concurrent file processing tasks:
+ * await processor.addChunks(chunks, filepath, mtime);
+ *
+ * // After all files processed:
+ * await processor.flush();
+ *
+ * // Get results:
+ * const { processedChunks, indexedFiles } = processor.getResults();
+ * ```
+ */
+export class ChunkBatchProcessor {
+    vectorDB;
+    embeddings;
+    config;
+    progressTracker;
+    accumulator = [];
+    indexedFiles = [];
+    processedChunkCount = 0;
+    // Mutex state for concurrent access protection
+    addChunksLock = null;
+    processingQueue = null;
+    constructor(vectorDB, embeddings, config, progressTracker) {
+        this.vectorDB = vectorDB;
+        this.embeddings = embeddings;
+        this.config = config;
+        this.progressTracker = progressTracker;
+    }
+    /**
+     * Add chunks from a processed file.
+     * Thread-safe: uses mutex to prevent race conditions with concurrent calls.
+     *
+     * @param chunks - Code chunks to add
+     * @param filepath - Source file path (for manifest)
+     * @param mtime - File modification time in ms (for change detection)
+     */
+    async addChunks(chunks, filepath, mtime) {
+        if (chunks.length === 0) {
+            return;
+        }
+        // Wait for any in-progress add operation (mutex acquire)
+        if (this.addChunksLock) {
+            await this.addChunksLock;
+        }
+        // Create new lock promise
+        let releaseLock;
+        this.addChunksLock = new Promise(resolve => {
+            releaseLock = resolve;
+        });
+        try {
+            // Critical section: modify shared state
+            for (const chunk of chunks) {
+                this.accumulator.push({
+                    chunk,
+                    content: chunk.content,
+                });
+            }
+            // Track file for manifest
+            this.indexedFiles.push({
+                filepath,
+                chunkCount: chunks.length,
+                mtime,
+            });
+            // Process if batch threshold reached
+            if (this.accumulator.length >= this.config.batchThreshold) {
+                await this.triggerProcessing();
+            }
+        }
+        finally {
+            // Release mutex
+            releaseLock();
+            this.addChunksLock = null;
+        }
+    }
+    /**
+     * Flush any remaining accumulated chunks.
+     * Call this after all files have been processed.
+     */
+    async flush() {
+        this.progressTracker.setMessage?.('Processing final chunks...');
+        await this.triggerProcessing();
+    }
+    /**
+     * Get processing results.
+     */
+    getResults() {
+        return {
+            processedChunks: this.processedChunkCount,
+            indexedFiles: [...this.indexedFiles],
+        };
+    }
+    /**
+     * Trigger batch processing. Uses queue-based synchronization
+     * to prevent TOCTOU race conditions.
+     */
+    async triggerProcessing() {
+        // Chain onto existing processing promise to create a queue
+        if (this.processingQueue) {
+            this.processingQueue = this.processingQueue.then(() => this.doProcess());
+        }
+        else {
+            this.processingQueue = this.doProcess();
+        }
+        return this.processingQueue;
+    }
+    /**
+     * The actual batch processing logic.
+     * Processes accumulated chunks through embedding → vectordb pipeline.
+     */
+    async doProcess() {
+        if (this.accumulator.length === 0) {
+            return;
+        }
+        const currentPromise = this.processingQueue;
+        try {
+            // Drain accumulator atomically
+            const toProcess = this.accumulator.splice(0, this.accumulator.length);
+            // Process in batches for memory/API limits
+            for (let i = 0; i < toProcess.length; i += this.config.embeddingBatchSize) {
+                const batch = toProcess.slice(i, Math.min(i + this.config.embeddingBatchSize, toProcess.length));
+                const texts = batch.map(item => item.content);
+                // Generate embeddings
+                this.progressTracker.setMessage?.('Generating embeddings...');
+                const embeddingVectors = await processEmbeddingMicroBatches(texts, this.embeddings);
+                this.processedChunkCount += batch.length;
+                // Insert into vector database
+                this.progressTracker.setMessage?.(`Inserting ${batch.length} chunks...`);
+                await this.vectorDB.insertBatch(embeddingVectors, batch.map(item => item.chunk.metadata), texts);
+                // Yield to event loop
+                await new Promise(resolve => setImmediate(resolve));
+            }
+            this.progressTracker.setMessage?.('Processing files...');
+        }
+        finally {
+            // Clear queue reference if we're the current operation
+            if (this.processingQueue === currentPromise) {
+                this.processingQueue = null;
+            }
+        }
+    }
+}
+//# sourceMappingURL=chunk-batch-processor.js.map

package/dist/indexer/chunk-batch-processor.js.map

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

package/dist/indexer/chunker.d.ts

@@ -0,0 +1,10 @@
+import { CodeChunk } from './types.js';
+export interface ChunkOptions {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    useAST?: boolean;
+    astFallback?: 'line-based' | 'error';
+}
+export declare function chunkFile(filepath: string, content: string, options?: ChunkOptions): CodeChunk[];
+export declare function chunkText(text: string, options?: ChunkOptions): string[];
+//# sourceMappingURL=chunker.d.ts.map

package/dist/indexer/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/indexer/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAOvC,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;CACtC;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,YAAiB,GACzB,SAAS,EAAE,CAmCb;AAuDD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,EAAE,CAqB5E"}

package/dist/indexer/chunker.js

@@ -0,0 +1,96 @@
+import { detectLanguage } from './scanner.js';
+import { extractSymbols } from './symbol-extractor.js';
+import { shouldUseAST, chunkByAST } from './ast/chunker.js';
+import { chunkLiquidFile } from './liquid-chunker.js';
+import { chunkJSONTemplate } from './json-template-chunker.js';
+export function chunkFile(filepath, content, options = {}) {
+    const { chunkSize = 75, chunkOverlap = 10, useAST = true, astFallback = 'line-based' } = options;
+    // Special handling for Liquid files
+    if (filepath.endsWith('.liquid')) {
+        return chunkLiquidFile(filepath, content, chunkSize, chunkOverlap);
+    }
+    // Special handling for Shopify JSON template files (templates/**/*.json)
+    // Use regex to ensure 'templates/' is a path segment, not part of another name
+    // Matches: templates/product.json OR some-path/templates/customers/account.json
+    // Rejects: my-templates/config.json OR node_modules/pkg/templates/file.json (filtered by scanner)
+    if (filepath.endsWith('.json') && /(?:^|\/)templates\//.test(filepath)) {
+        return chunkJSONTemplate(filepath, content);
+    }
+    // Try AST-based chunking for supported languages
+    if (useAST && shouldUseAST(filepath)) {
+        try {
+            return chunkByAST(filepath, content, {
+                minChunkSize: Math.floor(chunkSize / 10),
+            });
+        }
+        catch (error) {
+            // Handle AST errors based on configuration
+            if (astFallback === 'error') {
+                // Throw error if user wants strict AST-only behavior
+                throw new Error(`AST chunking failed for ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            // Otherwise fallback to line-based chunking
+            console.warn(`AST chunking failed for ${filepath}, falling back to line-based:`, error);
+        }
+    }
+    // Line-based chunking (original implementation)
+    return chunkByLines(filepath, content, chunkSize, chunkOverlap);
+}
+/**
+ * Original line-based chunking implementation
+ */
+function chunkByLines(filepath, content, chunkSize, chunkOverlap) {
+    const lines = content.split('\n');
+    const chunks = [];
+    const language = detectLanguage(filepath);
+    // Handle empty files
+    if (lines.length === 0 || (lines.length === 1 && lines[0].trim() === '')) {
+        return chunks;
+    }
+    // Chunk by lines with overlap
+    for (let i = 0; i < lines.length; i += chunkSize - chunkOverlap) {
+        const endLine = Math.min(i + chunkSize, lines.length);
+        const chunkLines = lines.slice(i, endLine);
+        const chunkContent = chunkLines.join('\n');
+        // Skip empty chunks
+        if (chunkContent.trim().length === 0) {
+            continue;
+        }
+        // Extract symbols from the chunk
+        const symbols = extractSymbols(chunkContent, language);
+        chunks.push({
+            content: chunkContent,
+            metadata: {
+                file: filepath,
+                startLine: i + 1,
+                endLine: endLine,
+                type: 'block', // MVP: all chunks are 'block' type
+                language,
+                symbols,
+            },
+        });
+        // If we've reached the end, break
+        if (endLine >= lines.length) {
+            break;
+        }
+    }
+    return chunks;
+}
+export function chunkText(text, options = {}) {
+    const { chunkSize = 75, chunkOverlap = 10 } = options;
+    const lines = text.split('\n');
+    const chunks = [];
+    for (let i = 0; i < lines.length; i += chunkSize - chunkOverlap) {
+        const endLine = Math.min(i + chunkSize, lines.length);
+        const chunkLines = lines.slice(i, endLine);
+        const chunkContent = chunkLines.join('\n');
+        if (chunkContent.trim().length > 0) {
+            chunks.push(chunkContent);
+        }
+        if (endLine >= lines.length) {
+            break;
+        }
+    }
+    return chunks;
+}
+//# sourceMappingURL=chunker.js.map

package/dist/indexer/chunker.js.map

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

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

@@ -0,0 +1,60 @@
+import { SearchResult } from '../vectordb/types.js';
+import { 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;
+    };
+}
+/**
+ * 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: SearchResult[], workspaceRoot: string): DependencyAnalysisResult;
+//# sourceMappingURL=dependency-analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-analyzer.d.ts","sourceRoot":"","sources":["../../src/indexer/dependency-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAc,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;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;AAyOD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,YAAY,EAAE,EACzB,aAAa,EAAE,MAAM,GACpB,wBAAwB,CAwC1B"}

package/dist/indexer/dependency-analyzer.js

@@ -0,0 +1,261 @@
+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';
+}
+/**
+ * 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);
+    // 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/indexer/dependency-analyzer.js.map

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