codehere 0.2.2 → 0.3.0-rc.10

package/dist/domain/services/decision-recorder.js

@@ -1,223 +0,0 @@
-/**
- * Domain Service: DecisionRecorder
- * Records architectural and design decisions
- *
- * Clean Architecture: Domain Layer
- *
- * Responsibilities:
- * - Record architectural decisions
- * - Record technology choices
- * - Record design pattern choices
- * - Extract decisions from planning context
- */
-import { randomUUID } from 'crypto';
-/**
- * Decision Recorder Service
- * Records decisions with full context and rationale
- */
-export class DecisionRecorder {
-    decisionRepository;
-    constructor(decisionRepository) {
-        this.decisionRepository = decisionRepository;
-    }
-    /**
-     * Record a decision
-     */
-    async recordDecision(request) {
-        const decision = {
-            id: randomUUID(),
-            codebaseId: request.codebaseId,
-            type: request.type,
-            title: request.title,
-            description: request.description,
-            rationale: request.rationale,
-            alternatives: request.alternatives,
-            constraints: request.constraints,
-            tradeoffs: request.tradeoffs,
-            consequences: request.consequences,
-            metadata: {
-                context: request.context,
-                relatedDecisions: request.relatedDecisions,
-                relatedPatterns: request.relatedPatterns,
-                status: 'accepted',
-                impact: 'medium',
-                confidence: 8,
-            },
-            createdAt: new Date(),
-            author: request.author,
-        };
-        await this.decisionRepository.store(decision);
-        return decision;
-    }
-    /**
-     * Extract decision from planning context
-     * Uses AI to identify decisions made during planning
-     */
-    async extractDecisionFromPlanning(planningContext, codebaseId, aiService // IAIService - optional for AI extraction
-    ) {
-        // If AI service is available, use it to extract decision
-        if (aiService) {
-            return await this.extractDecisionWithAI(planningContext, codebaseId, aiService);
-        }
-        // Otherwise, create a basic decision from planning context
-        return await this.createBasicDecisionFromPlanning(planningContext, codebaseId);
-    }
-    /**
-     * Extract decision using AI
-     */
-    async extractDecisionWithAI(planningContext, codebaseId, aiService) {
-        const prompt = `Analyze this planning context and extract the architectural or design decision made:
-
-Goal: ${planningContext.goal}
-Plan: ${JSON.stringify(planningContext.plan, null, 2)}
-${planningContext.alternatives ? `Alternatives considered: ${planningContext.alternatives.join(', ')}` : ''}
-${planningContext.constraints ? `Constraints: ${planningContext.constraints.join(', ')}` : ''}
-
-Extract the decision in JSON format:
-{
-  "type": "architectural|technology|design-pattern|convention|process|security|performance|custom",
-  "title": "Short decision title",
-  "description": "Full description of decision",
-  "rationale": "Why this decision was made",
-  "alternatives": ["alternative1", "alternative2"],
-  "constraints": ["constraint1", "constraint2"],
-  "tradeoffs": ["tradeoff1", "tradeoff2"],
-  "consequences": ["consequence1", "consequence2"]
-}
-
-Only extract if a clear decision was made. Return valid JSON or null.`;
-        try {
-            const response = await aiService.chat(prompt, []);
-            const jsonMatch = response.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const extracted = JSON.parse(jsonMatch[0]);
-                if (extracted.title && extracted.description) {
-                    const decision = {
-                        id: randomUUID(),
-                        codebaseId,
-                        type: extracted.type || 'architectural',
-                        title: extracted.title,
-                        description: extracted.description,
-                        rationale: extracted.rationale || extracted.description,
-                        alternatives: extracted.alternatives || [],
-                        constraints: extracted.constraints || planningContext.constraints || [],
-                        tradeoffs: extracted.tradeoffs || [],
-                        consequences: extracted.consequences || [],
-                        metadata: {
-                            context: planningContext.goal,
-                            status: 'accepted',
-                            impact: 'medium',
-                            confidence: 7,
-                        },
-                        createdAt: new Date(),
-                    };
-                    await this.decisionRepository.store(decision);
-                    return decision;
-                }
-            }
-        }
-        catch (error) {
-            console.warn('AI decision extraction failed:', error);
-            // Fall back to basic extraction
-        }
-        return null;
-    }
-    /**
-     * Create basic decision from planning context (fallback)
-     */
-    async createBasicDecisionFromPlanning(planningContext, codebaseId) {
-        const decision = {
-            id: randomUUID(),
-            codebaseId,
-            type: 'architectural',
-            title: `Decision: ${planningContext.goal.substring(0, 50)}`,
-            description: `Decision made during planning: ${planningContext.goal}`,
-            rationale: 'Decision extracted from planning context',
-            alternatives: planningContext.alternatives || [],
-            constraints: planningContext.constraints || [],
-            metadata: {
-                context: planningContext.goal,
-                status: 'accepted',
-                impact: 'medium',
-                confidence: 5, // Lower confidence for basic extraction
-            },
-            createdAt: new Date(),
-        };
-        await this.decisionRepository.store(decision);
-        return decision;
-    }
-    /**
-     * Record technology choice decision
-     */
-    async recordTechnologyChoice(codebaseId, technology, rationale, alternatives, author) {
-        return await this.recordDecision({
-            codebaseId,
-            type: 'technology',
-            title: `Use ${technology}`,
-            description: `Decision to use ${technology} for this codebase`,
-            rationale,
-            alternatives,
-            author,
-        });
-    }
-    /**
-     * Record design pattern choice
-     */
-    async recordDesignPattern(codebaseId, patternName, rationale, alternatives, author) {
-        return await this.recordDecision({
-            codebaseId,
-            type: 'design-pattern',
-            title: `Use ${patternName} Pattern`,
-            description: `Decision to use ${patternName} design pattern`,
-            rationale,
-            alternatives,
-            author,
-        });
-    }
-    /**
-     * Record convention decision
-     */
-    async recordConvention(codebaseId, convention, rationale, author) {
-        return await this.recordDecision({
-            codebaseId,
-            type: 'convention',
-            title: `Convention: ${convention}`,
-            description: `Code convention: ${convention}`,
-            rationale,
-            author,
-        });
-    }
-    /**
-     * Link related decisions
-     */
-    async linkDecisions(decisionId1, decisionId2) {
-        const decision1 = await this.decisionRepository.getById(decisionId1);
-        const decision2 = await this.decisionRepository.getById(decisionId2);
-        if (!decision1 || !decision2) {
-            throw new Error('One or both decisions not found');
-        }
-        // Update decision1 to include decision2 in related decisions
-        if (!decision1.metadata) {
-            decision1.metadata = {};
-        }
-        if (!decision1.metadata.relatedDecisions) {
-            decision1.metadata.relatedDecisions = [];
-        }
-        if (!decision1.metadata.relatedDecisions.includes(decisionId2)) {
-            decision1.metadata.relatedDecisions.push(decisionId2);
-            await this.decisionRepository.update(decision1);
-        }
-        // Update decision2 to include decision1 in related decisions
-        if (!decision2.metadata) {
-            decision2.metadata = {};
-        }
-        if (!decision2.metadata.relatedDecisions) {
-            decision2.metadata.relatedDecisions = [];
-        }
-        if (!decision2.metadata.relatedDecisions.includes(decisionId1)) {
-            decision2.metadata.relatedDecisions.push(decisionId1);
-            await this.decisionRepository.update(decision2);
-        }
-    }
-}
-//# sourceMappingURL=decision-recorder.js.map

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

