codehere 0.2.2 → 0.3.0-rc.10

package/dist/application/use-cases/explain-file-use-case.js

@@ -1,50 +0,0 @@
-/**
- * Application Use Case: ExplainFileUseCase
- * Explains a code file using AI
- */
-import { GitContextService } from '../services/git-context-service.js';
-export class ExplainFileUseCase {
-    aiService;
-    gitContextService;
-    constructor(aiService, cwd = process.cwd()) {
-        this.aiService = aiService;
-        this.gitContextService = new GitContextService(cwd);
-    }
-    async execute(request) {
-        const { readFileSync, existsSync } = await import('fs');
-        const { join } = await import('path');
-        const fullPath = join(process.cwd(), request.filepath);
-        if (!existsSync(fullPath)) {
-            throw new Error(`File not found: ${request.filepath}`);
-        }
-        const fileContent = readFileSync(fullPath, 'utf-8');
-        // Get Git context if requested (best practice: include recent changes for context)
-        let gitContext;
-        if (request.includeGitContext !== false) {
-            try {
-                gitContext = await this.gitContextService.getDiffSummary(request.filepath);
-            }
-            catch {
-                // Git context is optional - continue without it
-            }
-        }
-        // Create code chunk for context
-        const chunk = {
-            filepath: request.filepath,
-            content: fileContent,
-            score: 1.0,
-        };
-        // Build query with Git context if available
-        let query = `Explain this file: ${request.filepath}`;
-        if (gitContext) {
-            query += `\n\nRecent changes context:\n${gitContext}`;
-        }
-        const explanation = await this.aiService.chat(query, [chunk], []);
-        return {
-            explanation,
-            fileContent,
-            gitContext,
-        };
-    }
-}
-//# sourceMappingURL=explain-file-use-case.js.map

package/dist/application/use-cases/index-codebase-use-case.js

@@ -1,113 +0,0 @@
-/**
- * Application Use Case: IndexCodebaseUseCase
- * Handles the "index" command - builds embeddings index
- */
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-import { readFileSync, existsSync } from 'fs';
-export class IndexCodebaseUseCase {
-    embeddingRepository;
-    fileScanner;
-    chunker;
-    aiService;
-    patternExtractor;
-    knowledgeExtractor;
-    constructor(embeddingRepository, fileScanner, chunker, aiService, patternExtractor, // Optional - for pattern extraction during indexing
-    knowledgeExtractor // Optional - for knowledge extraction during indexing (KnowledgeExtractor)
-    ) {
-        this.embeddingRepository = embeddingRepository;
-        this.fileScanner = fileScanner;
-        this.chunker = chunker;
-        this.aiService = aiService;
-        this.patternExtractor = patternExtractor;
-        this.knowledgeExtractor = knowledgeExtractor;
-    }
-    async execute(request) {
-        const startTime = Date.now();
-        // 1. Scan repository for code files
-        const files = await this.fileScanner.scan(request.repoPath);
-        // 2. Process files in parallel
-        const chunks = [];
-        let indexed = 0;
-        let cached = 0;
-        // TODO: Implement parallel processing with caching
-        for (const file of files) {
-            // Check if already indexed
-            const isIndexed = await this.embeddingRepository.isIndexed(file);
-            if (isIndexed && request.options?.useCache) {
-                cached++;
-                continue;
-            }
-            // Read and chunk file
-            const fileChunks = await this.chunker.chunk(file);
-            // Generate embeddings
-            const contents = fileChunks.map(c => c.content);
-            const embeddings = await this.aiService.embed(contents);
-            // Create chunks with embeddings
-            const chunksWithEmbeddings = fileChunks.map((chunk, i) => ({
-                ...chunk,
-                embedding: Array.isArray(embeddings[i])
-                    ? embeddings[i]
-                    : embeddings,
-            }));
-            chunks.push(...chunksWithEmbeddings);
-            indexed++;
-        }
-        // 3. Store embeddings
-        if (chunks.length > 0) {
-            await this.embeddingRepository.store(chunks);
-        }
-        // 4. Extract patterns from indexed files (if pattern extractor available)
-        if (this.patternExtractor) {
-            try {
-                // Detect codebase context
-                const codebaseInfo = findCodebaseRoot(request.repoPath);
-                if (codebaseInfo && files.length > 0) {
-                    // Extract patterns from newly indexed files (asynchronously, non-blocking)
-                    // Only extract from files that were actually indexed (not cached)
-                    const filesToExtract = files.slice(0, indexed); // Limit to newly indexed files
-                    // Extract patterns in parallel (non-blocking)
-                    Promise.all(filesToExtract.slice(0, 10).map(async (filepath) => {
-                        try {
-                            if (existsSync(filepath)) {
-                                const content = readFileSync(filepath, 'utf-8');
-                                // Extract patterns
-                                if (this.patternExtractor) {
-                                    await this.patternExtractor.extractFromCode({
-                                        content,
-                                        filepath,
-                                        codebaseId: codebaseInfo.codebaseId,
-                                        codebasePath: codebaseInfo.rootPath,
-                                        source: 'code',
-                                    });
-                                }
-                                // Extract knowledge (from comments, structure)
-                                if (this.knowledgeExtractor) {
-                                    await this.knowledgeExtractor.extractFromFile(filepath, codebaseInfo.codebaseId, codebaseInfo.rootPath);
-                                }
-                            }
-                        }
-                        catch (error) {
-                            // Non-critical - extraction shouldn't fail indexing
-                            console.warn(`Pattern/knowledge extraction failed for ${filepath} (non-critical):`, error);
-                        }
-                    })).catch(error => {
-                        // Log but don't fail
-                        console.warn('Pattern/knowledge extraction during indexing completed with some errors (non-critical):', error);
-                    });
-                }
-            }
-            catch (error) {
-                // Non-critical - pattern extraction shouldn't fail indexing
-                console.warn('Pattern extraction during indexing failed (non-critical):', error);
-            }
-        }
-        const timeMs = Date.now() - startTime;
-        return {
-            indexed,
-            cached,
-            totalChunks: chunks.length,
-            timeMs,
-        };
-    }
-}
-//# sourceMappingURL=index-codebase-use-case.js.map

