codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/verification/verification-service.js

@@ -1,47 +0,0 @@
-/**
- * Infrastructure: VerificationService
- * Implements IVerificationService using existing verification system
- */
-import { verifyFile } from '../../verification/index.js';
-export class VerificationService {
-    async verifyCompilation(filepath) {
-        const result = await verifyFile(filepath, {
-            verifyCompilation: true,
-            runTests: false,
-        });
-        return {
-            success: result.success,
-            compiled: result.compiled,
-            testsPassed: false,
-            errors: result.errors,
-            warnings: result.warnings,
-        };
-    }
-    async runTests(filepath) {
-        const result = await verifyFile(filepath, {
-            verifyCompilation: false,
-            runTests: true,
-        });
-        return {
-            success: result.success,
-            compiled: true,
-            testsPassed: result.testsPassed,
-            errors: result.errors,
-            warnings: result.warnings,
-        };
-    }
-    async verify(filepath) {
-        const result = await verifyFile(filepath, {
-            verifyCompilation: true,
-            runTests: true,
-        });
-        return {
-            success: result.success,
-            compiled: result.compiled,
-            testsPassed: result.testsPassed,
-            errors: result.errors,
-            warnings: result.warnings,
-        };
-    }
-}
-//# sourceMappingURL=verification-service.js.map

package/dist/infrastructure/xai/attention-visualizer.js

