codehere 0.2.2 → 0.3.0-rc.10

package/dist/domain/services/knowledge-extractor.js

@@ -1,247 +0,0 @@
-/**
- * Domain Service: Knowledge Extractor
- * Extracts knowledge from code, comments, and structure
- *
- * Clean Architecture: Domain Layer
- *
- * Responsibilities:
- * - Extract domain knowledge from code comments
- * - Extract architectural knowledge from code structure
- * - Extract conventions from patterns
- * - Extract best practices from codebase
- */
-import { readFileSync, existsSync } from 'fs';
-import { randomUUID } from 'crypto';
-/**
- * Knowledge Extractor Service
- * Extracts various types of knowledge from codebases
- */
-export class KnowledgeExtractor {
-    knowledgeRepository;
-    patternRepository;
-    aiService;
-    constructor(knowledgeRepository, patternRepository, aiService) {
-        this.knowledgeRepository = knowledgeRepository;
-        this.patternRepository = patternRepository;
-        this.aiService = aiService;
-    }
-    /**
-     * Extract knowledge from code comments
-     */
-    async extractFromComments(filepath, codebaseId, codebasePath) {
-        if (!existsSync(filepath)) {
-            return [];
-        }
-        const content = readFileSync(filepath, 'utf-8');
-        const knowledge = [];
-        // Extract JSDoc/TSDoc comments
-        const docCommentPattern = /\/\*\*([\s\S]*?)\*\//g;
-        const docMatches = [...content.matchAll(docCommentPattern)];
-        for (const match of docMatches) {
-            const comment = match[1];
-            const lines = comment.split('\n').map(l => l.replace(/^\s*\*\s?/, '').trim()).filter(Boolean);
-            if (lines.length > 0) {
-                // Extract description, params, returns, examples
-                const description = lines.filter(l => !l.startsWith('@')).join(' ').trim();
-                if (description && description.length > 20) {
-                    const lineNumber = content.substring(0, match.index).split('\n').length;
-                    knowledge.push({
-                        id: randomUUID(),
-                        codebaseId,
-                        type: 'documentation',
-                        title: `Documentation: ${filepath}:${lineNumber}`,
-                        content: description,
-                        source: {
-                            type: 'code-comment',
-                            filepath,
-                            lineNumbers: { start: lineNumber, end: lineNumber + lines.length },
-                            context: `Extracted from JSDoc comment in ${filepath}`,
-                        },
-                        extractedAt: new Date(),
-                        relevanceScore: 0.7,
-                    });
-                }
-            }
-        }
-        // Extract inline comments with keywords (TODO, NOTE, FIXME, etc.)
-        const inlineCommentPattern = /\/\/\s*(TODO|NOTE|FIXME|HACK|XXX|IMPORTANT|WARNING):\s*(.+)/gi;
-        const inlineMatches = [...content.matchAll(inlineCommentPattern)];
-        for (const match of inlineMatches) {
-            const keyword = match[1];
-            const comment = match[2].trim();
-            if (comment && comment.length > 10) {
-                const lineNumber = content.substring(0, match.index).split('\n').length;
-                let knowledgeType = 'domain-knowledge';
-                if (keyword === 'TODO' || keyword === 'FIXME') {
-                    knowledgeType = 'gotcha';
-                }
-                else if (keyword === 'NOTE' || keyword === 'IMPORTANT') {
-                    knowledgeType = 'documentation';
-                }
-                knowledge.push({
-                    id: randomUUID(),
-                    codebaseId,
-                    type: knowledgeType,
-                    title: `${keyword}: ${comment.substring(0, 50)}`,
-                    content: comment,
-                    source: {
-                        type: 'code-comment',
-                        filepath,
-                        lineNumbers: { start: lineNumber, end: lineNumber },
-                        context: `Extracted from ${keyword} comment in ${filepath}`,
-                    },
-                    extractedAt: new Date(),
-                    relevanceScore: keyword === 'IMPORTANT' || keyword === 'WARNING' ? 0.9 : 0.6,
-                });
-            }
-        }
-        return knowledge;
-    }
-    /**
-     * Extract architectural knowledge from code structure
-     */
-    async extractFromStructure(filepath, codebaseId, codebasePath) {
-        if (!existsSync(filepath)) {
-            return [];
-        }
-        const content = readFileSync(filepath, 'utf-8');
-        const knowledge = [];
-        // Extract architectural patterns (e.g., directory structure, naming conventions)
-        const isInDomainLayer = filepath.includes('/domain/');
-        const isInInfrastructureLayer = filepath.includes('/infrastructure/');
-        const isInApplicationLayer = filepath.includes('/application/');
-        if (isInDomainLayer || isInInfrastructureLayer || isInApplicationLayer) {
-            // This file follows Clean Architecture
-            const layerName = isInDomainLayer ? 'Domain' : isInInfrastructureLayer ? 'Infrastructure' : 'Application';
-            knowledge.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'architectural',
-                title: `Clean Architecture: ${layerName} Layer`,
-                content: `This codebase follows Clean Architecture principles. Files in the ${layerName.toLowerCase()} layer follow specific responsibilities.`,
-                source: {
-                    type: 'code-structure',
-                    filepath,
-                    context: `Detected Clean Architecture structure from file path`,
-                },
-                extractedAt: new Date(),
-                relevanceScore: 0.8,
-                metadata: {
-                    tags: ['clean-architecture', 'architecture', layerName.toLowerCase()],
-                },
-            });
-        }
-        return knowledge;
-    }
-    /**
-     * Extract knowledge from existing patterns
-     */
-    async extractFromPatterns(codebaseId, codebasePath) {
-        const patterns = await this.patternRepository.findByCodebase(codebaseId);
-        const knowledge = [];
-        for (const pattern of patterns.slice(0, 20)) { // Limit to most used patterns
-            knowledge.push({
-                id: randomUUID(),
-                codebaseId,
-                type: 'convention',
-                title: `Pattern: ${pattern.name}`,
-                content: pattern.description,
-                source: {
-                    type: 'pattern',
-                    filepath: pattern.filepath,
-                    lineNumbers: pattern.lineNumbers,
-                    context: `Extracted from pattern library`,
-                },
-                extractedAt: new Date(),
-                relevanceScore: (pattern.usageCount || 0) > 0 ? 0.8 : 0.6,
-                metadata: {
-                    tags: pattern.metadata?.tags || [],
-                    relatedPatterns: [pattern.id],
-                },
-            });
-        }
-        return knowledge;
-    }
-    /**
-     * Extract knowledge using AI analysis
-     */
-    async extractWithAI(request) {
-        if (!request.content && !request.filepath) {
-            return [];
-        }
-        const content = request.content || (request.filepath && existsSync(request.filepath)
-            ? readFileSync(request.filepath, 'utf-8')
-            : '');
-        if (!content || content.length < 50) {
-            return [];
-        }
-        try {
-            const prompt = `Analyze this code and extract key knowledge:
-
-${request.filepath ? `File: ${request.filepath}` : 'Code snippet'}
-\`\`\`
-${content.substring(0, 2000)} // Truncated for AI analysis
-\`\`\`
-
-Extract:
-1. Domain knowledge (business logic, concepts)
-2. Architectural insights
-3. Best practices
-4. Gotchas or warnings
-
-Respond with JSON array:
-[
-  {
-    "type": "domain-knowledge|architectural|best-practice|gotcha",
-    "title": "Short title",
-    "content": "Detailed knowledge",
-    "relevanceScore": 0.0-1.0
-  }
-]`;
-            const response = await this.aiService.chat(prompt, []);
-            const jsonMatch = response.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const extracted = JSON.parse(jsonMatch[0]);
-                return extracted.map(item => ({
-                    id: randomUUID(),
-                    codebaseId: request.codebaseId,
-                    type: item.type || 'domain-knowledge',
-                    title: item.title,
-                    content: item.content,
-                    source: {
-                        type: 'ai-extraction',
-                        filepath: request.filepath,
-                        context: `AI-extracted knowledge from ${request.filepath || 'code snippet'}`,
-                    },
-                    extractedAt: new Date(),
-                    relevanceScore: item.relevanceScore || 0.7,
-                    metadata: {
-                        confidence: item.relevanceScore || 0.7,
-                    },
-                }));
-            }
-        }
-        catch (error) {
-            console.warn('AI knowledge extraction failed:', error);
-        }
-        return [];
-    }
-    /**
-     * Extract all knowledge from a file
-     */
-    async extractFromFile(filepath, codebaseId, codebasePath) {
-        // Extract from comments
-        const commentKnowledge = await this.extractFromComments(filepath, codebaseId, codebasePath);
-        for (const knowledge of commentKnowledge) {
-            await this.knowledgeRepository.store(knowledge);
-        }
-        // Extract from structure
-        const structureKnowledge = await this.extractFromStructure(filepath, codebaseId, codebasePath);
-        for (const knowledge of structureKnowledge) {
-            await this.knowledgeRepository.store(knowledge);
-        }
-        // Extract with AI (optional, can be expensive)
-        // Only do this for important files or on-demand
-    }
-}
-//# sourceMappingURL=knowledge-extractor.js.map

