agent-ide 0.2.0 → 0.4.0

package/dist/core/shit-score/shit-score-analyzer.d.ts

@@ -1,84 +0,0 @@
-/**
- * ShitScore 分析器
- * 主服務類別，整合所有分析功能（通過 ParserPlugin）
- */
-import type { ParserRegistry } from '../../infrastructure/parser/registry.js';
-import type { ShitScoreResult, ShitScoreOptions } from './types.js';
-/**
- * ShitScore 錯誤
- */
-export declare class ShitScoreError extends Error {
-    readonly score: number;
-    readonly maxAllowed: number;
-    constructor(message: string, score: number, maxAllowed: number);
-}
-/**
- * ShitScore 分析器
- */
-export declare class ShitScoreAnalyzer {
-    private readonly calculator;
-    private readonly grading;
-    private readonly parserRegistry;
-    constructor(parserRegistry: ParserRegistry);
-    /**
-     * 分析專案的垃圾度
-     */
-    analyze(projectPath: string, options: Partial<ShitScoreOptions>): Promise<ShitScoreResult>;
-    /**
-     * 收集專案檔案
-     */
-    private collectFiles;
-    /**
-     * 建立檔案分析快取（解析 AST 和提取 symbols）
-     */
-    private buildFileCache;
-    /**
-     * 收集複雜度資料（使用 parser.analyzeComplexity）
-     */
-    private collectComplexityData;
-    /**
-     * 收集維護性資料（使用 parser 方法）
-     */
-    private collectMaintainabilityData;
-    /**
-     * 檢測代碼重複（簡化版 DuplicationDetector）
-     */
-    private detectDuplication;
-    /**
-     * 收集架構資料
-     */
-    private collectArchitectureData;
-    /**
-     * 收集品質保證資料（使用 parser checker 方法）
-     */
-    private collectQualityAssuranceData;
-    /**
-     * 檢查 tsconfig.json 的 strict 設定
-     */
-    private checkTsConfigStrict;
-    /**
-     * 建立詳細結果
-     */
-    private buildDetailedResult;
-    /**
-     * 提取最嚴重的垃圾項目
-     */
-    private extractTopShit;
-    /**
-     * 收集詳細檔案列表
-     */
-    private collectDetailedFiles;
-    /**
-     * 檢測循環依賴
-     */
-    private detectCycles;
-    /**
-     * 計算孤立檔案數量
-     */
-    private countOrphans;
-    /**
-     * 計算高耦合檔案數量
-     */
-    private countHighCoupling;
-}
-//# sourceMappingURL=shit-score-analyzer.d.ts.map

package/dist/core/shit-score/shit-score-analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shit-score-analyzer.d.ts","sourceRoot":"","sources":["../../../src/core/shit-score/shit-score-analyzer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAI9E,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAQjB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;aACM,KAAK,EAAE,MAAM;aAAkB,UAAU,EAAE,MAAM;gBAAlF,OAAO,EAAE,MAAM,EAAkB,KAAK,EAAE,MAAM,EAAkB,UAAU,EAAE,MAAM;CAI/F;AAYD;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;gBAEpC,cAAc,EAAE,cAAc;IAM1C;;OAEG;IACG,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAmDhG;;OAEG;YACW,YAAY;IA8B1B;;OAEG;YACW,cAAc;IAuB5B;;OAEG;YACW,qBAAqB;IA8CnC;;OAEG;YACW,0BAA0B;IAwDxC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;OAEG;YACW,uBAAuB;IAkCrC;;OAEG;YACW,2BAA2B;IAuDzC;;OAEG;YACW,mBAAmB;IAejC;;OAEG;YACW,mBAAmB;IAuCjC;;OAEG;YACW,cAAc;IA0F5B;;OAEG;YACW,oBAAoB;IA+FlC;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAmBpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAS1B"}

package/dist/core/shit-score/shit-score-analyzer.js

