codehere 0.2.2 → 0.3.0-rc.1

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

@@ -1,187 +0,0 @@
-/**
- * Domain Service: KnowledgeGraphQuery
- * Query and analyze knowledge graph
- *
- * Clean Architecture: Domain Layer
- *
- * Responsibilities:
- * - Find related patterns
- * - Discover dependencies
- * - Identify architectural relationships
- * - Graph traversal and analysis
- */
-/**
- * Knowledge Graph Query Service
- * Provides query and analysis capabilities for the knowledge graph
- */
-export class KnowledgeGraphQuery {
-    graphRepository;
-    constructor(graphRepository) {
-        this.graphRepository = graphRepository;
-    }
-    /**
-     * Find patterns related to a given pattern
-     */
-    async findRelatedPatterns(patternId, maxDepth = 2) {
-        // Get neighbors (directly connected patterns)
-        const neighbors = await this.graphRepository.getNeighbors(patternId, 'both');
-        // Filter to only pattern nodes
-        const patternNeighbors = neighbors.filter(n => n.type === 'pattern' || n.type === 'pattern-instance');
-        // Get edges connecting to these patterns
-        const edges = [];
-        for (const neighbor of patternNeighbors) {
-            if (neighbor.id) {
-                const fromEdges = await this.graphRepository.findEdgesFromNode(patternId);
-                const toEdges = await this.graphRepository.findEdgesToNode(patternId);
-                edges.push(...fromEdges, ...toEdges);
-            }
-        }
-        // Get nodes within N hops for deeper relationships
-        const nodesWithinHops = await this.graphRepository.getNodesWithinHops(patternId, maxDepth);
-        const relatedPatterns = nodesWithinHops.filter(n => n.type === 'pattern' || n.type === 'pattern-instance');
-        return {
-            patterns: relatedPatterns,
-            relationships: edges,
-        };
-    }
-    /**
-     * Discover dependencies for a pattern or node
-     */
-    async discoverDependencies(nodeId, maxDepth = 3) {
-        // Get outgoing edges (dependencies)
-        const outgoingEdges = await this.graphRepository.findEdgesFromNode(nodeId);
-        const dependencyIds = new Set();
-        for (const edge of outgoingEdges) {
-            if (edge.type === 'depends-on' || edge.type === 'uses' || edge.type === 'imports') {
-                dependencyIds.add(edge.toNodeId);
-            }
-        }
-        // Get incoming edges (dependents)
-        const incomingEdges = await this.graphRepository.findEdgesToNode(nodeId);
-        const dependentIds = new Set();
-        for (const edge of incomingEdges) {
-            if (edge.type === 'depends-on' || edge.type === 'uses' || edge.type === 'imports') {
-                dependentIds.add(edge.fromNodeId);
-            }
-        }
-        // Get nodes within maxDepth for transitive dependencies
-        const nodesWithinHops = await this.graphRepository.getNodesWithinHops(nodeId, maxDepth);
-        const allDependencyIds = new Set(dependencyIds);
-        const allDependentIds = new Set(dependentIds);
-        // Add transitive dependencies
-        for (const node of nodesWithinHops) {
-            if (node.id) {
-                const nodeEdges = await this.graphRepository.findEdgesFromNode(node.id);
-                for (const edge of nodeEdges) {
-                    if (edge.type === 'depends-on' || edge.type === 'uses') {
-                        allDependencyIds.add(edge.toNodeId);
-                    }
-                }
-            }
-        }
-        // Fetch dependency nodes
-        const dependencies = [];
-        for (const id of allDependencyIds) {
-            const node = await this.graphRepository.getNodeById(id);
-            if (node) {
-                dependencies.push(node);
-            }
-        }
-        // Fetch dependent nodes
-        const dependents = [];
-        for (const id of allDependentIds) {
-            const node = await this.graphRepository.getNodeById(id);
-            if (node) {
-                dependents.push(node);
-            }
-        }
-        return {
-            dependencies,
-            dependents,
-            depth: maxDepth,
-        };
-    }
-    /**
-     * Identify architectural relationships
-     */
-    async identifyArchitecturalRelationships(codebaseId) {
-        // Get all pattern nodes
-        const patterns = await this.graphRepository.findNodesByType(codebaseId, 'pattern');
-        // Group patterns by architectural layer (based on metadata or type)
-        const layers = [];
-        const architecturalPatterns = [];
-        const structuralPatterns = [];
-        const behavioralPatterns = [];
-        for (const pattern of patterns) {
-            if (pattern.type === 'pattern') {
-                // Categorize based on pattern metadata or content
-                if (pattern.content.toLowerCase().includes('architectural') ||
-                    pattern.content.toLowerCase().includes('architecture') ||
-                    pattern.content.toLowerCase().includes('layer')) {
-                    architecturalPatterns.push(pattern);
-                }
-                else if (pattern.content.toLowerCase().includes('structure') ||
-                    pattern.content.toLowerCase().includes('organization')) {
-                    structuralPatterns.push(pattern);
-                }
-                else {
-                    behavioralPatterns.push(pattern);
-                }
-            }
-        }
-        if (architecturalPatterns.length > 0)
-            layers.push(architecturalPatterns);
-        if (structuralPatterns.length > 0)
-            layers.push(structuralPatterns);
-        if (behavioralPatterns.length > 0)
-            layers.push(behavioralPatterns);
-        // Get relationships between architectural patterns
-        const relationships = [];
-        for (const pattern of architecturalPatterns) {
-            if (pattern.id) {
-                const edges = await this.graphRepository.findEdgesFromNode(pattern.id);
-                relationships.push(...edges.filter(e => e.type === 'depends-on' || e.type === 'uses' || e.type === 'implements'));
-            }
-        }
-        return { layers, relationships };
-    }
-    /**
-     * Find shortest path between two nodes
-     */
-    async findPath(fromNodeId, toNodeId) {
-        return await this.graphRepository.findShortestPath(fromNodeId, toNodeId);
-    }
-    /**
-     * Get all nodes of a specific type
-     */
-    async getNodesByType(codebaseId, type) {
-        return await this.graphRepository.findNodesByType(codebaseId, type);
-    }
-    /**
-     * Search nodes by query
-     */
-    async searchNodes(codebaseId, query) {
-        return await this.graphRepository.searchNodes(codebaseId, query);
-    }
-    /**
-     * Get graph statistics
-     */
-    async getGraphStatistics(codebaseId) {
-        const graph = await this.graphRepository.getGraphByCodebase(codebaseId);
-        if (!graph.metadata) {
-            return {
-                nodeCount: graph.nodes.length,
-                edgeCount: graph.edges.length,
-                nodeTypes: {},
-                relationshipTypes: {},
-            };
-        }
-        return {
-            nodeCount: graph.metadata.nodeCount,
-            edgeCount: graph.metadata.edgeCount,
-            nodeTypes: graph.metadata.nodeTypes,
-            relationshipTypes: graph.metadata.relationshipTypes,
-        };
-    }
-}
-//# sourceMappingURL=knowledge-graph-query.js.map

