codehere 0.2.2 → 0.3.0-rc.2

package/dist/infrastructure/xai/decision-tree-log.js

@@ -1,212 +0,0 @@
-/**
- * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
- *
- * Decision Tree Log - Complete audit trail for multi-step agentic workflows.
- * Used internally for logging/debugging. Not guaranteed to be stable.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-/**
- * Decision Tree Log
- * Maintains complete execution trace for agentic workflows
- */
-export class DecisionTreeLog {
-    nodes = new Map();
-    rootNodeId = null;
-    /**
-     * Log goal interpretation
-     */
-    logGoalInterpretation(goalId, interpretation, parentId) {
-        if (!this.rootNodeId) {
-            this.rootNodeId = goalId;
-        }
-        const node = {
-            id: goalId,
-            type: 'goal',
-            timestamp: Date.now(),
-            description: `Goal: ${interpretation.parsedIntent}`,
-            metadata: {
-                parsedIntent: interpretation.parsedIntent,
-                constraints: interpretation.constraints,
-                dependencies: interpretation.dependencies,
-                confidence: interpretation.confidence,
-            },
-            parentId,
-        };
-        this.nodes.set(goalId, node);
-        return goalId;
-    }
-    /**
-     * Log plan step
-     */
-    logPlanStep(planId, stepDescription, metadata, parentId) {
-        const node = {
-            id: planId,
-            type: 'plan',
-            timestamp: Date.now(),
-            description: stepDescription,
-            metadata,
-            parentId,
-        };
-        this.nodes.set(planId, node);
-        this.addChild(parentId, planId);
-        return planId;
-    }
-    /**
-     * Log tool execution with rationale
-     */
-    logToolExecution(toolId, rationale, parentId) {
-        const node = {
-            id: toolId,
-            type: 'tool',
-            timestamp: Date.now(),
-            description: `Tool: ${rationale.toolName}`,
-            metadata: {
-                toolName: rationale.toolName,
-                parameters: rationale.parameters,
-                reasoning: rationale.reasoning,
-                alternativeTools: rationale.alternativeTools,
-                executionTime: rationale.executionTime,
-                rawOutput: rationale.rawOutput, // Unaltered tool result for provenance
-            },
-            parentId,
-        };
-        this.nodes.set(toolId, node);
-        this.addChild(parentId, toolId);
-        return toolId;
-    }
-    /**
-     * Log external data provenance
-     */
-    logExternalData(dataId, provenance, parentId) {
-        const node = {
-            id: dataId,
-            type: 'tool', // External data comes via tools
-            timestamp: Date.now(),
-            description: `External Data: ${provenance.source}`,
-            metadata: {
-                source: provenance.source,
-                timestamp: provenance.timestamp,
-                freshness: provenance.freshness,
-                trustLevel: provenance.trustLevel,
-                url: provenance.url,
-                dataAge: Date.now() - provenance.timestamp, // Age in milliseconds
-            },
-            parentId,
-        };
-        this.nodes.set(dataId, node);
-        this.addChild(parentId, dataId);
-        return dataId;
-    }
-    /**
-     * Log integration step (how LLM processed external data)
-     */
-    logIntegrationStep(integrationId, step, parentId) {
-        const node = {
-            id: integrationId,
-            type: 'synthesis',
-            timestamp: Date.now(),
-            description: step.processingDescription,
-            metadata: {
-                inputData: step.inputData,
-                outputData: step.outputData,
-                transformations: step.transformations,
-            },
-            parentId,
-        };
-        this.nodes.set(integrationId, node);
-        this.addChild(parentId, integrationId);
-        return integrationId;
-    }
-    /**
-     * Log error
-     */
-    logError(errorId, error, context, parentId) {
-        const node = {
-            id: errorId,
-            type: 'error',
-            timestamp: Date.now(),
-            description: `Error: ${error.message}`,
-            metadata: {
-                error: error.message,
-                stack: error.stack,
-                context,
-            },
-            parentId,
-        };
-        this.nodes.set(errorId, node);
-        this.addChild(parentId, errorId);
-        return errorId;
-    }
-    /**
-     * Get complete execution tree
-     */
-    getExecutionTree() {
-        if (!this.rootNodeId) {
-            return null;
-        }
-        return this.buildTree(this.rootNodeId);
-    }
-    /**
-     * Build tree structure recursively
-     */
-    buildTree(nodeId) {
-        const node = this.nodes.get(nodeId);
-        if (!node) {
-            return null;
-        }
-        const children = [];
-        if (node.childNodeIds && node.childNodeIds.length > 0) {
-            for (const childId of node.childNodeIds) {
-                const childNode = this.buildTree(childId);
-                if (childNode) {
-                    children.push(childNode);
-                }
-            }
-        }
-        return {
-            ...node,
-            children: children.length > 0 ? children : undefined,
-        };
-    }
-    /**
-     * Add child node to parent
-     */
-    addChild(parentId, childId) {
-        const parent = this.nodes.get(parentId);
-        if (parent) {
-            if (!parent.childNodeIds) {
-                parent.childNodeIds = [];
-            }
-            if (!parent.childNodeIds.includes(childId)) {
-                parent.childNodeIds.push(childId);
-            }
-        }
-    }
-    /**
-     * Get trace for fault attribution
-     */
-    getErrorTrace(errorId) {
-        const trace = [];
-        let currentId = errorId;
-        while (currentId) {
-            const node = this.nodes.get(currentId);
-            if (!node) {
-                break;
-            }
-            trace.unshift(node);
-            currentId = node.parentId;
-        }
-        return trace;
-    }
-    /**
-     * Clear log
-     */
-    clear() {
-        this.nodes.clear();
-        this.rootNodeId = null;
-    }
-}
-//# sourceMappingURL=decision-tree-log.js.map