@@ -1,133 +0,0 @@
-/**
- * Domain Service: DecisionRetriever
- * Retrieves and queries decisions
- *
- * Clean Architecture: Domain Layer
- *
- * Responsibilities:
- * - Query decisions by context
- * - Find related decisions
- * - Explain why decisions were made
- * - Retrieve decisions for planning
- */
-/**
- * Decision Retriever Service
- * Provides query and explanation capabilities for decisions
- */
-export class DecisionRetriever {
-    decisionRepository;
-    constructor(decisionRepository) {
-        this.decisionRepository = decisionRepository;
-    }
-    /**
-     * Query decisions by context
-     */
-    async queryByContext(codebaseId, query, limit = 10) {
-        const decisions = await this.decisionRepository.search(codebaseId, query, limit);
-        // Generate explanation
-        const explanation = decisions.length > 0
-            ? this.generateExplanation(decisions)
-            : undefined;
-        return {
-            decisions,
-            totalCount: decisions.length,
-            explanation,
-        };
-    }
-    /**
-     * Find related decisions
-     */
-    async findRelated(decisionId, limit = 10) {
-        return await this.decisionRepository.findRelated(decisionId, limit);
-    }
-    /**
-     * Get decisions relevant to a planning goal
-     */
-    async getRelevantDecisions(codebaseId, goal, limit = 5) {
-        // Search for decisions relevant to the goal
-        const decisions = await this.decisionRepository.search(codebaseId, goal, limit);
-        // Also search by keywords from the goal
-        const keywords = this.extractKeywords(goal);
-        const keywordDecisions = [];
-        for (const keyword of keywords.slice(0, 3)) {
-            const keywordResults = await this.decisionRepository.search(codebaseId, keyword, 3);
-            keywordDecisions.push(...keywordResults);
-        }
-        // Combine and deduplicate
-        const allDecisions = [...decisions, ...keywordDecisions];
-        const uniqueDecisions = new Map();
-        for (const decision of allDecisions) {
-            if (decision.id && !uniqueDecisions.has(decision.id)) {
-                uniqueDecisions.set(decision.id, decision);
-            }
-        }
-        return Array.from(uniqueDecisions.values()).slice(0, limit);
-    }
-    /**
-     * Explain why a decision was made
-     */
-    async explainDecision(decisionId) {
-        const decision = await this.decisionRepository.getById(decisionId);
-        if (!decision) {
-            return null;
-        }
-        return {
-            decision,
-            rationale: decision.rationale,
-            context: decision.metadata?.context || decision.description,
-            alternatives: decision.alternatives,
-            tradeoffs: decision.tradeoffs,
-        };
-    }
-    /**
-     * Get decisions by type
-     */
-    async getByType(codebaseId, type, limit = 20) {
-        return await this.decisionRepository.findByType(codebaseId, type, limit);
-    }
-    /**
-     * Get recent decisions
-     */
-    async getRecent(codebaseId, limit = 10) {
-        return await this.decisionRepository.getRecent(codebaseId, limit);
-    }
-    /**
-     * Get decisions by status
-     */
-    async getByStatus(codebaseId, status, limit = 20) {
-        return await this.decisionRepository.getByStatus(codebaseId, status, limit);
-    }
-    /**
-     * Get all decisions for a codebase
-     */
-    async getAllDecisions(codebaseId) {
-        return await this.decisionRepository.findByCodebase(codebaseId, 1000);
-    }
-    /**
-     * Generate explanation for a set of decisions
-     */
-    generateExplanation(decisions) {
-        if (decisions.length === 0) {
-            return '';
-        }
-        if (decisions.length === 1) {
-            const decision = decisions[0];
-            return `Decision: ${decision.title}. Rationale: ${decision.rationale}`;
-        }
-        const types = new Set(decisions.map(d => d.type));
-        const typeList = Array.from(types).join(', ');
-        return `${decisions.length} decisions found (types: ${typeList}). These decisions inform the context and constraints for this codebase.`;
-    }
-    /**
-     * Extract keywords from a query string
-     */
-    extractKeywords(query) {
-        // Simple keyword extraction - can be enhanced with NLP
-        const words = query.toLowerCase().split(/\s+/);
-        const stopWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by']);
-        return words
-            .filter(word => word.length > 3 && !stopWords.has(word))
-            .slice(0, 5);
-    }
-}
-//# sourceMappingURL=decision-retriever.js.map