package/dist/domain/services/memory-retriever.js

@@ -1,82 +0,0 @@
-/**
- * Domain Service: MemoryRetriever
- * Retrieves relevant memories using 3-factor scoring + Graded Activation
- * (Recency × Importance × Relevance × Activation)
- *
- * Pure domain logic - no external dependencies
- */
-import { GradedMemoryActivation } from './graded-memory-activation.js';
-export class MemoryRetriever {
-    DECAY_CONSTANT = 86400000; // 24 hours in ms
-    gradedActivation;
-    constructor() {
-        this.gradedActivation = new GradedMemoryActivation();
-    }
-    /**
-     * Retrieve relevant memories with 3-factor scoring + graded activation
-     * @param memories - All available memories
-     * @param queryEmbedding - Pre-computed query embedding vector
-     * @param limit - Maximum number of memories to return
-     * @param useGradedActivation - Whether to apply g(t) function (default: true)
-     */
-    retrieve(memories, queryEmbedding, limit, useGradedActivation = true) {
-        if (memories.length === 0) {
-            return [];
-        }
-        // Score each memory with 3-factor scoring
-        const scored = memories.map((memory) => {
-            const recency = this.calculateRecency(memory.lastAccessed);
-            const importance = memory.importance / 10; // Normalize to 0-1
-            const relevance = this.cosineSimilarity(queryEmbedding, memory.embedding);
-            const baseScore = recency * importance * relevance;
-            return { memory, baseScore };
-        });
-        // Apply graded activation if enabled
-        let finalScored;
-        if (useGradedActivation && memories.length > 10) {
-            // Use graded activation for strategic learning
-            finalScored = this.gradedActivation.applyGradedActivation(scored);
-        }
-        else {
-            finalScored = scored.map(({ memory, baseScore }) => ({
-                memory,
-                finalScore: baseScore,
-            }));
-        }
-        // Sort by final score and return top N
-        return finalScored
-            .sort((a, b) => b.finalScore - a.finalScore)
-            .slice(0, limit)
-            .map(({ memory }) => memory);
-    }
-    /**
-     * Calculate recency score (exponential decay)
-     */
-    calculateRecency(lastAccessed) {
-        const now = Date.now();
-        const timeSinceAccess = now - lastAccessed.getTime();
-        return Math.exp(-timeSinceAccess / this.DECAY_CONSTANT);
-    }
-    /**
-     * Calculate cosine similarity
-     */
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length) {
-            return 0;
-        }
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-        if (denominator === 0) {
-            return 0;
-        }
-        return dotProduct / denominator;
-    }
-}
-//# sourceMappingURL=memory-retriever.js.map

