devchain-cli 0.11.4 → 0.12.0

package/dist/server/modules/codebase-overview-analyzer/services/codebase-overview-analyzer.service.js

@@ -0,0 +1,1128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CodebaseOverviewAnalyzerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodebaseOverviewAnalyzerService = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const fs_1 = require("fs");
+const fs = __importStar(require("fs/promises"));
+const path_1 = require("path");
+const path_matcher_1 = require("../utils/path-matcher");
+const constants_1 = require("../utils/constants");
+const logger_1 = require("../../../common/logging/logger");
+const identity_resolver_service_1 = require("./identity-resolver.service");
+const hotspot_scoring_service_1 = require("./hotspot-scoring.service");
+const district_splitting_service_1 = require("./district-splitting.service");
+const dependency_aggregation_service_1 = require("./dependency-aggregation.service");
+const evidence_query_service_1 = require("./evidence-query.service");
+const language_adapter_registry_service_1 = require("./language-adapter-registry.service");
+const scope_resolver_service_1 = require("./scope-resolver.service");
+const scope_auto_detector_service_1 = require("./scope-auto-detector.service");
+const overview_scope_repository_1 = require("../repositories/overview-scope.repository");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const MAX_BUFFER = 10 * 1024 * 1024;
+const MAX_ADAPTER_FILE_SIZE = 256 * 1024;
+const EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf899d15f0a75b9a7';
+const ROOT_REGION_NAME = '(root)';
+const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
+const logger = (0, logger_1.createLogger)('CodebaseOverviewAnalyzer');
+let CodebaseOverviewAnalyzerService = CodebaseOverviewAnalyzerService_1 = class CodebaseOverviewAnalyzerService {
+    constructor(identityResolver, hotspotScoring, districtSplitting, dependencyAggregation, evidenceQuery, adapterRegistry, scopeResolver, scopeAutoDetector, scopeRepository) {
+        this.identityResolver = identityResolver;
+        this.hotspotScoring = hotspotScoring;
+        this.districtSplitting = districtSplitting;
+        this.dependencyAggregation = dependencyAggregation;
+        this.evidenceQuery = evidenceQuery;
+        this.adapterRegistry = adapterRegistry;
+        this.scopeResolver = scopeResolver;
+        this.scopeAutoDetector = scopeAutoDetector;
+        this.scopeRepository = scopeRepository;
+        this.identityStore = new Map();
+        this.queryStore = new Map();
+    }
+    async getSnapshot(projectPath, projectId) {
+        const capabilities = await this.detectCapabilities(projectPath);
+        const userEntries = this.scopeRepository.readUserEntries(projectPath, projectId);
+        const preResolvedScope = this.scopeResolver.resolve(userEntries);
+        const preExcludedFolders = this.scopeResolver.getExcludedFolders(preResolvedScope);
+        const { files, locFallbackStats } = await this.scanFiles(projectPath, capabilities, preExcludedFolders);
+        const observedFolders = this.extractObservedFolders(files);
+        const autoDetected = this.scopeAutoDetector.detect(observedFolders);
+        const resolvedScope = this.scopeResolver.resolve(userEntries, autoDetected);
+        const excludedFolders = this.scopeResolver.getExcludedFolders(resolvedScope);
+        const generatedFolders = this.scopeResolver.getGeneratedFolders(resolvedScope);
+        const scopeConfigHash = (0, crypto_1.createHash)('sha256')
+            .update(JSON.stringify(resolvedScope))
+            .digest('hex')
+            .slice(0, 8);
+        const extraExcluded = excludedFolders.filter((f) => !preExcludedFolders.includes(f));
+        let filteredFiles = files;
+        if (extraExcluded.length > 0) {
+            filteredFiles = files.filter((f) => !(0, path_matcher_1.isUnderAnyFolder)(f.path, extraExcluded));
+        }
+        const segmented = this.segmentFiles(filteredFiles);
+        const regions = segmented.regions;
+        const locMap = new Map(filteredFiles.map((f) => [f.path, f.loc]));
+        const { districts, districtFileMap } = this.districtSplitting.splitOversizedDistricts(segmented.districts, segmented.districtFileMap, locMap, filteredFiles.length);
+        const previousState = this.identityStore.get(projectPath) ?? null;
+        const commitSha = capabilities.isGitRepo ? await this.getCurrentCommitSha(projectPath) : null;
+        const gitRenames = capabilities.isGitRepo
+            ? await this.detectGitRenames(projectPath, previousState?.commitSha ?? null)
+            : [];
+        const fileIds = this.identityResolver.resolveFileIds(filteredFiles.map((f) => f.path), previousState, gitRenames);
+        const regionIds = this.identityResolver.resolveRegionIds(regions.map((r) => r.name), previousState);
+        const districtCandidates = [...districtFileMap.entries()].map(([key, paths]) => ({
+            key,
+            memberFileIds: paths.map((p) => fileIds.get(p)),
+        }));
+        const districtIds = this.identityResolver.resolveDistrictIds(districtCandidates, previousState);
+        for (const region of regions) {
+            region.id = regionIds.get(region.name);
+        }
+        for (const district of districts) {
+            const districtKey = district.id.slice('district:'.length);
+            const resolvedId = districtIds.get(districtKey);
+            if (resolvedId)
+                district.id = resolvedId;
+            const regionName = districtKey.split('/')[0];
+            district.regionId = regionIds.get(regionName);
+        }
+        this.storeIdentityState(projectPath, commitSha, fileIds, regionIds, districtIds, districtFileMap);
+        const [churn1d, churn7d, churn30d, dailyChurnFileMap] = capabilities.isGitRepo
+            ? await Promise.all([
+                this.getChurnMap(projectPath, 1),
+                this.getChurnMap(projectPath, 7),
+                this.getChurnMap(projectPath, 30),
+                this.getDailyChurnMap(projectPath, 14),
+            ])
+            : [
+                new Map(),
+                new Map(),
+                new Map(),
+                null,
+            ];
+        const fileByPath = new Map(filteredFiles.map((f) => [f.path, f]));
+        const districtFilesById = new Map();
+        for (const [districtKey, filePaths] of districtFileMap) {
+            const districtId = districtIds.get(districtKey);
+            if (!districtId)
+                continue;
+            const enriched = filePaths.map((p) => {
+                const file = fileByPath.get(p);
+                return {
+                    path: p,
+                    loc: file?.loc ?? 0,
+                    lastModified: file?.lastModified ?? Date.now(),
+                    churn1d: churn1d.get(p) ?? 0,
+                    churn7d: churn7d.get(p) ?? 0,
+                    churn30d: churn30d.get(p) ?? 0,
+                    isTest: (0, hotspot_scoring_service_1.isTestFile)(p),
+                };
+            });
+            districtFilesById.set(districtId, enriched);
+        }
+        const analysisDistrictFilesById = new Map();
+        for (const [districtId, dFiles] of districtFilesById) {
+            const filtered = dFiles.filter((f) => !(0, path_matcher_1.isUnderAnyFolder)(f.path, generatedFolders));
+            analysisDistrictFilesById.set(districtId, filtered);
+        }
+        const analysisDistricts = districts.filter((d) => {
+            const files = analysisDistrictFilesById.get(d.id);
+            return Array.isArray(files) && files.length > 0;
+        });
+        this.hotspotScoring.enrichDistrictMetrics(districts, analysisDistrictFilesById);
+        const [windowedAuthor7d, windowedAuthor30d] = capabilities.isGitRepo
+            ? await Promise.all([
+                this.getWindowedAuthorMap(projectPath, 7),
+                this.getWindowedAuthorMap(projectPath, 30),
+            ])
+            : [null, null];
+        const activity = this.hotspotScoring.computeActivitySummaries(districts, districtFilesById, dailyChurnFileMap, windowedAuthor7d, windowedAuthor30d);
+        const globalContributors = this.buildGlobalContributors(districts, districtFilesById, windowedAuthor7d, windowedAuthor30d);
+        const allFilePaths = new Set();
+        for (const dFiles of districtFilesById.values()) {
+            for (const f of dFiles)
+                allFilePaths.add(f.path);
+        }
+        const adapterResult = await this.analyzeWithAdapters(projectPath, allFilePaths);
+        this.hotspotScoring.enrichDistrictAdapterMetrics(districts, analysisDistrictFilesById, adapterResult.enrichments);
+        const fileAuthors = capabilities.isGitRepo
+            ? await this.getFileAuthorMap(projectPath)
+            : new Map();
+        this.hotspotScoring.enrichDistrictOwnership(districts, districtFilesById, fileAuthors);
+        const fileToDistrictId = new Map();
+        for (const [districtId, dFiles] of districtFilesById) {
+            for (const f of dFiles) {
+                fileToDistrictId.set(f.path, districtId);
+            }
+        }
+        const dependencies = this.dependencyAggregation.aggregateDistrictDependencies(adapterResult.fileEdges, fileToDistrictId);
+        this.dependencyAggregation.enrichDistrictWeights(districts, dependencies);
+        const blastRadiusMap = this.dependencyAggregation.computeBlastRadius(districts, dependencies);
+        const hotspots = this.hotspotScoring.rankHotspots(analysisDistricts, analysisDistrictFilesById);
+        const hasImportData = adapterResult.fileEdges.length > 0;
+        const warnings = this.buildWarnings(capabilities, hasImportData, adapterResult.adapterFileCount, locFallbackStats);
+        const hasUnmeasuredCoverage = districts.some((d) => {
+            const dFiles = analysisDistrictFilesById.get(d.id) ?? [];
+            return dFiles.some((f) => !f.isTest) && d.testCoverageRate === null;
+        });
+        if (hasUnmeasuredCoverage) {
+            warnings.push({
+                code: 'coverage_unmeasured',
+                message: 'Some districts contain source files but no supported language adapter could measure test coverage.',
+            });
+        }
+        if (capabilities.isGitRepo && dailyChurnFileMap === null) {
+            warnings.push({
+                code: 'daily_churn_unavailable',
+                message: 'Daily churn data could not be retrieved. The per-day change heatmap will be unavailable.',
+            });
+        }
+        if (capabilities.isGitRepo && (windowedAuthor7d === null || windowedAuthor30d === null)) {
+            warnings.push({
+                code: 'windowed_authors_unavailable',
+                message: 'Windowed author data could not be retrieved. Contributor rankings will be incomplete.',
+            });
+        }
+        const excludedAuthorCount = this.computeExcludedAuthorCount(fileAuthors, excludedFolders, globalContributors);
+        const metrics = this.computeMetrics(filteredFiles, regions, districts, capabilities, warnings, excludedAuthorCount, scopeConfigHash);
+        const activityByDistrictId = new Map(activity.map((a) => [a.targetId, a]));
+        for (const district of districts) {
+            if (district.primaryAuthorName == null) {
+                district.primaryAuthorRecentlyActive = false;
+                continue;
+            }
+            const act = activityByDistrictId.get(district.id);
+            const recentNames = new Set(act?.recentContributors30d.map((c) => c.authorName) ?? []);
+            district.primaryAuthorRecentlyActive = recentNames.has(district.primaryAuthorName);
+        }
+        const regionById = new Map(regions.map((r) => [r.id, r]));
+        const signals = districts.map((district) => {
+            const dFiles = districtFilesById.get(district.id) ?? [];
+            const extCounts = {};
+            let sourceFileCount = 0;
+            let supportFileCount = 0;
+            for (const f of dFiles) {
+                const ext = (0, path_1.extname)(f.path) || '(no ext)';
+                extCounts[ext] = (extCounts[ext] ?? 0) + 1;
+                if (f.isTest) {
+                    supportFileCount++;
+                }
+                else {
+                    sourceFileCount++;
+                }
+            }
+            return {
+                districtId: district.id,
+                name: district.name,
+                path: district.path,
+                regionId: district.regionId,
+                regionName: regionById.get(district.regionId)?.name ?? '',
+                files: district.totalFiles,
+                sourceFileCount,
+                supportFileCount,
+                hasSourceFiles: sourceFileCount > 0,
+                loc: district.totalLOC,
+                churn7d: district.churn7d,
+                churn30d: district.churn30d,
+                testCoverageRate: district.testCoverageRate,
+                sourceCoverageMeasured: district.testCoverageRate !== null,
+                complexityAvg: district.complexityAvg,
+                inboundWeight: district.inboundWeight,
+                outboundWeight: district.outboundWeight,
+                blastRadius: district.blastRadius,
+                couplingScore: district.couplingScore,
+                ownershipHHI: district.ownershipConcentration,
+                ownershipMeasured: district.ownershipConcentration !== null,
+                primaryAuthorName: district.primaryAuthorName,
+                primaryAuthorShare: district.primaryAuthorShare,
+                primaryAuthorRecentlyActive: district.primaryAuthorRecentlyActive,
+                fileTypeBreakdown: { kind: 'extension', counts: extCounts },
+            };
+        });
+        const snapshot = {
+            snapshotId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            projectKey: projectPath,
+            name: projectPath.split(path_1.sep).pop() || projectPath,
+            regions,
+            districts,
+            dependencies,
+            hotspots,
+            activity,
+            metrics,
+            signals,
+            globalContributors,
+        };
+        this.queryStore.set(projectPath, {
+            snapshot,
+            districtFilesById,
+            fileIds,
+            allFilePaths,
+            fileEnrichments: adapterResult.enrichments,
+            blastRadiusMap,
+            fileEdges: adapterResult.fileEdges,
+            isGitRepo: capabilities.isGitRepo,
+        });
+        return snapshot;
+    }
+    async getTargetDetails(projectPath, targetId) {
+        const state = this.queryStore.get(projectPath);
+        if (!state)
+            return null;
+        const district = state.snapshot.districts.find((d) => d.id === targetId);
+        if (!district)
+            return null;
+        const filePaths = state.districtFilesById.get(targetId)?.map((f) => f.path) ?? [];
+        const recentCommits = state.isGitRepo
+            ? await this.getRecentCommits(projectPath, filePaths)
+            : [];
+        const topAuthors = state.isGitRepo ? await this.getTopAuthors(projectPath, filePaths) : [];
+        const blastRadius = state.blastRadiusMap.get(targetId);
+        return this.evidenceQuery.buildTargetDetail(district, state.snapshot.hotspots, state.snapshot.activity, state.snapshot.dependencies, recentCommits, topAuthors, blastRadius);
+    }
+    getDependencyPairDetails(projectPath, fromDistrictId, toDistrictId) {
+        const state = this.queryStore.get(projectPath);
+        if (!state)
+            return null;
+        const fromDistrict = state.snapshot.districts.find((d) => d.id === fromDistrictId);
+        const toDistrict = state.snapshot.districts.find((d) => d.id === toDistrictId);
+        if (!fromDistrict || !toDistrict)
+            return null;
+        const exemplars = this.buildExemplarEdges(fromDistrictId, toDistrictId, state.fileEdges, state.districtFilesById, state.fileIds);
+        return this.evidenceQuery.buildDependencyPairDetail(fromDistrictId, toDistrictId, state.snapshot.dependencies, fromDistrict.name, toDistrict.name, exemplars);
+    }
+    listDistrictFiles(projectPath, districtId, cursor) {
+        const state = this.queryStore.get(projectPath);
+        if (!state)
+            return null;
+        const files = state.districtFilesById.get(districtId);
+        if (!files)
+            return null;
+        return this.evidenceQuery.buildDistrictFilePage(districtId, files, state.fileIds, state.allFilePaths, cursor, state.fileEnrichments);
+    }
+    async execGit(projectPath, args, options) {
+        try {
+            const { stdout } = await execFileAsync('git', args, {
+                cwd: projectPath,
+                maxBuffer: MAX_BUFFER,
+            });
+            return stdout;
+        }
+        catch (err) {
+            if (options?.allowNonZero && isExecError(err) && err.stdout != null) {
+                return err.stdout;
+            }
+            throw err;
+        }
+    }
+    async getRecentCommits(projectPath, filePaths, limit = 10) {
+        if (filePaths.length === 0)
+            return [];
+        try {
+            const out = await this.execGit(projectPath, [
+                'log',
+                `--format=%H%n%s%n%at`,
+                `-n`,
+                String(limit),
+                '--',
+                ...filePaths,
+            ]);
+            const lines = out.split('\n').filter((l) => l.length > 0);
+            const commits = [];
+            for (let i = 0; i + 2 < lines.length; i += 3) {
+                const ts = parseInt(lines[i + 2], 10);
+                commits.push({
+                    sha: lines[i],
+                    message: lines[i + 1],
+                    timestamp: isNaN(ts) ? 0 : ts,
+                });
+            }
+            return commits;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getTopAuthors(projectPath, filePaths, limit = 5) {
+        if (filePaths.length === 0)
+            return [];
+        try {
+            const out = await this.execGit(projectPath, ['shortlog', '-sn', 'HEAD', '--', ...filePaths]);
+            const entries = [];
+            for (const line of out.split('\n')) {
+                const match = line.match(/^\s*(\d+)\s+(.+)$/);
+                if (match) {
+                    entries.push({ author: match[2].trim(), count: parseInt(match[1], 10) });
+                }
+            }
+            const total = entries.reduce((sum, e) => sum + e.count, 0);
+            if (total === 0)
+                return [];
+            return entries.slice(0, limit).map((e) => ({
+                author: e.author,
+                share: Math.round((e.count / total) * 100) / 100,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    buildExemplarEdges(fromDistrictId, toDistrictId, fileEdges, districtFilesById, fileIds, limit = 10) {
+        const fromFiles = new Set((districtFilesById.get(fromDistrictId) ?? []).map((f) => f.path));
+        const toFiles = new Set((districtFilesById.get(toDistrictId) ?? []).map((f) => f.path));
+        const edgeMap = new Map();
+        for (const edge of fileEdges) {
+            if (!fromFiles.has(edge.fromPath) || !toFiles.has(edge.toPath))
+                continue;
+            const key = `${edge.fromPath}\0${edge.toPath}`;
+            const existing = edgeMap.get(key);
+            if (existing) {
+                existing.weight += edge.weight ?? 1;
+            }
+            else {
+                edgeMap.set(key, {
+                    fromPath: edge.fromPath,
+                    toPath: edge.toPath,
+                    weight: edge.weight ?? 1,
+                });
+            }
+        }
+        return [...edgeMap.values()]
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, limit)
+            .map((e) => ({
+            fromFileId: fileIds.get(e.fromPath) ?? e.fromPath,
+            toFileId: fileIds.get(e.toPath) ?? e.toPath,
+            fromPath: e.fromPath,
+            toPath: e.toPath,
+            weight: e.weight,
+        }));
+    }
+    async getFileAuthorMap(projectPath) {
+        const result = new Map();
+        try {
+            const out = await this.execGit(projectPath, ['log', '--format=%aN', '--name-only', 'HEAD']);
+            let currentAuthor = null;
+            let seenFiles = false;
+            for (const line of out.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    if (seenFiles) {
+                        currentAuthor = null;
+                        seenFiles = false;
+                    }
+                    continue;
+                }
+                if (currentAuthor === null) {
+                    currentAuthor = trimmed;
+                    continue;
+                }
+                seenFiles = true;
+                let authorMap = result.get(trimmed);
+                if (!authorMap) {
+                    authorMap = new Map();
+                    result.set(trimmed, authorMap);
+                }
+                authorMap.set(currentAuthor, (authorMap.get(currentAuthor) ?? 0) + 1);
+            }
+        }
+        catch {
+        }
+        return result;
+    }
+    async detectCapabilities(projectPath) {
+        const gitDir = (0, path_1.join)(projectPath, '.git');
+        const isGitRepo = (0, fs_1.existsSync)(gitDir);
+        if (!isGitRepo) {
+            return {
+                isGitRepo: false,
+                isShallow: false,
+                totalCommits: 0,
+                oldestCommitTimestamp: null,
+                gitHistoryDays: null,
+            };
+        }
+        let isShallow = false;
+        try {
+            const out = await this.execGit(projectPath, ['rev-parse', '--is-shallow-repository']);
+            isShallow = out.trim() === 'true';
+        }
+        catch {
+        }
+        let totalCommits = 0;
+        let oldestCommitTimestamp = null;
+        try {
+            const countOut = await this.execGit(projectPath, ['rev-list', '--count', 'HEAD']);
+            totalCommits = parseInt(countOut.trim(), 10) || 0;
+            if (totalCommits > 0) {
+                const oldestOut = await this.execGit(projectPath, [
+                    'log',
+                    '--format=%at',
+                    '--reverse',
+                    '-1',
+                ]);
+                const ts = parseInt(oldestOut.trim(), 10);
+                if (!isNaN(ts)) {
+                    oldestCommitTimestamp = ts;
+                }
+            }
+        }
+        catch {
+        }
+        const gitHistoryDays = oldestCommitTimestamp != null
+            ? Math.floor((Date.now() / 1000 - oldestCommitTimestamp) / 86400)
+            : null;
+        return {
+            isGitRepo,
+            isShallow,
+            totalCommits,
+            oldestCommitTimestamp,
+            gitHistoryDays,
+        };
+    }
+    extractObservedFolders(files) {
+        const seen = new Set();
+        for (const file of files) {
+            const segments = file.path.split(/[/\\]/);
+            const limit = Math.min(segments.length - 1, constants_1.MAX_FOLDER_DEPTH);
+            for (let d = 1; d <= limit; d++) {
+                seen.add(segments.slice(0, d).join('/'));
+            }
+        }
+        return [...seen];
+    }
+    async scanFiles(projectPath, capabilities, excludedFolders = []) {
+        let filePaths;
+        if (capabilities.isGitRepo) {
+            filePaths = await this.listGitFiles(projectPath);
+        }
+        else {
+            filePaths = await this.listFsFiles(projectPath, projectPath, 10, new Set(excludedFolders));
+        }
+        if (excludedFolders.length > 0) {
+            filePaths = filePaths.filter((p) => !(0, path_matcher_1.isUnderAnyFolder)(p, excludedFolders));
+        }
+        let locMap;
+        let locFallbackStats;
+        if (capabilities.isGitRepo) {
+            locMap = await this.getLocMap(projectPath);
+            if (locMap.size === 0 && filePaths.length > 0) {
+                const fallback = await this.computeFallbackLineCounts(projectPath, filePaths);
+                locMap = fallback.map;
+                locFallbackStats = {
+                    counted: fallback.counted,
+                    skipped: fallback.skipped,
+                    eligible: fallback.eligible,
+                };
+            }
+        }
+        else {
+            locMap = new Map();
+        }
+        const files = [];
+        for (const filePath of filePaths) {
+            const absPath = (0, path_1.join)(projectPath, filePath);
+            let lastModified = Date.now();
+            try {
+                const stat = await fs.stat(absPath);
+                lastModified = stat.mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            const loc = locMap.get(filePath) ?? 0;
+            files.push({ path: filePath, loc, lastModified });
+        }
+        return { files, locFallbackStats };
+    }
+    async listGitFiles(projectPath) {
+        try {
+            const out = await this.execGit(projectPath, ['ls-files', '-z']);
+            return out.split('\0').filter((p) => p.length > 0);
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to list git files, falling back to fs scan');
+            return this.listFsFiles(projectPath, projectPath);
+        }
+    }
+    async listFsFiles(rootPath, currentPath, maxDepth = 10, excludedFolders = new Set()) {
+        if (maxDepth <= 0)
+            return [];
+        const result = [];
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true, encoding: 'utf-8' });
+        }
+        catch {
+            return result;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const relDir = (0, path_1.join)((0, path_1.relative)(rootPath, currentPath), entry.name);
+                if ((0, path_matcher_1.isUnderAnyFolder)(relDir, excludedFolders))
+                    continue;
+            }
+            const fullPath = (0, path_1.join)(currentPath, entry.name);
+            if (entry.isFile()) {
+                result.push((0, path_1.relative)(rootPath, fullPath));
+            }
+            else if (entry.isDirectory()) {
+                const sub = await this.listFsFiles(rootPath, fullPath, maxDepth - 1, excludedFolders);
+                result.push(...sub);
+            }
+        }
+        return result;
+    }
+    async getLocMap(projectPath) {
+        const map = new Map();
+        try {
+            const out = await this.execGit(projectPath, ['diff', '--numstat', EMPTY_TREE_SHA, 'HEAD'], {
+                allowNonZero: true,
+            });
+            for (const line of out.split('\n')) {
+                if (!line)
+                    continue;
+                const parts = line.split('\t');
+                if (parts.length < 3)
+                    continue;
+                const added = parseInt(parts[0], 10);
+                const filePath = parts[2];
+                if (!isNaN(added) && filePath) {
+                    map.set(filePath, added);
+                }
+            }
+        }
+        catch {
+        }
+        return map;
+    }
+    async computeFallbackLineCounts(projectPath, filePaths) {
+        const map = new Map();
+        const eligible = filePaths.length;
+        let skipped = 0;
+        const CONCURRENCY = 16;
+        for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
+            const batch = filePaths.slice(i, i + CONCURRENCY);
+            const results = await Promise.all(batch.map(async (filePath) => {
+                try {
+                    const absPath = (0, path_1.join)(projectPath, filePath);
+                    const stat = await fs.stat(absPath);
+                    if (stat.size > MAX_ADAPTER_FILE_SIZE)
+                        return null;
+                    const buf = await fs.readFile(absPath);
+                    const checkLen = Math.min(buf.length, 8192);
+                    for (let j = 0; j < checkLen; j++) {
+                        if (buf[j] <= 0x08)
+                            return null;
+                    }
+                    let lines = 0;
+                    for (let j = 0; j < buf.length; j++) {
+                        if (buf[j] === 0x0a)
+                            lines++;
+                    }
+                    if (buf.length > 0 && buf[buf.length - 1] !== 0x0a)
+                        lines++;
+                    return { path: filePath, loc: lines };
+                }
+                catch {
+                    return null;
+                }
+            }));
+            for (const r of results) {
+                if (r === null) {
+                    skipped++;
+                }
+                else {
+                    map.set(r.path, r.loc);
+                }
+            }
+        }
+        return { map, counted: eligible - skipped, skipped, eligible };
+    }
+    async getChurnMap(projectPath, sinceDays) {
+        const map = new Map();
+        try {
+            const out = await this.execGit(projectPath, [
+                'log',
+                `--since=${sinceDays} days ago`,
+                '--name-only',
+                '--format=',
+                'HEAD',
+            ]);
+            for (const line of out.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                map.set(trimmed, (map.get(trimmed) ?? 0) + 1);
+            }
+        }
+        catch {
+        }
+        return map;
+    }
+    async getDailyChurnMap(projectPath, days) {
+        try {
+            const out = await this.execGit(projectPath, [
+                'log',
+                `--since=${days} days ago`,
+                '--format=COMMIT %H%n%aI%n%aN',
+                '--name-only',
+                'HEAD',
+            ]);
+            if (!out.trim())
+                return null;
+            const map = new Map();
+            const lines = out.split('\n');
+            let i = 0;
+            while (i < lines.length) {
+                const line = lines[i];
+                if (line.startsWith('COMMIT ')) {
+                    const aI = (lines[i + 1] ?? '').trim();
+                    const dateStr = aI.slice(0, 10);
+                    i += 3;
+                    while (i < lines.length && lines[i]?.trim() === '')
+                        i++;
+                    while (i < lines.length && lines[i]?.trim() !== '' && !lines[i].startsWith('COMMIT ')) {
+                        const filePath = lines[i].trim();
+                        if (filePath) {
+                            let dateMap = map.get(filePath);
+                            if (!dateMap) {
+                                dateMap = new Map();
+                                map.set(filePath, dateMap);
+                            }
+                            dateMap.set(dateStr, (dateMap.get(dateStr) ?? 0) + 1);
+                        }
+                        i++;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            return map;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getWindowedAuthorMap(projectPath, days) {
+        try {
+            const out = await this.execGit(projectPath, [
+                'log',
+                `--since=${days} days ago`,
+                '--format=COMMIT %H%n%aI%n%aN',
+                '--name-only',
+                'HEAD',
+            ]);
+            if (!out.trim())
+                return null;
+            const map = new Map();
+            const lines = out.split('\n');
+            let i = 0;
+            while (i < lines.length) {
+                const line = lines[i];
+                if (line.startsWith('COMMIT ')) {
+                    i += 2;
+                    const authorName = (lines[i] ?? '').trim();
+                    i++;
+                    while (i < lines.length && lines[i]?.trim() === '')
+                        i++;
+                    while (i < lines.length && lines[i]?.trim() !== '' && !lines[i].startsWith('COMMIT ')) {
+                        const filePath = lines[i].trim();
+                        if (filePath) {
+                            let authorMap = map.get(filePath);
+                            if (!authorMap) {
+                                authorMap = new Map();
+                                map.set(filePath, authorMap);
+                            }
+                            authorMap.set(authorName, (authorMap.get(authorName) ?? 0) + 1);
+                        }
+                        i++;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            return map;
+        }
+        catch {
+            return null;
+        }
+    }
+    buildGlobalContributors(districts, districtFiles, windowedAuthor7d, windowedAuthor30d) {
+        if (!windowedAuthor7d && !windowedAuthor30d)
+            return [];
+        const author7dTotals = new Map();
+        const author30dTotals = new Map();
+        for (const district of districts) {
+            const files = districtFiles.get(district.id) ?? [];
+            for (const f of files) {
+                if (windowedAuthor7d) {
+                    const fileAuthors = windowedAuthor7d.get(f.path);
+                    if (fileAuthors) {
+                        for (const [author, count] of fileAuthors) {
+                            author7dTotals.set(author, (author7dTotals.get(author) ?? 0) + count);
+                        }
+                    }
+                }
+                if (windowedAuthor30d) {
+                    const fileAuthors = windowedAuthor30d.get(f.path);
+                    if (fileAuthors) {
+                        for (const [author, count] of fileAuthors) {
+                            author30dTotals.set(author, (author30dTotals.get(author) ?? 0) + count);
+                        }
+                    }
+                }
+            }
+        }
+        const allAuthors = new Set([...author7dTotals.keys(), ...author30dTotals.keys()]);
+        const result = [];
+        for (const author of allAuthors) {
+            result.push({
+                authorName: author,
+                commitCount7d: author7dTotals.get(author) ?? 0,
+                commitCount30d: author30dTotals.get(author) ?? 0,
+            });
+        }
+        return result
+            .sort((a, b) => b.commitCount30d - a.commitCount30d)
+            .slice(0, CodebaseOverviewAnalyzerService_1.GLOBAL_CONTRIBUTORS_CAP);
+    }
+    computeExcludedAuthorCount(fileAuthors, excludedFolders, globalContributors) {
+        if (excludedFolders.length === 0)
+            return 0;
+        const authorsInExcluded = new Set();
+        const authorsInNonExcluded = new Set();
+        for (const [filePath, authorMap] of fileAuthors) {
+            const isExcluded = (0, path_matcher_1.isUnderAnyFolder)(filePath, excludedFolders);
+            for (const author of authorMap.keys()) {
+                if (isExcluded) {
+                    authorsInExcluded.add(author);
+                }
+                else {
+                    authorsInNonExcluded.add(author);
+                }
+            }
+        }
+        const globalNames = new Set(globalContributors.map((c) => c.authorName));
+        let count = 0;
+        for (const author of authorsInExcluded) {
+            if (!authorsInNonExcluded.has(author) && !globalNames.has(author)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    segmentFiles(files) {
+        const regionMap = new Map();
+        for (const file of files) {
+            const segments = file.path.split(/[/\\]/);
+            const regionName = segments.length > 1 ? segments[0] : ROOT_REGION_NAME;
+            const districtName = segments.length > 2 ? segments[1] : ROOT_REGION_NAME;
+            if (!regionMap.has(regionName)) {
+                regionMap.set(regionName, { files: [], districtMap: new Map() });
+            }
+            const region = regionMap.get(regionName);
+            region.files.push(file);
+            const districtKey = `${regionName}/${districtName}`;
+            if (!region.districtMap.has(districtKey)) {
+                region.districtMap.set(districtKey, []);
+            }
+            region.districtMap.get(districtKey).push(file);
+        }
+        const regions = [];
+        const districts = [];
+        const districtFileMap = new Map();
+        for (const [regionName, regionData] of regionMap) {
+            const regionId = `region:${regionName}`;
+            const totalFiles = regionData.files.length;
+            const totalLOC = regionData.files.reduce((sum, f) => sum + f.loc, 0);
+            const regionPath = regionName === ROOT_REGION_NAME ? '.' : regionName;
+            regions.push({
+                id: regionId,
+                path: regionPath,
+                name: regionName,
+                totalFiles,
+                totalLOC,
+            });
+            for (const [districtKey, districtFiles] of regionData.districtMap) {
+                const districtName = districtKey.split('/')[1] || districtKey;
+                const districtId = `district:${districtKey}`;
+                const dTotalFiles = districtFiles.length;
+                const dTotalLOC = districtFiles.reduce((sum, f) => sum + f.loc, 0);
+                const districtPath = regionName === ROOT_REGION_NAME
+                    ? '.'
+                    : districtName === ROOT_REGION_NAME
+                        ? regionName
+                        : `${regionName}/${districtName}`;
+                districts.push({
+                    id: districtId,
+                    regionId,
+                    path: districtPath,
+                    name: districtName,
+                    totalFiles: dTotalFiles,
+                    totalLOC: dTotalLOC,
+                    churn7d: 0,
+                    churn30d: 0,
+                    inboundWeight: 0,
+                    outboundWeight: 0,
+                    couplingScore: 0,
+                    testFileCount: 0,
+                    testFileRatio: null,
+                    role: 'mixed',
+                    complexityAvg: null,
+                    ownershipConcentration: null,
+                    testCoverageRate: null,
+                    blastRadius: 0,
+                    primaryAuthorName: null,
+                    primaryAuthorShare: null,
+                    primaryAuthorRecentlyActive: false,
+                });
+                districtFileMap.set(districtKey, districtFiles.map((f) => f.path));
+            }
+        }
+        regions.sort((a, b) => b.totalLOC - a.totalLOC);
+        districts.sort((a, b) => b.totalLOC - a.totalLOC);
+        return { regions, districts, districtFileMap };
+    }
+    async getCurrentCommitSha(projectPath) {
+        try {
+            const out = await this.execGit(projectPath, ['rev-parse', 'HEAD']);
+            return out.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async detectGitRenames(projectPath, previousCommitSha) {
+        if (!previousCommitSha)
+            return [];
+        try {
+            const out = await this.execGit(projectPath, ['diff', '--name-status', '-M', previousCommitSha, 'HEAD'], { allowNonZero: true });
+            const renames = [];
+            for (const line of out.split('\n')) {
+                if (!line.startsWith('R'))
+                    continue;
+                const parts = line.split('\t');
+                if (parts.length < 3)
+                    continue;
+                const similarity = parseInt(parts[0].slice(1), 10);
+                renames.push({
+                    oldPath: parts[1],
+                    newPath: parts[2],
+                    similarity: isNaN(similarity) ? 100 : similarity,
+                });
+            }
+            return renames;
+        }
+        catch {
+            return [];
+        }
+    }
+    storeIdentityState(projectPath, commitSha, fileIds, regionIds, districtIds, districtFileMap) {
+        const districts = new Map();
+        for (const [key, id] of districtIds) {
+            const filePaths = districtFileMap.get(key) ?? [];
+            const memberFileIds = new Set(filePaths.map((p) => fileIds.get(p)).filter(Boolean));
+            districts.set(key, { id, memberFileIds });
+        }
+        this.identityStore.set(projectPath, {
+            commitSha,
+            files: new Map(fileIds),
+            districts,
+            regions: new Map(regionIds),
+        });
+    }
+    buildWarnings(capabilities, hasImportData, adapterFileCount, locFallbackStats) {
+        const warnings = [];
+        if (!capabilities.isGitRepo) {
+            warnings.push({
+                code: 'shallow_git_history',
+                message: 'No git repository detected. Churn and staleness signals are unavailable.',
+            });
+        }
+        else if (capabilities.isShallow) {
+            warnings.push({
+                code: 'shallow_git_history',
+                message: 'Shallow git history detected. Churn and staleness signals may be incomplete.',
+            });
+        }
+        if (locFallbackStats) {
+            warnings.push({
+                code: 'loc_unavailable',
+                message: `LOC computed via file-read fallback (${locFallbackStats.counted} files counted, ${locFallbackStats.skipped} skipped).`,
+                data: locFallbackStats,
+            });
+        }
+        if (!hasImportData) {
+            if (adapterFileCount === 0) {
+                warnings.push({
+                    code: 'missing_dependency_data',
+                    message: 'No supported source files found for import analysis. Coupling scores are empty.',
+                });
+            }
+            else {
+                warnings.push({
+                    code: 'missing_dependency_data',
+                    message: 'Import analysis found no cross-district dependencies. Coupling scores are empty.',
+                });
+            }
+        }
+        return warnings;
+    }
+    async analyzeWithAdapters(projectPath, allFilePaths) {
+        const enrichments = new Map();
+        const fileEdges = [];
+        let adapterFileCount = 0;
+        const adapterFiles = [];
+        for (const filePath of allFilePaths) {
+            if (this.adapterRegistry.getAdapter(filePath)) {
+                adapterFiles.push(filePath);
+            }
+        }
+        adapterFileCount = adapterFiles.length;
+        if (adapterFiles.length === 0) {
+            return { fileEdges, enrichments, adapterFileCount };
+        }
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < adapterFiles.length; i += BATCH_SIZE) {
+            const batch = adapterFiles.slice(i, i + BATCH_SIZE);
+            const results = await Promise.allSettled(batch.map(async (filePath) => {
+                const absPath = (0, path_1.join)(projectPath, filePath);
+                const stat = await fs.stat(absPath);
+                if (stat.size > MAX_ADAPTER_FILE_SIZE)
+                    return null;
+                const content = await fs.readFile(absPath, 'utf-8');
+                return { filePath, content };
+            }));
+            for (const result of results) {
+                if (result.status !== 'fulfilled' || !result.value)
+                    continue;
+                const { filePath, content } = result.value;
+                const role = this.adapterRegistry.classifyRole(filePath, content);
+                const symbolCount = this.adapterRegistry.countSymbols(filePath, content);
+                const complexity = this.adapterRegistry.computeComplexity(filePath, content);
+                const testPair = this.adapterRegistry.detectTestPair(filePath, allFilePaths);
+                enrichments.set(filePath, { role, symbolCount, complexity, testPair });
+                const specifiers = this.adapterRegistry.extractImports(filePath, content);
+                if (specifiers) {
+                    const resolvedTargets = new Set();
+                    for (const specifier of specifiers) {
+                        const resolved = this.adapterRegistry.resolveImport(filePath, specifier, allFilePaths) ??
+                            resolveImportSpecifier(specifier, filePath, allFilePaths);
+                        if (resolved) {
+                            resolvedTargets.add(resolved);
+                        }
+                    }
+                    for (const toPath of resolvedTargets) {
+                        fileEdges.push({ fromPath: filePath, toPath });
+                    }
+                }
+            }
+        }
+        logger.info({ adapterFiles: adapterFileCount, enriched: enrichments.size, edges: fileEdges.length }, 'Language adapter analysis complete');
+        return { fileEdges, enrichments, adapterFileCount };
+    }
+    computeMetrics(files, regions, districts, capabilities, warnings, excludedAuthorCount, scopeConfigHash) {
+        return {
+            totalRegions: regions.length,
+            totalDistricts: districts.length,
+            totalFiles: files.length,
+            gitHistoryDaysAvailable: capabilities.gitHistoryDays,
+            shallowHistoryDetected: capabilities.isShallow || !capabilities.isGitRepo,
+            dependencyCoverage: null,
+            warnings,
+            excludedAuthorCount,
+            scopeConfigHash,
+        };
+    }
+};
+exports.CodebaseOverviewAnalyzerService = CodebaseOverviewAnalyzerService;
+CodebaseOverviewAnalyzerService.GLOBAL_CONTRIBUTORS_CAP = 20;
+exports.CodebaseOverviewAnalyzerService = CodebaseOverviewAnalyzerService = CodebaseOverviewAnalyzerService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [identity_resolver_service_1.IdentityResolverService,
+        hotspot_scoring_service_1.HotspotScoringService,
+        district_splitting_service_1.DistrictSplittingService,
+        dependency_aggregation_service_1.DependencyAggregationService,
+        evidence_query_service_1.EvidenceQueryService,
+        language_adapter_registry_service_1.LanguageAdapterRegistryService,
+        scope_resolver_service_1.ScopeResolverService,
+        scope_auto_detector_service_1.ScopeAutoDetectorService,
+        overview_scope_repository_1.OverviewScopeRepository])
+], CodebaseOverviewAnalyzerService);
+function isExecError(err) {
+    return err instanceof Error && 'stdout' in err;
+}
+function resolveImportSpecifier(specifier, importerPath, allPaths) {
+    if (!specifier.startsWith('.'))
+        return null;
+    const importerDir = (0, path_1.dirname)(importerPath);
+    const resolved = (0, path_1.normalize)((0, path_1.join)(importerDir, specifier));
+    if (allPaths.has(resolved))
+        return resolved;
+    const existingExt = (0, path_1.extname)(resolved);
+    if (existingExt) {
+        const withoutExt = resolved.slice(0, -existingExt.length);
+        for (const ext of RESOLVE_EXTENSIONS) {
+            if (allPaths.has(withoutExt + ext))
+                return withoutExt + ext;
+        }
+    }
+    for (const ext of RESOLVE_EXTENSIONS) {
+        if (allPaths.has(resolved + ext))
+            return resolved + ext;
+    }
+    for (const ext of RESOLVE_EXTENSIONS) {
+        const indexPath = (0, path_1.join)(resolved, 'index' + ext);
+        if (allPaths.has(indexPath))
+            return indexPath;
+    }
+    return null;
+}
+//# sourceMappingURL=codebase-overview-analyzer.service.js.map