@intrect/openswarm 0.2.2 → 0.4.0

package/dist/registry/entityScanner.js

@@ -0,0 +1,693 @@
+// ============================================
+// OpenSwarm - Entity Scanner
+// Created: 2026-04-10
+// Purpose: 레포 소스 파일에서 함수/클래스/타입/상수 선언을 추출하여 레지스트리에 등록
+// Dependencies: registry/sqliteStore
+// Supported: TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, C#
+// ============================================
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, extname, dirname } from 'node:path';
+import { getRegistryStore } from './sqliteStore.js';
+// ============ 상수 ============
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '__pycache__',
+    '.next', '.venv', 'venv', '.tox', '.mypy_cache', '.pytest_cache',
+    'coverage', '.turbo', '.cache', '.parcel-cache',
+    '.venv-mcp', 'site-packages', '.openswarm',
+    'trash', 'testing', 'vendor', 'third_party',
+    'target', // Rust/Java
+    'bin', 'obj', // C#
+    'cmake-build-debug', 'cmake-build-release', // C/C++
+]);
+const SKIP_DIR_PREFIXES = ['.venv'];
+const MAX_FILE_SIZE = 512 * 1024;
+const MAX_DEPTH = 15;
+const SCAN_TIMEOUT_MS = 60_000;
+// ---- TypeScript / JavaScript ----
+const TS_CONFIG = {
+    extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+    testPatterns: [/\.test\.[tj]sx?$/, /\.spec\.[tj]sx?$/],
+    blockStyle: 'brace',
+    skipIndented: ['function'],
+    commentPrefixes: ['//', '*', '/*'],
+    patterns: [
+        { pattern: /^export\s+(?:async\s+)?function\s+(\w+)\s*(\([^)]*\)(?:\s*:\s*[^{]+)?)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        { pattern: /^export\s+(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)\s*(?::\s*\w[^=]*)?\s*=>|function)/, kind: 'function' },
+        { pattern: /^export\s+(?:abstract\s+)?class\s+(\w+)/, kind: 'class' },
+        { pattern: /^export\s+(?:interface|type)\s+(\w+)/, kind: 'type' },
+        { pattern: /^export\s+(?:const\s+)?enum\s+(\w+)/, kind: 'type' },
+        { pattern: /^export\s+const\s+([A-Z][A-Z0-9_]+)\s*=/, kind: 'constant' },
+        { pattern: /^(?:async\s+)?function\s+(\w+)\s*(\([^)]*\)(?:\s*:\s*[^{]+)?)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        { pattern: /^(?:abstract\s+)?class\s+(\w+)/, kind: 'class' },
+    ],
+};
+// ---- Python ----
+const PY_CONFIG = {
+    extensions: ['.py', '.pyw'],
+    testPatterns: [/_test\.py$/, /test_.*\.py$/, /\.test\.py$/],
+    blockStyle: 'indent',
+    commentPrefixes: ['#'],
+    patterns: [
+        { pattern: /^(?:async\s+)?def\s+(\w+)\s*(\([^)]*\)(?:\s*->\s*[^:]+)?)?\s*:/, kind: 'function', sigGroup: 2 },
+        { pattern: /^class\s+(\w+)/, kind: 'class' },
+        // 타입 별칭: Name = Literal[...] / Name = Union[...] / Name: TypeAlias = ...
+        { pattern: /^([A-Z]\w+)\s*(?::\s*TypeAlias\s*)?=\s*(?:Literal|Union|Optional|Type|Annotated|Final)\[/, kind: 'type' },
+        // 상수: UPPER_CASE = ...
+        { pattern: /^([A-Z][A-Z0-9_]+)\s*(?::\s*\w[^=]*)?\s*=/, kind: 'constant' },
+    ],
+};
+// ---- Go ----
+const GO_CONFIG = {
+    extensions: ['.go'],
+    testPatterns: [/_test\.go$/],
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '*', '/*'],
+    patterns: [
+        // func FuncName(params) returnType {
+        { pattern: /^func\s+(\w+)\s*(\([^)]*\)(?:\s*(?:\([^)]*\)|[^{]+))?)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        // func (receiver) MethodName(params) — 메서드 (receiver 있음)
+        { pattern: /^func\s+\([^)]+\)\s+(\w+)\s*(\([^)]*\)(?:\s*(?:\([^)]*\)|[^{]+))?)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        // type StructName struct {
+        { pattern: /^type\s+(\w+)\s+struct\s*\{?/, kind: 'class' },
+        // type InterfaceName interface {
+        { pattern: /^type\s+(\w+)\s+interface\s*\{?/, kind: 'type' },
+        // type TypeName = ... / type TypeName ...
+        { pattern: /^type\s+(\w+)\s+[^si]/, kind: 'type' },
+        // const ConstName = ... (단일 const)
+        { pattern: /^const\s+(\w+)\s*(?:\w+)?\s*=/, kind: 'constant' },
+        // var VarName = ... (패키지 수준)
+        { pattern: /^var\s+(\w+)\s+/, kind: 'constant' },
+    ],
+};
+// ---- Rust ----
+const RUST_CONFIG = {
+    extensions: ['.rs'],
+    testPatterns: [], // Rust는 같은 파일 내 #[cfg(test)] mod tests {}
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '///', '*', '/*'],
+    patterns: [
+        // pub fn func_name(params) -> ReturnType {
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?(?:async\s+)?fn\s+(\w+)\s*(<[^>]*>)?\s*(\([^)]*\)(?:\s*->\s*[^{]+)?)?\s*(?:where\s+[^{]*)?\{?/, kind: 'function', sigGroup: 3 },
+        // pub struct StructName {
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?struct\s+(\w+)/, kind: 'class' },
+        // pub enum EnumName {
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?enum\s+(\w+)/, kind: 'type' },
+        // pub trait TraitName {
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?trait\s+(\w+)/, kind: 'type' },
+        // type TypeAlias = ...
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?type\s+(\w+)/, kind: 'type' },
+        // const CONST_NAME: Type = ...
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?const\s+([A-Z][A-Z0-9_]+)\s*:/, kind: 'constant' },
+        // static STATIC_NAME: Type = ...
+        { pattern: /^(?:pub(?:\(crate\))?\s+)?static\s+(?:mut\s+)?([A-Z][A-Z0-9_]+)\s*:/, kind: 'constant' },
+        // impl StructName {
+        { pattern: /^impl(?:<[^>]*>)?\s+(\w+)(?:<[^>]*>)?\s*(?:for\s+\w+)?\s*\{/, kind: 'class' },
+    ],
+};
+// ---- Java ----
+const JAVA_CONFIG = {
+    extensions: ['.java'],
+    testPatterns: [/Test\.java$/, /Tests\.java$/, /IT\.java$/],
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '*', '/*', '@'],
+    patterns: [
+        // public/private/protected ReturnType methodName(params) {
+        { pattern: /^(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:abstract\s+)?(?:native\s+)?(?:<[^>]+>\s+)?(?:\w+(?:<[^>]*>)?(?:\[\])*)\s+(\w+)\s*(\([^)]*\))\s*(?:throws\s+[^{]+)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        // public class ClassName {
+        { pattern: /^(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:final\s+)?(?:abstract\s+)?class\s+(\w+)/, kind: 'class' },
+        // public interface InterfaceName {
+        { pattern: /^(?:(?:public|private|protected)\s+)?(?:static\s+)?interface\s+(\w+)/, kind: 'type' },
+        // public enum EnumName {
+        { pattern: /^(?:(?:public|private|protected)\s+)?enum\s+(\w+)/, kind: 'type' },
+        // @interface AnnotationName {
+        { pattern: /^(?:(?:public|private|protected)\s+)?@interface\s+(\w+)/, kind: 'type' },
+        // public record RecordName(...)
+        { pattern: /^(?:(?:public|private|protected)\s+)?record\s+(\w+)/, kind: 'class' },
+        // public static final Type CONST_NAME = ...
+        { pattern: /^(?:(?:public|private|protected)\s+)?static\s+final\s+\w+(?:<[^>]*>)?\s+([A-Z][A-Z0-9_]+)\s*=/, kind: 'constant' },
+    ],
+};
+// ---- C ----
+const C_CONFIG = {
+    extensions: ['.c', '.h'],
+    testPatterns: [/_test\.c$/, /test_.*\.c$/],
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '*', '/*'],
+    patterns: [
+        // returnType funcName(params) { — top-level 함수
+        // 캡처: 반환형 다음 함수명, 괄호
+        { pattern: /^(?:static\s+)?(?:inline\s+)?(?:extern\s+)?(?:const\s+)?(?:unsigned\s+)?(?:signed\s+)?(?:long\s+)?(?:short\s+)?\w+[\s*]+(\w+)\s*(\([^)]*\))\s*\{/, kind: 'function', sigGroup: 2 },
+        // typedef struct { ... } Name;
+        { pattern: /^typedef\s+struct\s+(?:\w+\s*)?\{/, kind: 'class' },
+        // struct Name {
+        { pattern: /^(?:typedef\s+)?struct\s+(\w+)\s*\{?/, kind: 'class' },
+        // enum Name {
+        { pattern: /^(?:typedef\s+)?enum\s+(\w+)/, kind: 'type' },
+        // typedef returnType (*Name)(params);
+        { pattern: /^typedef\s+\w+[\s*]*\(\s*\*\s*(\w+)\s*\)/, kind: 'type' },
+        // typedef ... Name;
+        { pattern: /^typedef\s+.+\s+(\w+)\s*;/, kind: 'type' },
+        // #define MACRO_NAME
+        { pattern: /^#define\s+([A-Z][A-Z0-9_]+)/, kind: 'constant' },
+        // const type CONST = ... / static const ...
+        { pattern: /^(?:static\s+)?const\s+\w+\s+([A-Z][A-Z0-9_]+)\s*=/, kind: 'constant' },
+    ],
+};
+// ---- C++ ----
+const CPP_CONFIG = {
+    extensions: ['.cpp', '.cxx', '.cc', '.hpp', '.hxx', '.hh'],
+    testPatterns: [/_test\.cpp$/, /test_.*\.cpp$/, /_test\.cc$/, /Test\.cpp$/],
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '*', '/*'],
+    patterns: [
+        // class ClassName { (C++ 우선 — 함수보다 먼저 매칭)
+        { pattern: /^(?:template\s*<[^>]*>\s*)?(?:class|struct)\s+(?:\[\[.*?\]\]\s+)?(\w+)(?:\s*final)?\s*(?::\s*(?:public|private|protected)\s+[^{]+)?\s*\{/, kind: 'class' },
+        // namespace Name {
+        { pattern: /^namespace\s+(\w+)/, kind: 'module' },
+        // ReturnType ClassName::methodName(params) { — 이건 메서드이므로 별도 처리
+        { pattern: /^(?:template\s*<[^>]*>\s*)?(?:\w+[\s*&]+)?(\w+)::(\w+)\s*(\([^)]*\))/, kind: 'function', sigGroup: 3 },
+        // returnType funcName(params) {
+        { pattern: /^(?:template\s*<[^>]*>\s*)?(?:static\s+)?(?:inline\s+)?(?:virtual\s+)?(?:explicit\s+)?(?:constexpr\s+)?(?:const\s+)?(?:unsigned\s+)?\w+[\s*&]+(\w+)\s*(\([^)]*\))\s*(?:const)?\s*(?:override|final|noexcept)?\s*\{?/, kind: 'function', sigGroup: 2 },
+        // enum class Name {
+        { pattern: /^enum\s+(?:class\s+)?(\w+)/, kind: 'type' },
+        // using Name = ...
+        { pattern: /^using\s+(\w+)\s*=/, kind: 'type' },
+        // typedef
+        { pattern: /^typedef\s+.+\s+(\w+)\s*;/, kind: 'type' },
+        // constexpr auto CONST = ...
+        { pattern: /^(?:static\s+)?(?:inline\s+)?constexpr\s+\w+\s+([A-Z][A-Z0-9_]+)\s*[={]/, kind: 'constant' },
+        { pattern: /^#define\s+([A-Z][A-Z0-9_]+)/, kind: 'constant' },
+        { pattern: /^(?:static\s+)?const\s+\w+\s+([A-Z][A-Z0-9_]+)\s*=/, kind: 'constant' },
+    ],
+};
+// ---- C# ----
+const CSHARP_CONFIG = {
+    extensions: ['.cs'],
+    testPatterns: [/Tests?\.cs$/, /\.test\.cs$/],
+    blockStyle: 'brace',
+    commentPrefixes: ['//', '///', '*', '/*'],
+    patterns: [
+        // public class ClassName
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?(?:static\s+)?(?:sealed\s+)?(?:abstract\s+)?(?:partial\s+)?class\s+(\w+)/, kind: 'class' },
+        // public struct StructName
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?(?:readonly\s+)?(?:ref\s+)?(?:partial\s+)?struct\s+(\w+)/, kind: 'class' },
+        // public record RecordName
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?(?:sealed\s+)?(?:abstract\s+)?record\s+(?:struct\s+|class\s+)?(\w+)/, kind: 'class' },
+        // public interface IInterfaceName
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?(?:partial\s+)?interface\s+(\w+)/, kind: 'type' },
+        // public enum EnumName
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?enum\s+(\w+)/, kind: 'type' },
+        // public delegate ReturnType DelegateName(params);
+        { pattern: /^(?:(?:public|private|protected|internal)\s+)?delegate\s+\w+[\s<>[\],*]*\s+(\w+)\s*[(<]/, kind: 'type' },
+        // public ReturnType MethodName(params) {
+        { pattern: /^(?:\[.*?\]\s*)?(?:(?:public|private|protected|internal)\s+)?(?:static\s+)?(?:virtual\s+)?(?:override\s+)?(?:abstract\s+)?(?:async\s+)?(?:new\s+)?(?:\w+(?:<[^>]*>)?(?:\[\]|\?)?)\s+(\w+)\s*(<[^>]*>)?\s*(\([^)]*\))\s*(?:where\s+[^{]*)?\s*[{=>]/, kind: 'function', sigGroup: 3 },
+        // public const Type CONST = ...
+        { pattern: /^(?:(?:public|private|protected|internal)\s+)?(?:static\s+)?(?:readonly\s+)?const\s+\w+\s+(\w+)\s*=/, kind: 'constant' },
+    ],
+};
+// ============ 언어 레지스트리 ============
+const LANGUAGE_CONFIGS = {
+    typescript: TS_CONFIG,
+    python: PY_CONFIG,
+    go: GO_CONFIG,
+    rust: RUST_CONFIG,
+    java: JAVA_CONFIG,
+    c: C_CONFIG,
+    cpp: CPP_CONFIG,
+    csharp: CSHARP_CONFIG,
+};
+// 확장자 → 언어 매핑
+const EXT_TO_LANGUAGE = {};
+for (const [lang, config] of Object.entries(LANGUAGE_CONFIGS)) {
+    for (const ext of config.extensions) {
+        EXT_TO_LANGUAGE[ext] = lang;
+    }
+}
+// 지원되는 확장자 전체
+const SOURCE_EXTENSIONS = new Set(Object.keys(EXT_TO_LANGUAGE));
+function detectLanguage(ext) {
+    return EXT_TO_LANGUAGE[ext] ?? null;
+}
+function isTestFile(name, language) {
+    return LANGUAGE_CONFIGS[language].testPatterns.some(p => p.test(name));
+}
+// ============ 엔티티 추출 ============
+/**
+ * 소스 파일 내용에서 엔티티 선언을 추출
+ */
+export function extractEntities(content, filePath, language) {
+    const lines = content.split('\n');
+    const entities = [];
+    const config = LANGUAGE_CONFIGS[language];
+    const seen = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trimStart();
+        if (!trimmed)
+            continue;
+        // 주석 스킵
+        if (config.commentPrefixes.some(p => trimmed.startsWith(p)))
+            continue;
+        for (const { pattern, kind, sigGroup } of config.patterns) {
+            const match = trimmed.match(pattern);
+            if (!match)
+                continue;
+            const name = match[1];
+            if (!name)
+                continue;
+            const key = `${name}:${i}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            // Python: 인덴트 있는 함수 = 메서드 → 스킵
+            if (language === 'python' && kind === 'function' && lines[i].match(/^\s+/))
+                continue;
+            // TS: skipIndented 설정된 kind가 인덴트 있으면 스킵
+            if (config.skipIndented?.includes(kind) && lines[i].match(/^\s{2,}/))
+                continue;
+            const isExported = language === 'go'
+                ? /^[A-Z]/.test(name) // Go: 대문자 시작 = exported
+                : trimmed.startsWith('export') || trimmed.startsWith('pub');
+            const signature = sigGroup ? match[sigGroup]?.trim() : undefined;
+            // 블록 끝 추정
+            let lineEnd;
+            if (config.blockStyle === 'brace') {
+                lineEnd = findBraceBlockEnd(lines, i);
+            }
+            else if (config.blockStyle === 'indent') {
+                lineEnd = findIndentBlockEnd(lines, i);
+            }
+            // 복잡도 산정
+            const complexity = (kind === 'function' || kind === 'class')
+                ? computeBlockMetrics(lines, i, lineEnd)
+                : { loc: 0, nestingDepth: 0, paramCount: 0 };
+            entities.push({
+                kind,
+                name,
+                filePath,
+                lineStart: i + 1,
+                lineEnd: lineEnd ? lineEnd + 1 : undefined,
+                signature,
+                isExported,
+                loc: complexity.loc,
+                nestingDepth: complexity.nestingDepth,
+                paramCount: complexity.paramCount,
+            });
+            break;
+        }
+    }
+    return entities;
+}
+// ============ 블록 끝 추정 ============
+/** 중괄호 카운팅 (C계열, Go, Rust, Java, C#) */
+function findBraceBlockEnd(lines, startIdx) {
+    let depth = 0;
+    let started = false;
+    for (let i = startIdx; i < Math.min(startIdx + 500, lines.length); i++) {
+        for (const ch of lines[i]) {
+            if (ch === '{') {
+                depth++;
+                started = true;
+            }
+            if (ch === '}')
+                depth--;
+        }
+        if (started && depth <= 0)
+            return i;
+    }
+    return undefined;
+}
+/** 인덴트 기반 (Python) */
+function findIndentBlockEnd(lines, startIdx) {
+    // 선언 줄의 인덴트 수준 파악
+    const startLine = lines[startIdx];
+    const baseIndent = startLine.length - startLine.trimStart().length;
+    for (let i = startIdx + 1; i < Math.min(startIdx + 500, lines.length); i++) {
+        const line = lines[i];
+        // 빈 줄은 건너뜀
+        if (line.trim().length === 0)
+            continue;
+        const currentIndent = line.length - line.trimStart().length;
+        // 인덴트가 기본 수준 이하로 돌아오면 블록 끝
+        if (currentIndent <= baseIndent)
+            return i - 1;
+    }
+    return undefined;
+}
+// ============ 복잡도 산정 ============
+function computeBlockMetrics(lines, startIdx, endIdx) {
+    const end = endIdx ?? Math.min(startIdx + 50, lines.length);
+    const blockLines = lines.slice(startIdx, end + 1);
+    const loc = blockLines.filter(l => l.trim().length > 0).length;
+    let maxNesting = 0;
+    let currentNesting = 0;
+    for (const line of blockLines) {
+        for (const ch of line) {
+            if (ch === '{' || ch === '(')
+                currentNesting++;
+            if (ch === '}' || ch === ')')
+                currentNesting--;
+        }
+        if (currentNesting > maxNesting)
+            maxNesting = currentNesting;
+    }
+    const firstLine = blockLines[0] ?? '';
+    const paramMatch = firstLine.match(/\(([^)]*)\)/);
+    const paramCount = paramMatch
+        ? paramMatch[1].split(',').filter(p => p.trim().length > 0).length
+        : 0;
+    return { loc, nestingDepth: maxNesting, paramCount };
+}
+function computeComplexityFromMetrics(loc, nestingDepth, paramCount) {
+    let score = 0;
+    if (loc > 100)
+        score += 3;
+    else if (loc > 50)
+        score += 2;
+    else if (loc > 20)
+        score += 1;
+    if (nestingDepth > 6)
+        score += 3;
+    else if (nestingDepth > 4)
+        score += 2;
+    else if (nestingDepth > 2)
+        score += 1;
+    if (paramCount > 6)
+        score += 2;
+    else if (paramCount > 3)
+        score += 1;
+    return Math.min(score, 10);
+}
+function computeRisk(complexityScore, hasTests) {
+    if (complexityScore >= 8)
+        return 'high';
+    if (complexityScore >= 6 && !hasTests)
+        return 'high';
+    if (complexityScore >= 6)
+        return 'medium';
+    if (complexityScore >= 4 && !hasTests)
+        return 'medium';
+    return 'low';
+}
+const TS_IMPORT_FROM = /import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+// import 예약어 — 테스트 프레임워크 함수 등
+const RESERVED_NAMES = new Set([
+    'describe', 'it', 'test', 'expect', 'beforeEach', 'afterEach',
+    'beforeAll', 'afterAll', 'vi', 'jest', 'mock', 'fn', 'spyOn',
+    'console', 'setTimeout', 'setInterval', 'Promise', 'Date',
+    'Array', 'Object', 'String', 'Number', 'Boolean', 'Map', 'Set',
+    'JSON', 'Math', 'Error', 'RegExp', 'require', 'import',
+    'resolve', 'reject', 'then', 'catch', 'finally', 'push',
+    'filter', 'map', 'reduce', 'forEach', 'find', 'includes',
+    'join', 'split', 'trim', 'slice', 'splice', 'pop', 'shift',
+    'assert', 'assertEqual', 'assertTrue', 'assertFalse', 'assertRaises', // Python
+    'testing', 'Errorf', 'Fatalf', 'Run', 'Equal', 'NotNil', // Go
+    'assert_eq', 'assert_ne', 'assert', 'panic', 'println', // Rust
+    'assertEquals', 'assertNotNull', 'assertThrows', 'assertTrue', // Java
+    'Assert', 'Fact', 'Theory', // C#
+]);
+function parseTestFile(content, testFilePath, language) {
+    const importedSymbols = new Map();
+    const referencedNames = new Set();
+    // TS/JS: import { A, B } from './path'
+    if (language === 'typescript') {
+        TS_IMPORT_FROM.lastIndex = 0;
+        let match;
+        while ((match = TS_IMPORT_FROM.exec(content)) !== null) {
+            const symbols = match[1].split(',')
+                .map(s => s.trim().split(/\s+as\s+/)[0].trim())
+                .filter(s => s && !s.startsWith('type '));
+            const importPath = match[2];
+            if (importPath.startsWith('.')) {
+                const resolved = resolveImportPath(testFilePath, importPath);
+                if (resolved) {
+                    const existing = importedSymbols.get(resolved) ?? new Set();
+                    for (const s of symbols)
+                        existing.add(s);
+                    importedSymbols.set(resolved, existing);
+                }
+            }
+        }
+    }
+    // Go: 함수 호출 패턴으로 매핑 (import는 패키지 단위라 심볼 매핑 어려움)
+    // Java/C#: import/using 은 클래스 단위
+    // Rust: use crate::module::Name
+    // 범용: 코드 내 함수 호출 참조 수집
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        const calls = trimmed.matchAll(/\b([a-zA-Z_]\w+)\s*\(/g);
+        for (const c of calls) {
+            if (!RESERVED_NAMES.has(c[1]))
+                referencedNames.add(c[1]);
+        }
+    }
+    return { testFilePath, importedSymbols, referencedNames };
+}
+function resolveImportPath(fromFile, importPath) {
+    const dir = dirname(fromFile);
+    const cleaned = importPath.replace(/\.[jt]sx?$/, '');
+    const resolved = join(dir, cleaned).replace(/\\/g, '/');
+    if (resolved.startsWith('..'))
+        return null;
+    return resolved.replace(/^\.\//, '');
+}
+function buildTestMap(entities, testFiles) {
+    const result = new Map();
+    const entitiesByFile = new Map();
+    const entityByName = new Map();
+    for (const e of entities) {
+        const list = entitiesByFile.get(e.filePath) ?? [];
+        list.push(e);
+        entitiesByFile.set(e.filePath, list);
+        const nameList = entityByName.get(e.name) ?? [];
+        nameList.push(e);
+        entityByName.set(e.name, nameList);
+    }
+    for (const tf of testFiles) {
+        // import 기반 매핑 (TS)
+        for (const [sourcePath, symbols] of tf.importedSymbols) {
+            const candidates = [
+                sourcePath + '.ts', sourcePath + '.tsx', sourcePath + '.js',
+                sourcePath + '/index.ts', sourcePath,
+            ];
+            for (const candidate of candidates) {
+                const fileEntities = entitiesByFile.get(candidate);
+                if (!fileEntities)
+                    continue;
+                for (const entity of fileEntities) {
+                    if (symbols.has(entity.name)) {
+                        result.set(`${entity.filePath}::${entity.name}`, { hasTests: true, testFile: tf.testFilePath });
+                    }
+                }
+                break;
+            }
+        }
+        // 참조 이름 기반 (범용)
+        for (const refName of tf.referencedNames) {
+            const matchingEntities = entityByName.get(refName);
+            if (!matchingEntities)
+                continue;
+            for (const entity of matchingEntities) {
+                const qName = `${entity.filePath}::${entity.name}`;
+                if (result.has(qName))
+                    continue;
+                if (isNearbyTest(entity.filePath, tf.testFilePath)) {
+                    result.set(qName, { hasTests: true, testFile: tf.testFilePath });
+                }
+            }
+        }
+    }
+    return result;
+}
+function isNearbyTest(sourceFile, testFile) {
+    const sourceDir = dirname(sourceFile);
+    const testDir = dirname(testFile);
+    const sourceBase = sourceFile.replace(/\.[^.]+$/, '');
+    const testBase = testFile
+        .replace(/\.test\.[^.]+$|\.spec\.[^.]+$/, '')
+        .replace(/_test\.[^.]+$/, '')
+        .replace(/Test\.[^.]+$/, '')
+        .replace(/Tests\.[^.]+$/, '');
+    // 파일명 매칭 (확장자 제외)
+    const srcName = sourceBase.split('/').pop();
+    const tstName = testBase.split('/').pop();
+    if (srcName && tstName && srcName === tstName)
+        return true;
+    if (sourceDir === testDir)
+        return true;
+    if (testDir === `${sourceDir}/__tests__`)
+        return true;
+    if (testDir === `${sourceDir}/tests`)
+        return true;
+    if (testDir === `${sourceDir}/test`)
+        return true;
+    const sourceParent = dirname(sourceDir);
+    if (testDir === `${sourceParent}/__tests__` || testDir === 'src/__tests__')
+        return true;
+    return false;
+}
+// ============ 메인 스캔 함수 ============
+export async function scanRepository(projectPath, projectId, options) {
+    const startTime = Date.now();
+    const maxDepth = options?.maxDepth ?? MAX_DEPTH;
+    const timeoutMs = options?.timeoutMs ?? SCAN_TIMEOUT_MS;
+    const verbose = options?.verbose ?? false;
+    const store = getRegistryStore();
+    const allExtracted = [];
+    const testFiles = [];
+    const errors = [];
+    const languageBreakdown = {};
+    let scannedFiles = 0;
+    async function walk(dirPath, relPath, depth) {
+        if (depth > maxDepth)
+            return;
+        if (Date.now() - startTime > timeoutMs)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dirPath, { withFileTypes: true });
+        }
+        catch (err) {
+            if (verbose)
+                console.log(`  [scan] skip dir ${relPath}: ${err instanceof Error ? err.message : 'access denied'}`);
+            return;
+        }
+        for (const entry of entries) {
+            if (Date.now() - startTime > timeoutMs)
+                return;
+            const fullPath = join(dirPath, entry.name);
+            const entryRelPath = relPath ? `${relPath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || SKIP_DIR_PREFIXES.some(p => entry.name.startsWith(p)))
+                    continue;
+                await walk(fullPath, entryRelPath, depth + 1);
+            }
+            else if (entry.isFile()) {
+                const ext = extname(entry.name);
+                if (!SOURCE_EXTENSIONS.has(ext))
+                    continue;
+                const language = detectLanguage(ext);
+                if (!language)
+                    continue;
+                try {
+                    const fileStat = await stat(fullPath);
+                    if (fileStat.size > MAX_FILE_SIZE)
+                        continue;
+                }
+                catch (err) {
+                    if (verbose)
+                        console.log(`  [scan] skip stat ${entryRelPath}: ${err instanceof Error ? err.message : 'access denied'}`);
+                    continue;
+                }
+                try {
+                    const content = await readFile(fullPath, 'utf-8');
+                    if (isTestFile(entry.name, language)) {
+                        testFiles.push(parseTestFile(content, entryRelPath, language));
+                    }
+                    else {
+                        const entities = extractEntities(content, entryRelPath, language);
+                        allExtracted.push(...entities);
+                        scannedFiles++;
+                        languageBreakdown[language] = (languageBreakdown[language] ?? 0) + 1;
+                        if (verbose && entities.length > 0) {
+                            console.log(`  [scan] ${entryRelPath}: ${entities.length} entities (${language})`);
+                        }
+                    }
+                }
+                catch (err) {
+                    errors.push(`${entryRelPath}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+    }
+    await walk(projectPath, '', 0);
+    // 테스트 매핑 빌드
+    const testMap = buildTestMap(allExtracted, testFiles);
+    if (verbose && testMap.size > 0) {
+        console.log(`  [test-map] ${testMap.size} entities mapped to tests`);
+    }
+    // 레지스트리 동기화
+    const existing = store.listEntities({ projectId, limit: 100_000, offset: 0 });
+    const existingByQName = new Map(existing.entities.map(e => [e.qualifiedName, e]));
+    const extractedQNames = new Set();
+    let registered = 0;
+    let updated = 0;
+    let testsMapped = 0;
+    for (const ext of allExtracted) {
+        const qualifiedName = `${ext.filePath}::${ext.name}`;
+        extractedQNames.add(qualifiedName);
+        const testInfo = testMap.get(qualifiedName);
+        const hasTests = testInfo?.hasTests ?? false;
+        const testFile = testInfo?.testFile;
+        const score = computeComplexityFromMetrics(ext.loc, ext.nestingDepth, ext.paramCount);
+        const riskLevel = computeRisk(score, hasTests);
+        if (hasTests)
+            testsMapped++;
+        const existingEntity = existingByQName.get(qualifiedName);
+        if (!existingEntity) {
+            try {
+                store.registerEntity({
+                    projectId,
+                    kind: ext.kind,
+                    name: ext.name,
+                    filePath: ext.filePath,
+                    lineStart: ext.lineStart,
+                    lineEnd: ext.lineEnd,
+                    signature: ext.signature,
+                    status: 'active',
+                    hasTests,
+                    testFile,
+                    complexityScore: score,
+                    riskLevel,
+                    author: 'scanner',
+                });
+                registered++;
+            }
+            catch (err) {
+                if (!(err instanceof Error && err.message.includes('UNIQUE'))) {
+                    errors.push(`register ${qualifiedName}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        else {
+            const needsUpdate = existingEntity.lineStart !== ext.lineStart ||
+                existingEntity.lineEnd !== ext.lineEnd ||
+                existingEntity.signature !== ext.signature ||
+                existingEntity.hasTests !== hasTests ||
+                existingEntity.testFile !== testFile ||
+                existingEntity.complexityScore !== score ||
+                existingEntity.riskLevel !== riskLevel;
+            if (needsUpdate) {
+                store.updateEntity(existingEntity.id, {
+                    lineStart: ext.lineStart,
+                    lineEnd: ext.lineEnd,
+                    signature: ext.signature,
+                    hasTests,
+                    testFile,
+                    complexityScore: score,
+                    riskLevel,
+                }, 'scanner');
+                updated++;
+            }
+        }
+    }
+    // 사라진 엔티티 → broken
+    let removed = 0;
+    for (const [qName, entity] of existingByQName) {
+        if (!extractedQNames.has(qName) && entity.author === 'scanner' && entity.status === 'active') {
+            store.changeEntityStatus(entity.id, 'broken', 'scanner');
+            removed++;
+        }
+    }
+    return {
+        scanned: scannedFiles,
+        extracted: allExtracted.length,
+        registered,
+        updated,
+        removed,
+        testsMapped,
+        errors,
+        durationMs: Date.now() - startTime,
+        languageBreakdown,
+    };
+}
+//# sourceMappingURL=entityScanner.js.map