package/dist/domain/services/environment-mode-manager.js

@@ -1,22 +0,0 @@
-/**
- * Environment Mode Manager
- * Manages environment mode (LOCAL/ORG/INTERNET)
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { EnvironmentMode } from '../entities/task.js';
-/**
- * Get current environment mode
- */
-export function getCurrentEnvironmentMode() {
-    const envMode = process.env.CODEHERE_ENV_MODE?.toLowerCase();
-    if (envMode === 'org') {
-        return EnvironmentMode.ORG;
-    }
-    else if (envMode === 'internet') {
-        return EnvironmentMode.INTERNET;
-    }
-    // Default to LOCAL
-    return EnvironmentMode.LOCAL;
-}
-//# sourceMappingURL=environment-mode-manager.js.map

package/dist/domain/services/graded-memory-activation.js

@@ -1,69 +0,0 @@
-/**
- * Domain Service: Graded Memory Activation
- * Implements g(t) function for temporal relevance weighting
- *
- * Based on research: Nodes in middle of episodes get higher activation
- * This optimizes strategic learning by focusing on high-utility segments
- */
-export class GradedMemoryActivation {
-    /**
-     * Calculate graded activation for memory based on temporal position
-     * g(t) function: middle of episode gets higher weight
-     *
-     * @param memory - The memory to calculate activation for
-     * @param episodeStart - Start timestamp of the episode
-     * @param episodeEnd - End timestamp of the episode
-     * @returns Activation value between 0 and 1
-     */
-    calculateActivation(memory, episodeStart, episodeEnd) {
-        const episodeDuration = episodeEnd.getTime() - episodeStart.getTime();
-        if (episodeDuration === 0)
-            return 1.0;
-        const memoryTime = memory.timestamp.getTime();
-        const relativePosition = (memoryTime - episodeStart.getTime()) / episodeDuration;
-        // g(t) function: bell curve centered at 0.5 (middle of episode)
-        // Higher activation for memories in the middle, lower for start/end
-        const center = 0.5;
-        const spread = 0.3; // Controls how wide the activation zone is
-        // Gaussian-like function
-        const distanceFromCenter = Math.abs(relativePosition - center);
-        const activation = Math.exp(-Math.pow(distanceFromCenter / spread, 2));
-        return Math.max(0.1, Math.min(1.0, activation)); // Clamp between 0.1 and 1.0
-    }
-    /**
-     * Calculate activation for memory within recent episode window
-     * Uses last N memories as episode context
-     */
-    calculateActivationForRecent(memory, recentMemories, windowSize = 100) {
-        if (recentMemories.length === 0)
-            return 1.0;
-        // Find episode boundaries (first and last memory in window)
-        const sortedMemories = [...recentMemories].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-        const episodeStart = sortedMemories[0].timestamp;
-        const episodeEnd = sortedMemories[sortedMemories.length - 1].timestamp;
-        return this.calculateActivation(memory, episodeStart, episodeEnd);
-    }
-    /**
-     * Apply graded activation to memory retrieval
-     * Multiplies base relevance score by activation weight
-     */
-    applyGradedActivation(memories, episodeStart, episodeEnd) {
-        if (!episodeStart || !episodeEnd) {
-            // Use recent memories as episode context
-            const sorted = [...memories].sort((a, b) => a.memory.timestamp.getTime() - b.memory.timestamp.getTime());
-            if (sorted.length > 0) {
-                episodeStart = sorted[0].memory.timestamp;
-                episodeEnd = sorted[sorted.length - 1].memory.timestamp;
-            }
-            else {
-                return memories.map(m => ({ memory: m.memory, finalScore: m.baseScore }));
-            }
-        }
-        return memories.map(({ memory, baseScore }) => {
-            const activation = this.calculateActivation(memory, episodeStart, episodeEnd);
-            const finalScore = baseScore * activation;
-            return { memory, finalScore };
-        });
-    }
-}
-//# sourceMappingURL=graded-memory-activation.js.map

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

