codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/context/context-compressor.js

@@ -1,329 +0,0 @@
-/**
- * Infrastructure: Context Compression Service
- *
- * Prevents context bloat through intelligent compression techniques
- * Research: Context bloat leads to escalating costs and degraded reliability
- *
- * Techniques:
- * 1. LLM Summarization: Compress large contexts into concise summaries
- * 2. Observation Masking: Remove redundant observations in ReAct loops
- * 3. Hybrid Memory: Combine transient (session) and persistent (long-term) memory
- * 4. Selective Context: Keep only most relevant chunks based on attention scores
- */
-/**
- * Context Compressor Service
- * Implements multiple compression techniques to prevent context bloat
- */
-export class ContextCompressor {
-    aiService;
-    constructor(aiService) {
-        this.aiService = aiService;
-    }
-    /**
-     * Compress context using multi-stage compression (selective + summarization)
-     * OPTIMIZED: Multi-stage approach achieves 50%+ reduction
-     */
-    async compressWithSummarization(chunks, query, strategy) {
-        const originalTokenCount = this.estimateTokens(chunks);
-        if (originalTokenCount <= strategy.maxTokens) {
-            // No compression needed
-            return {
-                chunks,
-                memories: [],
-                originalTokenCount,
-                compressedTokenCount: originalTokenCount,
-                reductionPercent: 0,
-                strategy,
-            };
-        }
-        // STAGE 1: Selective compression - keep only most relevant chunks
-        // Target: Reduce to 70% of original (30% reduction)
-        const targetAfterSelective = Math.floor(originalTokenCount * 0.7);
-        const maxChunksAfterSelective = Math.ceil((chunks.length * targetAfterSelective) / originalTokenCount);
-        const selectiveChunks = this.selectiveCompression(chunks, query, maxChunksAfterSelective);
-        const selectiveTokenCount = this.estimateTokens(selectiveChunks);
-        // If selective compression is enough, return early
-        if (selectiveTokenCount <= strategy.maxTokens) {
-            const reductionPercent = ((originalTokenCount - selectiveTokenCount) / originalTokenCount) * 100;
-            return {
-                chunks: selectiveChunks,
-                memories: [],
-                summary: `Selective compression: ${chunks.length} → ${selectiveChunks.length} chunks`,
-                originalTokenCount,
-                compressedTokenCount: selectiveTokenCount,
-                reductionPercent,
-                strategy,
-            };
-        }
-        // STAGE 2: Code-aware preprocessing - remove comments, whitespace, etc.
-        const preprocessedChunks = this.preprocessCode(selectiveChunks);
-        const preprocessedTokenCount = this.estimateTokens(preprocessedChunks);
-        // If preprocessing is enough, return
-        if (preprocessedTokenCount <= strategy.maxTokens) {
-            const reductionPercent = ((originalTokenCount - preprocessedTokenCount) / originalTokenCount) * 100;
-            return {
-                chunks: preprocessedChunks,
-                memories: [],
-                summary: `Preprocessed: removed comments/whitespace`,
-                originalTokenCount,
-                compressedTokenCount: preprocessedTokenCount,
-                reductionPercent,
-                strategy,
-            };
-        }
-        // STAGE 3: LLM summarization - aggressive compression
-        // Group chunks by file for better summarization
-        const chunksByFile = this.groupChunksByFile(preprocessedChunks);
-        const compressedChunks = [];
-        for (const [filepath, fileChunks] of Object.entries(chunksByFile)) {
-            const fileContent = fileChunks.map(c => c.content).join('\n\n---\n\n');
-            if (strategy.preserveCode) {
-                // Aggressive compression: Keep only essential code, summarize rest
-                const summary = await this.summarizeFileContextAggressive(fileContent, query, filepath);
-                compressedChunks.push({
-                    filepath,
-                    content: summary.summarized,
-                    score: fileChunks[0]?.score || 0.5,
-                });
-            }
-            else {
-                // Full summarization with aggressive target
-                const summary = await this.summarizeFileContentAggressive(fileContent, query, filepath);
-                compressedChunks.push({
-                    filepath,
-                    content: summary,
-                    score: fileChunks[0]?.score || 0.5,
-                });
-            }
-        }
-        const compressedTokenCount = this.estimateTokens(compressedChunks);
-        const reductionPercent = ((originalTokenCount - compressedTokenCount) / originalTokenCount) * 100;
-        return {
-            chunks: compressedChunks,
-            memories: [],
-            summary: `Multi-stage compression: ${chunks.length} chunks, ${originalTokenCount} → ${compressedTokenCount} tokens (${reductionPercent.toFixed(1)}% reduction)`,
-            originalTokenCount,
-            compressedTokenCount,
-            reductionPercent,
-            strategy,
-        };
-    }
-    /**
-     * Mask observations in ReAct loops
-     * Remove redundant observations while preserving critical information
-     */
-    maskObservations(observations, toolCalls, errors, mask) {
-        let maskedObservations = [];
-        let maskedToolCalls = [];
-        let maskedErrors = [];
-        // Keep only recent observations if masking enabled
-        if (mask.observations) {
-            maskedObservations = observations.slice(-mask.maxHistoryLength);
-        }
-        else {
-            maskedObservations = observations;
-        }
-        // Always keep tool calls (they're compact)
-        maskedToolCalls = mask.toolCalls ? toolCalls.slice(-mask.maxHistoryLength) : toolCalls;
-        // Always keep errors (critical information)
-        maskedErrors = mask.errors ? errors : errors;
-        return {
-            maskedObservations,
-            maskedToolCalls,
-            maskedErrors,
-        };
-    }
-    /**
-     * Compress memories by summarizing similar memories
-     */
-    async compressMemories(memories, query, maxMemories = 10) {
-        if (memories.length <= maxMemories) {
-            return memories;
-        }
-        // Group similar memories
-        const grouped = this.groupSimilarMemories(memories);
-        // Keep most relevant from each group
-        const compressed = [];
-        for (const group of grouped) {
-            // Sort by relevance to query
-            const relevant = group.sort((a, b) => {
-                const aRelevance = this.calculateRelevance(a.description, query);
-                const bRelevance = this.calculateRelevance(b.description, query);
-                return bRelevance - aRelevance;
-            });
-            // Keep top 1-2 from each group
-            compressed.push(...relevant.slice(0, Math.min(2, group.length)));
-            if (compressed.length >= maxMemories) {
-                break;
-            }
-        }
-        return compressed.slice(0, maxMemories);
-    }
-    /**
-     * Hybrid memory compression: Combine transient and persistent
-     */
-    createHybridContext(transientMemories, // Recent session memories
-    persistentMemories, // Long-term memories
-    query) {
-        // Prioritize transient (more relevant to current session)
-        const hybrid = [...transientMemories];
-        // Add persistent only if they add new information
-        for (const persistent of persistentMemories) {
-            const isDuplicate = hybrid.some(t => this.calculateRelevance(t.description, persistent.description) > 0.8);
-            if (!isDuplicate && this.calculateRelevance(persistent.description, query) > 0.5) {
-                hybrid.push(persistent);
-            }
-        }
-        return hybrid.slice(0, 20); // Limit total hybrid memories
-    }
-    /**
-     * Selective context compression: Keep only most relevant chunks
-     */
-    selectiveCompression(chunks, query, maxChunks, attentionScores // Optional attention scores from visualizer
-    ) {
-        // Score chunks by relevance
-        const scored = chunks.map(chunk => ({
-            chunk,
-            score: attentionScores?.get(chunk.filepath) ||
-                this.calculateRelevance(chunk.content, query),
-        }));
-        // Sort by score and keep top N
-        return scored
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxChunks)
-            .map(s => s.chunk);
-    }
-    // Private helper methods
-    /**
-     * Preprocess code: remove comments, excessive whitespace, etc.
-     * Achieves ~15-20% reduction without LLM calls
-     */
-    preprocessCode(chunks) {
-        return chunks.map(chunk => {
-            let content = chunk.content;
-            // Remove single-line comments (// ...)
-            content = content.replace(/\/\/.*$/gm, '');
-            // Remove multi-line comments (/* ... */)
-            content = content.replace(/\/\*[\s\S]*?\*\//g, '');
-            // Remove excessive blank lines (more than 2 consecutive)
-            content = content.replace(/\n{3,}/g, '\n\n');
-            // Remove trailing whitespace
-            content = content.split('\n').map(line => line.trimEnd()).join('\n');
-            return {
-                ...chunk,
-                content: content.trim(),
-            };
-        });
-    }
-    async summarizeFileContext(content, query, filepath) {
-        const prompt = `Summarize the context and comments in this code file, but keep the actual code intact.
-    
-File: ${filepath}
-Query: ${query}
-
-Code:
-${content}
-
-Return a summary that preserves code structure but compresses comments and context.`;
-        const summary = await this.aiService.chat(prompt, []);
-        return { summarized: summary || content };
-    }
-    /**
-     * Aggressive summarization: Target 50%+ reduction
-     */
-    async summarizeFileContextAggressive(content, query, filepath) {
-        const prompt = `Compress this code file aggressively while preserving functionality relevant to: ${query}
-
-File: ${filepath}
-Query: ${query}
-
-Code:
-${content}
-
-Instructions:
-- Remove all comments and docstrings
-- Keep only code directly relevant to the query
-- Summarize helper functions in 1-2 lines
-- Preserve function signatures and critical logic
-- Target: 50%+ token reduction
-
-Return compressed code:`;
-        const summary = await this.aiService.chat(prompt, []);
-        return { summarized: summary || content };
-    }
-    async summarizeFileContent(content, query, filepath) {
-        const prompt = `Provide a concise summary of this code file, focusing on how it relates to: ${query}
-    
-File: ${filepath}
-Code:
-${content}
-
-Return a brief summary (2-3 sentences) of the key functionality.`;
-        const summary = await this.aiService.chat(prompt, []);
-        return summary || content;
-    }
-    /**
-     * Aggressive summarization: Target 50%+ reduction
-     */
-    async summarizeFileContentAggressive(content, query, filepath) {
-        const prompt = `Provide an extremely concise summary (1-2 sentences) of this code file, focusing ONLY on: ${query}
-
-File: ${filepath}
-Code:
-${content}
-
-Return ONLY the essential functionality relevant to the query. Be extremely brief.`;
-        const summary = await this.aiService.chat(prompt, []);
-        return summary || content;
-    }
-    groupChunksByFile(chunks) {
-        const grouped = {};
-        for (const chunk of chunks) {
-            if (!grouped[chunk.filepath]) {
-                grouped[chunk.filepath] = [];
-            }
-            grouped[chunk.filepath].push(chunk);
-        }
-        return grouped;
-    }
-    groupSimilarMemories(memories) {
-        const groups = [];
-        const processed = new Set();
-        for (let i = 0; i < memories.length; i++) {
-            if (processed.has(i))
-                continue;
-            const group = [memories[i]];
-            processed.add(i);
-            // Find similar memories
-            for (let j = i + 1; j < memories.length; j++) {
-                if (processed.has(j))
-                    continue;
-                const similarity = this.calculateRelevance(memories[i].description, memories[j].description);
-                if (similarity > 0.7) {
-                    group.push(memories[j]);
-                    processed.add(j);
-                }
-            }
-            groups.push(group);
-        }
-        return groups;
-    }
-    calculateRelevance(text1, text2) {
-        // Simple word overlap similarity (could be enhanced with embeddings)
-        const words1 = new Set(text1.toLowerCase().split(/\s+/));
-        const words2 = new Set(text2.toLowerCase().split(/\s+/));
-        const intersection = new Set([...words1].filter(w => words2.has(w)));
-        const union = new Set([...words1, ...words2]);
-        return union.size > 0 ? intersection.size / union.size : 0;
-    }
-    estimateTokens(chunks) {
-        // Improved estimation: Code has more tokens per character than prose
-        // Average: ~3.5 characters per token for code, ~4 for prose
-        return chunks.reduce((sum, chunk) => {
-            const isCode = chunk.filepath.match(/\.(ts|js|py|java|cpp|go|rs)$/);
-            const charsPerToken = isCode ? 3.5 : 4;
-            return sum + Math.ceil(chunk.content.length / charsPerToken);
-        }, 0);
-    }
-}
-//# sourceMappingURL=context-compressor.js.map

