codehere 0.2.2 → 0.3.0-rc.2

package/dist/infrastructure/ux/progress-indicator.js

@@ -1,116 +0,0 @@
-/**
- * Progress Indicator Utilities
- * Provides progress indicators for long-running operations
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { createSpinner } from '../../ui.js';
-export class ProgressIndicator {
-    spinner = null;
-    progressBar = '';
-    operationStartTime = 0;
-    currentValue = 0;
-    total = 0;
-    message = '';
-    /**
-     * Start progress indicator
-     */
-    start(options = {}) {
-        this.operationStartTime = Date.now();
-        this.currentValue = 0;
-        this.total = options.total || 0;
-        this.message = options.message || 'Processing...';
-        if (this.total > 0) {
-            // Progress bar mode
-            this.update(0, this.message);
-        }
-        else {
-            // Spinner mode
-            this.spinner = createSpinner(this.message);
-            this.spinner.start();
-        }
-    }
-    /**
-     * Update progress
-     */
-    update(value, message) {
-        this.currentValue = value;
-        if (message) {
-            this.message = message;
-        }
-        if (this.total > 0) {
-            // Progress bar
-            const percentage = Math.min(100, Math.floor((value / this.total) * 100));
-            const barLength = 20;
-            const filled = Math.floor((percentage / 100) * barLength);
-            const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
-            process.stdout.write(`\r${this.message} [${bar}] ${percentage}% (${value}/${this.total})`);
-        }
-        else if (this.spinner) {
-            // Spinner
-            this.spinner.text = this.message;
-        }
-    }
-    /**
-     * Increment progress
-     */
-    increment(delta = 1, message) {
-        this.update(this.currentValue + delta, message);
-    }
-    /**
-     * Stop progress indicator with smooth transition
-     */
-    stop(success = true, finalMessage) {
-        if (this.spinner) {
-            this.spinner.stop();
-            this.spinner = null;
-        }
-        else if (this.total > 0) {
-            // Clear progress bar
-            process.stdout.write('\r' + ' '.repeat(80) + '\r');
-        }
-        if (finalMessage) {
-            console.log(finalMessage);
-        }
-    }
-    /**
-     * Get elapsed time
-     */
-    getElapsedTime() {
-        return Date.now() - this.operationStartTime;
-    }
-}
-/**
- * Create progress indicator for embedding search
- */
-export function createEmbeddingSearchProgress(total) {
-    const indicator = new ProgressIndicator();
-    indicator.start({
-        total,
-        message: 'Searching embeddings',
-        showPercentage: true,
-        showCount: true,
-    });
-    return indicator;
-}
-/**
- * Create progress indicator for plan generation
- */
-export function createPlanGenerationProgress() {
-    const indicator = new ProgressIndicator();
-    indicator.start({
-        message: 'Generating plan',
-    });
-    return indicator;
-}
-/**
- * Create progress indicator for memory synthesis
- */
-export function createMemorySynthesisProgress() {
-    const indicator = new ProgressIndicator();
-    indicator.start({
-        message: 'Synthesizing memories',
-    });
-    return indicator;
-}
-//# sourceMappingURL=progress-indicator.js.map

package/dist/infrastructure/ux/progressive-disclosure.js