package/dist/application/use-cases/planning-use-case.js

@@ -1,276 +0,0 @@
-/**
- * Planning Use Case
- * Synthesizes memories into hierarchical plans
- * Memory-based hierarchical planning
- */
-import { MemorySynthesizer } from '../../domain/services/memory-synthesizer.js';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-import { getPlanRepository } from '../../infrastructure/storage/plan-repository.js';
-import { randomUUID } from 'crypto';
-export class PlanningUseCase {
-    aiService;
-    patternExtractor;
-    memoryStream;
-    memorySynthesizer;
-    memoryRepository;
-    constructor(aiService, memoryStream, memoryRepository, patternExtractor) {
-        this.aiService = aiService;
-        this.patternExtractor = patternExtractor;
-        this.memoryStream = memoryStream;
-        this.memorySynthesizer = new MemorySynthesizer(patternExtractor);
-        this.memoryRepository = memoryRepository;
-    }
-    async execute(request) {
-        const startTime = Date.now();
-        // 1. Detect codebase context (for codebase-aware operations)
-        const currentDirectory = request.context?.currentDirectory || process.cwd();
-        const codebaseInfo = findCodebaseRoot(currentDirectory);
-        const codebaseId = codebaseInfo?.codebaseId;
-        const codebasePath = codebaseInfo?.rootPath;
-        // 2. Retrieve relevant memories (3-factor scoring: Recency × Importance × Relevance)
-        // Use codebase-aware retrieval if codebase detected
-        let recentMemories;
-        let relevantMemories;
-        if (codebaseId) {
-            recentMemories = await this.memoryRepository.findRecentByCodebase(codebaseId, 100);
-            relevantMemories = await this.memoryStream.retrieveByCodebase(request.goal, codebaseId, 50);
-        }
-        else {
-            // Fallback to global memory retrieval (backward compatibility)
-            recentMemories = await this.memoryRepository.findRecent(100);
-            relevantMemories = await this.memoryStream.retrieve(request.goal, 50);
-        }
-        // 2. Synthesize memories into reflections (with streaming progress)
-        if (request.streamHandler?.onProgress) {
-            request.streamHandler.onProgress('synthesizing', 'Analyzing memories and extracting insights...');
-        }
-        const reflections = await this.synthesizeMemories(recentMemories, request.goal);
-        // 3. Generate salient questions from memories
-        if (request.streamHandler?.onProgress) {
-            request.streamHandler.onProgress('questioning', 'Generating clarifying questions...');
-        }
-        const questions = await this.generateSalientQuestions(recentMemories);
-        // 4. Use reflections and memories to create hierarchical plan (with streaming)
-        if (request.streamHandler?.onProgress) {
-            request.streamHandler.onProgress('planning', 'Creating hierarchical plan...');
-        }
-        const plan = await this.createHierarchicalPlan(request, reflections, relevantMemories);
-        if (request.streamHandler?.onProgress) {
-            request.streamHandler.onProgress('finalizing', `Plan created with ${plan.subPlans.length} sub-plans`);
-        }
-        if (request.streamHandler?.onComplete) {
-            request.streamHandler.onComplete(plan);
-        }
-        const synthesisTime = Date.now() - startTime;
-        // 5. Extract patterns from memory reflections (if pattern extractor available)
-        if (this.patternExtractor && codebaseId && codebasePath && relevantMemories.length > 0) {
-            try {
-                // Extract patterns from memory reflections for pattern learning
-                await this.patternExtractor.extractFromMemory(relevantMemories, codebaseId, codebasePath);
-            }
-            catch (error) {
-                // Non-critical - pattern extraction shouldn't fail planning
-                console.warn('Pattern extraction during planning failed (non-critical):', error);
-            }
-        }
-        // 6. Store plan in memory stream (with codebase context)
-        await this.memoryStream.recordObservation(`Plan created: ${request.goal}`, {
-            plan: plan.id,
-            goal: request.goal,
-            subPlans: plan.subPlans.length,
-        }, codebaseId, codebasePath);
-        // 7. Persist plan to repository for later execution
-        const planRepository = getPlanRepository();
-        const planId = await planRepository.save({
-            ...plan,
-            id: plan.id || randomUUID(),
-            status: 'draft',
-        });
-        return {
-            plan: { ...plan, id: planId },
-            reflections,
-            memoriesUsed: relevantMemories.length,
-            synthesisTime,
-        };
-    }
-    async synthesizeMemories(memories, goal) {
-        // Query LLM with recent memories to identify salient questions
-        const memoryContext = memories
-            .slice(0, 100)
-            .map((m, i) => `${i + 1}. ${m.description} (${m.timestamp})`)
-            .join('\n');
-        const prompt = `Given these recent memories from an AI coding agent, identify 5-10 salient, high-level questions that can be answered from these experiences.
-
-Memories:
-${memoryContext}
-
-Goal: ${goal}
-
-Generate questions that help understand patterns, successful strategies, common failures, and important insights. Format as a JSON array of strings.`;
-        const response = await this.aiService.chat(prompt, []);
-        try {
-            const jsonMatch = response.match(/\[[\s\S]*\]/);
-            if (jsonMatch) {
-                const questions = JSON.parse(jsonMatch[0]);
-                // For each question, retrieve relevant memories and extract insights
-                const reflections = [];
-                for (const question of questions) {
-                    const relevant = await this.memoryStream.retrieve(question, 10);
-                    const insight = await this.extractInsight(question, relevant);
-                    reflections.push({
-                        question,
-                        insight,
-                        evidence: relevant.map(m => m.id || ''),
-                        timestamp: new Date(),
-                        level: 1, // Higher-level reflection
-                    });
-                }
-                return reflections;
-            }
-        }
-        catch (e) {
-            // Fallback
-        }
-        return [];
-    }
-    async generateSalientQuestions(memories) {
-        // Already done in synthesizeMemories, but can be extracted separately
-        return [];
-    }
-    async extractInsight(question, memories) {
-        const memoryContext = memories
-            .map((m, i) => `${i + 1}. ${m.description}`)
-            .join('\n');
-        const prompt = `Based on these memories, answer this question and cite specific evidence:
-
-Question: ${question}
-
-Memories:
-${memoryContext}
-
-Provide a concise insight (2-3 sentences) that answers the question, citing which memory numbers support your answer.`;
-        const response = await this.aiService.chat(prompt, []);
-        return response;
-    }
-    async createHierarchicalPlan(request, reflections, memories) {
-        // Use AI to decompose goal into hierarchical sub-plans
-        const reflectionContext = reflections
-            .map((r, i) => `${i + 1}. ${r.question}: ${r.insight}`)
-            .join('\n');
-        const memoryContext = memories
-            .slice(0, 20)
-            .map((m, i) => `${i + 1}. ${m.description}`)
-            .join('\n');
-        const planningMode = request.planningMode || 'hybrid';
-        const prompt = `Create a hierarchical plan to achieve this goal, using insights from past experiences.
-
-Goal: ${request.goal}
-Planning Mode: ${planningMode}
-Context: ${JSON.stringify(request.context || {})}
-
-Past Insights (Reflections):
-${reflectionContext}
-
-Relevant Past Experiences:
-${memoryContext}
-
-Generate a hierarchical plan with:
-1. Main goal broken into sub-plans
-2. Each sub-plan has: type (search/edit/refactor/review/analyze/implement/test), description, dependencies
-3. Dependencies between sub-plans (sequential/parallel/conditional)
-4. Estimated steps for each sub-plan
-
-Use Plan-then-Execute decomposition: generate the entire sequence upfront, but allow for iterative refinement.
-
-Respond with valid JSON in this format:
-{
-  "goal": "...",
-  "description": "...",
-  "subPlans": [
-    {
-      "id": "subplan_1",
-      "description": "...",
-      "type": "search|edit|refactor|review|analyze|implement|test",
-      "dependencies": [],
-      "estimatedSteps": 3
-    }
-  ],
-  "dependencies": [
-    {
-      "from": "subplan_1",
-      "to": "subplan_2",
-      "type": "sequential|parallel|conditional",
-      "condition": "optional"
-    }
-  ],
-  "complexity": "simple|medium|complex",
-  "estimatedDuration": 30
-}`;
-        const response = await this.aiService.chat(prompt, []);
-        try {
-            const jsonMatch = response.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const planData = JSON.parse(jsonMatch[0]);
-                const plan = {
-                    goal: planData.goal || request.goal,
-                    description: planData.description || '',
-                    status: 'draft',
-                    createdAt: new Date(),
-                    updatedAt: new Date(),
-                    subPlans: (planData.subPlans || []).map((sp, i) => ({
-                        id: sp.id || `subplan_${i + 1}`,
-                        description: sp.description,
-                        type: sp.type || 'analyze',
-                        status: 'pending',
-                        dependencies: sp.dependencies || [],
-                        estimatedSteps: sp.estimatedSteps || 1,
-                        reflections: reflections.map(r => r.question), // Link reflections
-                    })),
-                    dependencies: (planData.dependencies || []).map((dep) => ({
-                        from: dep.from,
-                        to: dep.to,
-                        type: dep.type || 'sequential',
-                        condition: dep.condition,
-                    })),
-                    metadata: {
-                        memoriesUsed: memories.map(m => m.id || ''),
-                        reflections: reflections.map(r => r.question),
-                        complexity: planData.complexity || 'medium',
-                        estimatedDuration: planData.estimatedDuration,
-                        priority: 5,
-                    },
-                };
-                return plan;
-            }
-        }
-        catch (e) {
-            // Fallback to basic plan
-        }
-        // Fallback: Create basic plan
-        return {
-            goal: request.goal,
-            description: `Plan to achieve: ${request.goal}`,
-            status: 'draft',
-            createdAt: new Date(),
-            updatedAt: new Date(),
-            subPlans: [
-                {
-                    id: 'subplan_1',
-                    description: `Analyze and plan: ${request.goal}`,
-                    type: 'analyze',
-                    status: 'pending',
-                    dependencies: [],
-                    estimatedSteps: 1,
-                },
-            ],
-            dependencies: [],
-            metadata: {
-                memoriesUsed: [],
-                reflections: [],
-                complexity: 'medium',
-                priority: 5,
-            },
-        };
-    }
-}
-//# sourceMappingURL=planning-use-case.js.map