@barissozen/csns 0.6.0

package/dist/agent/tracer/semantic-analyzer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Semantic Analyzer — LLM ile Wiring Mantık Kontrolü
+ *
+ * LLMProvider abstraction ile herhangi bir model kullanabilir.
+ */
+import type { LLMProvider } from '../../llm/types.js';
+import type { DependencyEdge, ExportNode, WiringIssue, SemanticInsight } from '../../types/index.js';
+export declare class SemanticAnalyzer {
+    private provider;
+    constructor(provider?: LLMProvider | null);
+    /**
+     * Import graph + dosya özetlerini LLM'e gönder, semantic sorunları tespit et
+     */
+    analyze(edges: DependencyEdge[], exports: ExportNode[], fileSummaries: Map<string, string>, architecture?: string): Promise<SemanticInsight[]>;
+    /**
+     * Semantic insight'ları WiringIssue'lara dönüştür
+     */
+    toWiringIssues(insights: SemanticInsight[]): WiringIssue[];
+    private buildPrompt;
+    private parseResponse;
+    private mapCategory;
+    private generateSuggestion;
+}
+//# sourceMappingURL=semantic-analyzer.d.ts.map

package/dist/agent/tracer/semantic-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-analyzer.d.ts","sourceRoot":"","sources":["../../../src/agent/tracer/semantic-analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,WAAW,EACX,eAAe,EAChB,MAAM,sBAAsB,CAAC;AA0B9B,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAIzC;;OAEG;IACG,OAAO,CACX,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,UAAU,EAAE,EACrB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC;IAqB7B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,WAAW,EAAE;IAc1D,OAAO,CAAC,WAAW;IAyCnB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,kBAAkB;CAU3B"}

package/dist/agent/tracer/semantic-analyzer.js

@@ -0,0 +1,132 @@
+/**
+ * Semantic Analyzer — LLM ile Wiring Mantık Kontrolü
+ *
+ * LLMProvider abstraction ile herhangi bir model kullanabilir.
+ */
+const SEMANTIC_SYSTEM_PROMPT = `You are an experienced software architect. Your task is to identify wiring issues in a TypeScript project.
+
+You will receive:
+1. Import/export graph — which file imports what
+2. File summaries — what each file does
+3. Architecture decisions — how the project is structured
+
+Detect:
+- **injection-missing**: A service/handler needs another service but it's not injected
+- **config-mismatch**: Env variable or config value used but undefined or type mismatch
+- **interface-drift**: Contract mismatch between two modules (parameter types, return types)
+- **handler-gap**: Route defined but handler not connected, or missing link in middleware chain
+- **data-flow-break**: Data should flow A→B→C but B→C connection is broken
+
+OUTPUT: JSON array only, each element:
+{
+  "category": "injection-missing|config-mismatch|interface-drift|handler-gap|data-flow-break",
+  "description": "Human-readable description",
+  "files": ["file1.ts", "file2.ts"],
+  "confidence": 0.0-1.0
+}
+
+Mark uncertain findings with low confidence. Stay silent rather than produce false positives.`;
+export class SemanticAnalyzer {
+    provider;
+    constructor(provider) {
+        this.provider = provider ?? null;
+    }
+    /**
+     * Import graph + dosya özetlerini LLM'e gönder, semantic sorunları tespit et
+     */
+    async analyze(edges, exports, fileSummaries, architecture) {
+        if (!this.provider) {
+            return []; // No LLM provider, skip
+        }
+        const prompt = this.buildPrompt(edges, exports, fileSummaries, architecture);
+        try {
+            const response = await this.provider.chat([{ role: 'user', content: prompt }], { system: SEMANTIC_SYSTEM_PROMPT, maxTokens: 4096 });
+            return this.parseResponse(response.text);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            console.warn(`⚠️ Semantic analysis failed: ${msg}`);
+            return [];
+        }
+    }
+    /**
+     * Semantic insight'ları WiringIssue'lara dönüştür
+     */
+    toWiringIssues(insights) {
+        return insights
+            .filter(i => i.confidence >= 0.5) // düşük güvenli olanları filtrele
+            .map(insight => ({
+            type: this.mapCategory(insight.category),
+            severity: insight.confidence >= 0.8 ? 'warning' : 'info',
+            file: insight.files[0] ?? 'unknown',
+            detail: `[LLM %.0f%%] ${insight.description}`.replace('%.0f', String(Math.round(insight.confidence * 100))),
+            suggestion: this.generateSuggestion(insight),
+        }));
+    }
+    // ── Private ────────────────────────────────────────────────
+    buildPrompt(edges, exports, fileSummaries, architecture) {
+        const parts = [];
+        // Graph özeti
+        parts.push('## Import/Export Grafiği\n');
+        for (const edge of edges.slice(0, 100)) { // max 100 edge
+            parts.push(`${edge.source} → ${edge.target} [${edge.symbols.join(', ')}]`);
+        }
+        // Export listesi
+        parts.push('\n## Dosya Export\'ları\n');
+        const byFile = new Map();
+        for (const exp of exports) {
+            if (!byFile.has(exp.file))
+                byFile.set(exp.file, []);
+            byFile.get(exp.file).push(exp);
+        }
+        for (const [file, exps] of byFile) {
+            parts.push(`**${file}**: ${exps.map(e => `${e.symbol}(${e.kind})`).join(', ')}`);
+        }
+        // Dosya özetleri
+        parts.push('\n## Dosya İçerik Özetleri\n');
+        for (const [file, summary] of fileSummaries) {
+            parts.push(`### ${file}\n${summary.slice(0, 500)}\n`);
+        }
+        // Mimari
+        if (architecture) {
+            parts.push(`\n## Mimari Kararlar\n${architecture.slice(0, 1500)}\n`);
+        }
+        parts.push('\n---\nBu projedeki wiring sorunlarını JSON array olarak raporla.');
+        return parts.join('\n');
+    }
+    parseResponse(text) {
+        // JSON array çıkar
+        const jsonMatch = text.match(/\[[\s\S]*\]/);
+        if (!jsonMatch)
+            return [];
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return parsed.filter(item => item.category && item.description && Array.isArray(item.files) &&
+                typeof item.confidence === 'number');
+        }
+        catch {
+            return [];
+        }
+    }
+    mapCategory(category) {
+        const map = {
+            'injection-missing': 'missing-import',
+            'config-mismatch': 'type-mismatch',
+            'interface-drift': 'type-mismatch',
+            'handler-gap': 'missing-import',
+            'data-flow-break': 'runtime-gap',
+        };
+        return map[category];
+    }
+    generateSuggestion(insight) {
+        const map = {
+            'injection-missing': 'Inject the missing service via constructor or factory',
+            'config-mismatch': 'Check config/env values, compare with .env.example',
+            'interface-drift': 'Define a shared interface and ensure both sides implement it',
+            'handler-gap': 'Check route definition and handler binding, verify middleware chain',
+            'data-flow-break': 'Find the broken point in data flow, add missing intermediate layer',
+        };
+        return map[insight.category];
+    }
+}
+//# sourceMappingURL=semantic-analyzer.js.map