package/dist/domain/services/memory-synthesizer.js

@@ -1,91 +0,0 @@
-/**
- * Domain Service: Memory Synthesizer
- * Synthesizes episodic memories into higher-level reflections
- */
-/**
- * Synthesize memories into hierarchical reflections
- * Process:
- * 1. Query recent memories to identify salient questions
- * 2. Use questions to retrieve relevant memories
- * 3. Extract insights and cite evidence
- * 4. Create trees of reflections (non-leaf nodes = abstract thoughts)
- */
-export class MemorySynthesizer {
-    patternExtractor;
-    constructor(patternExtractor) {
-        this.patternExtractor = patternExtractor;
-    }
-    /**
-     * Generate salient questions from recent memories
-     * These questions help identify what high-level insights can be extracted
-     */
-    generateSalientQuestions(memories, maxQuestions = 5) {
-        // This will be implemented using AI in the application layer
-        // For now, return placeholder
-        return [];
-    }
-    /**
-     * Extract patterns from memory reflections (if pattern extractor available)
-     */
-    async extractPatternsFromReflections(memories, codebaseId, codebasePath) {
-        if (!this.patternExtractor) {
-            return; // Pattern extraction not available
-        }
-        try {
-            // Extract patterns from memory reflections
-            await this.patternExtractor.extractFromMemory(memories, codebaseId, codebasePath);
-        }
-        catch (error) {
-            // Don't fail memory synthesis if pattern extraction fails
-            console.warn('Pattern extraction from memories failed (non-critical):', error);
-        }
-    }
-    /**
-     * Synthesize memories into reflections
-     * Takes raw observations and creates higher-level insights
-     */
-    synthesizeReflections(memories, questions) {
-        // This will be implemented using AI in the application layer
-        // Returns reflections with evidence citations
-        return [];
-    }
-    /**
-     * Build trees of reflections
-     * Non-leaf nodes represent abstract thoughts that influence future decisions
-     */
-    buildReflectionTree(reflections) {
-        // Organize reflections hierarchically
-        // Parent reflections are more abstract, children are more specific
-        const tree = [];
-        const byParent = new Map();
-        // Group by parent
-        for (const reflection of reflections) {
-            if (reflection.parentReflectionId) {
-                if (!byParent.has(reflection.parentReflectionId)) {
-                    byParent.set(reflection.parentReflectionId, []);
-                }
-                byParent.get(reflection.parentReflectionId).push(reflection);
-            }
-            else {
-                tree.push(reflection);
-            }
-        }
-        // Attach children to parents
-        const attachChildren = (parent) => {
-            const children = byParent.get(parent.id) || [];
-            // In a full implementation, we'd attach children here
-            return parent;
-        };
-        return tree.map(attachChildren);
-    }
-    /**
-     * Retrieve relevant memories for planning context
-     * Uses 3-factor scoring: Recency × Importance × Relevance
-     */
-    retrieveForPlanning(query, allMemories, maxMemories = 100) {
-        // This uses the same 3-factor scoring as MemoryRetriever
-        // Will be implemented in application layer with actual retrieval
-        return allMemories.slice(0, maxMemories);
-    }
-}
-//# sourceMappingURL=memory-synthesizer.js.map