package/dist/domain/services/knowledge-graph-builder.js

@@ -1,268 +0,0 @@
-/**
- * Domain Service: KnowledgeGraphBuilder
- * Builds knowledge graph from code, patterns, and memories
- *
- * Clean Architecture: Domain Layer
- * Pattern: Builder Pattern
- *
- * Responsibilities:
- * - Extract relationships from code (AST-based)
- * - Extract relationships from patterns
- * - Extract relationships from memories
- * - Build graph incrementally
- */
-import { randomUUID } from 'crypto';
-/**
- * Knowledge Graph Builder Service
- * Builds knowledge graph incrementally from various sources
- */
-export class KnowledgeGraphBuilder {
-    graphRepository;
-    patternRepository;
-    memoryRepository;
-    constructor(graphRepository, patternRepository, memoryRepository) {
-        this.graphRepository = graphRepository;
-        this.patternRepository = patternRepository;
-        this.memoryRepository = memoryRepository;
-    }
-    /**
-     * Build knowledge graph from patterns, memories, and code
-     */
-    async buildGraph(request) {
-        const startTime = Date.now();
-        let nodesCreated = 0;
-        let edgesCreated = 0;
-        const sources = request.sources || {
-            patterns: true,
-            memories: true,
-            code: false, // Code analysis requires AST parsing - can be added later
-        };
-        // 1. Build from patterns
-        if (sources.patterns) {
-            const patternResult = await this.buildFromPatterns(request.codebaseId);
-            nodesCreated += patternResult.nodesCreated;
-            edgesCreated += patternResult.edgesCreated;
-        }
-        // 2. Build from memories
-        if (sources.memories) {
-            const memoryResult = await this.buildFromMemories(request.codebaseId);
-            nodesCreated += memoryResult.nodesCreated;
-            edgesCreated += memoryResult.edgesCreated;
-        }
-        // 3. Build relationships between patterns and memories
-        const relationshipResult = await this.buildPatternMemoryRelationships(request.codebaseId);
-        edgesCreated += relationshipResult.edgesCreated;
-        const buildTime = Date.now() - startTime;
-        return {
-            nodesCreated,
-            edgesCreated,
-            buildTime,
-        };
-    }
-    /**
-     * Build graph nodes and edges from patterns
-     */
-    async buildFromPatterns(codebaseId) {
-        const patterns = await this.patternRepository.findByCodebase(codebaseId);
-        let nodesCreated = 0;
-        let edgesCreated = 0;
-        for (const pattern of patterns) {
-            // Create pattern node
-            const patternNode = {
-                id: pattern.id || randomUUID(),
-                codebaseId,
-                type: 'pattern',
-                label: pattern.name,
-                content: pattern.description,
-                metadata: {
-                    source: 'pattern',
-                    sourceId: pattern.id,
-                    filepath: pattern.filepath,
-                    lineNumbers: pattern.lineNumbers,
-                    importance: pattern.metadata?.complexity || 5,
-                    confidence: pattern.metadata?.confidence || 5,
-                    tags: pattern.metadata?.tags,
-                },
-                createdAt: pattern.createdAt,
-                lastUpdated: pattern.lastUsed || pattern.createdAt,
-            };
-            await this.graphRepository.storeNode(patternNode);
-            nodesCreated++;
-            // Create pattern instance nodes if pattern has code examples
-            if (pattern.codeExample && pattern.filepath) {
-                const instanceNode = {
-                    id: randomUUID(),
-                    codebaseId,
-                    type: 'pattern-instance',
-                    label: `${pattern.name} Instance`,
-                    content: pattern.codeExample.substring(0, 500),
-                    metadata: {
-                        source: 'pattern',
-                        sourceId: pattern.id,
-                        filepath: pattern.filepath,
-                        lineNumbers: pattern.lineNumbers,
-                    },
-                    createdAt: pattern.createdAt,
-                    lastUpdated: pattern.createdAt,
-                };
-                await this.graphRepository.storeNode(instanceNode);
-                nodesCreated++;
-                // Create edge: pattern-instance follows pattern
-                const edge = {
-                    id: randomUUID(),
-                    fromNodeId: instanceNode.id,
-                    toNodeId: patternNode.id,
-                    type: 'follows',
-                    weight: 0.9,
-                    metadata: {
-                        confidence: 9,
-                        source: 'pattern',
-                        sourceId: pattern.id,
-                        filepath: pattern.filepath,
-                    },
-                    createdAt: pattern.createdAt,
-                };
-                await this.graphRepository.storeEdge(edge);
-                edgesCreated++;
-            }
-            // Create relationships between related patterns
-            if (pattern.metadata?.relatedPatterns && pattern.metadata.relatedPatterns.length > 0) {
-                for (const relatedPatternId of pattern.metadata.relatedPatterns) {
-                    const relatedPattern = await this.patternRepository.getById(relatedPatternId);
-                    if (relatedPattern && relatedPattern.codebaseId === codebaseId) {
-                        const edge = {
-                            id: randomUUID(),
-                            fromNodeId: patternNode.id,
-                            toNodeId: relatedPatternId,
-                            type: 'related-to',
-                            weight: 0.7,
-                            metadata: {
-                                confidence: 7,
-                                source: 'pattern',
-                                sourceId: pattern.id,
-                            },
-                            createdAt: new Date(),
-                        };
-                        await this.graphRepository.storeEdge(edge);
-                        edgesCreated++;
-                    }
-                }
-            }
-        }
-        return { nodesCreated, edgesCreated };
-    }
-    /**
-     * Build graph nodes and edges from memories
-     */
-    async buildFromMemories(codebaseId) {
-        const memories = await this.memoryRepository.getAllByCodebase(codebaseId);
-        let nodesCreated = 0;
-        let edgesCreated = 0;
-        for (const memory of memories) {
-            // Create memory node
-            const memoryNode = {
-                id: memory.id || randomUUID(),
-                codebaseId,
-                type: 'memory',
-                label: `Memory: ${memory.type}`,
-                content: memory.description,
-                metadata: {
-                    source: 'memory',
-                    sourceId: memory.id,
-                    filepath: memory.metadata?.filepath,
-                    importance: memory.importance,
-                },
-                createdAt: memory.timestamp,
-                lastUpdated: memory.lastAccessed,
-            };
-            await this.graphRepository.storeNode(memoryNode);
-            nodesCreated++;
-            // Create relationships between memories and patterns (if memory references patterns)
-            if (memory.metadata?.filepath) {
-                // Try to find related patterns
-                const relatedPatterns = await this.patternRepository.search(codebaseId, memory.description.substring(0, 100), 5);
-                for (const pattern of relatedPatterns) {
-                    if (pattern.id) {
-                        const edge = {
-                            id: randomUUID(),
-                            fromNodeId: memoryNode.id,
-                            toNodeId: pattern.id,
-                            type: 'references',
-                            weight: 0.6,
-                            metadata: {
-                                confidence: 6,
-                                source: 'memory',
-                                sourceId: memory.id,
-                            },
-                            createdAt: memory.timestamp,
-                        };
-                        await this.graphRepository.storeEdge(edge);
-                        edgesCreated++;
-                    }
-                }
-            }
-        }
-        return { nodesCreated, edgesCreated };
-    }
-    /**
-     * Build relationships between patterns and memories
-     */
-    async buildPatternMemoryRelationships(codebaseId) {
-        const patterns = await this.patternRepository.findByCodebase(codebaseId);
-        const memories = await this.memoryRepository.getAllByCodebase(codebaseId);
-        let edgesCreated = 0;
-        // Create relationships where memories mention patterns
-        for (const memory of memories) {
-            for (const pattern of patterns) {
-                if (pattern.name && memory.description.toLowerCase().includes(pattern.name.toLowerCase())) {
-                    if (memory.id && pattern.id) {
-                        const edge = {
-                            id: randomUUID(),
-                            fromNodeId: memory.id,
-                            toNodeId: pattern.id,
-                            type: 'references',
-                            weight: 0.7,
-                            metadata: {
-                                confidence: 7,
-                                source: 'memory',
-                                sourceId: memory.id,
-                            },
-                            createdAt: memory.timestamp,
-                        };
-                        await this.graphRepository.storeEdge(edge);
-                        edgesCreated++;
-                    }
-                }
-            }
-        }
-        return { edgesCreated };
-    }
-    /**
-     * Add a node to the graph
-     */
-    async addNode(node) {
-        await this.graphRepository.storeNode(node);
-    }
-    /**
-     * Add an edge to the graph
-     */
-    async addEdge(edge) {
-        await this.graphRepository.storeEdge(edge);
-    }
-    /**
-     * Update graph incrementally (add new patterns/memories)
-     */
-    async updateGraphIncremental(codebaseId) {
-        // Only build from new patterns and memories
-        return await this.buildGraph({
-            codebaseId,
-            codebasePath: '', // Not needed for incremental updates
-            sources: {
-                patterns: true,
-                memories: true,
-                code: false,
-            },
-        });
-    }
-}
-//# sourceMappingURL=knowledge-graph-builder.js.map