@@ -1,236 +0,0 @@
-/**
- * Infrastructure: Progressive Disclosure System
- *
- * Staged capability introduction to build trust and reduce cognitive load
- * Research: Progressive disclosure for capability introduction, expectation management
- *
- * Features:
- * - Feature capability levels (beginner, intermediate, advanced)
- * - Staged feature revelation based on user experience
- * - Contextual feature discovery
- * - Onboarding flow management
- */
-/**
- * Progressive Disclosure System
- * Manages staged feature introduction based on user experience
- */
-export class ProgressiveDisclosure {
-    featureRegistry = new Map();
-    userProfiles = new Map();
-    constructor() {
-        this.initializeDefaultFeatures();
-    }
-    /**
-     * Register feature capability level
-     */
-    registerFeature(feature) {
-        this.featureRegistry.set(feature.featureId, feature);
-    }
-    /**
-     * Get user profile (create if doesn't exist)
-     */
-    getUserProfile(userId) {
-        if (!this.userProfiles.has(userId)) {
-            this.userProfiles.set(userId, {
-                userId,
-                level: 'beginner',
-                featuresDiscovered: [],
-                featuresUsed: new Map(),
-                onboardingComplete: false,
-                createdAt: Date.now(),
-                lastUpdated: Date.now(),
-            });
-        }
-        return this.userProfiles.get(userId);
-    }
-    /**
-     * Check if feature should be shown to user
-     */
-    shouldShowFeature(userId, featureId) {
-        const profile = this.getUserProfile(userId);
-        const feature = this.featureRegistry.get(featureId);
-        if (!feature) {
-            return { show: false, reason: 'Feature not found' };
-        }
-        // Check if prerequisites are met
-        if (feature.prerequisites) {
-            for (const prereqId of feature.prerequisites) {
-                if (!profile.featuresDiscovered.includes(prereqId)) {
-                    return {
-                        show: false,
-                        reason: `Requires learning "${prereqId}" first`,
-                    };
-                }
-            }
-        }
-        // Check user level
-        const levelOrder = ['beginner', 'intermediate', 'advanced', 'expert'];
-        const userLevelIndex = levelOrder.indexOf(profile.level);
-        const requiredLevelIndex = levelOrder.indexOf(feature.requiredLevel);
-        if (userLevelIndex < requiredLevelIndex) {
-            return {
-                show: false,
-                reason: `Requires ${feature.requiredLevel} level (you are ${profile.level})`,
-                suggestedLevel: feature.requiredLevel,
-            };
-        }
-        return { show: true };
-    }
-    /**
-     * Get features available to user
-     */
-    getAvailableFeatures(userId) {
-        const profile = this.getUserProfile(userId);
-        const available = [];
-        const features = Array.from(this.featureRegistry.values());
-        for (const feature of features) {
-            const { show } = this.shouldShowFeature(userId, feature.featureId);
-            if (show) {
-                available.push(feature);
-            }
-        }
-        return available.sort((a, b) => {
-            // Sort by capability level (basic first) then by name
-            const capabilityOrder = ['basic', 'standard', 'advanced', 'experimental'];
-            const aIndex = capabilityOrder.indexOf(a.capability);
-            const bIndex = capabilityOrder.indexOf(b.capability);
-            if (aIndex !== bIndex)
-                return aIndex - bIndex;
-            return a.featureName.localeCompare(b.featureName);
-        });
-    }
-    /**
-     * Get features to suggest next (not yet discovered)
-     */
-    getNextSuggestedFeatures(userId, limit = 3) {
-        const profile = this.getUserProfile(userId);
-        const available = this.getAvailableFeatures(userId);
-        const undiscovered = available.filter(f => !profile.featuresDiscovered.includes(f.featureId));
-        return undiscovered.slice(0, limit);
-    }
-    /**
-     * Mark feature as discovered
-     */
-    markFeatureDiscovered(userId, featureId) {
-        const profile = this.getUserProfile(userId);
-        if (!profile.featuresDiscovered.includes(featureId)) {
-            profile.featuresDiscovered.push(featureId);
-            profile.lastUpdated = Date.now();
-        }
-    }
-    /**
-     * Record feature usage
-     */
-    recordFeatureUsage(userId, featureId) {
-        const profile = this.getUserProfile(userId);
-        const currentCount = profile.featuresUsed.get(featureId) || 0;
-        profile.featuresUsed.set(featureId, currentCount + 1);
-        profile.lastUpdated = Date.now();
-        // Auto-discover on first use
-        this.markFeatureDiscovered(userId, featureId);
-        // Check for level progression
-        this.checkLevelProgression(userId);
-    }
-    /**
-     * Update user level
-     */
-    setUserLevel(userId, level) {
-        const profile = this.getUserProfile(userId);
-        profile.level = level;
-        profile.lastUpdated = Date.now();
-    }
-    /**
-     * Mark onboarding as complete
-     */
-    completeOnboarding(userId) {
-        const profile = this.getUserProfile(userId);
-        profile.onboardingComplete = true;
-        profile.lastUpdated = Date.now();
-    }
-    // Private helpers
-    initializeDefaultFeatures() {
-        // Basic features (beginner)
-        this.registerFeature({
-            featureId: 'ask-question',
-            featureName: 'Ask Questions About Code',
-            capability: 'basic',
-            requiredLevel: 'beginner',
-            description: 'Ask questions about your codebase and get AI-powered answers',
-        });
-        this.registerFeature({
-            featureId: 'edit-file',
-            featureName: 'Edit Files',
-            capability: 'basic',
-            requiredLevel: 'beginner',
-            description: 'Edit existing files with natural language instructions',
-        });
-        // Standard features (intermediate)
-        this.registerFeature({
-            featureId: 'multi-file-edit',
-            featureName: 'Multi-File Editing',
-            capability: 'standard',
-            requiredLevel: 'intermediate',
-            description: 'Edit multiple files in a single operation',
-            prerequisites: ['edit-file'],
-        });
-        this.registerFeature({
-            featureId: 'code-search',
-            featureName: 'Intelligent Code Search',
-            capability: 'standard',
-            requiredLevel: 'intermediate',
-            description: 'Search codebase using AST-based understanding',
-            prerequisites: ['ask-question'],
-        });
-        // Advanced features (advanced)
-        this.registerFeature({
-            featureId: 'react-orchestration',
-            featureName: 'ReAct Orchestration',
-            capability: 'advanced',
-            requiredLevel: 'advanced',
-            description: 'Multi-step reasoning with tool execution',
-            prerequisites: ['edit-file', 'code-search'],
-        });
-        this.registerFeature({
-            featureId: 'planning',
-            featureName: 'Hierarchical Planning',
-            capability: 'advanced',
-            requiredLevel: 'advanced',
-            description: 'Break down complex tasks into sub-plans',
-            prerequisites: ['react-orchestration'],
-        });
-        // Experimental features (expert)
-        this.registerFeature({
-            featureId: 'xai-visualization',
-            featureName: 'XAI Visualization',
-            capability: 'experimental',
-            requiredLevel: 'expert',
-            description: 'Interactive explainable AI features (CoT, Attention)',
-            prerequisites: ['react-orchestration'],
-        });
-        this.registerFeature({
-            featureId: 'governance-policies',
-            featureName: 'Governance Policies',
-            capability: 'experimental',
-            requiredLevel: 'expert',
-            description: 'Policy-as-Code and governance features',
-            prerequisites: ['planning'],
-        });
-    }
-    checkLevelProgression(userId) {
-        const profile = this.getUserProfile(userId);
-        const featuresUsed = Array.from(profile.featuresUsed.values());
-        const totalUsage = featuresUsed.reduce((sum, count) => sum + count, 0);
-        const uniqueFeaturesUsed = profile.featuresUsed.size;
-        // Progression logic
-        if (profile.level === 'beginner' && uniqueFeaturesUsed >= 3 && totalUsage >= 10) {
-            this.setUserLevel(userId, 'intermediate');
-        }
-        else if (profile.level === 'intermediate' && uniqueFeaturesUsed >= 6 && totalUsage >= 30) {
-            this.setUserLevel(userId, 'advanced');
-        }
-        else if (profile.level === 'advanced' && uniqueFeaturesUsed >= 10 && totalUsage >= 100) {
-            this.setUserLevel(userId, 'expert');
-        }
-    }
-}
-//# sourceMappingURL=progressive-disclosure.js.map

