synapsexcoder 6.0.0

package/dist/tools/deepwiki/extractor.js

@@ -0,0 +1,923 @@
+/**
+ * DeepWiki Tool - Documentation Extractor
+ *
+ * Extracts documentation from code and generates wiki content.
+ */
+// ============================================================================
+// Documentation Extractor
+// ============================================================================
+export class DocumentationExtractor {
+    analysis;
+    pageIdCounter = 0;
+    edgeIdCounter = 0;
+    constructor(analysis) {
+        this.analysis = analysis;
+    }
+    /**
+     * Extract all wiki pages from the analysis
+     */
+    extractAllPages() {
+        const pages = [];
+        // Generate overview page
+        pages.push(this.generateOverviewPage());
+        // Generate architecture page
+        pages.push(this.generateArchitecturePage());
+        // Generate module pages
+        for (const module of this.analysis.modules) {
+            pages.push(this.generateModulePage(module));
+        }
+        // Generate class pages
+        for (const cls of this.analysis.classes) {
+            pages.push(this.generateClassPage(cls));
+        }
+        // Generate function pages for significant functions
+        for (const func of this.analysis.functions) {
+            if (this.isSignificantFunction(func)) {
+                pages.push(this.generateFunctionPage(func));
+            }
+        }
+        // Generate interface pages
+        for (const iface of this.analysis.interfaces) {
+            pages.push(this.generateInterfacePage(iface));
+        }
+        // Generate pattern pages
+        for (const pattern of this.analysis.patterns) {
+            pages.push(this.generatePatternPage(pattern));
+        }
+        // Generate API reference page
+        pages.push(this.generateApiReferencePage());
+        // Generate getting started guide
+        pages.push(this.generateGettingStartedGuide());
+        return pages;
+    }
+    /**
+     * Extract knowledge graph from the analysis
+     */
+    extractKnowledgeGraph() {
+        const nodes = new Map();
+        const edges = [];
+        // Add module nodes
+        for (const module of this.analysis.modules) {
+            const node = this.createModuleNode(module);
+            nodes.set(node.id, node);
+        }
+        // Add class nodes
+        for (const cls of this.analysis.classes) {
+            const node = this.createClassNode(cls);
+            nodes.set(node.id, node);
+            // Add edge to module
+            const moduleId = this.getModuleId(cls.module);
+            if (moduleId) {
+                edges.push(this.createEdge(node.id, moduleId, "contains"));
+            }
+        }
+        // Add function nodes
+        for (const func of this.analysis.functions) {
+            const node = this.createFunctionNode(func);
+            nodes.set(node.id, node);
+            // Add edge to module
+            const moduleId = this.getModuleId(func.module);
+            if (moduleId) {
+                edges.push(this.createEdge(node.id, moduleId, "contains"));
+            }
+        }
+        // Add interface nodes
+        for (const iface of this.analysis.interfaces) {
+            const node = this.createInterfaceNode(iface);
+            nodes.set(node.id, node);
+            // Add edge to module
+            const moduleId = this.getModuleId(iface.module);
+            if (moduleId) {
+                edges.push(this.createEdge(node.id, moduleId, "contains"));
+            }
+        }
+        // Add dependency edges
+        for (const dep of this.analysis.dependencies) {
+            for (const user of dep.usedBy) {
+                const moduleId = this.getModuleId(user);
+                if (moduleId) {
+                    edges.push(this.createEdge(moduleId, `dep-${dep.name}`, "depends_on"));
+                }
+            }
+        }
+        // Add inheritance edges
+        for (const cls of this.analysis.classes) {
+            if (cls.extends) {
+                const classId = this.getClassId(cls.name);
+                const parentId = this.getClassId(cls.extends);
+                if (classId && parentId) {
+                    edges.push(this.createEdge(classId, parentId, "extends"));
+                }
+            }
+            for (const impl of cls.implements) {
+                const classId = this.getClassId(cls.name);
+                const interfaceId = this.getInterfaceId(impl);
+                if (classId && interfaceId) {
+                    edges.push(this.createEdge(classId, interfaceId, "implements"));
+                }
+            }
+        }
+        // Calculate metadata
+        const nodeTypes = {
+            module: 0,
+            class: 0,
+            function: 0,
+            interface: 0,
+            type: 0,
+            constant: 0,
+            config: 0,
+            concept: 0,
+            pattern: 0,
+            dependency: 0,
+        };
+        const connectionTypes = {
+            uses: 0,
+            extends: 0,
+            implements: 0,
+            depends_on: 0,
+            contains: 0,
+            calls: 0,
+            imports: 0,
+            related_to: 0,
+            alternative_to: 0,
+            conflicts_with: 0,
+        };
+        for (const node of nodes.values()) {
+            nodeTypes[node.type]++;
+        }
+        for (const edge of edges) {
+            connectionTypes[edge.type]++;
+        }
+        return {
+            nodes,
+            edges,
+            metadata: {
+                totalNodes: nodes.size,
+                totalEdges: edges.length,
+                nodeTypes,
+                connectionTypes,
+                generatedAt: Date.now(),
+            },
+        };
+    }
+    // ============================================================================
+    // Page Generators
+    // ============================================================================
+    /**
+     * Generate overview page
+     */
+    generateOverviewPage() {
+        const project = this.analysis.project;
+        const metrics = this.analysis.metrics;
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Project Overview",
+                level: 1,
+                content: `# ${project.name}\n\n${project.description || "No description provided."}`,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Quick Stats",
+                level: 2,
+                content: `| Metric | Value |\n|--------|-------|\n| Total Files | ${metrics.totalFiles} |\n| Total Lines | ${metrics.totalLines} |\n| Modules | ${metrics.totalModules} |\n| Classes | ${metrics.totalClasses} |\n| Functions | ${metrics.totalFunctions} |\n| Interfaces | ${metrics.totalInterfaces} |`,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Technologies",
+                level: 2,
+                content: `**Languages:** ${project.languages.join(", ")}\n\n**Frameworks:** ${project.frameworks.join(", ") || "None detected"}`,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Entry Points",
+                level: 2,
+                content: project.entryPoints.length > 0
+                    ? project.entryPoints.map((ep) => `- \`${ep}\``).join("\n")
+                    : "No entry points detected.",
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        return this.createPage("overview", "Project Overview", "overview", sections, ["overview", "introduction", project.name]);
+    }
+    /**
+     * Generate architecture page
+     */
+    generateArchitecturePage() {
+        const patterns = this.analysis.patterns;
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Architecture Overview",
+                level: 1,
+                content: "This document describes the high-level architecture of the project.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Module Structure",
+                level: 2,
+                content: this.generateModuleTree(),
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Design Patterns",
+                level: 2,
+                content: patterns.length > 0
+                    ? patterns
+                        .map((p) => `### ${p.name}\n\n${p.description}\n\n**Occurrences:** ${p.occurrences.length}`)
+                        .join("\n\n")
+                    : "No design patterns detected.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Dependencies",
+                level: 2,
+                content: this.generateDependencySummary(),
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        return this.createPage("architecture", "Architecture", "architecture", sections, ["architecture", "design", "structure"]);
+    }
+    /**
+     * Generate module page
+     */
+    generateModulePage(module) {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Module Overview",
+                level: 1,
+                content: `# ${module.name}\n\n**Path:** \`${module.path}\`\n\n${module.description || "No description provided."}`,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Statistics",
+                level: 2,
+                content: `| Metric | Value |\n|--------|-------|\n| Lines of Code | ${module.linesOfCode} |\n| Complexity | ${module.complexity} |\n| Classes | ${module.classes.length} |\n| Functions | ${module.functions.length} |\n| Interfaces | ${module.interfaces.length} |`,
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        // Add exports section
+        if (module.exports.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Exports",
+                level: 2,
+                content: module.exports.map((e) => `- \`${e}\``).join("\n"),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add imports section
+        if (module.imports.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Dependencies",
+                level: 2,
+                content: module.imports.map((i) => `- \`${i}\``).join("\n"),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        return this.createPage(`module-${module.name}`, module.name, "module", sections, ["module", module.name, ...module.exports], [module.path]);
+    }
+    /**
+     * Generate class page
+     */
+    generateClassPage(cls) {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Class Overview",
+                level: 1,
+                content: this.generateClassSignature(cls),
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        // Add description
+        if (cls.description) {
+            sections.push({
+                id: this.generateId(),
+                title: "Description",
+                level: 2,
+                content: cls.description,
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add properties section
+        if (cls.properties.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Properties",
+                level: 2,
+                content: this.generatePropertiesTable(cls.properties),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add methods section
+        if (cls.methods.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Methods",
+                level: 2,
+                content: this.generateMethodsDocumentation(cls.methods),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        return this.createPage(`class-${cls.name}`, cls.name, "class", sections, ["class", cls.name, cls.module], [cls.module]);
+    }
+    /**
+     * Generate function page
+     */
+    generateFunctionPage(func) {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Function Signature",
+                level: 1,
+                content: this.generateFunctionSignature(func),
+                codeBlocks: [
+                    {
+                        language: "typescript",
+                        code: this.generateFunctionCode(func),
+                        description: "Function signature",
+                    },
+                ],
+                subsections: [],
+            },
+        ];
+        // Add description
+        if (func.description) {
+            sections.push({
+                id: this.generateId(),
+                title: "Description",
+                level: 2,
+                content: func.description,
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add parameters section
+        if (func.parameters.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Parameters",
+                level: 2,
+                content: this.generateParametersTable(func.parameters),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add return type section
+        sections.push({
+            id: this.generateId(),
+            title: "Returns",
+            level: 2,
+            content: `\`${func.returnType}\``,
+            codeBlocks: [],
+            subsections: [],
+        });
+        return this.createPage(`function-${func.name}`, func.name, "function", sections, ["function", func.name, func.module], [func.module]);
+    }
+    /**
+     * Generate interface page
+     */
+    generateInterfacePage(iface) {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Interface Definition",
+                level: 1,
+                content: this.generateInterfaceSignature(iface),
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        // Add description
+        if (iface.description) {
+            sections.push({
+                id: this.generateId(),
+                title: "Description",
+                level: 2,
+                content: iface.description,
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add properties section
+        if (iface.properties.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Properties",
+                level: 2,
+                content: this.generatePropertiesTable(iface.properties),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        // Add methods section
+        if (iface.methods.length > 0) {
+            sections.push({
+                id: this.generateId(),
+                title: "Methods",
+                level: 2,
+                content: this.generateMethodsDocumentation(iface.methods),
+                codeBlocks: [],
+                subsections: [],
+            });
+        }
+        return this.createPage(`interface-${iface.name}`, iface.name, "interface", sections, ["interface", iface.name, iface.module], [iface.module]);
+    }
+    /**
+     * Generate pattern page
+     */
+    generatePatternPage(pattern) {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: `${pattern.name} Pattern`,
+                level: 1,
+                content: pattern.description,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Occurrences",
+                level: 2,
+                content: pattern.occurrences
+                    .map((o) => `- \`${o.file}\` (lines ${o.lineStart}-${o.lineEnd}): ${o.description}`)
+                    .join("\n"),
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Confidence",
+                level: 2,
+                content: `Detection confidence: **${Math.round(pattern.confidence * 100)}%**`,
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        return this.createPage(`pattern-${pattern.name.toLowerCase()}`, `${pattern.name} Pattern`, "concept", sections, ["pattern", pattern.name, pattern.type]);
+    }
+    /**
+     * Generate API reference page
+     */
+    generateApiReferencePage() {
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "API Reference",
+                level: 1,
+                content: "Complete API reference for all exported functions, classes, and interfaces.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Exported Classes",
+                level: 2,
+                content: this.analysis.classes
+                    .filter((c) => c.isExported)
+                    .map((c) => `- [[class-${c.name}|${c.name}]] - ${c.description || "No description"}`)
+                    .join("\n") || "No exported classes.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Exported Functions",
+                level: 2,
+                content: this.analysis.functions
+                    .filter((f) => f.isExported)
+                    .map((f) => `- [[function-${f.name}|${f.name}]] - ${f.description || "No description"}`)
+                    .join("\n") || "No exported functions.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Exported Interfaces",
+                level: 2,
+                content: this.analysis.interfaces
+                    .filter((i) => i.isExported)
+                    .map((i) => `- [[interface-${i.name}|${i.name}]] - ${i.description || "No description"}`)
+                    .join("\n") || "No exported interfaces.",
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        return this.createPage("api-reference", "API Reference", "reference", sections, ["api", "reference", "exports"]);
+    }
+    /**
+     * Generate getting started guide
+     */
+    generateGettingStartedGuide() {
+        const project = this.analysis.project;
+        const sections = [
+            {
+                id: this.generateId(),
+                title: "Getting Started",
+                level: 1,
+                content: `Welcome to ${project.name}! This guide will help you get started.`,
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Installation",
+                level: 2,
+                content: "```bash\nnpm install\n```",
+                codeBlocks: [
+                    {
+                        language: "bash",
+                        code: "npm install",
+                        description: "Install dependencies",
+                    },
+                ],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Running the Project",
+                level: 2,
+                content: project.entryPoints.length > 0
+                    ? `Entry points:\n${project.entryPoints.map((ep) => `- \`${ep}\``).join("\n")}`
+                    : "No entry points detected.",
+                codeBlocks: [],
+                subsections: [],
+            },
+            {
+                id: this.generateId(),
+                title: "Project Structure",
+                level: 2,
+                content: this.generateModuleTree(),
+                codeBlocks: [],
+                subsections: [],
+            },
+        ];
+        return this.createPage("getting-started", "Getting Started", "guide", sections, ["guide", "tutorial", "getting-started"]);
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    /**
+     * Create a wiki page
+     */
+    createPage(id, title, category, sections, tags, sourceFiles = []) {
+        const content = sections.map((s) => s.content).join("\n\n");
+        const summary = this.generateSummary(content);
+        return {
+            id,
+            title,
+            slug: this.slugify(title),
+            content,
+            summary,
+            category,
+            tags,
+            links: this.extractLinks(content),
+            metadata: {
+                sourceFiles,
+                complexity: "intermediate",
+                estimatedReadTime: Math.ceil(content.length / 1000),
+                lastVerified: Date.now(),
+                contributors: [],
+                status: "published",
+            },
+            sections,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+    }
+    /**
+     * Generate a unique ID
+     */
+    generateId() {
+        return `id-${++this.pageIdCounter}`;
+    }
+    /**
+     * Generate a slug from a title
+     */
+    slugify(title) {
+        return title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-|-$/g, "");
+    }
+    /**
+     * Generate a summary from content
+     */
+    generateSummary(content) {
+        const plainText = content
+            .replace(/#{1,6}\s+/g, "")
+            .replace(/\*\*/g, "")
+            .replace(/\[\[.*?\]\]/g, "")
+            .replace(/`[^`]+`/g, "");
+        const firstParagraph = plainText.split("\n\n")[0] || "";
+        return (firstParagraph.substring(0, 200) +
+            (firstParagraph.length > 200 ? "..." : ""));
+    }
+    /**
+     * Extract links from content
+     */
+    extractLinks(content) {
+        const links = [];
+        const linkRegex = /\[\[(.*?)(?:\|(.*?))?\]\]/g;
+        let match;
+        while ((match = linkRegex.exec(content)) !== null) {
+            links.push({
+                targetId: match[1],
+                targetSlug: this.slugify(match[1]),
+                text: match[2] || match[1],
+                type: "internal",
+            });
+        }
+        return links;
+    }
+    /**
+     * Check if a function is significant enough for its own page
+     */
+    isSignificantFunction(func) {
+        return func.isExported || func.description.length > 50;
+    }
+    /**
+     * Generate module tree
+     */
+    generateModuleTree() {
+        const tree = {};
+        for (const module of this.analysis.modules) {
+            const parts = module.path.split("/");
+            const dir = parts.slice(0, -1).join("/") || "/";
+            if (!tree[dir])
+                tree[dir] = [];
+            tree[dir].push(parts[parts.length - 1]);
+        }
+        let output = "```\n";
+        for (const [dir, files] of Object.entries(tree).sort()) {
+            output += `${dir}/\n`;
+            for (const file of files.sort()) {
+                output += `  ├── ${file}\n`;
+            }
+        }
+        output += "```";
+        return output;
+    }
+    /**
+     * Generate dependency summary
+     */
+    generateDependencySummary() {
+        const prodDeps = this.analysis.dependencies.filter((d) => d.type === "production");
+        const devDeps = this.analysis.dependencies.filter((d) => d.type === "development");
+        let output = `**Production Dependencies:** ${prodDeps.length}\n\n`;
+        output += `**Development Dependencies:** ${devDeps.length}\n\n`;
+        if (prodDeps.length > 0) {
+            output += "### Production\n\n";
+            output += prodDeps
+                .map((d) => `- \`${d.name}\` (${d.version})`)
+                .join("\n");
+        }
+        return output;
+    }
+    /**
+     * Generate class signature
+     */
+    generateClassSignature(cls) {
+        let sig = "";
+        if (cls.isExported)
+            sig += "export ";
+        if (cls.isAbstract)
+            sig += "abstract ";
+        sig += `class ${cls.name}`;
+        if (cls.extends)
+            sig += ` extends ${cls.extends}`;
+        if (cls.implements.length > 0)
+            sig += ` implements ${cls.implements.join(", ")}`;
+        return `\`${sig}\``;
+    }
+    /**
+     * Generate function signature
+     */
+    generateFunctionSignature(func) {
+        let sig = "";
+        if (func.isExported)
+            sig += "export ";
+        if (func.isAsync)
+            sig += "async ";
+        sig += `function ${func.name}(`;
+        sig += func.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
+        sig += `): ${func.returnType}`;
+        return `\`${sig}\``;
+    }
+    /**
+     * Generate function code
+     */
+    generateFunctionCode(func) {
+        let code = "";
+        if (func.isExported)
+            code += "export ";
+        if (func.isAsync)
+            code += "async ";
+        code += `function ${func.name}(\n`;
+        code += func.parameters.map((p) => `  ${p.name}: ${p.type},`).join("\n");
+        code += `\n): ${func.returnType} {\n  // Implementation\n}`;
+        return code;
+    }
+    /**
+     * Generate interface signature
+     */
+    generateInterfaceSignature(iface) {
+        let sig = "";
+        if (iface.isExported)
+            sig += "export ";
+        sig += `interface ${iface.name}`;
+        if (iface.extends.length > 0)
+            sig += ` extends ${iface.extends.join(", ")}`;
+        return `\`${sig}\``;
+    }
+    /**
+     * Generate properties table
+     */
+    generatePropertiesTable(properties) {
+        let table = "| Name | Type | Visibility | Description |\n";
+        table += "|------|------|------------|-------------|\n";
+        for (const prop of properties) {
+            table += `| \`${prop.name}\` | \`${prop.type}\` | ${prop.visibility} | ${prop.description || "-"} |\n`;
+        }
+        return table;
+    }
+    /**
+     * Generate methods documentation
+     */
+    generateMethodsDocumentation(methods) {
+        let doc = "";
+        for (const method of methods) {
+            doc += `### \`${method.name}\`\n\n`;
+            if (method.description) {
+                doc += `${method.description}\n\n`;
+            }
+            doc += `**Signature:** \`${method.visibility} ${method.isStatic ? "static " : ""}${method.isAsync ? "async " : ""}${method.name}(${method.parameters.map((p) => `${p.name}: ${p.type}`).join(", ")}): ${method.returnType}\`\n\n`;
+            if (method.parameters.length > 0) {
+                doc += "**Parameters:**\n\n";
+                for (const param of method.parameters) {
+                    doc += `- \`${param.name}\` (\`${param.type}\`)${param.isOptional ? " (optional)" : ""}: ${param.description || "No description"}\n`;
+                }
+                doc += "\n";
+            }
+        }
+        return doc;
+    }
+    /**
+     * Generate parameters table
+     */
+    generateParametersTable(parameters) {
+        let table = "| Name | Type | Optional | Description |\n";
+        table += "|------|------|----------|-------------|\n";
+        for (const param of parameters) {
+            table += `| \`${param.name}\` | \`${param.type}\` | ${param.isOptional ? "Yes" : "No"} | ${param.description || "-"} |\n`;
+        }
+        return table;
+    }
+    // ============================================================================
+    // Knowledge Graph Helpers
+    // ============================================================================
+    /**
+     * Create a module node
+     */
+    createModuleNode(module) {
+        return {
+            id: `module-${module.name}`,
+            type: "module",
+            name: module.name,
+            description: module.description,
+            properties: {
+                path: module.path,
+                linesOfCode: module.linesOfCode,
+                complexity: module.complexity,
+            },
+            connections: [],
+            pageId: `module-${module.name}`,
+        };
+    }
+    /**
+     * Create a class node
+     */
+    createClassNode(cls) {
+        return {
+            id: `class-${cls.name}`,
+            type: "class",
+            name: cls.name,
+            description: cls.description,
+            properties: {
+                module: cls.module,
+                isAbstract: cls.isAbstract,
+                isExported: cls.isExported,
+                methodCount: cls.methods.length,
+                propertyCount: cls.properties.length,
+            },
+            connections: [],
+            pageId: `class-${cls.name}`,
+        };
+    }
+    /**
+     * Create a function node
+     */
+    createFunctionNode(func) {
+        return {
+            id: `function-${func.name}`,
+            type: "function",
+            name: func.name,
+            description: func.description,
+            properties: {
+                module: func.module,
+                isAsync: func.isAsync,
+                isExported: func.isExported,
+                parameterCount: func.parameters.length,
+            },
+            connections: [],
+            pageId: `function-${func.name}`,
+        };
+    }
+    /**
+     * Create an interface node
+     */
+    createInterfaceNode(iface) {
+        return {
+            id: `interface-${iface.name}`,
+            type: "interface",
+            name: iface.name,
+            description: iface.description,
+            properties: {
+                module: iface.module,
+                isExported: iface.isExported,
+                propertyCount: iface.properties.length,
+                methodCount: iface.methods.length,
+            },
+            connections: [],
+            pageId: `interface-${iface.name}`,
+        };
+    }
+    /**
+     * Create an edge
+     */
+    createEdge(sourceId, targetId, type) {
+        return {
+            id: `edge-${++this.edgeIdCounter}`,
+            sourceId,
+            targetId,
+            type,
+            weight: 1,
+        };
+    }
+    /**
+     * Get module ID from path
+     */
+    getModuleId(path) {
+        const module = this.analysis.modules.find((m) => m.path === path);
+        return module ? `module-${module.name}` : undefined;
+    }
+    /**
+     * Get class ID from name
+     */
+    getClassId(name) {
+        const cls = this.analysis.classes.find((c) => c.name === name);
+        return cls ? `class-${cls.name}` : undefined;
+    }
+    /**
+     * Get interface ID from name
+     */
+    getInterfaceId(name) {
+        const iface = this.analysis.interfaces.find((i) => i.name === name);
+        return iface ? `interface-${iface.name}` : undefined;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createDocumentationExtractor(analysis) {
+    return new DocumentationExtractor(analysis);
+}
+export default DocumentationExtractor;
+//# sourceMappingURL=extractor.js.map