synapsexcoder 6.0.0

package/dist/tools/deepwiki/analyzer.js

@@ -0,0 +1,925 @@
+/**
+ * DeepWiki Tool - Code Analyzer
+ *
+ * Analyzes codebase structure and extracts information for documentation.
+ */
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { extname, basename, relative, join } from "path";
+// ============================================================================
+// Constants
+// ============================================================================
+const SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+// ============================================================================
+// Analyzer Class
+// ============================================================================
+export class DeepWikiAnalyzer {
+    config;
+    files = [];
+    cache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Analyze the entire codebase
+     */
+    async analyze() {
+        // Discover files
+        this.files = this.discoverFiles(this.config.rootPath);
+        // Analyze project
+        const project = this.analyzeProject();
+        // Analyze modules
+        const modules = this.analyzeModules();
+        // Analyze classes
+        const classes = this.analyzeClasses();
+        // Analyze functions
+        const functions = this.analyzeFunctions();
+        // Analyze interfaces
+        const interfaces = this.analyzeInterfaces();
+        // Analyze dependencies
+        const dependencies = this.analyzeDependencies();
+        // Detect patterns
+        const patterns = this.detectPatterns();
+        // Calculate metrics
+        const metrics = this.calculateMetrics(modules, classes, functions, interfaces);
+        return {
+            project,
+            modules,
+            classes,
+            functions,
+            interfaces,
+            dependencies,
+            patterns,
+            metrics,
+        };
+    }
+    /**
+     * Discover all relevant files in the project
+     */
+    discoverFiles(dirPath, depth = 0) {
+        if (depth > this.config.maxDepth)
+            return [];
+        const files = [];
+        try {
+            const entries = readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dirPath, entry.name);
+                const relativePath = relative(this.config.rootPath, fullPath);
+                // Check exclusions
+                if (this.shouldExclude(relativePath))
+                    continue;
+                if (entry.isDirectory()) {
+                    files.push(...this.discoverFiles(fullPath, depth + 1));
+                }
+                else if (entry.isFile() && this.isSupportedFile(fullPath)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+        return files;
+    }
+    /**
+     * Check if a file should be excluded
+     */
+    shouldExclude(path) {
+        for (const pattern of this.config.exclude) {
+            if (this.matchGlob(path, pattern))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Check if a file is supported
+     */
+    isSupportedFile(path) {
+        const ext = extname(path);
+        return SUPPORTED_EXTENSIONS.includes(ext);
+    }
+    /**
+     * Simple glob matching
+     */
+    matchGlob(path, pattern) {
+        const regex = pattern
+            .replace(/\*\*/g, ".*")
+            .replace(/\*/g, "[^/]*")
+            .replace(/\?/g, ".");
+        return new RegExp(`^${regex}$`).test(path);
+    }
+    /**
+     * Read file content with caching
+     */
+    readFile(filePath) {
+        if (this.cache.has(filePath)) {
+            return this.cache.get(filePath);
+        }
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            this.cache.set(filePath, content);
+            return content;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Analyze project information
+     */
+    analyzeProject() {
+        const packageJsonPath = join(this.config.rootPath, "package.json");
+        let name = basename(this.config.rootPath);
+        let version = "0.0.0";
+        let description = "";
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+                name = packageJson.name || name;
+                version = packageJson.version || version;
+                description = packageJson.description || description;
+            }
+            catch {
+                // Use defaults
+            }
+        }
+        // Detect languages
+        const languages = new Set();
+        for (const file of this.files) {
+            const ext = extname(file);
+            switch (ext) {
+                case ".ts":
+                case ".tsx":
+                    languages.add("TypeScript");
+                    break;
+                case ".js":
+                case ".jsx":
+                case ".mjs":
+                case ".cjs":
+                    languages.add("JavaScript");
+                    break;
+            }
+        }
+        // Detect frameworks
+        const frameworks = this.detectFrameworks();
+        // Find entry points
+        const entryPoints = this.findEntryPoints();
+        return {
+            name,
+            version,
+            description,
+            rootPath: this.config.rootPath,
+            languages: Array.from(languages),
+            frameworks,
+            entryPoints,
+        };
+    }
+    /**
+     * Detect frameworks used in the project
+     */
+    detectFrameworks() {
+        const frameworks = [];
+        const packageJsonPath = join(this.config.rootPath, "package.json");
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+                const allDeps = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies,
+                };
+                const frameworkPatterns = {
+                    react: "React",
+                    vue: "Vue.js",
+                    angular: "Angular",
+                    svelte: "Svelte",
+                    next: "Next.js",
+                    nuxt: "Nuxt.js",
+                    express: "Express.js",
+                    fastify: "Fastify",
+                    nest: "NestJS",
+                    koa: "Koa.js",
+                    vitest: "Vitest",
+                    jest: "Jest",
+                    mocha: "Mocha",
+                    typescript: "TypeScript",
+                };
+                for (const [pkg, framework] of Object.entries(frameworkPatterns)) {
+                    if (allDeps[pkg]) {
+                        frameworks.push(framework);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return frameworks;
+    }
+    /**
+     * Find entry points
+     */
+    findEntryPoints() {
+        const entryPoints = [];
+        const candidates = [
+            "index.ts",
+            "index.js",
+            "src/index.ts",
+            "src/index.js",
+            "main.ts",
+            "main.js",
+            "src/main.ts",
+            "src/main.js",
+            "app.ts",
+            "app.js",
+            "src/app.ts",
+            "src/app.js",
+        ];
+        for (const candidate of candidates) {
+            const fullPath = join(this.config.rootPath, candidate);
+            if (existsSync(fullPath)) {
+                entryPoints.push(candidate);
+            }
+        }
+        return entryPoints;
+    }
+    /**
+     * Analyze all modules
+     */
+    analyzeModules() {
+        const modules = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            const moduleInfo = this.analyzeModule(file, content);
+            modules.push(moduleInfo);
+        }
+        return modules;
+    }
+    /**
+     * Analyze a single module
+     */
+    analyzeModule(filePath, content) {
+        const relativePath = relative(this.config.rootPath, filePath);
+        const name = basename(filePath, extname(filePath));
+        // Extract imports
+        const imports = this.extractImports(content);
+        // Extract exports
+        const exports = this.extractExports(content);
+        // Extract classes
+        const classes = this.extractClassNames(content);
+        // Extract functions
+        const functions = this.extractFunctionNames(content);
+        // Extract interfaces
+        const interfaces = this.extractInterfaceNames(content);
+        // Extract types
+        const types = this.extractTypeNames(content);
+        // Calculate complexity
+        const complexity = this.calculateFileComplexity(content);
+        // Count lines
+        const linesOfCode = content.split("\n").length;
+        // Extract description from first JSDoc comment
+        const description = this.extractFileDescription(content);
+        return {
+            path: relativePath,
+            name,
+            description,
+            exports,
+            imports,
+            classes,
+            functions,
+            interfaces,
+            types,
+            complexity,
+            linesOfCode,
+        };
+    }
+    /**
+     * Extract imports from content
+     */
+    extractImports(content) {
+        const imports = [];
+        let match;
+        const importRegex = /import\s+(?:{([^}]+)}|(\w+)|\*\s+as\s+(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+        while ((match = importRegex.exec(content)) !== null) {
+            const modulePath = match[4];
+            if (modulePath && !modulePath.startsWith(".")) {
+                imports.push(modulePath);
+            }
+        }
+        return [...new Set(imports)];
+    }
+    /**
+     * Extract exports from content
+     */
+    extractExports(content) {
+        const exports = [];
+        let match;
+        const exportRegex = /export\s+(?:default\s+)?(?:class|interface|function|const|let|var|type|enum)\s+(\w+)/g;
+        while ((match = exportRegex.exec(content)) !== null) {
+            if (match[1]) {
+                exports.push(match[1]);
+            }
+        }
+        return [...new Set(exports)];
+    }
+    /**
+     * Extract class names from content
+     */
+    extractClassNames(content) {
+        const classes = [];
+        let match;
+        const classRegex = /class\s+(\w+)/g;
+        while ((match = classRegex.exec(content)) !== null) {
+            if (match[1]) {
+                classes.push(match[1]);
+            }
+        }
+        return classes;
+    }
+    /**
+     * Extract function names from content
+     */
+    extractFunctionNames(content) {
+        const functions = [];
+        let match;
+        // Named functions
+        const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)/g;
+        while ((match = funcRegex.exec(content)) !== null) {
+            if (match[1]) {
+                functions.push(match[1]);
+            }
+        }
+        // Arrow functions
+        const arrowRegex = /(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/g;
+        while ((match = arrowRegex.exec(content)) !== null) {
+            if (match[1] && !functions.includes(match[1])) {
+                functions.push(match[1]);
+            }
+        }
+        return functions;
+    }
+    /**
+     * Extract interface names from content
+     */
+    extractInterfaceNames(content) {
+        const interfaces = [];
+        let match;
+        const interfaceRegex = /interface\s+(\w+)/g;
+        while ((match = interfaceRegex.exec(content)) !== null) {
+            if (match[1]) {
+                interfaces.push(match[1]);
+            }
+        }
+        return interfaces;
+    }
+    /**
+     * Extract type names from content
+     */
+    extractTypeNames(content) {
+        const types = [];
+        let match;
+        const typeRegex = /type\s+(\w+)/g;
+        while ((match = typeRegex.exec(content)) !== null) {
+            if (match[1]) {
+                types.push(match[1]);
+            }
+        }
+        return types;
+    }
+    /**
+     * Calculate file complexity
+     */
+    calculateFileComplexity(content) {
+        let complexity = 1;
+        // Count decision points
+        const decisionPatterns = [
+            /\bif\s*\(/g,
+            /\belse\s+if\s*\(/g,
+            /\bfor\s*\(/g,
+            /\bwhile\s*\(/g,
+            /\bcase\s+/g,
+            /\bcatch\s*\(/g,
+            /\?\s*[^:]/g, // Ternary operators
+            /&&/g,
+            /\|\|/g,
+        ];
+        for (const pattern of decisionPatterns) {
+            const matches = content.match(pattern);
+            if (matches) {
+                complexity += matches.length;
+            }
+        }
+        return complexity;
+    }
+    /**
+     * Extract file description from first JSDoc comment
+     */
+    extractFileDescription(content) {
+        const jsdocRegex = /\/\*\*([\s\S]*?)\*\//;
+        const match = content.match(jsdocRegex);
+        if (match) {
+            const jsdoc = match[1].replace(/^\s*\*\s?/gm, "").trim();
+            return jsdoc.split("\n")[0] || "";
+        }
+        return "";
+    }
+    /**
+     * Analyze all classes
+     */
+    analyzeClasses() {
+        const classes = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            const fileClasses = this.extractClasses(file, content);
+            classes.push(...fileClasses);
+        }
+        return classes;
+    }
+    /**
+     * Extract classes from file content
+     */
+    extractClasses(filePath, content) {
+        const classes = [];
+        const lines = content.split("\n");
+        const relativePath = relative(this.config.rootPath, filePath);
+        let currentClass = null;
+        let braceCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Check for class declaration
+            const classMatch = line.match(/(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?\s*\{/);
+            if (classMatch) {
+                currentClass = {
+                    name: classMatch[1],
+                    module: relativePath,
+                    description: this.extractJsDocAbove(lines, i),
+                    methods: [],
+                    properties: [],
+                    extends: classMatch[2],
+                    implements: classMatch[3]?.split(",").map((s) => s.trim()) || [],
+                    isAbstract: line.includes("abstract"),
+                    isExported: line.includes("export"),
+                    lineStart: i + 1,
+                    lineEnd: 0,
+                };
+                braceCount = 1;
+                continue;
+            }
+            if (currentClass) {
+                // Count braces
+                braceCount += (line.match(/\{/g) || []).length;
+                braceCount -= (line.match(/\}/g) || []).length;
+                // Check for method
+                const methodMatch = line.match(/^\s+(public|private|protected)?\s*(static)?\s*(async)?\s*(\w+)\s*\(([^)]*)\)\s*(?::\s*(\w+))?\s*\{/);
+                if (methodMatch && currentClass.methods) {
+                    currentClass.methods.push({
+                        name: methodMatch[4],
+                        description: "",
+                        parameters: this.parseParameters(methodMatch[5]),
+                        returnType: methodMatch[6] || "void",
+                        visibility: methodMatch[1] ||
+                            "public",
+                        isStatic: !!methodMatch[2],
+                        isAsync: !!methodMatch[3],
+                        lineStart: i + 1,
+                        lineEnd: 0,
+                    });
+                }
+                // Check for property
+                const propertyMatch = line.match(/^\s+(public|private|protected)?\s*(static)?\s*(readonly)?\s*(\w+)\s*:\s*([^;=]+)/);
+                if (propertyMatch && currentClass.properties) {
+                    currentClass.properties.push({
+                        name: propertyMatch[4],
+                        description: "",
+                        type: propertyMatch[5].trim(),
+                        visibility: propertyMatch[1] ||
+                            "public",
+                        isStatic: !!propertyMatch[2],
+                        isReadonly: !!propertyMatch[3],
+                    });
+                }
+                // Check if class ended
+                if (braceCount === 0) {
+                    currentClass.lineEnd = i + 1;
+                    classes.push(currentClass);
+                    currentClass = null;
+                }
+            }
+        }
+        return classes;
+    }
+    /**
+     * Extract JSDoc comment above a line
+     */
+    extractJsDocAbove(lines, lineIndex) {
+        let jsdoc = "";
+        let i = lineIndex - 1;
+        // Skip empty lines
+        while (i >= 0 && lines[i].trim() === "")
+            i--;
+        // Check for JSDoc end
+        if (i >= 0 && lines[i].includes("*/")) {
+            const jsdocLines = [];
+            while (i >= 0) {
+                jsdocLines.unshift(lines[i]);
+                if (lines[i].includes("/**"))
+                    break;
+                i--;
+            }
+            jsdoc = jsdocLines
+                .join("\n")
+                .replace(/\/\*\*|\*\//g, "")
+                .replace(/^\s*\*\s?/gm, "")
+                .trim();
+        }
+        return jsdoc;
+    }
+    /**
+     * Parse function parameters
+     */
+    parseParameters(params) {
+        if (!params.trim())
+            return [];
+        return params.split(",").map((param) => {
+            const parts = param.trim().split(":");
+            const name = parts[0]?.replace(/\??$/, "").trim() || "";
+            const type = parts[1]?.trim() || "any";
+            const isOptional = param.includes("?") || param.includes("=");
+            return {
+                name,
+                type,
+                description: "",
+                isOptional,
+            };
+        });
+    }
+    /**
+     * Analyze all functions
+     */
+    analyzeFunctions() {
+        const functions = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            const fileFunctions = this.extractFunctions(file, content);
+            functions.push(...fileFunctions);
+        }
+        return functions;
+    }
+    /**
+     * Extract functions from file content
+     */
+    extractFunctions(filePath, content) {
+        const functions = [];
+        const relativePath = relative(this.config.rootPath, filePath);
+        const lines = content.split("\n");
+        // Named functions
+        const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*(\w+))?\s*\{/g;
+        let match;
+        while ((match = funcRegex.exec(content)) !== null) {
+            const lineNumber = content.substring(0, match.index).split("\n").length;
+            functions.push({
+                name: match[1],
+                module: relativePath,
+                description: this.extractJsDocAbove(lines, lineNumber - 1),
+                parameters: this.parseParameters(match[2]),
+                returnType: match[3] || "void",
+                isExported: match[0].includes("export"),
+                isAsync: match[0].includes("async"),
+                lineStart: lineNumber,
+                lineEnd: 0,
+            });
+        }
+        return functions;
+    }
+    /**
+     * Analyze all interfaces
+     */
+    analyzeInterfaces() {
+        const interfaces = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            const fileInterfaces = this.extractInterfaces(file, content);
+            interfaces.push(...fileInterfaces);
+        }
+        return interfaces;
+    }
+    /**
+     * Extract interfaces from file content
+     */
+    extractInterfaces(filePath, content) {
+        const interfaces = [];
+        const relativePath = relative(this.config.rootPath, filePath);
+        const lines = content.split("\n");
+        const interfaceRegex = /(?:export\s+)?interface\s+(\w+)(?:\s+extends\s+([\w,\s]+))?\s*\{/g;
+        let match;
+        while ((match = interfaceRegex.exec(content)) !== null) {
+            const lineNumber = content.substring(0, match.index).split("\n").length;
+            // Find interface body
+            let braceCount = 1;
+            let endIndex = lineNumber;
+            for (let i = lineNumber; i < lines.length; i++) {
+                braceCount += (lines[i].match(/\{/g) || []).length;
+                braceCount -= (lines[i].match(/\}/g) || []).length;
+                if (braceCount === 0) {
+                    endIndex = i + 1;
+                    break;
+                }
+            }
+            // Extract properties and methods from interface body
+            const interfaceBody = lines.slice(lineNumber - 1, endIndex).join("\n");
+            const properties = this.extractInterfaceProperties(interfaceBody);
+            const methods = this.extractInterfaceMethods(interfaceBody);
+            interfaces.push({
+                name: match[1],
+                module: relativePath,
+                description: this.extractJsDocAbove(lines, lineNumber - 1),
+                properties,
+                methods,
+                extends: match[2]?.split(",").map((s) => s.trim()) || [],
+                isExported: match[0].includes("export"),
+                lineStart: lineNumber,
+                lineEnd: endIndex,
+            });
+        }
+        return interfaces;
+    }
+    /**
+     * Extract properties from interface body
+     */
+    extractInterfaceProperties(body) {
+        const properties = [];
+        const propRegex = /^\s+(\w+)\??\s*:\s*([^;]+)/gm;
+        let match;
+        while ((match = propRegex.exec(body)) !== null) {
+            properties.push({
+                name: match[1],
+                description: "",
+                type: match[2].trim(),
+                visibility: "public",
+                isStatic: false,
+                isReadonly: body.includes(`readonly ${match[1]}`),
+            });
+        }
+        return properties;
+    }
+    /**
+     * Extract methods from interface body
+     */
+    extractInterfaceMethods(body) {
+        const methods = [];
+        const methodRegex = /^\s+(\w+)\s*\(([^)]*)\)\s*:\s*([^;]+)/gm;
+        let match;
+        while ((match = methodRegex.exec(body)) !== null) {
+            methods.push({
+                name: match[1],
+                description: "",
+                parameters: this.parseParameters(match[2]),
+                returnType: match[3].trim(),
+                visibility: "public",
+                isStatic: false,
+                isAsync: false,
+                lineStart: 0,
+                lineEnd: 0,
+            });
+        }
+        return methods;
+    }
+    /**
+     * Analyze dependencies
+     */
+    analyzeDependencies() {
+        const dependencies = [];
+        const packageJsonPath = join(this.config.rootPath, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            return dependencies;
+        }
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            // Production dependencies
+            if (packageJson.dependencies) {
+                for (const [name, version] of Object.entries(packageJson.dependencies)) {
+                    dependencies.push({
+                        name,
+                        version: version,
+                        type: "production",
+                        description: "",
+                        usedBy: this.findDependencyUsage(name),
+                    });
+                }
+            }
+            // Development dependencies
+            if (packageJson.devDependencies) {
+                for (const [name, version] of Object.entries(packageJson.devDependencies)) {
+                    dependencies.push({
+                        name,
+                        version: version,
+                        type: "development",
+                        description: "",
+                        usedBy: this.findDependencyUsage(name),
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return dependencies;
+    }
+    /**
+     * Find which files use a dependency
+     */
+    findDependencyUsage(depName) {
+        const usedBy = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if ((content && content.includes(`from "${depName}"`)) ||
+                content.includes(`from '${depName}'`)) {
+                usedBy.push(relative(this.config.rootPath, file));
+            }
+        }
+        return usedBy;
+    }
+    /**
+     * Detect patterns in the codebase
+     */
+    detectPatterns() {
+        const patterns = [];
+        // Detect singleton pattern
+        const singletonPattern = this.detectSingletonPattern();
+        if (singletonPattern)
+            patterns.push(singletonPattern);
+        // Detect factory pattern
+        const factoryPattern = this.detectFactoryPattern();
+        if (factoryPattern)
+            patterns.push(factoryPattern);
+        // Detect observer pattern
+        const observerPattern = this.detectObserverPattern();
+        if (observerPattern)
+            patterns.push(observerPattern);
+        // Detect middleware pattern
+        const middlewarePattern = this.detectMiddlewarePattern();
+        if (middlewarePattern)
+            patterns.push(middlewarePattern);
+        return patterns;
+    }
+    /**
+     * Detect singleton pattern
+     */
+    detectSingletonPattern() {
+        const occurrences = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            // Look for singleton indicators
+            if (content.includes("private static instance") ||
+                content.includes("static getInstance") ||
+                content.includes("private constructor")) {
+                occurrences.push({
+                    file: relative(this.config.rootPath, file),
+                    lineStart: 1,
+                    lineEnd: content.split("\n").length,
+                    description: "Singleton pattern detected",
+                });
+            }
+        }
+        if (occurrences.length === 0)
+            return null;
+        return {
+            name: "Singleton",
+            type: "singleton",
+            description: "Ensures a class has only one instance and provides a global point of access to it",
+            occurrences,
+            confidence: 0.8,
+        };
+    }
+    /**
+     * Detect factory pattern
+     */
+    detectFactoryPattern() {
+        const occurrences = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            // Look for factory indicators
+            if (content.includes("create") &&
+                (content.includes("Factory") || content.includes("factory"))) {
+                occurrences.push({
+                    file: relative(this.config.rootPath, file),
+                    lineStart: 1,
+                    lineEnd: content.split("\n").length,
+                    description: "Factory pattern detected",
+                });
+            }
+        }
+        if (occurrences.length === 0)
+            return null;
+        return {
+            name: "Factory",
+            type: "factory",
+            description: "Provides an interface for creating objects without specifying their concrete classes",
+            occurrences,
+            confidence: 0.7,
+        };
+    }
+    /**
+     * Detect observer pattern
+     */
+    detectObserverPattern() {
+        const occurrences = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            // Look for observer indicators
+            if ((content.includes("subscribe") || content.includes("on(")) &&
+                (content.includes("emit") || content.includes("publish"))) {
+                occurrences.push({
+                    file: relative(this.config.rootPath, file),
+                    lineStart: 1,
+                    lineEnd: content.split("\n").length,
+                    description: "Observer pattern detected",
+                });
+            }
+        }
+        if (occurrences.length === 0)
+            return null;
+        return {
+            name: "Observer",
+            type: "observer",
+            description: "Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified",
+            occurrences,
+            confidence: 0.75,
+        };
+    }
+    /**
+     * Detect middleware pattern
+     */
+    detectMiddlewarePattern() {
+        const occurrences = [];
+        for (const file of this.files) {
+            const content = this.readFile(file);
+            if (!content)
+                continue;
+            // Look for middleware indicators
+            if (content.includes("middleware") ||
+                content.includes("use(") ||
+                content.includes("next()")) {
+                occurrences.push({
+                    file: relative(this.config.rootPath, file),
+                    lineStart: 1,
+                    lineEnd: content.split("\n").length,
+                    description: "Middleware pattern detected",
+                });
+            }
+        }
+        if (occurrences.length === 0)
+            return null;
+        return {
+            name: "Middleware",
+            type: "middleware",
+            description: "Allows behavior to be added to an object dynamically without affecting other objects",
+            occurrences,
+            confidence: 0.8,
+        };
+    }
+    /**
+     * Calculate codebase metrics
+     */
+    calculateMetrics(modules, classes, functions, interfaces) {
+        const totalLines = modules.reduce((sum, m) => sum + m.linesOfCode, 0);
+        const totalComplexity = modules.reduce((sum, m) => sum + m.complexity, 0);
+        return {
+            totalFiles: this.files.length,
+            totalLines,
+            totalModules: modules.length,
+            totalClasses: classes.length,
+            totalFunctions: functions.length,
+            totalInterfaces: interfaces.length,
+            averageComplexity: modules.length > 0 ? totalComplexity / modules.length : 0,
+            documentationCoverage: this.calculateDocumentationCoverage(modules),
+        };
+    }
+    /**
+     * Calculate documentation coverage
+     */
+    calculateDocumentationCoverage(modules) {
+        const documented = modules.filter((m) => m.description.length > 0).length;
+        return modules.length > 0 ? (documented / modules.length) * 100 : 0;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createDeepWikiAnalyzer(config) {
+    return new DeepWikiAnalyzer(config);
+}
+export default DeepWikiAnalyzer;
+//# sourceMappingURL=analyzer.js.map