package/dist/infrastructure/ux/review-checkpoint.js

@@ -1,72 +0,0 @@
-/**
- * Review Checkpoint UI
- * Shows summary before applying edits
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { colors, separator } from '../../ui.js';
-/**
- * Display review checkpoint before applying edits
- */
-export function displayReviewCheckpoint(info) {
-    console.log('\n' + separator('═', 80));
-    console.log(colors.bold('📋 Review Checkpoint'));
-    console.log(separator('═', 80));
-    // Files summary
-    console.log(`\n${colors.bold('Files to modify:')} ${info.filesToModify.length}`);
-    info.filesToModify.forEach((file, idx) => {
-        console.log(`  ${idx + 1}. ${file.filepath}`);
-        console.log(`     +${file.linesAdded} -${file.linesRemoved} ~${file.linesChanged}`);
-    });
-    // Validation status
-    console.log(`\n${colors.bold('Validation:')}`);
-    console.log(`  Security scan: ${info.securityScanPassed ? colors.green('✓ Passed') : colors.red('✗ Failed')}`);
-    console.log(`  Compilation: ${info.compilationValid ? colors.green('✓ Valid') : colors.red('✗ Invalid')}`);
-    // Risk level
-    const riskColor = info.riskLevel === 'low' ? colors.green :
-        info.riskLevel === 'medium' ? colors.yellow :
-            info.riskLevel === 'high' ? colors.red :
-                colors.red;
-    console.log(`  Risk level: ${riskColor(info.riskLevel.toUpperCase())}`);
-    if (info.uncertainty !== undefined) {
-        console.log(`  Uncertainty: ${(info.uncertainty * 100).toFixed(1)}%`);
-    }
-    console.log(separator('═', 80) + '\n');
-}
-/**
- * Calculate diff summary from old and new content
- */
-export function calculateDiffSummary(oldContent, newContent) {
-    const oldLines = oldContent.split('\n');
-    const newLines = newContent.split('\n');
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    let linesChanged = 0;
-    // Simple line-by-line comparison
-    const maxLen = Math.max(oldLines.length, newLines.length);
-    for (let i = 0; i < maxLen; i++) {
-        const oldLine = oldLines[i];
-        const newLine = newLines[i];
-        if (oldLine === undefined) {
-            linesAdded++;
-        }
-        else if (newLine === undefined) {
-            linesRemoved++;
-        }
-        else if (oldLine !== newLine) {
-            linesChanged++;
-        }
-    }
-    return {
-        linesAdded,
-        linesRemoved,
-        linesChanged,
-    };
-}
-/**
- * Format edit summary for display
- */
-export function formatEditSummary(summary) {
-    return `${summary.filepath}: +${summary.linesAdded} -${summary.linesRemoved} ~${summary.linesChanged}`;
-}
-//# sourceMappingURL=review-checkpoint.js.map