package/dist/agent/tracer/semantic-analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-analyzer.js","sourceRoot":"","sources":["../../../src/agent/tracer/semantic-analyzer.ts"],"names":[],"mappings":"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"}

package/dist/agent/tracer/static-analyzer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Static Analyzer — Import/Export Graph + Dead Code + Circular Dep Tespiti
+ *
+ * AST-free, regex tabanlı hızlı analiz.
+ * Tüm .ts/.tsx dosyalarını tarar, import/export grafiği çıkarır.
+ * Kullanılmayan export'ları, kırık import'ları, döngüsel bağımlılıkları tespit eder.
+ */
+import type { ImportEdge, ExportNode, DependencyEdge, WiringIssue } from '../../types/index.js';
+export declare class StaticAnalyzer {
+    private projectRoot;
+    constructor(projectRoot: string);
+    /**
+     * Tüm kaynak dosyaları tara, import/export grafiğini çıkar
+     */
+    buildGraph(): Promise<{
+        imports: ImportEdge[];
+        exports: ExportNode[];
+        edges: DependencyEdge[];
+        files: string[];
+    }>;
+    /**
+     * Static wiring sorunlarını tespit et
+     */
+    findIssues(): Promise<WiringIssue[]>;
+    private extractImports;
+    private extractExports;
+    private buildEdges;
+    private findDeadExports;
+    private findMissingImports;
+    private findCircularDeps;
+    private findPhantomDeps;
+    private collectSourceFiles;
+    private walk;
+    /**
+     * Relative import'u dosya yoluna çözümle.
+     * './foo.js' → 'src/foo.ts' (TypeScript .js → .ts mapping dahil)
+     */
+    private resolveImportPath;
+    private isEntryPoint;
+    private isNodeBuiltin;
+    private findLineNumber;
+    private inferExportKind;
+}
+//# sourceMappingURL=static-analyzer.d.ts.map