package/dist/infrastructure/context/conversation-context.js

@@ -1,128 +0,0 @@
-/**
- * Conversation Context Manager
- * Manages conversation history and context for session-aware interactions
- *
- * Phase 1: v0.5.0-alpha.0
- */
-/**
- * In-memory conversation context manager
- * Stores conversation history per session for reference resolution
- */
-class ConversationContextManager {
-    sessions = new Map();
-    maxHistoryPerSession = 50;
-    /**
-     * Get conversation history for a session
-     */
-    getHistory(sessionId, limit = 10) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return [];
-        }
-        // Return most recent turns, up to limit
-        const turns = session.turns.slice(-limit);
-        return turns.map(turn => ({
-            query: turn.query,
-            response: turn.response,
-            timestamp: turn.timestamp,
-        }));
-    }
-    /**
-     * Resolve references in query (e.g., "it", "that", "the previous")
-     */
-    resolveReferences(sessionId, query) {
-        const history = this.getHistory(sessionId, 3);
-        if (history.length === 0) {
-            return query;
-        }
-        // Simple reference resolution - replace common references
-        let resolved = query;
-        const lastTurn = history[history.length - 1];
-        // Replace "it" with last mentioned entity/context
-        if (/\bit\b/i.test(query) && lastTurn.response) {
-            // Extract key entities from last response (simple heuristic)
-            const lastResponse = lastTurn.response;
-            const words = lastResponse.split(/\s+/).filter(w => w.length > 3);
-            if (words.length > 0) {
-                // Try to replace "it" with last significant noun phrase
-                resolved = resolved.replace(/\bit\b/gi, words[words.length - 1]);
-            }
-        }
-        // Replace "that" with last query
-        if (/\bthat\b/i.test(query)) {
-            resolved = resolved.replace(/\bthat\b/gi, `"${lastTurn.query}"`);
-        }
-        // Replace "the previous" with last query
-        if (/\bthe previous\b/i.test(query)) {
-            resolved = resolved.replace(/\bthe previous\b/gi, `"${lastTurn.query}"`);
-        }
-        return resolved;
-    }
-    /**
-     * Extract entities from text (simple heuristic-based extraction)
-     */
-    extractEntities(text, options) {
-        // Simple entity extraction - can be enhanced later
-        const entities = [];
-        // Extract file paths
-        const filePathRegex = /[\w\/\-\.]+\.(ts|js|tsx|jsx|json|md|yaml|yml|txt|py|go|rs|java|cpp|h|hpp)/g;
-        const filePaths = text.match(filePathRegex) || [];
-        filePaths.forEach(path => {
-            entities.push({ type: 'file', value: path });
-        });
-        // Extract function/class names (simple heuristic)
-        const functionRegex = /(?:function|class|const|let|var)\s+([A-Z][a-zA-Z0-9_]+|[a-z][a-zA-Z0-9_]+)/g;
-        const matches = text.matchAll(functionRegex);
-        for (const match of matches) {
-            entities.push({ type: 'symbol', value: match[1] });
-        }
-        return entities;
-    }
-    /**
-     * Add a conversation turn
-     */
-    addTurn(sessionId, query, response, entities = [], intent) {
-        let session = this.sessions.get(sessionId);
-        if (!session) {
-            session = {
-                sessionId,
-                turns: [],
-                createdAt: Date.now(),
-                lastUpdated: Date.now(),
-            };
-            this.sessions.set(sessionId, session);
-        }
-        const turn = {
-            query,
-            response,
-            timestamp: new Date().toISOString(),
-            entities,
-            intent,
-        };
-        session.turns.push(turn);
-        session.lastUpdated = Date.now();
-        // Trim history if too long
-        if (session.turns.length > this.maxHistoryPerSession) {
-            session.turns = session.turns.slice(-this.maxHistoryPerSession);
-        }
-    }
-    /**
-     * Get full context for a session
-     */
-    getContext(sessionId) {
-        return this.sessions.get(sessionId) || null;
-    }
-    /**
-     * Clear conversation history for a session
-     */
-    clear(sessionId) {
-        if (sessionId) {
-            this.sessions.delete(sessionId);
-        }
-        else {
-            this.sessions.clear();
-        }
-    }
-}
-export const conversationContextManager = new ConversationContextManager();
-//# sourceMappingURL=conversation-context.js.map