package/dist/infrastructure/ux/staged-feature-intro.js

@@ -1,24 +0,0 @@
-/**
- * Staged Feature Introduction
- * Checks feature access and displays availability
- *
- * Phase 1: v0.5.0-alpha.0
- */
-/**
- * Check feature access
- */
-export function checkFeatureAccess(progressiveDisclosure, userId, feature) {
-    // In alpha, all features are available
-    return {
-        available: true,
-        shouldContinue: true,
-    };
-}
-/**
- * Display feature availability
- */
-export function displayFeatureAvailability(featureName, capability, userLevel) {
-    // In alpha, no-op
-    // Can be enhanced later to show feature introductions
-}
-//# sourceMappingURL=staged-feature-intro.js.map

package/dist/infrastructure/ux/stream-markdown.js

@@ -1,151 +0,0 @@
-/**
- * Incremental Markdown Renderer for Streaming Output
- *
- * Converts markdown to terminal formatting as tokens arrive.
- * Handles: ## headers, **bold**, `code`, ```code blocks```, - bullets
- */
-import chalk from 'chalk';
-export function createMarkdownStream() {
-    let buffer = '';
-    let inCodeBlock = false;
-    let codeBlockLang = '';
-    let lineStart = true; // Are we at the start of a new line?
-    function emit(text) {
-        process.stdout.write(text);
-    }
-    function processLine(line) {
-        // Code block fence
-        if (line.startsWith('```')) {
-            if (!inCodeBlock) {
-                inCodeBlock = true;
-                codeBlockLang = line.slice(3).trim();
-                return chalk.dim('  ┌' + (codeBlockLang ? ' ' + codeBlockLang : ''));
-            }
-            else {
-                inCodeBlock = false;
-                codeBlockLang = '';
-                return chalk.dim('  └');
-            }
-        }
-        // Inside code block — dim, indented
-        if (inCodeBlock) {
-            return chalk.cyan('  │ ') + line;
-        }
-        // Headers
-        if (line.startsWith('### ')) {
-            return chalk.bold(line.slice(4));
-        }
-        if (line.startsWith('## ')) {
-            return '\n' + chalk.bold(line.slice(3));
-        }
-        if (line.startsWith('# ')) {
-            return '\n' + chalk.bold(line.slice(2));
-        }
-        // Bullet points
-        if (line.startsWith('- ') || line.startsWith('* ')) {
-            return '  • ' + formatInline(line.slice(2));
-        }
-        // Numbered list
-        const numMatch = line.match(/^(\d+)\.\s/);
-        if (numMatch) {
-            return '  ' + numMatch[1] + '. ' + formatInline(line.slice(numMatch[0].length));
-        }
-        // Regular line
-        return formatInline(line);
-    }
-    function formatInline(text) {
-        // Bold: **text**
-        text = text.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content));
-        // Inline code: `text`
-        text = text.replace(/`([^`]+)`/g, (_, content) => chalk.cyan(content));
-        // Italic: *text* (but not inside **)
-        text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, content) => chalk.dim(content));
-        return text;
-    }
-    return {
-        write(token) {
-            buffer += token;
-            // Process complete lines
-            while (buffer.includes('\n')) {
-                const newlineIdx = buffer.indexOf('\n');
-                const line = buffer.slice(0, newlineIdx);
-                buffer = buffer.slice(newlineIdx + 1);
-                const formatted = processLine(line);
-                emit(formatted + '\n');
-                lineStart = true;
-            }
-            // If there's remaining buffer without a newline, check for inline patterns
-            // Don't emit yet — wait for the line to complete
-            // Exception: if buffer is getting long (>200 chars without newline), flush it
-            if (buffer.length > 200) {
-                emit(formatInline(buffer));
-                buffer = '';
-                lineStart = false;
-            }
-        },
-        flush() {
-            if (buffer.length > 0) {
-                const formatted = processLine(buffer);
-                emit(formatted);
-                buffer = '';
-            }
-        },
-    };
-}
-/**
- * Format a complete markdown string for terminal display (returns string, doesn't write to stdout).
- */
-export function formatMarkdownForTerminal(text) {
-    const output = [];
-    let inCodeBlock = false;
-    let codeBlockLang = '';
-    function fmtInline(t) {
-        t = t.replace(/\*\*(.+?)\*\*/g, (_, c) => chalk.bold(c));
-        t = t.replace(/`([^`]+)`/g, (_, c) => chalk.cyan(c));
-        t = t.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, c) => chalk.dim(c));
-        return t;
-    }
-    for (const line of text.split('\n')) {
-        if (line.startsWith('```')) {
-            if (!inCodeBlock) {
-                inCodeBlock = true;
-                codeBlockLang = line.slice(3).trim();
-                output.push(chalk.dim('  ┌' + (codeBlockLang ? ' ' + codeBlockLang : '')));
-            }
-            else {
-                inCodeBlock = false;
-                codeBlockLang = '';
-                output.push(chalk.dim('  └'));
-            }
-            continue;
-        }
-        if (inCodeBlock) {
-            output.push(chalk.cyan('  │ ') + line);
-            continue;
-        }
-        if (line.startsWith('### ')) {
-            output.push(chalk.bold(line.slice(4)));
-            continue;
-        }
-        if (line.startsWith('## ')) {
-            output.push('\n' + chalk.bold(line.slice(3)));
-            continue;
-        }
-        if (line.startsWith('# ')) {
-            output.push('\n' + chalk.bold(line.slice(2)));
-            continue;
-        }
-        if (line.startsWith('- ') || line.startsWith('* ')) {
-            output.push('  • ' + fmtInline(line.slice(2)));
-            continue;
-        }
-        const numMatch = line.match(/^(\d+)\.\s/);
-        if (numMatch) {
-            output.push('  ' + numMatch[1] + '. ' + fmtInline(line.slice(numMatch[0].length)));
-            continue;
-        }
-        output.push(fmtInline(line));
-    }
-    return output.join('\n');
-}
-//# sourceMappingURL=stream-markdown.js.map