package/dist/infrastructure/xai/interactive-xai.js

@@ -1,260 +0,0 @@
-/**
- * INTERNAL ONLY — experimental feature, not a user-facing feature.
- *
- * Interactive XAI System - Allows users to click on code for explanations.
- * Experimental infrastructure. Not guaranteed to be stable. May be moved to experimental directory.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-/**
- * Interactive XAI System
- * Enables users to explore AI reasoning interactively
- */
-export class InteractiveXAI {
-    sessions = new Map();
-    /**
-     * Create new interactive XAI session
-     */
-    createSession(sessionId, query, options) {
-        const state = {
-            sessionId,
-            query,
-            explanations: new Map(),
-            cotTrajectoryId: options?.cotTrajectoryId,
-            attentionMapId: options?.attentionMapId,
-            createdAt: Date.now(),
-        };
-        this.sessions.set(sessionId, state);
-        return state;
-    }
-    /**
-     * Get explanation for code span
-     */
-    getExplanation(sessionId, filepath, startLine, endLine) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return null;
-        }
-        const key = this.getExplanationKey(filepath, startLine, endLine);
-        return session.explanations.get(key) || null;
-    }
-    /**
-     * Register code explanation
-     */
-    registerExplanation(sessionId, explanation) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        const key = this.getExplanationKey(explanation.codeSpan.filepath, explanation.codeSpan.startLine, explanation.codeSpan.endLine);
-        session.explanations.set(key, explanation);
-    }
-    /**
-     * Generate explanation for code span (on-demand)
-     */
-    async generateExplanation(sessionId, filepath, startLine, endLine, code, context) {
-        // Check if explanation already exists
-        const existing = this.getExplanation(sessionId, filepath, startLine, endLine);
-        if (existing) {
-            return existing;
-        }
-        // Generate explanation
-        const explanation = {
-            codeSpan: {
-                filepath,
-                startLine,
-                endLine,
-                content: code,
-            },
-            explanation: {
-                why: this.generateWhyExplanation(code, context.query),
-                how: this.generateHowExplanation(code, context.query),
-                confidence: this.calculateConfidence(context),
-                uncertainty: context.uncertainty ? {
-                    epistemic: context.uncertainty.epistemic?.value || 0,
-                    aleatoric: context.uncertainty.aleatoric?.value,
-                    isHallucinationRisk: context.uncertainty.isHallucinationRisk || false,
-                } : undefined,
-            },
-            reasoning: {
-                cotStepId: this.findRelatedCoTStep(context.cotTrajectory, code),
-                attentionSpans: this.findRelatedAttentionSpans(context.attentionMap, filepath, startLine, endLine),
-                decisionPoint: this.findDecisionPoint(context.cotTrajectory, code),
-            },
-            metadata: {
-                timestamp: Date.now(),
-            },
-        };
-        // Register explanation
-        this.registerExplanation(sessionId, explanation);
-        return explanation;
-    }
-    /**
-     * Get all explanations for a file
-     */
-    getFileExplanations(sessionId, filepath) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return [];
-        }
-        const explanations = [];
-        for (const explanation of session.explanations.values()) {
-            if (explanation.codeSpan.filepath === filepath) {
-                explanations.push(explanation);
-            }
-        }
-        return explanations.sort((a, b) => a.codeSpan.startLine - b.codeSpan.startLine);
-    }
-    /**
-     * Format explanation for display
-     */
-    formatExplanation(explanation, format) {
-        switch (format) {
-            case 'console':
-                return this.formatForConsole(explanation);
-            case 'json':
-                return JSON.stringify(explanation, null, 2);
-            case 'markdown':
-                return this.formatForMarkdown(explanation);
-        }
-    }
-    /**
-     * Get session state
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId) || null;
-    }
-    // Private helpers
-    getExplanationKey(filepath, startLine, endLine) {
-        return `${filepath}:${startLine}:${endLine}`;
-    }
-    generateWhyExplanation(code, query) {
-        // Simple heuristic-based explanation
-        // In production, this would use LLM to generate explanation
-        return `This code was generated to address: "${query.substring(0, 100)}". The implementation follows the requested functionality.`;
-    }
-    generateHowExplanation(code, query) {
-        // Simple heuristic-based explanation
-        // In production, this would use LLM to generate explanation
-        return `This code relates to the query by implementing the core logic requested.`;
-    }
-    calculateConfidence(context) {
-        // Calculate confidence based on uncertainty and context quality
-        let confidence = 0.8; // Default
-        if (context.uncertainty) {
-            const epistemic = context.uncertainty.epistemic?.value || 0;
-            confidence = 1 - epistemic; // Lower epistemic uncertainty = higher confidence
-        }
-        // Adjust based on attention map quality
-        if (context.attentionMap) {
-            const avgAttention = context.attentionMap.averageAttentionScore || 0;
-            confidence = (confidence + avgAttention) / 2;
-        }
-        return Math.max(0, Math.min(1, confidence));
-    }
-    findRelatedCoTStep(cotTrajectory, code) {
-        // Find CoT step that likely generated this code
-        // In production, this would analyze trajectory and code content
-        if (!cotTrajectory || !cotTrajectory.steps) {
-            return undefined;
-        }
-        // Find action steps that match code generation
-        for (const step of cotTrajectory.steps) {
-            if (step.type === 'action' && step.metadata?.tool === 'edit' || step.metadata?.tool === 'create') {
-                return step.stepId;
-            }
-        }
-        return undefined;
-    }
-    findRelatedAttentionSpans(attentionMap, filepath, startLine, endLine) {
-        if (!attentionMap || !attentionMap.spans) {
-            return undefined;
-        }
-        // Find attention spans related to this file/region
-        const related = [];
-        for (const span of attentionMap.spans) {
-            if (span.filepath === filepath) {
-                // Check if spans overlap
-                if (span.startLine <= endLine && span.endLine >= startLine) {
-                    related.push({
-                        filepath: span.filepath,
-                        lines: Array.from({ length: span.endLine - span.startLine + 1 }, (_, i) => span.startLine + i),
-                        relevanceScore: span.attentionScore,
-                    });
-                }
-            }
-        }
-        return related.length > 0 ? related : undefined;
-    }
-    findDecisionPoint(cotTrajectory, code) {
-        // Find decision point that led to this code
-        if (!cotTrajectory || !cotTrajectory.steps) {
-            return undefined;
-        }
-        for (const step of cotTrajectory.steps) {
-            if (step.type === 'decision') {
-                return step.metadata?.decision || step.content;
-            }
-        }
-        return undefined;
-    }
-    formatForConsole(explanation) {
-        let output = '';
-        output += `\n${'═'.repeat(80)}\n`;
-        output += `Code Explanation: ${explanation.codeSpan.filepath} (lines ${explanation.codeSpan.startLine}-${explanation.codeSpan.endLine})\n`;
-        output += `${'═'.repeat(80)}\n\n`;
-        output += `Why:\n  ${explanation.explanation.why}\n\n`;
-        output += `How:\n  ${explanation.explanation.how}\n\n`;
-        output += `Confidence: ${(explanation.explanation.confidence * 100).toFixed(1)}%\n`;
-        if (explanation.explanation.uncertainty) {
-            output += `\nUncertainty:\n`;
-            output += `  Epistemic: ${(explanation.explanation.uncertainty.epistemic * 100).toFixed(1)}%\n`;
-            if (explanation.explanation.uncertainty.isHallucinationRisk) {
-                output += `  ⚠️  Hallucination Risk Detected\n`;
-            }
-        }
-        if (explanation.reasoning.cotStepNumber) {
-            output += `\nRelated Reasoning Step: #${explanation.reasoning.cotStepNumber}\n`;
-        }
-        if (explanation.reasoning.attentionSpans && explanation.reasoning.attentionSpans.length > 0) {
-            output += `\nContext Influences:\n`;
-            for (const span of explanation.reasoning.attentionSpans.slice(0, 3)) {
-                output += `  - ${span.filepath} (lines ${span.lines[0]}-${span.lines[span.lines.length - 1]}) - Relevance: ${(span.relevanceScore * 100).toFixed(1)}%\n`;
-            }
-        }
-        output += `\n${'═'.repeat(80)}\n`;
-        return output;
-    }
-    formatForMarkdown(explanation) {
-        let output = '';
-        output += `## Code Explanation\n\n`;
-        output += `**File:** \`${explanation.codeSpan.filepath}\` (lines ${explanation.codeSpan.startLine}-${explanation.codeSpan.endLine})\n\n`;
-        output += `### Why\n\n${explanation.explanation.why}\n\n`;
-        output += `### How\n\n${explanation.explanation.how}\n\n`;
-        output += `**Confidence:** ${(explanation.explanation.confidence * 100).toFixed(1)}%\n\n`;
-        if (explanation.explanation.uncertainty) {
-            output += `### Uncertainty\n\n`;
-            output += `- Epistemic: ${(explanation.explanation.uncertainty.epistemic * 100).toFixed(1)}%\n`;
-            if (explanation.explanation.uncertainty.isHallucinationRisk) {
-                output += `- ⚠️  **Hallucination Risk Detected**\n`;
-            }
-            output += `\n`;
-        }
-        if (explanation.reasoning.cotStepNumber) {
-            output += `### Related Reasoning\n\n`;
-            output += `Part of reasoning step #${explanation.reasoning.cotStepNumber}\n\n`;
-        }
-        if (explanation.reasoning.attentionSpans && explanation.reasoning.attentionSpans.length > 0) {
-            output += `### Context Influences\n\n`;
-            for (const span of explanation.reasoning.attentionSpans.slice(0, 3)) {
-                output += `- \`${span.filepath}\` (lines ${span.lines[0]}-${span.lines[span.lines.length - 1]}) - Relevance: ${(span.relevanceScore * 100).toFixed(1)}%\n`;
-            }
-            output += `\n`;
-        }
-        output += `\`\`\`\n${explanation.codeSpan.content}\n\`\`\`\n`;
-        return output;
-    }
-}
-//# sourceMappingURL=interactive-xai.js.map

package/dist/infrastructure/xai/uncertainty-quantifier.js

@@ -1,198 +0,0 @@
-/**
- * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
- *
- * Uncertainty Quantifier - Distinguishes Epistemic vs Aleatoric uncertainty.
- * Used internally for logging/debugging. Not guaranteed to be stable.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-/**
- * Uncertainty Quantifier
- * Quantifies and communicates model uncertainty
- */
-export class UncertaintyQuantifier {
-    epistemicThreshold = 0.7; // High epistemic = hallucination risk
-    /**
-     * Quantify uncertainty from LLM response
-     * Uses multiple sampling approach (dropout method)
-     */
-    async quantifyUncertainty(query, response, context) {
-        // For now, use heuristics based on response characteristics
-        // In production, would use multiple sampling (dropout method)
-        // 1. Epistemic Uncertainty (model knowledge gap)
-        const epistemic = this.estimateEpistemicUncertainty(query, response, context);
-        // 2. Aleatoric Uncertainty (inherent randomness)
-        const aleatoric = this.estimateAleatoricUncertainty(response);
-        // 3. Combined Uncertainty
-        const combined = this.combineUncertainties(epistemic, aleatoric);
-        return {
-            epistemic,
-            aleatoric,
-            combined,
-            isHallucinationRisk: epistemic.value > this.epistemicThreshold,
-        };
-    }
-    /**
-     * Estimate epistemic uncertainty (model knowledge gap)
-     * High epistemic = query outside training distribution
-     */
-    estimateEpistemicUncertainty(query, response, context) {
-        let epistemicValue = 0;
-        const factors = [];
-        // Factor 1: Query complexity (unknown patterns)
-        if (this.hasUnknownPatterns(query)) {
-            epistemicValue += 0.3;
-            factors.push('Query contains unknown patterns');
-        }
-        // Factor 2: Context availability (low context = high uncertainty)
-        const contextScore = this.calculateContextScore(context);
-        if (contextScore < 0.3) {
-            epistemicValue += 0.3;
-            factors.push('Low context availability');
-        }
-        // Factor 3: Response confidence markers (hedging language)
-        if (this.hasHedgingLanguage(response)) {
-            epistemicValue += 0.2;
-            factors.push('Response contains hedging language');
-        }
-        // Factor 4: Niche/proprietary API usage (outside training)
-        if (this.hasNicheAPIs(response)) {
-            epistemicValue += 0.4;
-            factors.push('Niche or proprietary API usage detected');
-        }
-        epistemicValue = Math.min(epistemicValue, 1.0);
-        const riskLevel = this.getRiskLevel(epistemicValue);
-        const recommendation = epistemicValue > this.epistemicThreshold
-            ? 'High epistemic uncertainty detected. This may indicate hallucination risk. Verify output carefully, especially for niche APIs or proprietary patterns.'
-            : undefined;
-        return {
-            type: 'epistemic',
-            value: epistemicValue,
-            explanation: factors.length > 0
-                ? `Epistemic uncertainty factors: ${factors.join('; ')}`
-                : 'Low epistemic uncertainty - query appears within model knowledge',
-            riskLevel,
-            recommendation,
-        };
-    }
-    /**
-     * Estimate aleatoric uncertainty (inherent randomness)
-     */
-    estimateAleatoricUncertainty(response) {
-        // Aleatoric uncertainty is harder to estimate from single response
-        // Would require multiple samples in production
-        // For now, estimate based on response variability markers
-        let aleatoricValue = 0;
-        // Multiple valid solutions increase aleatoric uncertainty
-        if (response.includes('alternative') || response.includes('could also')) {
-            aleatoricValue += 0.2;
-        }
-        // Default to low aleatoric (assuming deterministic generation)
-        aleatoricValue = Math.min(aleatoricValue, 0.3);
-        return {
-            type: 'aleatoric',
-            value: aleatoricValue,
-            explanation: 'Inherent randomness in generation process',
-            riskLevel: aleatoricValue < 0.2 ? 'low' : 'medium',
-        };
-    }
-    /**
-     * Combine uncertainties
-     */
-    combineUncertainties(epistemic, aleatoric) {
-        const aleatoricValue = aleatoric?.value || 0;
-        const combinedValue = Math.max(epistemic.value, aleatoricValue);
-        return {
-            type: 'combined',
-            value: combinedValue,
-            explanation: `Combined uncertainty: ${epistemic.value.toFixed(2)} epistemic, ${aleatoricValue.toFixed(2)} aleatoric`,
-            riskLevel: this.getRiskLevel(combinedValue),
-            recommendation: epistemic.recommendation,
-        };
-    }
-    /**
-     * Check for unknown patterns (outside training distribution)
-     */
-    hasUnknownPatterns(query) {
-        // Heuristic: Very specific, niche terminology
-        const nichePatterns = [
-            /internal.*?api/i,
-            /proprietary/i,
-            /custom.*?framework/i,
-            /company.*?specific/i,
-        ];
-        return nichePatterns.some(pattern => pattern.test(query));
-    }
-    /**
-     * Calculate context availability score
-     */
-    calculateContextScore(context) {
-        if (!context) {
-            return 0;
-        }
-        const chunkCount = context.chunks?.length || 0;
-        const memoryCount = context.memories?.length || 0;
-        // More context = lower epistemic uncertainty
-        if (chunkCount > 5 && memoryCount > 2) {
-            return 0.8;
-        }
-        if (chunkCount > 3 || memoryCount > 1) {
-            return 0.5;
-        }
-        if (chunkCount > 0 || memoryCount > 0) {
-            return 0.3;
-        }
-        return 0;
-    }
-    /**
-     * Check for hedging language (indicates uncertainty)
-     */
-    hasHedgingLanguage(response) {
-        const hedging = [
-            /might/i,
-            /could/i,
-            /possibly/i,
-            /may/i,
-            /perhaps/i,
-            /probably/i,
-            /likely/i,
-        ];
-        return hedging.some(pattern => pattern.test(response));
-    }
-    /**
-     * Check for niche/proprietary APIs
-     */
-    hasNicheAPIs(response) {
-        const nichePatterns = [
-            /internal.*?sdk/i,
-            /company.*?api/i,
-            /custom.*?service/i,
-            /proprietary.*?library/i,
-        ];
-        return nichePatterns.some(pattern => pattern.test(response));
-    }
-    /**
-     * Get risk level from uncertainty value
-     */
-    getRiskLevel(value) {
-        if (value >= 0.8) {
-            return 'critical';
-        }
-        if (value >= 0.6) {
-            return 'high';
-        }
-        if (value >= 0.4) {
-            return 'medium';
-        }
-        return 'low';
-    }
-    /**
-     * Set epistemic threshold
-     */
-    setEpistemicThreshold(threshold) {
-        this.epistemicThreshold = threshold;
-    }
-}
-//# sourceMappingURL=uncertainty-quantifier.js.map