package/dist/infrastructure/context/session-manager.js

@@ -1,94 +0,0 @@
-/**
- * Session Manager
- * Manages CLI sessions for context tracking
- *
- * Phase 1: v0.5.0-alpha.0
- */
-/**
- * Session manager for tracking CLI sessions
- */
-class SessionManager {
-    sessions = new Map();
-    sessionTimeout = 24 * 60 * 60 * 1000; // 24 hours
-    /**
-     * Get or create session ID for a working directory
-     */
-    getSessionId(cwd) {
-        // Normalize cwd path
-        const normalizedCwd = cwd || process.cwd();
-        // Check if session exists and is still valid
-        const existingSession = this.sessions.get(normalizedCwd);
-        if (existingSession) {
-            const age = Date.now() - existingSession.lastActivity;
-            if (age < this.sessionTimeout) {
-                existingSession.lastActivity = Date.now();
-                return existingSession.sessionId;
-            }
-            else {
-                // Session expired, remove it
-                this.sessions.delete(normalizedCwd);
-            }
-        }
-        // Create new session
-        const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const session = {
-            sessionId,
-            cwd: normalizedCwd,
-            startedAt: Date.now(),
-            lastActivity: Date.now(),
-        };
-        this.sessions.set(normalizedCwd, session);
-        return sessionId;
-    }
-    /**
-     * Get current session for a working directory
-     */
-    getCurrentSession(cwd) {
-        const normalizedCwd = cwd || process.cwd();
-        return this.sessions.get(normalizedCwd) || null;
-    }
-    /**
-     * Create a new session explicitly
-     */
-    createSession(cwd) {
-        const normalizedCwd = cwd || process.cwd();
-        const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const session = {
-            sessionId,
-            cwd: normalizedCwd,
-            startedAt: Date.now(),
-            lastActivity: Date.now(),
-        };
-        this.sessions.set(normalizedCwd, session);
-        return session;
-    }
-    /**
-     * End a session
-     */
-    endSession(cwd) {
-        const normalizedCwd = cwd || process.cwd();
-        this.sessions.delete(normalizedCwd);
-    }
-    /**
-     * Clean up expired sessions
-     */
-    cleanup() {
-        const now = Date.now();
-        for (const [cwd, session] of this.sessions.entries()) {
-            const age = now - session.lastActivity;
-            if (age >= this.sessionTimeout) {
-                this.sessions.delete(cwd);
-            }
-        }
-    }
-}
-export const sessionManager = new SessionManager();
-// Cleanup expired sessions periodically
-// Use .unref() to allow process to exit even with timer active
-if (typeof setInterval !== 'undefined') {
-    const cleanupInterval = setInterval(() => {
-        sessionManager.cleanup();
-    }, 60 * 60 * 1000); // Every hour
-    cleanupInterval.unref();
-}
-//# sourceMappingURL=session-manager.js.map