package/dist/infrastructure/ux/syntax-highlighter.js

@@ -1,91 +0,0 @@
-/**
- * Syntax Highlighter for Terminal
- * Provides basic syntax highlighting for code snippets using chalk
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { colors } from '../../ui.js';
-/**
- * Detect language from file extension
- */
-export function detectLanguage(filepath) {
-    const ext = filepath.split('.').pop()?.toLowerCase();
-    switch (ext) {
-        case 'ts':
-        case 'tsx':
-            return 'typescript';
-        case 'js':
-        case 'jsx':
-            return 'javascript';
-        case 'py':
-            return 'python';
-        case 'json':
-            return 'json';
-        case 'yaml':
-        case 'yml':
-            return 'yaml';
-        case 'md':
-            return 'markdown';
-        case 'sh':
-        case 'bash':
-            return 'shell';
-        default:
-            return 'text';
-    }
-}
-/**
- * Highlight code based on language
- */
-export function highlightCode(code, language) {
-    if (!language || language === 'text') {
-        return code;
-    }
-    // Basic keyword highlighting (minimal implementation)
-    const keywords = {
-        typescript: [
-            /\b(const|let|var|function|class|interface|type|enum|import|export|async|await|return|if|else|for|while|try|catch|throw)\b/g,
-            /\b(true|false|null|undefined)\b/g,
-            /(["'`])(?:(?=(\\?))\2.)*?\1/g, // Strings
-            /\/\/.*$/gm, // Comments
-            /\/\*[\s\S]*?\*\//g, // Block comments
-        ],
-        javascript: [
-            /\b(const|let|var|function|class|async|await|return|if|else|for|while|try|catch|throw)\b/g,
-            /\b(true|false|null|undefined)\b/g,
-            /(["'`])(?:(?=(\\?))\2.)*?\1/g,
-            /\/\/.*$/gm,
-            /\/\*[\s\S]*?\*\//g,
-        ],
-        python: [
-            /\b(def|class|import|from|if|else|elif|for|while|try|except|return|True|False|None)\b/g,
-            /(["'`])(?:(?=(\\?))\2.)*?\1/g,
-            /#.*$/gm,
-        ],
-    };
-    const lang = language.toLowerCase();
-    const patterns = keywords[lang] || [];
-    let highlighted = code;
-    for (const pattern of patterns) {
-        highlighted = highlighted.replace(pattern, (match) => {
-            if (pattern.source.includes('string')) {
-                return colors.cyan(match);
-            }
-            else if (pattern.source.includes('comment')) {
-                return colors.gray(match);
-            }
-            else {
-                return colors.yellow(match);
-            }
-        });
-    }
-    return highlighted;
-}
-/**
- * Format code block with syntax highlighting
- */
-export function formatCodeBlockWithHighlight(code, language, filepath) {
-    const lang = language || (filepath ? detectLanguage(filepath) : 'text');
-    const highlighted = highlightCode(code, lang);
-    return `\n${colors.dim('```' + lang)}\n${highlighted}\n${colors.dim('```')}\n`;
-}
-//# sourceMappingURL=syntax-highlighter.js.map