@@ -1,172 +0,0 @@
-/**
- * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
- *
- * Attention Visualizer - Visualizes which parts of code/context the AI is focusing on.
- * Used internally for logging/debugging. Not guaranteed to be stable.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-/**
- * Attention Visualizer
- * Identifies and visualizes code regions the AI is focusing on
- */
-export class AttentionVisualizer {
-    /**
-     * Generate attention map from code chunks and relevance scores
-     */
-    generateAttentionMap(query, chunks) {
-        const spans = chunks.map((chunk, index) => {
-            // Normalize score to 0-1 range (if not already)
-            const rawScore = chunk.score || 0;
-            const maxScore = Math.max(...chunks.map(c => c.score || 0), 1);
-            const attentionScore = maxScore > 0 ? rawScore / maxScore : 0;
-            // Extract line numbers if available
-            const startLine = chunk.startLine || 1;
-            const endLine = chunk.endLine || startLine + chunk.content.split('\n').length;
-            return {
-                filepath: chunk.filepath,
-                startLine,
-                endLine,
-                content: chunk.content,
-                attentionScore,
-                relevanceReason: this.generateRelevanceReason(chunk, attentionScore),
-            };
-        });
-        // Sort by attention score (descending)
-        spans.sort((a, b) => b.attentionScore - a.attentionScore);
-        const averageAttentionScore = spans.reduce((sum, span) => sum + span.attentionScore, 0) / spans.length;
-        return {
-            query,
-            spans,
-            totalContextLines: spans.reduce((sum, span) => sum + (span.endLine - span.startLine + 1), 0),
-            averageAttentionScore,
-            topAttentionSpans: spans.slice(0, 5), // Top 5 most attended spans
-            createdAt: Date.now(),
-        };
-    }
-    /**
-     * Format attention map for console output
-     */
-    formatForConsole(attentionMap, options) {
-        const { maxSpans = 10, showContent = false } = options || {};
-        const spansToShow = attentionMap.topAttentionSpans.slice(0, maxSpans);
-        let output = '';
-        output += `\n${'═'.repeat(80)}\n`;
-        output += `Attention Map: ${attentionMap.query.substring(0, 60)}${attentionMap.query.length > 60 ? '...' : ''}\n`;
-        output += `${'═'.repeat(80)}\n\n`;
-        output += `Total context: ${attentionMap.totalContextLines} lines across ${attentionMap.spans.length} spans\n`;
-        output += `Average attention score: ${(attentionMap.averageAttentionScore * 100).toFixed(1)}%\n\n`;
-        output += `Top ${spansToShow.length} Most Attended Code Regions:\n`;
-        output += `${'─'.repeat(80)}\n\n`;
-        for (let i = 0; i < spansToShow.length; i++) {
-            const span = spansToShow[i];
-            const attentionBar = this.generateAttentionBar(span.attentionScore);
-            output += `${i + 1}. ${span.filepath} (lines ${span.startLine}-${span.endLine})\n`;
-            output += `   Attention: ${attentionBar} ${(span.attentionScore * 100).toFixed(1)}%\n`;
-            if (span.relevanceReason) {
-                output += `   Reason: ${span.relevanceReason}\n`;
-            }
-            if (showContent) {
-                const preview = span.content.split('\n').slice(0, 5).join('\n');
-                output += `   Preview:\n${preview.split('\n').map(line => `      ${line}`).join('\n')}\n`;
-                if (span.content.split('\n').length > 5) {
-                    output += `      ... (${span.content.split('\n').length - 5} more lines)\n`;
-                }
-            }
-            output += '\n';
-        }
-        return output;
-    }
-    /**
-     * Generate attention heatmap data (for UI visualization)
-     */
-    generateHeatmapData(attentionMap) {
-        // Group spans by filepath
-        const fileMap = new Map();
-        for (const span of attentionMap.spans) {
-            if (!fileMap.has(span.filepath)) {
-                fileMap.set(span.filepath, []);
-            }
-            fileMap.get(span.filepath).push(span);
-        }
-        // Generate heatmap data for each file
-        const heatmapData = [];
-        for (const [filepath, spans] of fileMap.entries()) {
-            const lineMap = new Map();
-            // Collect attention scores per line
-            for (const span of spans) {
-                const lines = span.content.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    const lineNumber = span.startLine + i;
-                    const existing = lineMap.get(lineNumber);
-                    // Use max attention score if line appears in multiple spans
-                    const score = existing
-                        ? Math.max(existing.score, span.attentionScore)
-                        : span.attentionScore;
-                    lineMap.set(lineNumber, {
-                        score,
-                        content: lines[i],
-                    });
-                }
-            }
-            // Convert to array and sort by line number
-            const lines = Array.from(lineMap.entries())
-                .map(([lineNumber, data]) => ({
-                lineNumber,
-                attentionScore: data.score,
-                content: data.content,
-            }))
-                .sort((a, b) => a.lineNumber - b.lineNumber);
-            heatmapData.push({
-                filepath,
-                lines,
-            });
-        }
-        return heatmapData;
-    }
-    /**
-     * Verify context grounding (check if attention spans actually relate to query)
-     */
-    verifyGrounding(attentionMap, query) {
-        const issues = [];
-        let totalScore = 0;
-        for (const span of attentionMap.topAttentionSpans.slice(0, 3)) {
-            totalScore += span.attentionScore;
-            // Check if high-attention spans have low relevance
-            if (span.attentionScore > 0.8 && !span.relevanceReason) {
-                issues.push(`High attention span (${span.filepath}) lacks clear relevance reason`);
-            }
-        }
-        const averageTopScore = totalScore / Math.min(3, attentionMap.topAttentionSpans.length);
-        const grounded = averageTopScore > 0.5 && issues.length === 0;
-        const confidence = averageTopScore;
-        return {
-            grounded,
-            confidence,
-            issues: issues.length > 0 ? issues : undefined,
-        };
-    }
-    // Private helpers
-    generateRelevanceReason(chunk, attentionScore) {
-        if (attentionScore > 0.8) {
-            return 'Highly relevant - direct match to query';
-        }
-        else if (attentionScore > 0.5) {
-            return 'Relevant - related functionality';
-        }
-        else if (attentionScore > 0.2) {
-            return 'Somewhat relevant - contextual reference';
-        }
-        else {
-            return 'Low relevance - background context';
-        }
-    }
-    generateAttentionBar(score, length = 20) {
-        const filled = Math.round(score * length);
-        const empty = length - filled;
-        return '█'.repeat(filled) + '░'.repeat(empty);
-    }
-}
-//# sourceMappingURL=attention-visualizer.js.map

package/dist/infrastructure/xai/cot-visualizer.js

