@mycodemap/mycodemap 0.4.2 → 0.5.1

package/dist/orchestrator/history-risk-service.js

@@ -0,0 +1,680 @@
+// [META] since:2026-04-15 | owner:architecture-team | stable:false
+// [WHY] Canonical history/risk service that materializes git signals once and degrades safely when history is missing
+import path from 'node:path';
+import { GitAnalyzer, TAG_WEIGHTS } from './git-analyzer.js';
+import { WorkflowGitAnalyzer } from './workflow/git-analyzer.js';
+const DEFAULT_MAX_COMMITS = 20;
+const DEFAULT_MAX_FILES_PER_REQUEST = 5;
+const DEFAULT_PRECOMPUTE_THRESHOLD = 25;
+const DEFAULT_STALE_AFTER_HOURS = 24;
+const DEFAULT_EXPIRED_AFTER_HOURS = 24 * 7;
+const DEFAULT_IMPACT_DEPTH = 2;
+function isHistoryRiskStorageAdapter(storage) {
+    const candidate = storage;
+    return typeof candidate.saveHistoryRiskSnapshot === 'function'
+        && typeof candidate.loadLatestFileHistorySignal === 'function'
+        && typeof candidate.loadLatestSymbolHistoryResult === 'function';
+}
+function uniqueValues(values) {
+    return [...new Set(values.map(value => value.trim()).filter(value => value.length > 0))];
+}
+function normalizeProjectRelativePath(filePath, projectRoot) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    if (!path.isAbsolute(filePath)) {
+        return normalizedPath;
+    }
+    const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, '/');
+    return relativePath.length > 0 ? relativePath : normalizedPath;
+}
+function toIsoString(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+    }
+    return null;
+}
+function createUnavailableRiskScore(reason) {
+    return {
+        level: 'unavailable',
+        score: null,
+        gravity: null,
+        heat: null,
+        impact: null,
+        riskFactors: reason ? [reason] : [],
+    };
+}
+function downgradeConfidence(confidence) {
+    if (confidence === 'high') {
+        return 'medium';
+    }
+    if (confidence === 'medium') {
+        return 'low';
+    }
+    return confidence;
+}
+function pickHigherConfidence(left, right) {
+    const rank = {
+        unavailable: 0,
+        low: 1,
+        medium: 2,
+        high: 3,
+    };
+    return rank[left] >= rank[right] ? left : right;
+}
+function calculateFreshness(analyzedAt, now, staleAfterHours, expiredAfterHours) {
+    if (!analyzedAt) {
+        return 'unknown';
+    }
+    const parsed = new Date(analyzedAt);
+    if (Number.isNaN(parsed.getTime())) {
+        return 'unknown';
+    }
+    const ageHours = (now.getTime() - parsed.getTime()) / (1000 * 60 * 60);
+    if (ageHours <= staleAfterHours) {
+        return 'fresh';
+    }
+    if (ageHours <= expiredAfterHours) {
+        return 'stale';
+    }
+    return 'expired';
+}
+function refreshDiagnostics(diagnostics, now, staleAfterHours, expiredAfterHours) {
+    const freshness = calculateFreshness(diagnostics.analyzedAt, now, staleAfterHours, expiredAfterHours);
+    let confidence = diagnostics.confidence;
+    const reasons = [...diagnostics.reasons];
+    if (freshness === 'stale') {
+        confidence = downgradeConfidence(confidence);
+        reasons.push('materialized history is stale');
+    }
+    else if (freshness === 'expired') {
+        confidence = 'low';
+        reasons.push('materialized history is expired');
+    }
+    return {
+        ...diagnostics,
+        freshness,
+        confidence,
+        source: diagnostics.source === 'unavailable' ? 'unavailable' : 'sqlite-cache',
+        reasons: uniqueValues(reasons),
+    };
+}
+function mapWorkflowHeat(heat) {
+    return {
+        freq30d: heat?.freq30d ?? 0,
+        lastType: (heat?.lastType ?? 'NEW'),
+        lastDate: toIsoString(heat?.lastDate),
+        stability: heat?.stability ?? true,
+    };
+}
+function hasHistoryEvidence(heat, timeline) {
+    return timeline.length > 0 || heat.freq30d > 0 || heat.lastDate !== null;
+}
+function createDiagnostics(params) {
+    return {
+        status: params.status,
+        confidence: params.confidence,
+        freshness: params.analyzedAt ? 'fresh' : 'unknown',
+        source: params.source,
+        reasons: uniqueValues(params.reasons),
+        analyzedAt: params.analyzedAt,
+        scopeMode: params.scopeMode,
+        requestedFiles: params.requestedFiles,
+        analyzedFiles: params.analyzedFiles,
+        requiresPrecompute: params.requiresPrecompute ?? false,
+    };
+}
+function createUnavailableFileSignal(file, reason, analyzedAt, source, status = 'unavailable') {
+    return {
+        file,
+        risk: createUnavailableRiskScore(reason),
+        timeline: [],
+        diagnostics: createDiagnostics({
+            status,
+            confidence: status === 'not_found' ? 'low' : 'unavailable',
+            source,
+            reasons: [reason],
+            analyzedAt,
+            scopeMode: 'partial',
+            requestedFiles: 1,
+            analyzedFiles: 0,
+        }),
+    };
+}
+function createUnavailableSymbolResult(query, reason, status = 'unavailable', candidates = []) {
+    return {
+        query,
+        candidates,
+        symbol: null,
+        files: [],
+        timeline: [],
+        risk: createUnavailableRiskScore(reason),
+        diagnostics: createDiagnostics({
+            status,
+            confidence: status === 'not_found' || status === 'ambiguous' ? 'low' : 'unavailable',
+            source: status === 'unavailable' ? 'unavailable' : 'git-live',
+            reasons: [reason],
+            analyzedAt: null,
+            scopeMode: 'partial',
+            requestedFiles: 0,
+            analyzedFiles: 0,
+        }),
+    };
+}
+function createSyntheticWorkflowContext(task) {
+    const now = new Date();
+    return {
+        id: 'history-risk-service',
+        task,
+        currentPhase: 'link',
+        phaseStatus: 'running',
+        artifacts: new Map(),
+        cachedResults: {},
+        userConfirmed: new Set(),
+        startedAt: now,
+        updatedAt: now,
+    };
+}
+function normalizeTimeline(commits, source) {
+    return commits.map((commit) => {
+        const tagType = commit.tag?.type ?? 'UNKNOWN';
+        return {
+            hash: commit.hash,
+            message: commit.message,
+            date: toIsoString(commit.date) ?? new Date(0).toISOString(),
+            author: commit.author,
+            files: commit.files,
+            tagType,
+            tagScope: commit.tag?.scope ?? 'general',
+            subject: commit.tag?.subject ?? commit.message,
+            riskWeight: TAG_WEIGHTS[tagType] ?? TAG_WEIGHTS.UNKNOWN,
+            source,
+        };
+    });
+}
+function filterCommitsForFile(commits, file) {
+    return commits.filter((commit) => commit.files.length === 0 || commit.files.includes(file));
+}
+function filterCommitsForSymbol(commits, candidate) {
+    return commits.filter((commit) => commit.files.includes(candidate.file) || commit.message.includes(candidate.name));
+}
+function buildCandidate(symbol, query) {
+    return {
+        symbolId: symbol.id,
+        moduleId: symbol.moduleId,
+        name: symbol.name,
+        kind: symbol.kind,
+        file: symbol.location.file,
+        line: symbol.location.line,
+        exactNameMatch: symbol.name === query,
+    };
+}
+export class GitHistoryService {
+    projectRoot;
+    storage;
+    gitAnalyzer;
+    workflowGitAnalyzer;
+    now;
+    maxCommits;
+    maxFilesPerRequest;
+    precomputeThreshold;
+    staleAfterHours;
+    expiredAfterHours;
+    impactDepth;
+    constructor(options) {
+        this.projectRoot = options.projectRoot;
+        this.storage = options.storage;
+        this.gitAnalyzer = options.gitAnalyzer ?? new GitAnalyzer();
+        this.workflowGitAnalyzer = options.workflowGitAnalyzer ?? new WorkflowGitAnalyzer(options.projectRoot);
+        this.now = options.now ?? (() => new Date());
+        this.maxCommits = options.maxCommits ?? DEFAULT_MAX_COMMITS;
+        this.maxFilesPerRequest = options.maxFilesPerRequest ?? DEFAULT_MAX_FILES_PER_REQUEST;
+        this.precomputeThreshold = options.precomputeThreshold ?? DEFAULT_PRECOMPUTE_THRESHOLD;
+        this.staleAfterHours = options.staleAfterHours ?? DEFAULT_STALE_AFTER_HOURS;
+        this.expiredAfterHours = options.expiredAfterHours ?? DEFAULT_EXPIRED_AFTER_HOURS;
+        this.impactDepth = options.impactDepth ?? DEFAULT_IMPACT_DEPTH;
+    }
+    async analyzeFiles(files, options = {}) {
+        const requestedFiles = uniqueValues(files);
+        if (requestedFiles.length === 0) {
+            return {
+                requestedFiles: [],
+                files: [],
+                aggregatedRisk: createUnavailableRiskScore('no target files provided'),
+                diagnostics: createDiagnostics({
+                    status: 'unavailable',
+                    confidence: 'unavailable',
+                    source: 'unavailable',
+                    reasons: ['no target files provided'],
+                    analyzedAt: null,
+                    scopeMode: 'partial',
+                    requestedFiles: 0,
+                    analyzedFiles: 0,
+                }),
+            };
+        }
+        const selection = await this.selectFilesForAnalysis(requestedFiles, options.maxFiles ?? this.maxFilesPerRequest);
+        const storageAdapter = this.getHistoryRiskStorageAdapter();
+        const analyzedAt = this.now().toISOString();
+        const gitAvailable = await this.gitAnalyzer.isGitRepository(this.projectRoot);
+        if (!gitAvailable) {
+            return this.loadFileAnalysisFromCache(requestedFiles, selection, storageAdapter);
+        }
+        const workflowAnalysis = await this.workflowGitAnalyzer.analyzeForPhase('link', selection.selectedFiles, createSyntheticWorkflowContext('history-risk:file'));
+        const heatMap = this.buildHeatMap(workflowAnalysis);
+        const commits = await this.gitAnalyzer.findRelatedCommits([], selection.selectedFiles, {
+            maxCommits: options.maxCommits ?? this.maxCommits,
+            projectRoot: this.projectRoot,
+        });
+        const fileSignals = selection.selectedFiles.map((file) => {
+            const timeline = normalizeTimeline(filterCommitsForFile(commits, file), 'file');
+            const heat = heatMap.get(file) ?? mapWorkflowHeat();
+            const metrics = selection.metricsByFile.get(file) ?? {
+                file,
+                moduleIds: [],
+                dependencyIds: [],
+                dependentIds: [],
+                gravity: 0,
+                impact: 0,
+            };
+            if (!hasHistoryEvidence(heat, timeline)) {
+                return {
+                    file,
+                    risk: createUnavailableRiskScore('no git history evidence for file'),
+                    timeline: [],
+                    diagnostics: createDiagnostics({
+                        status: 'not_found',
+                        confidence: selection.scopeReduced || selection.requiresPrecompute ? 'low' : 'medium',
+                        source: 'git-live',
+                        reasons: ['no git history evidence for file'],
+                        analyzedAt,
+                        scopeMode: selection.scopeMode,
+                        requestedFiles: 1,
+                        analyzedFiles: 1,
+                        requiresPrecompute: selection.requiresPrecompute,
+                    }),
+                };
+            }
+            let confidence = timeline.length > 0 && heat.lastDate ? 'high' : 'medium';
+            if (selection.scopeReduced || selection.requiresPrecompute) {
+                confidence = downgradeConfidence(confidence);
+            }
+            return {
+                file,
+                risk: this.calculateRiskFromFeed(file, commits, heat, metrics),
+                timeline,
+                diagnostics: createDiagnostics({
+                    status: 'ok',
+                    confidence,
+                    source: 'git-live',
+                    reasons: ['git history materialized from live repository'],
+                    analyzedAt,
+                    scopeMode: selection.scopeMode,
+                    requestedFiles: 1,
+                    analyzedFiles: 1,
+                    requiresPrecompute: selection.requiresPrecompute,
+                }),
+            };
+        });
+        let snapshotId;
+        if (storageAdapter && options.persist !== false) {
+            const snapshot = await storageAdapter.saveHistoryRiskSnapshot({
+                recordedAt: analyzedAt,
+                source: 'git-live',
+                fileSignals,
+            });
+            snapshotId = snapshot.snapshotId;
+        }
+        const availableSignals = fileSignals.filter((signal) => signal.risk.score !== null);
+        const aggregatedRisk = availableSignals.length > 0
+            ? this.calculateAggregatedLiveRisk(availableSignals, commits, selection.metricsByFile, heatMap)
+            : createUnavailableRiskScore('no file produced usable history evidence');
+        const overallConfidence = this.calculateOverallConfidence(fileSignals.map((signal) => signal.diagnostics.confidence), selection.scopeReduced || selection.requiresPrecompute);
+        return {
+            requestedFiles,
+            files: fileSignals,
+            aggregatedRisk,
+            diagnostics: createDiagnostics({
+                status: availableSignals.length > 0 ? 'ok' : 'not_found',
+                confidence: overallConfidence,
+                source: 'git-live',
+                reasons: [...selection.reasons, 'canonical history risk service completed live materialization'],
+                analyzedAt,
+                scopeMode: selection.scopeMode,
+                requestedFiles: requestedFiles.length,
+                analyzedFiles: selection.selectedFiles.length,
+                requiresPrecompute: selection.requiresPrecompute,
+            }),
+            snapshotId,
+        };
+    }
+    async resolveSymbolCandidates(query) {
+        const symbols = await this.storage.findSymbolByName(query);
+        return symbols
+            .map((symbol) => buildCandidate(symbol, query))
+            .sort((left, right) => {
+            if (left.exactNameMatch !== right.exactNameMatch) {
+                return left.exactNameMatch ? -1 : 1;
+            }
+            if (left.name.length !== right.name.length) {
+                return left.name.length - right.name.length;
+            }
+            return left.file.localeCompare(right.file);
+        });
+    }
+    async analyzeSymbol(query, options = {}) {
+        const trimmedQuery = query.trim();
+        if (trimmedQuery.length === 0) {
+            return createUnavailableSymbolResult(query, 'symbol query cannot be empty');
+        }
+        const directSymbol = await this.storage.findSymbolById(trimmedQuery);
+        const candidates = directSymbol
+            ? [buildCandidate(directSymbol, directSymbol.name)]
+            : await this.resolveSymbolCandidates(trimmedQuery);
+        if (candidates.length === 0) {
+            return createUnavailableSymbolResult(trimmedQuery, 'symbol not found in storage', 'not_found');
+        }
+        const exactCandidates = directSymbol
+            ? candidates
+            : candidates.filter((candidate) => candidate.exactNameMatch);
+        const isAmbiguous = !directSymbol
+            && ((exactCandidates.length > 1) || (exactCandidates.length === 0 && candidates.length > 1));
+        if (isAmbiguous) {
+            return createUnavailableSymbolResult(trimmedQuery, 'symbol query resolved to multiple candidates', 'ambiguous', candidates);
+        }
+        const selected = directSymbol
+            ? candidates[0]
+            : (exactCandidates[0] ?? candidates[0] ?? null);
+        if (!selected) {
+            return createUnavailableSymbolResult(trimmedQuery, 'failed to resolve target symbol', 'not_found');
+        }
+        const storageAdapter = this.getHistoryRiskStorageAdapter();
+        const analyzedAt = this.now().toISOString();
+        const gitAvailable = await this.gitAnalyzer.isGitRepository(this.projectRoot);
+        if (!gitAvailable) {
+            if (storageAdapter) {
+                const cached = await storageAdapter.loadLatestSymbolHistoryResult(selected.symbolId, trimmedQuery);
+                if (cached.diagnostics.status !== 'unavailable') {
+                    return {
+                        ...cached,
+                        candidates: cached.candidates.length > 0 ? cached.candidates : candidates,
+                        diagnostics: refreshDiagnostics(cached.diagnostics, this.now(), this.staleAfterHours, this.expiredAfterHours),
+                    };
+                }
+            }
+            return createUnavailableSymbolResult(trimmedQuery, 'git repository unavailable and no materialized symbol history found');
+        }
+        const workflowAnalysis = await this.workflowGitAnalyzer.analyzeForPhase('link', [selected.file], createSyntheticWorkflowContext(`history-risk:symbol:${trimmedQuery}`));
+        const heat = this.buildHeatMap(workflowAnalysis).get(selected.file) ?? mapWorkflowHeat();
+        const commits = await this.gitAnalyzer.findRelatedCommits([selected.name], [selected.file], {
+            maxCommits: options.maxCommits ?? this.maxCommits,
+            projectRoot: this.projectRoot,
+        });
+        const timeline = normalizeTimeline(filterCommitsForSymbol(commits, selected), 'symbol');
+        if (!hasHistoryEvidence(heat, timeline)) {
+            return {
+                query: trimmedQuery,
+                candidates,
+                symbol: selected,
+                files: [selected.file],
+                timeline: [],
+                risk: createUnavailableRiskScore('no git history evidence for symbol'),
+                diagnostics: createDiagnostics({
+                    status: 'not_found',
+                    confidence: 'low',
+                    source: 'git-live',
+                    reasons: ['no git history evidence for symbol'],
+                    analyzedAt,
+                    scopeMode: 'full',
+                    requestedFiles: 1,
+                    analyzedFiles: 1,
+                }),
+            };
+        }
+        const metrics = await this.resolveSymbolMetrics(selected);
+        const risk = this.calculateRiskFromFeed(selected.file, commits, heat, {
+            file: selected.file,
+            moduleIds: [selected.moduleId],
+            dependencyIds: metrics.dependencyIds,
+            dependentIds: metrics.dependentIds,
+            gravity: metrics.gravity,
+            impact: metrics.impact,
+        });
+        const result = {
+            query: trimmedQuery,
+            candidates,
+            symbol: selected,
+            files: [selected.file],
+            timeline,
+            risk,
+            diagnostics: createDiagnostics({
+                status: 'ok',
+                confidence: selected.exactNameMatch ? 'high' : 'medium',
+                source: 'git-live',
+                reasons: ['symbol history resolved from live git signals'],
+                analyzedAt,
+                scopeMode: 'full',
+                requestedFiles: 1,
+                analyzedFiles: 1,
+            }),
+        };
+        if (storageAdapter && options.persist !== false) {
+            const snapshot = await storageAdapter.saveHistoryRiskSnapshot({
+                recordedAt: analyzedAt,
+                source: 'git-live',
+                symbolSignals: [result],
+            });
+            result.snapshotId = snapshot.snapshotId;
+        }
+        return result;
+    }
+    async loadFileAnalysisFromCache(requestedFiles, selection, storageAdapter) {
+        if (!storageAdapter) {
+            return {
+                requestedFiles,
+                files: selection.selectedFiles.map((file) => createUnavailableFileSignal(file, 'git repository unavailable and storage does not support history materialization', null, 'unavailable')),
+                aggregatedRisk: createUnavailableRiskScore('git repository unavailable and no cache adapter present'),
+                diagnostics: createDiagnostics({
+                    status: 'unavailable',
+                    confidence: 'unavailable',
+                    source: 'unavailable',
+                    reasons: [...selection.reasons, 'git repository unavailable and no cache adapter present'],
+                    analyzedAt: null,
+                    scopeMode: selection.scopeMode,
+                    requestedFiles: requestedFiles.length,
+                    analyzedFiles: 0,
+                    requiresPrecompute: selection.requiresPrecompute,
+                }),
+            };
+        }
+        const cachedSignals = await Promise.all(selection.selectedFiles.map(async (file) => {
+            const signal = await storageAdapter.loadLatestFileHistorySignal(file);
+            if (!signal) {
+                return createUnavailableFileSignal(file, 'no materialized history snapshot found for file', null, 'unavailable');
+            }
+            return {
+                ...signal,
+                diagnostics: refreshDiagnostics(signal.diagnostics, this.now(), this.staleAfterHours, this.expiredAfterHours),
+            };
+        }));
+        const availableSignals = cachedSignals.filter((signal) => signal.risk.score !== null);
+        const bestConfidence = cachedSignals.reduce((current, signal) => pickHigherConfidence(current, signal.diagnostics.confidence), 'unavailable');
+        return {
+            requestedFiles,
+            files: cachedSignals,
+            aggregatedRisk: this.combinePersistedRisk(cachedSignals),
+            diagnostics: createDiagnostics({
+                status: availableSignals.length > 0 ? 'ok' : 'unavailable',
+                confidence: selection.scopeReduced || selection.requiresPrecompute
+                    ? downgradeConfidence(bestConfidence)
+                    : bestConfidence,
+                source: availableSignals.length > 0 ? 'sqlite-cache' : 'unavailable',
+                reasons: [...selection.reasons, 'served materialized history from SQLite cache'],
+                analyzedAt: availableSignals[0]?.diagnostics.analyzedAt ?? null,
+                scopeMode: selection.scopeMode,
+                requestedFiles: requestedFiles.length,
+                analyzedFiles: availableSignals.length,
+                requiresPrecompute: selection.requiresPrecompute,
+            }),
+        };
+    }
+    calculateAggregatedLiveRisk(fileSignals, commits, metricsByFile, heatMap) {
+        const targetFiles = fileSignals.map((signal) => signal.file);
+        const feedData = fileSignals.map((signal) => {
+            const metrics = metricsByFile.get(signal.file) ?? {
+                file: signal.file,
+                moduleIds: [],
+                dependencyIds: [],
+                dependentIds: [],
+                gravity: 0,
+                impact: 0,
+            };
+            const heat = heatMap.get(signal.file) ?? mapWorkflowHeat();
+            return this.createFeed(signal.file, heat, metrics);
+        });
+        return this.mapAnalyzerRisk(this.gitAnalyzer.calculateRiskScore(targetFiles, commits, feedData), heatMap.get(targetFiles[0] ?? ''));
+    }
+    calculateRiskFromFeed(file, commits, heat, metrics) {
+        const risk = this.gitAnalyzer.calculateRiskScore([file], commits, [this.createFeed(file, heat, metrics)]);
+        return this.mapAnalyzerRisk(risk, heat);
+    }
+    mapAnalyzerRisk(risk, heat) {
+        return {
+            level: risk.level,
+            score: risk.score,
+            gravity: risk.gravity,
+            heat: heat ?? {
+                freq30d: risk.heat.freq30d,
+                lastType: risk.heat.lastType,
+                lastDate: risk.heat.lastDate,
+                stability: risk.heat.stability,
+            },
+            impact: risk.impact,
+            riskFactors: [...risk.riskFactors],
+        };
+    }
+    createFeed(file, heat, metrics) {
+        return {
+            file,
+            gravity: metrics.gravity,
+            heat: {
+                freq30d: heat.freq30d,
+                lastType: heat.lastType,
+                lastDate: heat.lastDate,
+                stability: heat.stability,
+            },
+            meta: {
+                stable: heat.stability,
+            },
+            deps: metrics.dependencyIds,
+            dependents: metrics.dependentIds,
+        };
+    }
+    buildHeatMap(result) {
+        const heatMap = new Map();
+        for (const heat of result.fileHeat ?? []) {
+            heatMap.set(heat.file, mapWorkflowHeat(heat));
+        }
+        return heatMap;
+    }
+    async selectFilesForAnalysis(requestedFiles, maxFiles) {
+        const metricsEntries = await Promise.all(requestedFiles.map((file) => this.resolveFileMetrics(file)));
+        metricsEntries.sort((left, right) => {
+            const leftScore = left.gravity + left.impact;
+            const rightScore = right.gravity + right.impact;
+            if (leftScore !== rightScore) {
+                return rightScore - leftScore;
+            }
+            return left.file.localeCompare(right.file);
+        });
+        const selectedEntries = metricsEntries.slice(0, Math.max(1, maxFiles));
+        const metricsByFile = new Map(metricsEntries.map((entry) => [entry.file, entry]));
+        const scopeReduced = selectedEntries.length < requestedFiles.length;
+        const requiresPrecompute = requestedFiles.length > this.precomputeThreshold;
+        const reasons = [];
+        if (scopeReduced) {
+            reasons.push(`scope shrunk to top ${selectedEntries.length} files out of ${requestedFiles.length}`);
+        }
+        if (requiresPrecompute) {
+            reasons.push('request exceeds live git budget; precompute is recommended');
+        }
+        return {
+            selectedFiles: selectedEntries.map((entry) => entry.file),
+            metricsByFile,
+            scopeReduced,
+            scopeMode: scopeReduced ? 'top-files-only' : 'full',
+            requiresPrecompute,
+            reasons,
+        };
+    }
+    async resolveFileMetrics(file) {
+        const normalizedFile = normalizeProjectRelativePath(file, this.projectRoot);
+        const modules = (await this.storage.findModulesByPath(file))
+            .filter((module) => normalizeProjectRelativePath(module.path, this.projectRoot) === normalizedFile);
+        const dependencyIds = new Set();
+        const dependentIds = new Set();
+        for (const module of modules) {
+            for (const dependency of await this.storage.findDependencies(module.id)) {
+                dependencyIds.add(dependency.targetId);
+            }
+            for (const dependency of await this.storage.findDependents(module.id)) {
+                dependentIds.add(dependency.sourceId);
+            }
+            const impact = await this.storage.calculateImpact(module.id, this.impactDepth);
+            for (const impactedModule of impact.affectedModules) {
+                dependentIds.add(impactedModule.id);
+            }
+        }
+        return {
+            file,
+            moduleIds: modules.map((module) => module.id),
+            dependencyIds: [...dependencyIds],
+            dependentIds: [...dependentIds],
+            gravity: dependencyIds.size + dependentIds.size,
+            impact: dependentIds.size,
+        };
+    }
+    async resolveSymbolMetrics(candidate) {
+        const fileMetrics = await this.resolveFileMetrics(candidate.file);
+        const dependencyIds = new Set(fileMetrics.dependencyIds);
+        const dependentIds = new Set(fileMetrics.dependentIds);
+        for (const callee of await this.storage.findCallees(candidate.symbolId)) {
+            dependencyIds.add(callee.id);
+        }
+        for (const caller of await this.storage.findCallers(candidate.symbolId)) {
+            dependentIds.add(caller.id);
+        }
+        return {
+            dependencyIds: [...dependencyIds],
+            dependentIds: [...dependentIds],
+            gravity: dependencyIds.size + dependentIds.size,
+            impact: dependentIds.size,
+        };
+    }
+    calculateOverallConfidence(confidences, requiresDowngrade) {
+        const best = confidences.reduce((current, confidence) => pickHigherConfidence(current, confidence), 'unavailable');
+        return requiresDowngrade ? downgradeConfidence(best) : best;
+    }
+    combinePersistedRisk(signals) {
+        const availableSignals = signals.filter((signal) => signal.risk.score !== null);
+        if (availableSignals.length === 0) {
+            return createUnavailableRiskScore('no persisted history risk available');
+        }
+        const topSignal = availableSignals.reduce((current, signal) => ((signal.risk.score ?? -1) > (current.risk.score ?? -1) ? signal : current));
+        const riskFactors = uniqueValues(availableSignals.flatMap((signal) => signal.risk.riskFactors));
+        return {
+            level: topSignal.risk.level,
+            score: Math.max(...availableSignals.map((signal) => signal.risk.score ?? 0)),
+            gravity: Math.max(...availableSignals.map((signal) => signal.risk.gravity ?? 0)),
+            heat: topSignal.risk.heat,
+            impact: Math.max(...availableSignals.map((signal) => signal.risk.impact ?? 0)),
+            riskFactors,
+        };
+    }
+    getHistoryRiskStorageAdapter() {
+        return isHistoryRiskStorageAdapter(this.storage) ? this.storage : null;
+    }
+}
+//# sourceMappingURL=history-risk-service.js.map