agent-ide 0.3.3 → 0.4.0

package/dist/plugins/typescript/analyzers/duplication-detector.js

@@ -1,695 +0,0 @@
-/**
- * 重複程式碼檢測器
- * 檢測程式碼克隆，包括 Type-1、Type-2 和 Type-3 克隆
- */
-import { createHash } from 'crypto';
-/**
- * 計算程式碼片段的平均行數
- */
-function calculateAverageLines(fragments) {
-    const totalLines = fragments.reduce((sum, f) => sum + (f.location.endLine - f.location.startLine + 1), 0);
-    return Math.round(totalLines / fragments.length);
-}
-/**
- * Type-1 克隆檢測器（完全相同的代碼，除了空白和註釋）
- */
-export class Type1CloneDetector {
-    /**
-     * 檢測 Type-1 克隆
-     * @param fragments 程式碼片段列表
-     * @param config 檢測配置
-     * @returns Type-1 克隆列表
-     */
-    detect(fragments, config) {
-        const clones = [];
-        const hashGroups = new Map();
-        // 按 hash 分組
-        for (const fragment of fragments) {
-            if (fragment.tokens.length < config.minTokens) {
-                continue;
-            }
-            const hash = this.computeHash(fragment, config);
-            if (!hashGroups.has(hash)) {
-                hashGroups.set(hash, []);
-            }
-            const group = hashGroups.get(hash);
-            if (group) {
-                group.push(fragment);
-            }
-        }
-        // 找出重複的組
-        for (const group of hashGroups.values()) {
-            if (group.length > 1) {
-                clones.push({
-                    type: 'type-1',
-                    instances: group,
-                    lines: calculateAverageLines(group),
-                    similarity: 1.0,
-                    severity: this.calculateSeverity(group.length, calculateAverageLines(group))
-                });
-            }
-        }
-        return clones;
-    }
-    /**
-     * 計算程式碼片段的 hash
-     */
-    computeHash(fragment, config) {
-        let tokens = fragment.tokens.slice();
-        if (config.ignoreWhitespace) {
-            tokens = tokens.filter(token => !/^\s+$/.test(token));
-        }
-        if (config.ignoreComments) {
-            tokens = tokens.filter(token => !token.startsWith('//') && !token.startsWith('/*'));
-        }
-        const normalized = tokens.join('');
-        return createHash('md5').update(normalized).digest('hex');
-    }
-    calculateSeverity(instanceCount, lines) {
-        if (instanceCount >= 5 || lines >= 50) {
-            return 'high';
-        }
-        if (instanceCount >= 3 || lines >= 20) {
-            return 'medium';
-        }
-        return 'low';
-    }
-}
-/**
- * Type-2 克隆檢測器（結構相同但變數名、類型、字面值不同）
- */
-export class Type2CloneDetector {
-    /**
-     * 檢測 Type-2 克隆
-     * @param fragments 程式碼片段列表
-     * @param config 檢測配置
-     * @returns Type-2 克隆列表（僅包含跨檔案重複）
-     */
-    detect(fragments, config) {
-        const clones = [];
-        const normalizedGroups = new Map();
-        for (const fragment of fragments) {
-            if (fragment.tokens.length < config.minTokens) {
-                continue;
-            }
-            const normalized = this.normalizeAST(fragment.ast);
-            const hash = this.computeNormalizedHash(normalized);
-            if (!normalizedGroups.has(hash)) {
-                normalizedGroups.set(hash, []);
-            }
-            const group = normalizedGroups.get(hash);
-            if (group) {
-                group.push(fragment);
-            }
-        }
-        for (const group of normalizedGroups.values()) {
-            if (group.length > 1) {
-                // 過濾掉同一檔案內的重複（同一個類的不同方法不應視為重複）
-                const crossFileInstances = this.filterCrossFileInstances(group);
-                if (crossFileInstances.length > 1) {
-                    clones.push({
-                        type: 'type-2',
-                        instances: crossFileInstances,
-                        lines: calculateAverageLines(crossFileInstances),
-                        similarity: this.calculateSimilarity(crossFileInstances),
-                        severity: this.calculateSeverity(crossFileInstances.length, calculateAverageLines(crossFileInstances))
-                    });
-                }
-            }
-        }
-        return clones;
-    }
-    /**
-     * 過濾掉同一檔案內的實例，只保留跨檔案的重複
-     */
-    filterCrossFileInstances(instances) {
-        const fileGroups = new Map();
-        for (const instance of instances) {
-            const file = instance.location.file;
-            if (!fileGroups.has(file)) {
-                fileGroups.set(file, []);
-            }
-            fileGroups.get(file).push(instance);
-        }
-        // 如果所有實例都在同一個檔案，返回空陣列
-        if (fileGroups.size === 1) {
-            return [];
-        }
-        // 每個檔案只保留一個代表
-        return Array.from(fileGroups.values()).map(group => group[0]);
-    }
-    /**
-     * 正規化 AST（移除變數名、字面值等）
-     */
-    normalizeAST(ast) {
-        const normalized = {
-            type: ast.type
-        };
-        // 對於變數和字面值，統一為佔位符
-        if (ast.type === 'Identifier') {
-            normalized.value = '$VAR$';
-        }
-        else if (ast.type === 'Literal') {
-            normalized.value = '$LITERAL$';
-        }
-        else if (ast.value !== undefined) {
-            normalized.value = ast.value;
-        }
-        // 遞歸處理子節點
-        if (ast.children) {
-            normalized.children = ast.children.map(child => this.normalizeAST(child));
-        }
-        return normalized;
-    }
-    /**
-     * 計算正規化 AST 的 hash
-     */
-    computeNormalizedHash(ast) {
-        const json = JSON.stringify(ast, Object.keys(ast).sort());
-        return createHash('md5').update(json).digest('hex');
-    }
-    calculateSimilarity(fragments) {
-        // Type-2 克隆的相似度計算
-        return 0.85; // 簡化實作
-    }
-    calculateSeverity(instanceCount, lines) {
-        if (instanceCount >= 4 || lines >= 40) {
-            return 'high';
-        }
-        if (instanceCount >= 3 || lines >= 15) {
-            return 'medium';
-        }
-        return 'low';
-    }
-}
-/**
- * Type-3 克隆檢測器（結構相似但有些語句被修改、新增或刪除）
- */
-export class Type3CloneDetector {
-    threshold = 0.7; // 預設相似度閾值
-    /**
-     * 設定相似度閾值
-     * @param threshold 相似度閾值（0-1 之間）
-     */
-    setThreshold(threshold) {
-        this.threshold = Math.max(0, Math.min(1, threshold));
-    }
-    /**
-     * 檢測 Type-3 克隆
-     * @param fragments 程式碼片段列表
-     * @param config 檢測配置
-     * @returns Type-3 克隆列表（僅包含跨檔案重複）
-     */
-    detect(fragments, config) {
-        const clones = [];
-        const effectiveThreshold = Math.min(config.similarityThreshold, this.threshold);
-        // Type-3 檢測需要比較每對片段的相似度
-        for (let i = 0; i < fragments.length; i++) {
-            for (let j = i + 1; j < fragments.length; j++) {
-                // 跳過同一檔案內的片段
-                if (fragments[i].location.file === fragments[j].location.file) {
-                    continue;
-                }
-                const similarity = this.calculateSimilarity(fragments[i], fragments[j]);
-                if (similarity >= effectiveThreshold && similarity < 0.95) { // Type-3 不是完全相同
-                    clones.push({
-                        type: 'type-3',
-                        instances: [fragments[i], fragments[j]],
-                        lines: Math.max(fragments[i].location.endLine - fragments[i].location.startLine + 1, fragments[j].location.endLine - fragments[j].location.startLine + 1),
-                        similarity,
-                        severity: this.calculateSeverity(similarity, Math.max(fragments[i].location.endLine - fragments[i].location.startLine + 1, fragments[j].location.endLine - fragments[j].location.startLine + 1))
-                    });
-                }
-            }
-        }
-        return clones;
-    }
-    /**
-     * 計算兩個程式碼片段的相似度
-     */
-    calculateSimilarity(fragment1, fragment2) {
-        // 使用改進的相似度計算
-        return this.calculateAdvancedSimilarity(fragment1, fragment2);
-    }
-    /**
-     * 計算編輯距離（Levenshtein Distance）
-     */
-    calculateEditDistance(tokens1, tokens2) {
-        const m = tokens1.length;
-        const n = tokens2.length;
-        // 處理空陣列情況
-        if (m === 0) {
-            return n;
-        }
-        if (n === 0) {
-            return m;
-        }
-        const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-        // 初始化邊界條件
-        for (let i = 0; i <= m; i++) {
-            dp[i][0] = i;
-        }
-        for (let j = 0; j <= n; j++) {
-            dp[0][j] = j;
-        }
-        // 動態規劃計算編輯距離
-        for (let i = 1; i <= m; i++) {
-            for (let j = 1; j <= n; j++) {
-                if (tokens1[i - 1] === tokens2[j - 1]) {
-                    dp[i][j] = dp[i - 1][j - 1]; // 無需編輯
-                }
-                else {
-                    dp[i][j] = Math.min(dp[i - 1][j] + 1, // 刪除
-                    dp[i][j - 1] + 1, // 插入
-                    dp[i - 1][j - 1] + 1 // 替換
-                    );
-                }
-            }
-        }
-        return dp[m][n];
-    }
-    /**
-     * 改進的相似度計算（結合多種指標）
-     */
-    calculateAdvancedSimilarity(fragment1, fragment2) {
-        const tokens1 = fragment1.tokens;
-        const tokens2 = fragment2.tokens;
-        if (tokens1.length === 0 && tokens2.length === 0) {
-            return 1.0;
-        }
-        if (tokens1.length === 0 || tokens2.length === 0) {
-            return 0.0;
-        }
-        // 1. 編輯距離相似度
-        const editDistance = this.calculateEditDistance(tokens1, tokens2);
-        const maxLength = Math.max(tokens1.length, tokens2.length);
-        const editSimilarity = 1 - (editDistance / maxLength);
-        // 2. Jaccard 相似度（基於 token 集合）
-        const set1 = new Set(tokens1);
-        const set2 = new Set(tokens2);
-        const intersection = new Set([...set1].filter(x => set2.has(x)));
-        const union = new Set([...set1, ...set2]);
-        const jaccardSimilarity = intersection.size / union.size;
-        // 3. 長度相似度
-        const lengthSimilarity = Math.min(tokens1.length, tokens2.length) /
-            Math.max(tokens1.length, tokens2.length);
-        // 綜合相似度（加權平均）
-        return (editSimilarity * 0.5) + (jaccardSimilarity * 0.3) + (lengthSimilarity * 0.2);
-    }
-    calculateSeverity(similarity, lines) {
-        if (similarity >= 0.8 && lines >= 30) {
-            return 'high';
-        }
-        if (similarity >= 0.7 && lines >= 15) {
-            return 'medium';
-        }
-        return 'low';
-    }
-}
-/**
- * 重複程式碼檢測器主類
- */
-export class DuplicationDetector {
-    type1Detector = new Type1CloneDetector();
-    type2Detector = new Type2CloneDetector();
-    type3Detector = new Type3CloneDetector();
-    /**
-     * 設定 Type-3 檢測的相似度閾值
-     */
-    setThreshold(threshold) {
-        this.type3Detector.setThreshold(threshold);
-    }
-    /**
-     * 檢測程式碼克隆 (兼容舊介面)
-     */
-    detectClones(fragments) {
-        const fullConfig = {
-            minLines: 3,
-            minTokens: 5,
-            similarityThreshold: 0.7,
-            ignoreWhitespace: true,
-            ignoreComments: true
-        };
-        // 直接檢測不同類型的克隆
-        const type1Clones = this.type1Detector.detect(fragments, fullConfig);
-        const type2Clones = this.type2Detector.detect(fragments, fullConfig);
-        const type3Clones = this.type3Detector.detect(fragments, fullConfig);
-        return [...type1Clones, ...type2Clones, ...type3Clones];
-    }
-    /**
-     * 檢測檔案中的重複程式碼
-     * @param files 檔案路徑列表
-     * @param config 檢測配置
-     * @returns 重複程式碼檢測結果
-     */
-    async detect(files, config) {
-        // 輸入驗證
-        if (!Array.isArray(files)) {
-            throw new Error('檔案列表必須是陣列');
-        }
-        const fullConfig = {
-            minLines: 3,
-            minTokens: 5,
-            similarityThreshold: 0.7,
-            ignoreWhitespace: true,
-            ignoreComments: true,
-            ...config
-        };
-        // 解析所有檔案並提取程式碼片段
-        const fragments = await this.extractFragments(files);
-        // 檢測不同類型的克隆
-        const type1Clones = this.type1Detector.detect(fragments, fullConfig);
-        const type2Clones = this.type2Detector.detect(fragments, fullConfig);
-        const type3Clones = this.type3Detector.detect(fragments, fullConfig);
-        return [...type1Clones, ...type2Clones, ...type3Clones];
-    }
-    /**
-     * 從檔案中提取程式碼片段
-     */
-    async extractFragments(files) {
-        const { readFile } = await import('fs/promises');
-        const fragments = [];
-        for (const file of files) {
-            try {
-                const content = await readFile(file, 'utf-8');
-                const fileFragments = this.parseFileToFragments(file, content);
-                fragments.push(...fileFragments);
-            }
-            catch (error) {
-                continue;
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 將檔案內容解析為程式碼片段（提取多種類型的代碼結構）
-     */
-    parseFileToFragments(filePath, content) {
-        if (typeof filePath !== 'string' || filePath.trim() === '') {
-            throw new Error('檔案路徑必須是非空字串');
-        }
-        if (typeof content !== 'string') {
-            throw new Error('檔案內容必須是字串');
-        }
-        const fragments = [];
-        // 1. 提取頂層註解（版權宣告等）
-        fragments.push(...this.extractTopLevelComments(filePath, content));
-        // 2. 提取常數定義
-        fragments.push(...this.extractConstantDefinitions(filePath, content));
-        // 3. 提取配置物件
-        fragments.push(...this.extractConfigObjects(filePath, content));
-        // 4. 提取方法和函式
-        fragments.push(...this.extractMethods(filePath, content));
-        // 如果仍然沒有找到任何片段，回退到按行分割
-        if (fragments.length === 0) {
-            const lines = content.split('\n');
-            for (let i = 0; i < lines.length; i += 10) {
-                const endLine = Math.min(i + 9, lines.length - 1);
-                const fragmentContent = lines.slice(i, endLine + 1).join('\n');
-                if (fragmentContent.trim().length > 0) {
-                    fragments.push({
-                        id: `${filePath}:${i + 1}-${endLine + 1}`,
-                        ast: this.parseToAST(fragmentContent),
-                        tokens: this.tokenize(fragmentContent),
-                        location: {
-                            file: filePath,
-                            startLine: i + 1,
-                            endLine: endLine + 1
-                        }
-                    });
-                }
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 提取檔案開頭的頂層註解（如版權宣告）
-     */
-    extractTopLevelComments(filePath, content) {
-        const fragments = [];
-        const lines = content.split('\n');
-        // 只檢查檔案開頭的註解（前 50 行內）
-        const headerLines = lines.slice(0, Math.min(50, lines.length));
-        let commentStart = -1;
-        let commentEnd = -1;
-        let inBlockComment = false;
-        for (let i = 0; i < headerLines.length; i++) {
-            const line = headerLines[i].trim();
-            // 檢測多行註解開始
-            if (line.startsWith('/**') || line.startsWith('/*')) {
-                if (commentStart === -1) {
-                    commentStart = i;
-                }
-                inBlockComment = true;
-            }
-            // 檢測多行註解結束
-            if (inBlockComment && line.includes('*/')) {
-                commentEnd = i;
-                inBlockComment = false;
-                // 提取完整的註解區塊
-                const commentContent = lines.slice(commentStart, commentEnd + 1).join('\n');
-                const lineCount = commentEnd - commentStart + 1;
-                // 只處理 >= 3 行的註解區塊
-                if (lineCount >= 3) {
-                    fragments.push({
-                        id: `${filePath}:comment:${commentStart + 1}-${commentEnd + 1}`,
-                        ast: this.parseToAST(commentContent),
-                        tokens: this.tokenize(commentContent, true), // 保留註解
-                        location: {
-                            file: filePath,
-                            startLine: commentStart + 1,
-                            endLine: commentEnd + 1
-                        }
-                    });
-                }
-                commentStart = -1;
-                commentEnd = -1;
-            }
-            // 遇到非空白、非註解的行就停止（不再是頂層註解）
-            if (!line.startsWith('//') &&
-                !line.startsWith('/*') &&
-                !line.startsWith('*') &&
-                !line.includes('*/') &&
-                line.length > 0) {
-                break;
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 提取常數定義（export const、const 等）
-     */
-    extractConstantDefinitions(filePath, content) {
-        const fragments = [];
-        // 匹配常數定義（包括物件定義）
-        // 例如：export const XXX = { ... }; 或 const XXX = { ... };
-        const constRegex = /(export\s+)?const\s+([A-Z_][A-Z0-9_]*)\s*=\s*\{/gm;
-        let match;
-        while ((match = constRegex.exec(content)) !== null) {
-            const startPos = match.index;
-            const startLine = content.substring(0, startPos).split('\n').length;
-            const constName = match[2];
-            // 找到物件定義的開始 { 位置
-            const bracePos = match.index + match[0].length - 1;
-            // 找到配對的 }
-            const endPos = this.findMatchingBrace(content, bracePos);
-            if (endPos === -1) {
-                continue;
-            }
-            const endLine = content.substring(0, endPos + 1).split('\n').length;
-            const fragmentContent = content.substring(startPos, endPos + 1);
-            const lineCount = endLine - startLine + 1;
-            // 只處理 >= 3 行的常數定義
-            if (lineCount >= 3) {
-                fragments.push({
-                    id: `${filePath}:const:${startLine}:${constName}`,
-                    ast: this.parseToAST(fragmentContent),
-                    tokens: this.tokenize(fragmentContent),
-                    location: {
-                        file: filePath,
-                        startLine,
-                        endLine
-                    }
-                });
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 提取配置物件（識別常見的配置模式）
-     */
-    extractConfigObjects(filePath, content) {
-        const fragments = [];
-        // 匹配常見的配置物件模式
-        // 例如：{ host: ..., port: ..., database: ... }
-        const configKeywords = ['host', 'port', 'database', 'uri', 'url', 'connection', 'options', 'config'];
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            // 檢查是否包含配置相關關鍵字
-            const hasConfigKeyword = configKeywords.some(keyword => line.includes(`${keyword}:`) || line.includes(`${keyword} =`));
-            if (hasConfigKeyword && line.includes('{')) {
-                // 找到配置物件的開始
-                const startPos = content.substring(0, content.indexOf(lines.slice(0, i + 1).join('\n'))).length;
-                const braceIndex = line.indexOf('{');
-                const bracePos = startPos + braceIndex;
-                const endPos = this.findMatchingBrace(content, bracePos);
-                if (endPos === -1) {
-                    continue;
-                }
-                const startLine = i + 1;
-                const endLine = content.substring(0, endPos + 1).split('\n').length;
-                const fragmentContent = content.substring(bracePos, endPos + 1);
-                const lineCount = endLine - startLine + 1;
-                // 只處理 >= 3 行的配置物件
-                if (lineCount >= 3) {
-                    fragments.push({
-                        id: `${filePath}:config:${startLine}-${endLine}`,
-                        ast: this.parseToAST(fragmentContent),
-                        tokens: this.tokenize(fragmentContent),
-                        location: {
-                            file: filePath,
-                            startLine,
-                            endLine
-                        }
-                    });
-                    // 跳過已處理的行
-                    i = endLine - 1;
-                }
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 提取方法和函式（原有邏輯）
-     */
-    extractMethods(filePath, content) {
-        const fragments = [];
-        // 提取方法和函式的正則表達式（更寬鬆的匹配）
-        const methodRegex = /(\s*)(async\s+)?(\w+)\s*\([^)]*\)\s*\{/gm;
-        let match;
-        while ((match = methodRegex.exec(content)) !== null) {
-            const startPos = match.index;
-            const startLine = content.substring(0, startPos).split('\n').length;
-            const methodName = match[3];
-            // 找到方法開始的 { 位置
-            const bracePos = startPos + match[0].length - 1;
-            // 找到方法的結束位置（配對大括號）
-            const endPos = this.findMatchingBrace(content, bracePos);
-            if (endPos === -1) {
-                continue;
-            }
-            const endLine = content.substring(0, endPos + 1).split('\n').length;
-            const fragmentContent = content.substring(startPos, endPos + 1);
-            const lineCount = endLine - startLine + 1;
-            // 只處理行數 >= 3 的方法
-            if (lineCount >= 3) {
-                const tokens = this.tokenize(fragmentContent);
-                fragments.push({
-                    id: `${filePath}:${startLine}:${methodName}`,
-                    ast: this.parseToAST(fragmentContent),
-                    tokens,
-                    location: {
-                        file: filePath,
-                        startLine,
-                        endLine
-                    }
-                });
-            }
-        }
-        return fragments;
-    }
-    /**
-     * 找到配對的右大括號
-     */
-    findMatchingBrace(content, startPos) {
-        let braceCount = 1;
-        let inString = false;
-        let stringChar = '';
-        for (let i = startPos + 1; i < content.length; i++) {
-            const char = content[i];
-            const prevChar = content[i - 1];
-            // 處理字串
-            if ((char === '"' || char === '\'' || char === '`') && prevChar !== '\\') {
-                if (!inString) {
-                    inString = true;
-                    stringChar = char;
-                }
-                else if (char === stringChar) {
-                    inString = false;
-                }
-                continue;
-            }
-            if (!inString) {
-                if (char === '{') {
-                    braceCount++;
-                }
-                else if (char === '}') {
-                    braceCount--;
-                    if (braceCount === 0) {
-                        return i;
-                    }
-                }
-            }
-        }
-        return -1;
-    }
-    /**
-     * 簡化的 AST 解析
-     */
-    parseToAST(content) {
-        // 簡化實作：建立基本的 AST 結構
-        return {
-            type: 'Program',
-            children: content.split('\n').map(line => ({
-                type: 'Statement',
-                value: line.trim()
-            }))
-        };
-    }
-    /**
-     * 程式碼分詞
-     * @param content 程式碼內容
-     * @param preserveComments 是否保留註解（預設false會過濾註解）
-     */
-    tokenize(content, preserveComments = false) {
-        // 按空白和操作符分割
-        const tokens = content
-            .split(/(\s+|[(){}[\];,.]|\+|\-|\*|\/|=|!|<|>|&|\|)/)
-            .filter(token => token.trim().length > 0);
-        // 如果不保留註解，過濾掉註解 tokens
-        if (!preserveComments) {
-            return tokens.filter(token => {
-                const trimmed = token.trim();
-                return !trimmed.startsWith('//') &&
-                    !trimmed.startsWith('/*') &&
-                    !trimmed.startsWith('*') &&
-                    !trimmed.includes('*/');
-            });
-        }
-        return tokens;
-    }
-    /**
-     * 獲取重複檢測統計
-     */
-    async getStatistics(clones) {
-        const byType = { 'type-1': 0, 'type-2': 0, 'type-3': 0 };
-        const bySeverity = { low: 0, medium: 0, high: 0 };
-        let totalSimilarity = 0;
-        let totalLines = 0;
-        for (const clone of clones) {
-            byType[clone.type]++;
-            bySeverity[clone.severity]++;
-            totalSimilarity += clone.similarity;
-            totalLines += clone.lines * clone.instances.length;
-        }
-        return {
-            totalClones: clones.length,
-            byType,
-            bySeverity,
-            averageSimilarity: clones.length > 0 ? totalSimilarity / clones.length : 0,
-            totalDuplicatedLines: totalLines
-        };
-    }
-}
-//# sourceMappingURL=duplication-detector.js.map