@@ -1,132 +0,0 @@
-/**
- * Domain Service: Knowledge Access
- * Provides access to preserved knowledge
- *
- * Clean Architecture: Domain Layer
- *
- * Responsibilities:
- * - Query preserved knowledge
- * - Provide knowledge summaries
- * - Link knowledge to patterns and decisions
- */
-/**
- * Knowledge Access Service
- * Provides query and summary capabilities for preserved knowledge
- */
-export class KnowledgeAccess {
-    knowledgeRepository;
-    patternRepository;
-    decisionRepository;
-    constructor(knowledgeRepository, patternRepository, decisionRepository) {
-        this.knowledgeRepository = knowledgeRepository;
-        this.patternRepository = patternRepository;
-        this.decisionRepository = decisionRepository;
-    }
-    /**
-     * Query knowledge by context
-     */
-    async query(codebaseId, query, limit = 10) {
-        return await this.knowledgeRepository.search(codebaseId, query, limit);
-    }
-    /**
-     * Get knowledge by type
-     */
-    async getByType(codebaseId, type, limit = 20) {
-        return await this.knowledgeRepository.findByType(codebaseId, type, limit);
-    }
-    /**
-     * Get knowledge by tags
-     */
-    async getByTags(codebaseId, tags, limit = 20) {
-        return await this.knowledgeRepository.findByTags(codebaseId, tags, limit);
-    }
-    /**
-     * Get knowledge summary for a codebase
-     */
-    async getSummary(codebaseId) {
-        const allKnowledge = await this.knowledgeRepository.findByCodebase(codebaseId, 1000);
-        // Count by type
-        const byType = {};
-        for (const knowledge of allKnowledge) {
-            byType[knowledge.type] = (byType[knowledge.type] || 0) + 1;
-        }
-        // Get most accessed
-        const mostAccessed = await this.knowledgeRepository.getMostAccessed(codebaseId, 5);
-        // Get recent
-        const recent = await this.knowledgeRepository.getRecent(codebaseId, 5);
-        // Generate summary
-        const summary = this.generateSummary(allKnowledge, byType);
-        return {
-            totalKnowledge: allKnowledge.length,
-            byType,
-            mostAccessed,
-            recent,
-            summary,
-        };
-    }
-    /**
-     * Get relevant knowledge for planning/query
-     */
-    async getRelevantKnowledge(codebaseId, context, limit = 5) {
-        // Search for relevant knowledge
-        const searchResults = await this.knowledgeRepository.search(codebaseId, context, limit);
-        // Also get by type if context suggests specific type
-        const typeMatches = this.inferKnowledgeType(context);
-        if (typeMatches.length > 0) {
-            const typeResults = [];
-            for (const type of typeMatches.slice(0, 2)) {
-                const results = await this.knowledgeRepository.findByType(codebaseId, type, 3);
-                typeResults.push(...results);
-            }
-            // Combine and deduplicate
-            const allResults = [...searchResults, ...typeResults];
-            const unique = new Map();
-            for (const knowledge of allResults) {
-                if (knowledge.id && !unique.has(knowledge.id)) {
-                    unique.set(knowledge.id, knowledge);
-                }
-            }
-            return Array.from(unique.values()).slice(0, limit);
-        }
-        return searchResults;
-    }
-    /**
-     * Generate summary text
-     */
-    generateSummary(knowledge, byType) {
-        if (knowledge.length === 0) {
-            return 'No knowledge preserved yet.';
-        }
-        const typeSummary = Object.entries(byType)
-            .map(([type, count]) => `${count} ${type}`)
-            .join(', ');
-        return `Preserved ${knowledge.length} knowledge items: ${typeSummary}.`;
-    }
-    /**
-     * Infer knowledge type from context query
-     */
-    inferKnowledgeType(context) {
-        const contextLower = context.toLowerCase();
-        const types = [];
-        if (/architecture|structure|design|system/.test(contextLower)) {
-            types.push('architectural');
-        }
-        if (/domain|business|logic|concept/.test(contextLower)) {
-            types.push('domain-knowledge');
-        }
-        if (/pattern|convention|style/.test(contextLower)) {
-            types.push('convention');
-        }
-        if (/documentation|comment|doc/.test(contextLower)) {
-            types.push('documentation');
-        }
-        if (/best.practice|guideline|recommendation/.test(contextLower)) {
-            types.push('best-practice');
-        }
-        if (/gotcha|warning|pitfall|trap/.test(contextLower)) {
-            types.push('gotcha');
-        }
-        return types;
-    }
-}
-//# sourceMappingURL=knowledge-access.js.map