@@ -1,595 +0,0 @@
-/**
- * ShitScore 分析器
- * 主服務類別，整合所有分析功能（通過 ParserPlugin）
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { ScoreCalculator } from './score-calculator.js';
-import { Grading } from './grading.js';
-import { createDefaultShitScoreOptions } from './types.js';
-import { ShitType, SeverityLevel } from './types.js';
-/**
- * ShitScore 錯誤
- */
-export class ShitScoreError extends Error {
-    score;
-    maxAllowed;
-    constructor(message, score, maxAllowed) {
-        super(message);
-        this.score = score;
-        this.maxAllowed = maxAllowed;
-        this.name = 'ShitScoreError';
-    }
-}
-/**
- * ShitScore 分析器
- */
-export class ShitScoreAnalyzer {
-    calculator;
-    grading;
-    parserRegistry;
-    constructor(parserRegistry) {
-        this.calculator = new ScoreCalculator();
-        this.grading = new Grading();
-        this.parserRegistry = parserRegistry;
-    }
-    /**
-     * 分析專案的垃圾度
-     */
-    async analyze(projectPath, options) {
-        const fullOptions = { ...createDefaultShitScoreOptions(), ...options };
-        const files = await this.collectFiles(projectPath, fullOptions);
-        // 建立檔案分析快取（解析 AST 和 symbols）
-        const fileCache = await this.buildFileCache(files);
-        const complexityData = await this.collectComplexityData(fileCache);
-        const maintainabilityData = await this.collectMaintainabilityData(fileCache);
-        const architectureData = await this.collectArchitectureData(files);
-        const qualityAssuranceData = await this.collectQualityAssuranceData(fileCache, projectPath);
-        const { complexityScore, maintainabilityScore, architectureScore, qualityAssuranceScore, totalScore } = this.calculator.calculate(complexityData, maintainabilityData, architectureData, qualityAssuranceData);
-        const gradeInfo = this.grading.getGrade(totalScore);
-        if (fullOptions.maxAllowed !== undefined && totalScore > fullOptions.maxAllowed) {
-            throw new ShitScoreError(`ShitScore ${totalScore} exceeds maximum allowed ${fullOptions.maxAllowed}`, totalScore, fullOptions.maxAllowed);
-        }
-        const result = {
-            shitScore: totalScore,
-            grade: gradeInfo.level,
-            gradeInfo,
-            dimensions: {
-                complexity: complexityScore,
-                maintainability: maintainabilityScore,
-                architecture: architectureScore,
-                qualityAssurance: qualityAssuranceScore,
-            },
-            summary: {
-                totalFiles: files.length,
-                analyzedFiles: files.length,
-                totalShit: 0,
-            },
-            analyzedAt: new Date(),
-        };
-        if (fullOptions.detailed || fullOptions.showFiles) {
-            return await this.buildDetailedResult(result, fullOptions, fileCache, complexityData, maintainabilityData, architectureData, qualityAssuranceData);
-        }
-        return result;
-    }
-    /**
-     * 收集專案檔案
-     */
-    async collectFiles(projectPath, options) {
-        const files = [];
-        async function walk(dir) {
-            try {
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        if (!options.excludePatterns?.some((pattern) => fullPath.includes(pattern))) {
-                            await walk(fullPath);
-                        }
-                    }
-                    else if (entry.isFile()) {
-                        const ext = path.extname(entry.name);
-                        if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
-                            files.push(fullPath);
-                        }
-                    }
-                }
-            }
-            catch {
-                // 忽略無法讀取的目錄
-            }
-        }
-        await walk(projectPath);
-        return files;
-    }
-    /**
-     * 建立檔案分析快取（解析 AST 和提取 symbols）
-     */
-    async buildFileCache(files) {
-        const cache = new Map();
-        for (const file of files) {
-            try {
-                const parser = this.parserRegistry.getParser(path.extname(file));
-                if (!parser) {
-                    continue;
-                }
-                const content = await fs.readFile(file, 'utf-8');
-                const ast = await parser.parse(content, file);
-                const symbols = await parser.extractSymbols(ast);
-                cache.set(file, { ast, parser, symbols, content });
-            }
-            catch {
-                // 忽略無法解析的檔案
-            }
-        }
-        return cache;
-    }
-    /**
-     * 收集複雜度資料（使用 parser.analyzeComplexity）
-     */
-    async collectComplexityData(fileCache) {
-        let totalFunctions = 0;
-        let highComplexityCount = 0;
-        let longFunctionCount = 0;
-        let deepNestingCount = 0;
-        const tooManyParamsCount = 0;
-        for (const { ast, parser, content } of fileCache.values()) {
-            try {
-                const metrics = await parser.analyzeComplexity(content, ast);
-                totalFunctions += metrics.functionCount;
-                if (metrics.maxComplexity > 10) {
-                    highComplexityCount++;
-                }
-                // 簡化實作：根據平均複雜度估計長函式和深層巢狀
-                if (metrics.averageComplexity > 5) {
-                    longFunctionCount++;
-                }
-                if (metrics.cognitiveComplexity > 15) {
-                    deepNestingCount++;
-                }
-                // 參數計數需要從 symbols 中推算（簡化實作）
-                const functions = (await parser.extractSymbols(ast)).filter(s => s.type === 'function');
-                for (const func of functions) {
-                    // 簡化實作：假設沒有參數資訊
-                    // 實際應從 AST 中提取參數數量
-                }
-            }
-            catch {
-                // 忽略無法分析的檔案
-            }
-        }
-        return {
-            totalFunctions,
-            highComplexityCount,
-            longFunctionCount,
-            deepNestingCount,
-            tooManyParamsCount,
-        };
-    }
-    /**
-     * 收集維護性資料（使用 parser 方法）
-     */
-    async collectMaintainabilityData(fileCache) {
-        let deadCodeCount = 0;
-        let largeFileCount = 0;
-        const allFragments = [];
-        for (const [file, { ast, parser, content }] of fileCache.entries()) {
-            try {
-                const lines = content.split('\n').length;
-                if (lines > 500) {
-                    largeFileCount++;
-                }
-                // 使用 parser.detectUnusedSymbols 檢測死代碼
-                const allSymbols = await parser.extractSymbols(ast);
-                const unusedSymbols = await parser.detectUnusedSymbols(ast, allSymbols);
-                if (unusedSymbols.length > 0) {
-                    deadCodeCount++;
-                }
-                // 收集代碼片段用於重複檢測
-                const fragments = await parser.extractCodeFragments(content, file);
-                allFragments.push(...fragments);
-            }
-            catch {
-                // 忽略無法讀取的檔案
-            }
-        }
-        // 檢測重複代碼（Type-1, Type-2, Type-3）
-        const duplicateCodeCount = this.detectDuplication(allFragments, {
-            minLines: 3,
-            minTokens: 5,
-            similarityThreshold: 0.7,
-        });
-        // 檢測模式重複
-        let patternDuplicationCount = 0;
-        for (const { ast, parser, content } of fileCache.values()) {
-            try {
-                const patterns = await parser.detectPatterns(content, ast);
-                patternDuplicationCount += patterns.length;
-            }
-            catch {
-                // 忽略無法分析的檔案
-            }
-        }
-        return {
-            totalFiles: fileCache.size,
-            deadCodeCount,
-            largeFileCount,
-            duplicateCodeCount,
-            patternDuplicationCount,
-        };
-    }
-    /**
-     * 檢測代碼重複（簡化版 DuplicationDetector）
-     */
-    detectDuplication(fragments, options) {
-        let duplicateCount = 0;
-        // Type-1: 完全相同
-        const contentMap = new Map();
-        for (const fragment of fragments) {
-            const normalized = fragment.code.trim();
-            if (normalized.split('\n').length < options.minLines) {
-                continue;
-            }
-            const existing = contentMap.get(normalized) || [];
-            existing.push(fragment);
-            contentMap.set(normalized, existing);
-        }
-        for (const group of contentMap.values()) {
-            if (group.length > 1) {
-                // 過濾掉同檔案的重複（避免誤判方法內的重複）
-                const uniqueFiles = new Set(group.map(f => f.location.filePath));
-                if (uniqueFiles.size > 1) {
-                    duplicateCount += group.length - 1;
-                }
-            }
-        }
-        return duplicateCount;
-    }
-    /**
-     * 收集架構資料
-     */
-    async collectArchitectureData(files) {
-        const dependencies = new Map();
-        for (const file of files) {
-            try {
-                const content = await fs.readFile(file, 'utf-8');
-                const imports = content.match(/import\s+.*from\s+['"](.+)['"]/g) || [];
-                const deps = new Set();
-                for (const imp of imports) {
-                    const match = imp.match(/from\s+['"](.+)['"]/);
-                    if (match && match[1].startsWith('.')) {
-                        deps.add(match[1]);
-                    }
-                }
-                dependencies.set(file, deps);
-            }
-            catch {
-                // 忽略無法讀取的檔案
-            }
-        }
-        const cycles = this.detectCycles(dependencies);
-        const orphanCount = this.countOrphans(dependencies);
-        const highCouplingCount = this.countHighCoupling(dependencies);
-        return {
-            totalFiles: files.length,
-            circularDependencyCount: cycles,
-            orphanFileCount: orphanCount,
-            highCouplingCount,
-        };
-    }
-    /**
-     * 收集品質保證資料（使用 parser checker 方法）
-     */
-    async collectQualityAssuranceData(fileCache, projectPath) {
-        let typeSafetyIssues = 0;
-        let errorHandlingIssues = 0;
-        let namingIssues = 0;
-        let securityIssues = 0;
-        const testFiles = new Set();
-        const sourceFiles = new Set();
-        for (const [file, { ast, parser, symbols, content }] of fileCache.entries()) {
-            try {
-                // 型別安全檢查
-                const typeSafetyProblems = await parser.checkTypeSafety(content, ast);
-                typeSafetyIssues += typeSafetyProblems.length;
-                // 錯誤處理檢查
-                const errorHandlingProblems = await parser.checkErrorHandling(content, ast);
-                errorHandlingIssues += errorHandlingProblems.length;
-                // 命名規範檢查
-                const namingProblems = await parser.checkNamingConventions(symbols, file);
-                namingIssues += namingProblems.length;
-                // 安全性檢查
-                const securityProblems = await parser.checkSecurity(content, ast);
-                securityIssues += securityProblems.length;
-                // 測試覆蓋率統計
-                if (parser.isTestFile(file)) {
-                    testFiles.add(file);
-                }
-                else {
-                    sourceFiles.add(file);
-                }
-            }
-            catch {
-                // 忽略無法分析的檔案
-            }
-        }
-        const testCoverageRatio = sourceFiles.size > 0 ? testFiles.size / sourceFiles.size : 0;
-        // 檢查 tsconfig.json 的 strict 模式
-        const { strictModeEnabled, strictNullChecksEnabled } = await this.checkTsConfigStrict(projectPath);
-        return {
-            totalFiles: fileCache.size,
-            typeSafetyIssues,
-            testCoverageRatio,
-            errorHandlingIssues,
-            namingIssues,
-            securityIssues,
-            strictModeEnabled,
-            strictNullChecksEnabled,
-        };
-    }
-    /**
-     * 檢查 tsconfig.json 的 strict 設定
-     */
-    async checkTsConfigStrict(projectPath) {
-        try {
-            const tsconfigPath = path.join(projectPath, 'tsconfig.json');
-            const content = await fs.readFile(tsconfigPath, 'utf-8');
-            const config = JSON.parse(content);
-            const strictModeEnabled = config.compilerOptions?.strict === true;
-            const strictNullChecksEnabled = config.compilerOptions?.strictNullChecks === true || strictModeEnabled;
-            return { strictModeEnabled, strictNullChecksEnabled };
-        }
-        catch {
-            return { strictModeEnabled: false, strictNullChecksEnabled: false };
-        }
-    }
-    /**
-     * 建立詳細結果
-     */
-    async buildDetailedResult(baseResult, options, fileCache, complexity, maintainability, architecture, qualityAssurance) {
-        const files = Array.from(fileCache.keys());
-        const topShit = await this.extractTopShit(fileCache, complexity, maintainability, architecture, qualityAssurance, options.topCount);
-        const recommendations = this.grading.generateRecommendations(baseResult.dimensions.complexity, baseResult.dimensions.maintainability, baseResult.dimensions.architecture, baseResult.dimensions.qualityAssurance);
-        const result = {
-            ...baseResult,
-            topShit,
-            recommendations,
-            summary: {
-                ...baseResult.summary,
-                totalShit: topShit.length,
-            },
-        };
-        if (options.showFiles) {
-            const detailedFiles = await this.collectDetailedFiles(fileCache);
-            return {
-                ...result,
-                detailedFiles,
-            };
-        }
-        return result;
-    }
-    /**
-     * 提取最嚴重的垃圾項目
-     */
-    async extractTopShit(fileCache, complexity, maintainability, architecture, qualityAssurance, topCount) {
-        const items = [];
-        // 從實際分析結果中提取垃圾項目
-        for (const [file, { ast, parser, content, symbols }] of fileCache.entries()) {
-            try {
-                // 複雜度問題
-                const complexityMetrics = await parser.analyzeComplexity(content, ast);
-                if (complexityMetrics.maxComplexity > 10) {
-                    items.push({
-                        filePath: file,
-                        type: ShitType.HighComplexity,
-                        severity: SeverityLevel.High,
-                        score: Math.min(100, complexityMetrics.maxComplexity * 5),
-                        description: `函式複雜度過高 (${complexityMetrics.maxComplexity})`,
-                    });
-                }
-                // 型別安全問題
-                const typeSafetyIssues = await parser.checkTypeSafety(content, ast);
-                if (typeSafetyIssues.length > 0) {
-                    const anyCount = typeSafetyIssues.filter(i => i.type === 'any-type').length;
-                    const ignoreCount = typeSafetyIssues.filter(i => i.type === 'ignore-directive').length;
-                    const castCount = typeSafetyIssues.filter(i => i.type === 'unsafe-cast').length;
-                    const details = [];
-                    if (anyCount > 0) {
-                        details.push(`any 型別 ${anyCount} 處`);
-                    }
-                    if (ignoreCount > 0) {
-                        details.push(`@ts-ignore ${ignoreCount} 處`);
-                    }
-                    if (castCount > 0) {
-                        details.push(`as any ${castCount} 處`);
-                    }
-                    items.push({
-                        filePath: file,
-                        type: ShitType.TypeSafety,
-                        severity: SeverityLevel.High,
-                        score: 75,
-                        description: details.join('、'),
-                    });
-                }
-                // 錯誤處理問題
-                const errorHandlingIssues = await parser.checkErrorHandling(content, ast);
-                if (errorHandlingIssues.length > 0) {
-                    items.push({
-                        filePath: file,
-                        type: ShitType.PoorErrorHandling,
-                        severity: SeverityLevel.High,
-                        score: 70,
-                        description: `錯誤處理問題 (${errorHandlingIssues.length} 處)`,
-                    });
-                }
-                // 安全性問題
-                const securityIssues = await parser.checkSecurity(content, ast);
-                if (securityIssues.length > 0) {
-                    items.push({
-                        filePath: file,
-                        type: ShitType.SecurityRisk,
-                        severity: SeverityLevel.Critical,
-                        score: 95,
-                        description: `安全性風險 (${securityIssues.length} 處)`,
-                    });
-                }
-                // 命名規範問題
-                const namingIssues = await parser.checkNamingConventions(symbols, file);
-                if (namingIssues.length > 0) {
-                    items.push({
-                        filePath: file,
-                        type: ShitType.NamingViolation,
-                        severity: SeverityLevel.Low,
-                        score: 50,
-                        description: `命名規範違反 (${namingIssues.length} 處)`,
-                    });
-                }
-            }
-            catch {
-                // 忽略無法分析的檔案
-            }
-        }
-        // 按分數排序並取前 N 個
-        return items.sort((a, b) => b.score - a.score).slice(0, topCount);
-    }
-    /**
-     * 收集詳細檔案列表
-     */
-    async collectDetailedFiles(fileCache) {
-        const typeSafetyFiles = [];
-        const testCoverageFiles = [];
-        const errorHandlingFiles = [];
-        const namingViolationFiles = [];
-        const securityRiskFiles = [];
-        const duplicateCodeFiles = [];
-        for (const [file, { ast, parser, content, symbols }] of fileCache.entries()) {
-            try {
-                const lines = content.split('\n').length;
-                // 型別安全問題
-                const typeSafetyIssues = await parser.checkTypeSafety(content, ast);
-                if (typeSafetyIssues.length > 0) {
-                    const anyCount = typeSafetyIssues.filter(i => i.type === 'any-type').length;
-                    const tsIgnoreCount = typeSafetyIssues.filter(i => i.type === 'ignore-directive').length;
-                    typeSafetyFiles.push({
-                        path: file,
-                        lines,
-                        anyTypeCount: anyCount,
-                        tsIgnoreCount: tsIgnoreCount,
-                    });
-                }
-                // 錯誤處理問題
-                const errorHandlingIssues = await parser.checkErrorHandling(content, ast);
-                if (errorHandlingIssues.length > 0) {
-                    errorHandlingFiles.push({
-                        path: file,
-                        lines,
-                        emptyCatchCount: errorHandlingIssues.filter(i => i.type === 'empty-catch').length,
-                    });
-                }
-                // 命名問題
-                const namingIssues = await parser.checkNamingConventions(symbols, file);
-                if (namingIssues.length > 0) {
-                    namingViolationFiles.push({
-                        path: file,
-                        lines,
-                        namingIssues: namingIssues.length,
-                    });
-                }
-                // 安全問題
-                const securityIssues = await parser.checkSecurity(content, ast);
-                if (securityIssues.length > 0) {
-                    securityRiskFiles.push({
-                        path: file,
-                        lines,
-                        securityIssues: securityIssues.length,
-                    });
-                }
-                // 測試覆蓋率
-                if (!parser.isTestFile(file)) {
-                    testCoverageFiles.push({
-                        path: file,
-                        testCoverageRatio: 0, // 簡化實作：標記為無測試
-                    });
-                }
-            }
-            catch {
-                // 忽略無法讀取的檔案
-            }
-        }
-        return {
-            complexity: {
-                highComplexity: [],
-                longFunction: [],
-                deepNesting: [],
-                tooManyParams: [],
-            },
-            maintainability: {
-                deadCode: [],
-                largeFile: [],
-                duplicateCode: duplicateCodeFiles,
-            },
-            architecture: {
-                orphanFile: [],
-                highCoupling: [],
-                circularDependency: [],
-            },
-            qualityAssurance: {
-                typeSafety: typeSafetyFiles,
-                testCoverage: testCoverageFiles,
-                errorHandling: errorHandlingFiles,
-                namingViolation: namingViolationFiles,
-                securityRisk: securityRiskFiles,
-            },
-        };
-    }
-    /**
-     * 檢測循環依賴
-     */
-    detectCycles(dependencies) {
-        // 簡化實作：檢查互相引用
-        let cycles = 0;
-        for (const [file, deps] of dependencies.entries()) {
-            for (const dep of deps) {
-                const depDeps = dependencies.get(dep);
-                if (depDeps && depDeps.has(file)) {
-                    cycles++;
-                }
-            }
-        }
-        return Math.floor(cycles / 2); // 除以 2 因為每個循環被計算了兩次
-    }
-    /**
-     * 計算孤立檔案數量
-     */
-    countOrphans(dependencies) {
-        let orphans = 0;
-        for (const [file, deps] of dependencies.entries()) {
-            if (deps.size === 0) {
-                let isDependent = false;
-                for (const [, otherDeps] of dependencies.entries()) {
-                    if (otherDeps.has(file)) {
-                        isDependent = true;
-                        break;
-                    }
-                }
-                if (!isDependent) {
-                    orphans++;
-                }
-            }
-        }
-        return orphans;
-    }
-    /**
-     * 計算高耦合檔案數量
-     */
-    countHighCoupling(dependencies) {
-        let highCoupling = 0;
-        for (const [, deps] of dependencies.entries()) {
-            if (deps.size > 10) {
-                highCoupling++;
-            }
-        }
-        return highCoupling;
-    }
-}
-//# sourceMappingURL=shit-score-analyzer.js.map