package/dist/agent/tracer/static-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-analyzer.d.ts","sourceRoot":"","sources":["../../../src/agent/tracer/static-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,WAAW,EACZ,MAAM,sBAAsB,CAAC;AA+B9B,qBAAa,cAAc;IACzB,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM;IAM/B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC;QAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;QACtB,OAAO,EAAE,UAAU,EAAE,CAAC;QACtB,KAAK,EAAE,cAAc,EAAE,CAAC;QACxB,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;IAkBF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAqB1C,OAAO,CAAC,cAAc;IAyDtB,OAAO,CAAC,cAAc;IAgDtB,OAAO,CAAC,UAAU;IA8BlB,OAAO,CAAC,eAAe;IA2DvB,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,gBAAgB;YAkDV,eAAe;YA+Df,kBAAkB;YAMlB,IAAI;IAmBlB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA0BzB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,eAAe;CAQxB"}

package/dist/agent/tracer/static-analyzer.js

@@ -0,0 +1,453 @@
+/**
+ * Static Analyzer — Import/Export Graph + Dead Code + Circular Dep Tespiti
+ *
+ * AST-free, regex tabanlı hızlı analiz.
+ * Tüm .ts/.tsx dosyalarını tarar, import/export grafiği çıkarır.
+ * Kullanılmayan export'ları, kırık import'ları, döngüsel bağımlılıkları tespit eder.
+ */
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative, dirname, extname } from 'node:path';
+const SOURCE_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs']);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next']);
+// ── Regex Patterns ───────────────────────────────────────────
+/** import { X, Y } from './path' */
+const NAMED_IMPORT = /import\s+(?:type\s+)?{([^}]+)}\s+from\s+['"]([^'"]+)['"]/g;
+/** import X from './path' */
+const DEFAULT_IMPORT = /import\s+(?:type\s+)?(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+/** import * as X from './path' */
+const STAR_IMPORT = /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+/** export { X, Y } from './path' (re-export) */
+const RE_EXPORT = /export\s+(?:type\s+)?{([^}]+)}\s+from\s+['"]([^'"]+)['"]/g;
+/** export default class/function/const X */
+const EXPORT_DEFAULT = /export\s+default\s+(?:class|function|const|abstract\s+class)\s+(\w+)/g;
+/** export class/function/const/type/interface/enum X */
+const EXPORT_NAMED = /export\s+(?:declare\s+)?(?:abstract\s+)?(?:class|function|const|let|var|type|interface|enum)\s+(\w+)/g;
+/** export default (anonymous) */
+const EXPORT_DEFAULT_ANON = /export\s+default\s+(?!class|function|const|abstract)/g;
+/** import type { X } from ... (TypeScript) */
+const TYPE_IMPORT = /import\s+type\s+/;
+export class StaticAnalyzer {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    // ── Public API ─────────────────────────────────────────────
+    /**
+     * Tüm kaynak dosyaları tara, import/export grafiğini çıkar
+     */
+    async buildGraph() {
+        const files = await this.collectSourceFiles();
+        const allImports = [];
+        const allExports = [];
+        for (const file of files) {
+            const content = await readFile(join(this.projectRoot, file), 'utf-8');
+            const imports = this.extractImports(file, content);
+            const exports = this.extractExports(file, content);
+            allImports.push(...imports);
+            allExports.push(...exports);
+        }
+        const edges = this.buildEdges(allImports, files);
+        return { imports: allImports, exports: allExports, edges, files };
+    }
+    /**
+     * Static wiring sorunlarını tespit et
+     */
+    async findIssues() {
+        const { imports, exports, edges, files } = await this.buildGraph();
+        const issues = [];
+        // 1. Dead exports — hiçbir yerde import edilmeyen export'lar
+        issues.push(...this.findDeadExports(exports, imports, files));
+        // 2. Missing imports — resolve edilemeyen import'lar
+        issues.push(...this.findMissingImports(imports, files));
+        // 3. Circular dependencies
+        issues.push(...this.findCircularDeps(edges));
+        // 4. Phantom dependencies — package.json'da olmayan import'lar
+        issues.push(...await this.findPhantomDeps(imports));
+        return issues;
+    }
+    // ── Import Extraction ──────────────────────────────────────
+    extractImports(file, content) {
+        const imports = [];
+        const lines = content.split('\n');
+        // Named imports: import { X, Y } from './path'
+        for (const match of content.matchAll(NAMED_IMPORT)) {
+            const symbols = match[1].split(',').map(s => {
+                const parts = s.trim().split(/\s+as\s+/);
+                return parts[0].trim();
+            }).filter(s => s.length > 0);
+            const line = this.findLineNumber(lines, match.index);
+            const isTypeOnly = TYPE_IMPORT.test(match[0]);
+            imports.push({
+                from: file,
+                to: match[2],
+                symbols,
+                isTypeOnly,
+                line,
+            });
+        }
+        // Default imports: import X from './path'
+        for (const match of content.matchAll(DEFAULT_IMPORT)) {
+            // Named import regex ile overlap kontrolü
+            if (match[0].includes('{'))
+                continue;
+            const line = this.findLineNumber(lines, match.index);
+            const isTypeOnly = TYPE_IMPORT.test(match[0]);
+            imports.push({
+                from: file,
+                to: match[2],
+                symbols: ['default'],
+                isTypeOnly,
+                line,
+            });
+        }
+        // Star imports: import * as X from './path'
+        for (const match of content.matchAll(STAR_IMPORT)) {
+            const line = this.findLineNumber(lines, match.index);
+            imports.push({
+                from: file,
+                to: match[2],
+                symbols: ['*'],
+                isTypeOnly: false,
+                line,
+            });
+        }
+        return imports;
+    }
+    // ── Export Extraction ──────────────────────────────────────
+    extractExports(file, content) {
+        const exports = [];
+        const lines = content.split('\n');
+        const seen = new Set();
+        // Re-exports: export { X } from './path'
+        for (const match of content.matchAll(RE_EXPORT)) {
+            const symbols = match[1].split(',').map(s => s.trim().split(/\s+as\s+/).pop().trim());
+            for (const sym of symbols) {
+                if (sym && !seen.has(sym)) {
+                    seen.add(sym);
+                    exports.push({ file, symbol: sym, kind: 're-export', line: this.findLineNumber(lines, match.index) });
+                }
+            }
+        }
+        // Named exports: export class/function/const/type/interface/enum X
+        for (const match of content.matchAll(EXPORT_NAMED)) {
+            const sym = match[1];
+            if (!seen.has(sym)) {
+                seen.add(sym);
+                const kind = this.inferExportKind(match[0]);
+                exports.push({ file, symbol: sym, kind, line: this.findLineNumber(lines, match.index) });
+            }
+        }
+        // Default exports: export default class X
+        for (const match of content.matchAll(EXPORT_DEFAULT)) {
+            const sym = match[1];
+            if (!seen.has(sym)) {
+                seen.add(sym);
+                exports.push({ file, symbol: sym, kind: 'default', line: this.findLineNumber(lines, match.index) });
+            }
+        }
+        // Anonymous default exports
+        for (const match of content.matchAll(EXPORT_DEFAULT_ANON)) {
+            if (!seen.has('default')) {
+                seen.add('default');
+                exports.push({ file, symbol: 'default', kind: 'default', line: this.findLineNumber(lines, match.index) });
+            }
+        }
+        return exports;
+    }
+    // ── Edge Building ──────────────────────────────────────────
+    buildEdges(imports, files) {
+        const edgeMap = new Map();
+        const fileSet = new Set(files);
+        for (const imp of imports) {
+            const resolved = this.resolveImportPath(imp.from, imp.to, fileSet);
+            if (!resolved)
+                continue; // external package
+            const key = `${imp.from}→${resolved}`;
+            const existing = edgeMap.get(key);
+            if (existing) {
+                existing.weight++;
+                for (const s of imp.symbols) {
+                    if (!existing.symbols.includes(s))
+                        existing.symbols.push(s);
+                }
+            }
+            else {
+                edgeMap.set(key, {
+                    source: imp.from,
+                    target: resolved,
+                    symbols: [...imp.symbols],
+                    weight: 1,
+                });
+            }
+        }
+        return [...edgeMap.values()];
+    }
+    // ── Issue Detection ────────────────────────────────────────
+    findDeadExports(exports, imports, files) {
+        const issues = [];
+        const fileSet = new Set(files);
+        // Tüm import edilen symbol'leri topla (dosya bazlı)
+        const importedSymbols = new Map(); // file → symbols
+        for (const imp of imports) {
+            const resolved = this.resolveImportPath(imp.from, imp.to, fileSet);
+            if (!resolved)
+                continue;
+            if (!importedSymbols.has(resolved)) {
+                importedSymbols.set(resolved, new Set());
+            }
+            for (const sym of imp.symbols) {
+                importedSymbols.get(resolved).add(sym);
+                // Star import → tüm export'ları kullanılmış say
+                if (sym === '*') {
+                    importedSymbols.get(resolved).add('*');
+                }
+            }
+        }
+        for (const exp of exports) {
+            // Entry point dosyalarını atla (index.ts, bin/*, main)
+            if (this.isEntryPoint(exp.file))
+                continue;
+            // Type-only export'ları atla (type/interface)
+            if (exp.kind === 'type' || exp.kind === 'interface')
+                continue;
+            const usedSymbols = importedSymbols.get(exp.file);
+            if (!usedSymbols) {
+                // Hiçbir dosya bu dosyayı import etmiyor
+                issues.push({
+                    type: 'dead-export',
+                    severity: 'warning',
+                    file: exp.file,
+                    symbol: exp.symbol,
+                    detail: `Export '${exp.symbol}' hiçbir yerde kullanılmıyor (${exp.file}:${exp.line})`,
+                    suggestion: `Kullanılmıyorsa kaldır veya export'u internal yap`,
+                });
+            }
+            else if (!usedSymbols.has(exp.symbol) && !usedSymbols.has('default') && !usedSymbols.has('*')) {
+                issues.push({
+                    type: 'dead-export',
+                    severity: 'info',
+                    file: exp.file,
+                    symbol: exp.symbol,
+                    detail: `Export '${exp.symbol}' import ediliyor ama bu symbol kullanılmıyor (${exp.file}:${exp.line})`,
+                    suggestion: `Import listesinden ve export'tan kaldırılabilir`,
+                });
+            }
+        }
+        return issues;
+    }
+    findMissingImports(imports, files) {
+        const issues = [];
+        const fileSet = new Set(files);
+        for (const imp of imports) {
+            // Sadece relative import'ları kontrol et
+            if (!imp.to.startsWith('.'))
+                continue;
+            const resolved = this.resolveImportPath(imp.from, imp.to, fileSet);
+            if (!resolved) {
+                issues.push({
+                    type: 'missing-import',
+                    severity: 'critical',
+                    file: imp.from,
+                    symbol: imp.symbols.join(', '),
+                    detail: `Import çözümlenemedi: '${imp.to}' (${imp.from}:${imp.line})`,
+                    suggestion: `Dosya mevcut mu? Yol doğru mu? Extension .js ekli mi?`,
+                });
+            }
+        }
+        return issues;
+    }
+    findCircularDeps(edges) {
+        const issues = [];
+        const adjList = new Map();
+        for (const edge of edges) {
+            if (!adjList.has(edge.source))
+                adjList.set(edge.source, []);
+            adjList.get(edge.source).push(edge.target);
+        }
+        const visited = new Set();
+        const inStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            if (inStack.has(node)) {
+                // Döngü bulundu — path'ten cycle'ı çıkar
+                const cycleStart = path.indexOf(node);
+                const cycle = path.slice(cycleStart);
+                cycle.push(node);
+                issues.push({
+                    type: 'circular-dep',
+                    severity: 'warning',
+                    file: node,
+                    detail: `Döngüsel bağımlılık: ${cycle.join(' → ')}`,
+                    suggestion: `Bağımlılık yönünü değiştir veya ortak bir interface modülüne çıkar`,
+                });
+                return;
+            }
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            inStack.add(node);
+            path.push(node);
+            for (const neighbor of adjList.get(node) ?? []) {
+                dfs(neighbor);
+            }
+            path.pop();
+            inStack.delete(node);
+        };
+        for (const node of adjList.keys()) {
+            dfs(node);
+        }
+        return issues;
+    }
+    async findPhantomDeps(imports) {
+        const issues = [];
+        // package.json oku
+        let pkgDeps;
+        try {
+            const pkg = JSON.parse(await readFile(join(this.projectRoot, 'package.json'), 'utf-8'));
+            pkgDeps = new Set([
+                ...Object.keys(pkg.dependencies ?? {}),
+                ...Object.keys(pkg.devDependencies ?? {}),
+                ...Object.keys(pkg.peerDependencies ?? {}),
+            ]);
+        }
+        catch {
+            return issues; // package.json yoksa kontrol etme
+        }
+        // External import'ları topla
+        const externalImports = new Set();
+        for (const imp of imports) {
+            if (imp.to.startsWith('.') || imp.to.startsWith('node:'))
+                continue;
+            // Scoped package: @scope/name → @scope/name
+            const pkgName = imp.to.startsWith('@')
+                ? imp.to.split('/').slice(0, 2).join('/')
+                : imp.to.split('/')[0];
+            externalImports.add(pkgName);
+        }
+        for (const pkg of externalImports) {
+            // Node built-in modüllerini atla
+            if (this.isNodeBuiltin(pkg))
+                continue;
+            if (!pkgDeps.has(pkg)) {
+                issues.push({
+                    type: 'phantom-dep',
+                    severity: 'critical',
+                    file: 'package.json',
+                    symbol: pkg,
+                    detail: `'${pkg}' import ediliyor ama package.json'da dependency olarak tanımlı değil`,
+                    suggestion: `npm install ${pkg} veya import'u kaldır`,
+                });
+            }
+        }
+        // Kullanılmayan dependency'ler (ters yön)
+        for (const dep of pkgDeps) {
+            if (dep.startsWith('@types/'))
+                continue; // type packages
+            if (!externalImports.has(dep)) {
+                issues.push({
+                    type: 'unused-dep',
+                    severity: 'info',
+                    file: 'package.json',
+                    symbol: dep,
+                    detail: `'${dep}' package.json'da var ama hiçbir dosyada import edilmiyor`,
+                    suggestion: `npm uninstall ${dep} (veya dolaylı kullanılıyorsa ignore et)`,
+                });
+            }
+        }
+        return issues;
+    }
+    // ── Helpers ────────────────────────────────────────────────
+    async collectSourceFiles() {
+        const files = [];
+        await this.walk(this.projectRoot, files);
+        return files;
+    }
+    async walk(dir, files) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                await this.walk(join(dir, entry.name), files);
+            }
+            else if (entry.isFile()) {
+                const ext = extname(entry.name).toLowerCase();
+                if (SOURCE_EXTS.has(ext)) {
+                    files.push(relative(this.projectRoot, join(dir, entry.name)).replace(/\\/g, '/'));
+                }
+            }
+        }
+    }
+    /**
+     * Relative import'u dosya yoluna çözümle.
+     * './foo.js' → 'src/foo.ts' (TypeScript .js → .ts mapping dahil)
+     */
+    resolveImportPath(fromFile, importPath, fileSet) {
+        if (!importPath.startsWith('.'))
+            return null; // external
+        const fromDir = dirname(fromFile);
+        const rawResolved = join(fromDir, importPath).replace(/\\/g, '/');
+        // Aday uzantılar: olduğu gibi, .ts, .tsx, .js→.ts, /index.ts
+        const candidates = [
+            rawResolved,
+            rawResolved.replace(/\.js$/, '.ts'),
+            rawResolved.replace(/\.js$/, '.tsx'),
+            rawResolved.replace(/\.jsx$/, '.tsx'),
+            `${rawResolved}.ts`,
+            `${rawResolved}.tsx`,
+            `${rawResolved}/index.ts`,
+            `${rawResolved}/index.tsx`,
+            `${rawResolved}/index.js`,
+        ];
+        for (const candidate of candidates) {
+            if (fileSet.has(candidate))
+                return candidate;
+        }
+        return null;
+    }
+    isEntryPoint(file) {
+        return /^(src\/)?index\.ts$/.test(file) ||
+            file.includes('bin/') ||
+            file.endsWith('.test.ts') ||
+            file.endsWith('.spec.ts');
+    }
+    isNodeBuiltin(name) {
+        const builtins = new Set([
+            'assert', 'buffer', 'child_process', 'cluster', 'console', 'constants',
+            'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https',
+            'module', 'net', 'os', 'path', 'perf_hooks', 'process', 'punycode',
+            'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'sys',
+            'timers', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'worker_threads', 'zlib',
+        ]);
+        return builtins.has(name);
+    }
+    findLineNumber(lines, charIndex) {
+        let count = 0;
+        for (let i = 0; i < lines.length; i++) {
+            count += lines[i].length + 1; // +1 for \n
+            if (count > charIndex)
+                return i + 1;
+        }
+        return lines.length;
+    }
+    inferExportKind(match) {
+        if (match.includes('function'))
+            return 'function';
+        if (match.includes('class'))
+            return 'class';
+        if (match.includes('type '))
+            return 'type';
+        if (match.includes('interface'))
+            return 'interface';
+        if (match.includes('enum'))
+            return 'enum';
+        return 'const';
+    }
+}
+//# sourceMappingURL=static-analyzer.js.map