@@ -1,283 +0,0 @@
-/**
- * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
- *
- * Chain-of-Thought (CoT) Visualizer - Visualizes AI reasoning steps in a human-readable format.
- * Used internally for logging and debugging. Not guaranteed to be stable.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-import { colors } from '../../ui.js';
-/**
- * Chain-of-Thought Visualizer
- * Formats reasoning steps for human-readable display
- */
-export class CoTVisualizer {
-    /**
-     * Create new CoT trajectory
-     */
-    createTrajectory(query) {
-        return {
-            trajectoryId: `cot-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            query,
-            steps: [],
-            currentStep: 0,
-            status: 'in_progress',
-            startedAt: Date.now(),
-        };
-    }
-    /**
-     * Add thought step
-     */
-    addThought(trajectory, thought, metadata) {
-        const stepId = `step-${Date.now()}-thought`;
-        const step = {
-            stepId,
-            stepNumber: trajectory.steps.length + 1,
-            type: 'thought',
-            content: thought,
-            timestamp: Date.now(),
-            metadata,
-        };
-        trajectory.steps.push(step);
-        trajectory.currentStep = trajectory.steps.length;
-        return stepId;
-    }
-    /**
-     * Add action step (tool call, edit, etc.)
-     */
-    addAction(trajectory, action, metadata) {
-        const stepId = `step-${Date.now()}-action`;
-        const step = {
-            stepId,
-            stepNumber: trajectory.steps.length + 1,
-            type: 'action',
-            content: action,
-            timestamp: Date.now(),
-            metadata,
-        };
-        trajectory.steps.push(step);
-        trajectory.currentStep = trajectory.steps.length;
-        return stepId;
-    }
-    /**
-     * Add observation step (tool result, file content, etc.)
-     */
-    addObservation(trajectory, observation, metadata) {
-        const stepId = `step-${Date.now()}-observation`;
-        const step = {
-            stepId,
-            stepNumber: trajectory.steps.length + 1,
-            type: 'observation',
-            content: observation,
-            timestamp: Date.now(),
-            metadata,
-        };
-        trajectory.steps.push(step);
-        trajectory.currentStep = trajectory.steps.length;
-        return stepId;
-    }
-    /**
-     * Add decision step (choice point, branching)
-     */
-    addDecision(trajectory, decision, options, chosen, rationale) {
-        const stepId = `step-${Date.now()}-decision`;
-        const step = {
-            stepId,
-            stepNumber: trajectory.steps.length + 1,
-            type: 'decision',
-            content: decision,
-            timestamp: Date.now(),
-            metadata: {
-                options,
-                chosen,
-                reasoning: rationale,
-            },
-        };
-        trajectory.steps.push(step);
-        trajectory.currentStep = trajectory.steps.length;
-        return stepId;
-    }
-    /**
-     * Add error step
-     */
-    addError(trajectory, error, errorDetails) {
-        const stepId = `step-${Date.now()}-error`;
-        const step = {
-            stepId,
-            stepNumber: trajectory.steps.length + 1,
-            type: 'error',
-            content: error,
-            timestamp: Date.now(),
-            metadata: {
-                errorDetails,
-            },
-        };
-        trajectory.steps.push(step);
-        trajectory.currentStep = trajectory.steps.length;
-        trajectory.status = 'failed';
-        return stepId;
-    }
-    /**
-     * Mark trajectory as completed
-     */
-    completeTrajectory(trajectory) {
-        trajectory.status = 'completed';
-        trajectory.completedAt = Date.now();
-    }
-    /**
-     * Format trajectory for console output (human-readable)
-     */
-    formatForConsole(trajectory, options) {
-        const { showMetadata = false, maxSteps, compact = false } = options || {};
-        const steps = maxSteps ? trajectory.steps.slice(0, maxSteps) : trajectory.steps;
-        let output = '';
-        if (!compact) {
-            output += `\n${'═'.repeat(80)}\n`;
-            output += `Chain of Thought: ${trajectory.query.substring(0, 60)}${trajectory.query.length > 60 ? '...' : ''}\n`;
-            output += `${'═'.repeat(80)}\n\n`;
-        }
-        for (const step of steps) {
-            output += this.formatStep(step, { showMetadata, compact });
-        }
-        if (trajectory.status === 'completed' && !compact) {
-            output += `\n${'─'.repeat(80)}\n`;
-            output += `✓ Completed in ${trajectory.steps.length} steps`;
-            if (trajectory.completedAt && trajectory.startedAt) {
-                const duration = ((trajectory.completedAt - trajectory.startedAt) / 1000).toFixed(2);
-                output += ` (${duration}s)\n`;
-            }
-            output += `${'─'.repeat(80)}\n`;
-        }
-        return output;
-    }
-    /**
-     * Format trajectory for JSON export
-     */
-    formatForJSON(trajectory) {
-        return JSON.stringify(trajectory, null, 2);
-    }
-    /**
-     * Format trajectory for interactive UI (structured data)
-     */
-    formatForUI(trajectory) {
-        return {
-            query: trajectory.query,
-            status: trajectory.status,
-            steps: trajectory.steps.map(step => ({
-                number: step.stepNumber,
-                type: step.type,
-                content: step.content,
-                timestamp: step.timestamp,
-                metadata: step.metadata,
-            })),
-            duration: trajectory.completedAt && trajectory.startedAt
-                ? trajectory.completedAt - trajectory.startedAt
-                : undefined,
-        };
-    }
-    // Private helpers
-    formatStep(step, options) {
-        const { showMetadata = false, compact = false } = options;
-        let output = '';
-        const maxWidth = process.stdout.columns || 80;
-        const indent = '  ';
-        const contentWidth = maxWidth - indent.length - 10; // Reserve space for prefix/icon
-        const prefix = compact ? '' : `[Step ${step.stepNumber}] `;
-        const icon = this.getStepIcon(step.type);
-        // Word wrap helper for long content
-        const wrapText = (text, width, prefix = '') => {
-            if (compact && text.length > 150) {
-                // In compact mode, truncate long content
-                return text.substring(0, 150) + '...';
-            }
-            const words = text.split(' ');
-            const lines = [];
-            let currentLine = '';
-            for (const word of words) {
-                if ((currentLine + word).length > width) {
-                    if (currentLine)
-                        lines.push(prefix + currentLine.trim());
-                    currentLine = word + ' ';
-                }
-                else {
-                    currentLine += word + ' ';
-                }
-            }
-            if (currentLine)
-                lines.push(prefix + currentLine.trim());
-            return lines.join('\n');
-        };
-        switch (step.type) {
-            case 'thought':
-                output += colors.dim(`${prefix}${icon}`) + ` ${colors.bold('Thought:')}\n`;
-                output += wrapText(step.content, contentWidth, indent);
-                // Show reasoning quality if available
-                if (showMetadata && step.metadata?.confidence !== undefined) {
-                    const conf = step.metadata.confidence;
-                    const confLabel = conf >= 0.8 ? colors.green('✓ High') : conf >= 0.6 ? colors.yellow('⚠ Medium') : colors.red('✗ Low');
-                    output += `\n${indent}└─ Confidence: ${confLabel} ${colors.dim(`(${(conf * 100).toFixed(0)}%)`)}`;
-                }
-                break;
-            case 'action':
-                output += colors.dim(`${prefix}${icon}`) + ` ${colors.cyan('Action:')} ${colors.cyan(step.content)}\n`;
-                if (showMetadata && step.metadata?.tool) {
-                    output += `${indent}└─ Tool: ${colors.cyan(step.metadata.tool)}\n`;
-                    if (step.metadata.reasoning) {
-                        output += `${indent}└─ Reasoning: ${colors.dim(wrapText(step.metadata.reasoning, contentWidth - 14, ''))}\n`;
-                    }
-                }
-                break;
-            case 'observation':
-                const obsText = compact && step.content.length > 150
-                    ? step.content.substring(0, 150) + '...'
-                    : step.content;
-                output += colors.dim(`${prefix}${icon}`) + ` ${colors.green('Observation:')}\n`;
-                output += wrapText(obsText, contentWidth, indent);
-                break;
-            case 'decision':
-                output += colors.dim(`${prefix}${icon}`) + ` ${colors.magenta('Decision:')} ${colors.magenta(step.content)}\n`;
-                if (showMetadata && step.metadata?.options) {
-                    output += `${indent}└─ Options: ${colors.dim(step.metadata.options.join(', '))}\n`;
-                    output += `${indent}└─ Chosen: ${colors.green(step.metadata.chosen)}\n`;
-                    if (step.metadata.reasoning) {
-                        output += `${indent}└─ Reasoning: ${colors.dim(wrapText(step.metadata.reasoning, contentWidth - 14, ''))}\n`;
-                    }
-                    if (step.metadata.confidence !== undefined) {
-                        const conf = step.metadata.confidence;
-                        const confLabel = conf >= 0.8 ? colors.green('✓ High') : conf >= 0.6 ? colors.yellow('⚠ Medium') : colors.red('✗ Low');
-                        output += `${indent}└─ Confidence: ${confLabel} ${colors.dim(`(${(conf * 100).toFixed(0)}%)`)}\n`;
-                    }
-                }
-                break;
-            case 'error':
-                output += colors.dim(`${prefix}${icon}`) + ` ${colors.red('Error:')} ${colors.red(step.content)}\n`;
-                if (showMetadata && step.metadata?.errorDetails) {
-                    output += `${indent}└─ Details: ${colors.dim(JSON.stringify(step.metadata.errorDetails))}\n`;
-                }
-                break;
-        }
-        if (!compact) {
-            output += '\n';
-        }
-        return output;
-    }
-    getStepIcon(type) {
-        switch (type) {
-            case 'thought':
-                return '💭';
-            case 'action':
-                return '⚡';
-            case 'observation':
-                return '👁️';
-            case 'decision':
-                return '🔀';
-            case 'error':
-                return '❌';
-            default:
-                return '•';
-        }
-    }
-}
-//# sourceMappingURL=cot-visualizer.js.map