codehere 0.2.2 → 0.3.0-rc.2

package/dist/infrastructure/ux/bi-directional-learning.js

@@ -1,337 +0,0 @@
-/**
- * Infrastructure: Bi-directional Learning System
- *
- * Continuous refinement of AI models based on explicit and implicit user feedback
- * Research: Bi-directional learning from user corrections, adapt to team preferences
- *
- * Features:
- * - Edit/deletion tracking
- * - Personalization engine
- * - Learning from user corrections
- * - Preference adaptation
- */
-/**
- * Bi-directional Learning System
- * Learns from user edits, deletions, and explicit feedback
- */
-export class BiDirectionalLearning {
-    feedbackHistory = new Map(); // userId -> feedbacks
-    learningPatterns = new Map(); // userId -> patterns
-    userPreferences = new Map();
-    /**
-     * Record user feedback (edit, deletion, etc.)
-     */
-    recordFeedback(userId, feedback) {
-        const feedbackId = `feedback-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const fullFeedback = {
-            ...feedback,
-            feedbackId,
-            timestamp: Date.now(),
-        };
-        // Store feedback
-        if (!this.feedbackHistory.has(userId)) {
-            this.feedbackHistory.set(userId, []);
-        }
-        this.feedbackHistory.get(userId).push(fullFeedback);
-        // Learn from feedback
-        this.learnFromFeedback(userId, fullFeedback);
-        // Update preferences
-        this.updatePreferences(userId, fullFeedback);
-        return feedbackId;
-    }
-    /**
-     * Record explicit feedback (thumbs up/down, comments)
-     */
-    recordExplicitFeedback(userId, feedback) {
-        return this.recordFeedback(userId, {
-            type: 'explicit_feedback',
-            signal: feedback.signal,
-            filepath: feedback.codeExample || 'general',
-            context: {
-                ...feedback.context,
-            },
-            metadata: {
-                explicitFeedback: feedback.message,
-            },
-        });
-    }
-    /**
-     * Get user preferences
-     */
-    getUserPreferences(userId) {
-        if (!this.userPreferences.has(userId)) {
-            this.userPreferences.set(userId, {
-                userId,
-                preferences: {},
-                learnedAt: Date.now(),
-                lastUpdated: Date.now(),
-            });
-        }
-        return this.userPreferences.get(userId);
-    }
-    /**
-     * Get learned patterns for user
-     */
-    getLearnedPatterns(userId) {
-        return this.learningPatterns.get(userId) || [];
-    }
-    /**
-     * Apply learned preferences to code generation
-     * Task 6.2: Enhanced to apply learned patterns and preferences
-     */
-    applyPreferences(userId, code) {
-        const preferences = this.getUserPreferences(userId);
-        const patterns = this.getLearnedPatterns(userId);
-        if (!preferences.preferences.codeStyle && patterns.length === 0) {
-            return code; // No preferences or patterns learned yet
-        }
-        // Apply basic style preferences (simplified - in production, use AST transformation)
-        let modifiedCode = code;
-        const style = preferences.preferences.codeStyle;
-        // Apply quote preference (basic example)
-        if (style?.quotes === 'single') {
-            modifiedCode = modifiedCode.replace(/"/g, "'");
-        }
-        else if (style?.quotes === 'double') {
-            modifiedCode = modifiedCode.replace(/'/g, '"');
-        }
-        // Task 6.2: Apply learned patterns (high confidence patterns only)
-        for (const pattern of patterns) {
-            if (pattern.confidence >= 0.7 && pattern.type === 'correction') {
-                // Apply high-confidence correction patterns
-                // In production, use AST transformation for accurate pattern application
-                // For now, this is a placeholder for pattern application logic
-            }
-        }
-        // In production, apply more sophisticated transformations based on preferences and patterns
-        return modifiedCode;
-    }
-    /**
-     * Task 6.2: Get learned patterns as prompt context for code generation
-     * Returns patterns formatted for inclusion in AI prompts
-     */
-    getPatternsAsPromptContext(userId, maxPatterns = 5) {
-        const patterns = this.getLearnedPatterns(userId)
-            .filter(p => p.confidence >= 0.6) // Only high-confidence patterns
-            .sort((a, b) => b.confidence - a.confidence) // Sort by confidence
-            .slice(0, maxPatterns);
-        if (patterns.length === 0) {
-            return '';
-        }
-        const contextLines = [
-            'Learned patterns from previous edits:',
-            ...patterns.map(p => {
-                const examples = p.examples.slice(0, 2).join('; ');
-                return `- ${p.pattern} (confidence: ${(p.confidence * 100).toFixed(0)}%, seen ${p.occurrences}x)${examples ? ` - Examples: ${examples}` : ''}`;
-            }),
-        ];
-        return contextLines.join('\n');
-    }
-    /**
-     * Task 6.2: Get user preferences as prompt context for code generation
-     */
-    getPreferencesAsPromptContext(userId) {
-        const preferences = this.getUserPreferences(userId);
-        if (!preferences.preferences.codeStyle) {
-            return '';
-        }
-        const style = preferences.preferences.codeStyle;
-        const contextLines = [];
-        if (style.indentation) {
-            contextLines.push(`- Indentation: ${style.indentation === 'spaces' ? 'Use spaces' : 'Use tabs'}`);
-        }
-        if (style.quotes) {
-            contextLines.push(`- Quotes: Use ${style.quotes} quotes`);
-        }
-        if (style.naming) {
-            contextLines.push(`- Naming: Use ${style.naming} convention`);
-        }
-        if (style.spacing) {
-            contextLines.push(`- Spacing: ${style.spacing} spacing style`);
-        }
-        if (contextLines.length === 0) {
-            return '';
-        }
-        return 'User code style preferences:\n' + contextLines.join('\n');
-    }
-    /**
-     * Get feedback history for user
-     */
-    getFeedbackHistory(userId, filter) {
-        const feedbacks = this.feedbackHistory.get(userId) || [];
-        let filtered = [...feedbacks];
-        if (filter?.type) {
-            filtered = filtered.filter(f => f.type === filter.type);
-        }
-        if (filter?.signal) {
-            filtered = filtered.filter(f => f.signal === filter.signal);
-        }
-        if (filter?.startTime) {
-            filtered = filtered.filter(f => f.timestamp >= filter.startTime);
-        }
-        if (filter?.endTime) {
-            filtered = filtered.filter(f => f.timestamp <= filter.endTime);
-        }
-        return filtered.sort((a, b) => b.timestamp - a.timestamp);
-    }
-    // Private helpers
-    learnFromFeedback(userId, feedback) {
-        // Learn patterns from edits and deletions
-        if (feedback.type === 'edit' && feedback.originalCode && feedback.modifiedCode) {
-            const pattern = this.extractPattern(feedback.originalCode, feedback.modifiedCode);
-            if (pattern) {
-                this.addLearningPattern(userId, {
-                    type: 'correction',
-                    pattern: pattern,
-                    confidence: 0.7,
-                    occurrences: 1,
-                    examples: [feedback.modifiedCode],
-                });
-            }
-        }
-        // Learn from deletions (what user removes = not wanted)
-        if (feedback.type === 'deletion' && feedback.originalCode) {
-            this.addLearningPattern(userId, {
-                type: 'pattern',
-                pattern: `Avoid: ${feedback.originalCode.substring(0, 50)}`,
-                confidence: 0.6,
-                occurrences: 1,
-                examples: [],
-            });
-        }
-    }
-    updatePreferences(userId, feedback) {
-        const preferences = this.getUserPreferences(userId);
-        // Infer preferences from edits
-        if (feedback.type === 'edit' && feedback.originalCode && feedback.modifiedCode) {
-            // Infer code style preferences (simplified)
-            if (feedback.modifiedCode.includes("'") && !feedback.originalCode.includes("'")) {
-                preferences.preferences.codeStyle = preferences.preferences.codeStyle || {};
-                preferences.preferences.codeStyle.quotes = 'single';
-            }
-            else if (feedback.modifiedCode.includes('"') && !feedback.originalCode.includes('"')) {
-                preferences.preferences.codeStyle = preferences.preferences.codeStyle || {};
-                preferences.preferences.codeStyle.quotes = 'double';
-            }
-            preferences.lastUpdated = Date.now();
-        }
-        // Update based on explicit feedback
-        if (feedback.type === 'explicit_feedback' && feedback.metadata?.explicitFeedback) {
-            // Parse explicit feedback for preferences
-            const message = feedback.metadata.explicitFeedback.toLowerCase();
-            if (message.includes('style') || message.includes('format')) {
-                // Extract style preferences from feedback
-                // (In production, use NLP to parse structured preferences)
-            }
-        }
-    }
-    /**
-     * Task 6.2: Enhanced pattern extraction from edits
-     * Extracts meaningful patterns from code edits for learning
-     */
-    extractPattern(original, modified) {
-        if (original.length === 0 || modified.length === 0) {
-            return null;
-        }
-        // Simple pattern extraction (in production, use AST diffing for better accuracy)
-        // For now, extract basic patterns:
-        // 1. Quote style changes
-        if (original.includes('"') && modified.includes("'") && !original.includes("'")) {
-            return 'Prefer single quotes over double quotes';
-        }
-        if (original.includes("'") && modified.includes('"') && !original.includes('"')) {
-            return 'Prefer double quotes over single quotes';
-        }
-        // 2. Indentation changes (basic detection)
-        const originalIndent = this.detectIndentation(original);
-        const modifiedIndent = this.detectIndentation(modified);
-        if (originalIndent !== modifiedIndent && modifiedIndent !== 'mixed') {
-            return `Prefer ${modifiedIndent} indentation`;
-        }
-        // 3. Naming convention changes (basic detection)
-        const namingChange = this.detectNamingChange(original, modified);
-        if (namingChange) {
-            return namingChange;
-        }
-        // Fallback: Generic pattern description
-        if (modified.length > 30) {
-            return `Pattern: ${modified.substring(0, 30)}...`;
-        }
-        return `Pattern: ${modified}`;
-    }
-    /**
-     * Task 6.2: Detect indentation style
-     */
-    detectIndentation(code) {
-        const lines = code.split('\n').filter(line => line.trim().length > 0);
-        if (lines.length === 0)
-            return 'spaces';
-        let spacesCount = 0;
-        let tabsCount = 0;
-        for (const line of lines.slice(0, 10)) { // Check first 10 lines
-            const indent = line.match(/^(\s+)/)?.[1];
-            if (indent) {
-                if (indent.includes('\t')) {
-                    tabsCount++;
-                }
-                else if (indent.includes(' ')) {
-                    spacesCount++;
-                }
-            }
-        }
-        if (tabsCount > spacesCount * 2)
-            return 'tabs';
-        if (spacesCount > tabsCount * 2)
-            return 'spaces';
-        return 'mixed';
-    }
-    /**
-     * Task 6.2: Detect naming convention changes
-     */
-    detectNamingChange(original, modified) {
-        // Simple detection: Look for camelCase vs snake_case vs PascalCase
-        const camelCaseRegex = /\b[a-z][a-zA-Z0-9]*\b/g;
-        const snakeCaseRegex = /\b[a-z][a-z0-9_]*\b/g;
-        const pascalCaseRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
-        const originalCamel = (original.match(camelCaseRegex) || []).length;
-        const originalSnake = (original.match(snakeCaseRegex) || []).length;
-        const originalPascal = (original.match(pascalCaseRegex) || []).length;
-        const modifiedCamel = (modified.match(camelCaseRegex) || []).length;
-        const modifiedSnake = (modified.match(snakeCaseRegex) || []).length;
-        const modifiedPascal = (modified.match(pascalCaseRegex) || []).length;
-        // Detect significant shifts
-        if (originalSnake > originalCamel && modifiedCamel > modifiedSnake) {
-            return 'Prefer camelCase over snake_case';
-        }
-        if (originalCamel > originalSnake && modifiedSnake > modifiedCamel) {
-            return 'Prefer snake_case over camelCase';
-        }
-        if (originalCamel > originalPascal && modifiedPascal > modifiedCamel) {
-            return 'Prefer PascalCase over camelCase';
-        }
-        return null;
-    }
-    addLearningPattern(userId, pattern) {
-        if (!this.learningPatterns.has(userId)) {
-            this.learningPatterns.set(userId, []);
-        }
-        const patterns = this.learningPatterns.get(userId);
-        // Check if similar pattern exists
-        const existing = patterns.find(p => p.pattern === pattern.pattern);
-        if (existing) {
-            existing.occurrences++;
-            existing.confidence = Math.min(1.0, existing.confidence + 0.1);
-            existing.examples.push(...pattern.examples.slice(0, 3)); // Keep max 3 examples
-            existing.lastSeen = Date.now();
-        }
-        else {
-            patterns.push({
-                ...pattern,
-                patternId: `pattern-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                createdAt: Date.now(),
-                lastSeen: Date.now(),
-            });
-        }
-    }
-}
-//# sourceMappingURL=bi-directional-learning.js.map

package/dist/infrastructure/ux/capability-boundaries.js

@@ -1,42 +0,0 @@
-/**
- * Capability Boundaries
- * Detects unsupported operations and displays boundaries
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { colors, warning } from '../../ui.js';
-export class CapabilityBoundaryDetector {
-    /**
-     * Detect unsupported operations
-     */
-    detectUnsupported(query) {
-        // In alpha, minimal detection
-        // Can be enhanced later with more sophisticated detection
-        const unsupportedPatterns = [
-            { pattern: /\b(deploy|publish|release|ship)\b/i, reason: 'Deployment operations are not supported' },
-            { pattern: /\b(delete|remove|destroy|wipe)\s+(all|everything|database|data)\b/i, reason: 'Bulk deletion operations are not supported' },
-        ];
-        for (const { pattern, reason } of unsupportedPatterns) {
-            if (pattern.test(query)) {
-                return {
-                    operation: query,
-                    reason,
-                };
-            }
-        }
-        return null;
-    }
-}
-/**
- * Display capability boundary message
- */
-export function displayCapabilityBoundary(boundary) {
-    console.log(warning('\n⚠️  Capability Boundary'));
-    console.log(warning(`Operation: ${boundary.operation}`));
-    console.log(warning(`Reason: ${boundary.reason}`));
-    if (boundary.alternative) {
-        console.log(colors.dim(`Alternative: ${boundary.alternative}`));
-    }
-    console.log('');
-}
-//# sourceMappingURL=capability-boundaries.js.map

package/dist/infrastructure/ux/comprehensive-formatter.js

@@ -1,117 +0,0 @@
-/**
- * Comprehensive Formatter
- * Format content for CLI display with proper indentation and wrapping
- *
- * Phase 1: v0.5.0-alpha.0
- */
-/**
- * Format content for CLI display
- */
-export function formatContent(content, options = {}) {
-    const { indent = 0, maxWidth = 76, preserveMarkdown = true, } = options;
-    if (!content) {
-        return '';
-    }
-    const indentStr = ' '.repeat(indent);
-    const actualMaxWidth = maxWidth - indent;
-    // If content is short enough, return as-is with indentation
-    if (content.length <= actualMaxWidth && !content.includes('\n')) {
-        return indentStr + content;
-    }
-    // Handle markdown code blocks
-    if (preserveMarkdown && content.includes('```')) {
-        return formatMarkdownContent(content, indent, actualMaxWidth);
-    }
-    // Simple word wrapping
-    const lines = content.split('\n');
-    const wrappedLines = [];
-    for (const line of lines) {
-        if (line.length <= actualMaxWidth) {
-            wrappedLines.push(indentStr + line);
-        }
-        else {
-            // Word wrap
-            const words = line.split(/\s+/);
-            let currentLine = '';
-            for (const word of words) {
-                if ((currentLine + word).length <= actualMaxWidth) {
-                    currentLine += (currentLine ? ' ' : '') + word;
-                }
-                else {
-                    if (currentLine) {
-                        wrappedLines.push(indentStr + currentLine);
-                    }
-                    currentLine = word;
-                }
-            }
-            if (currentLine) {
-                wrappedLines.push(indentStr + currentLine);
-            }
-        }
-    }
-    return wrappedLines.join('\n');
-}
-/**
- * Format reflection/analysis output
- */
-export function formatReflection(reflection, options = {}) {
-    if (!reflection) {
-        return '';
-    }
-    if (typeof reflection === 'string') {
-        return formatContent(reflection, options);
-    }
-    if (typeof reflection === 'object') {
-        // Format structured reflection
-        const parts = [];
-        if (reflection.insight) {
-            parts.push(`💡 Insight:\n${formatContent(reflection.insight, { ...options, indent: (options.indent || 0) + 2 })}`);
-        }
-        if (reflection.reasoning) {
-            parts.push(`🧠 Reasoning:\n${formatContent(reflection.reasoning, { ...options, indent: (options.indent || 0) + 2 })}`);
-        }
-        if (reflection.summary) {
-            parts.push(`📋 Summary:\n${formatContent(reflection.summary, { ...options, indent: (options.indent || 0) + 2 })}`);
-        }
-        if (parts.length === 0) {
-            return formatContent(JSON.stringify(reflection, null, 2), options);
-        }
-        return parts.join('\n\n');
-    }
-    return String(reflection);
-}
-/**
- * Format markdown content with code block preservation
- */
-function formatMarkdownContent(content, indent, maxWidth) {
-    const indentStr = ' '.repeat(indent);
-    const lines = content.split('\n');
-    const formatted = [];
-    let inCodeBlock = false;
-    let codeBlockLang = '';
-    for (const line of lines) {
-        if (line.trim().startsWith('```')) {
-            inCodeBlock = !inCodeBlock;
-            if (inCodeBlock) {
-                codeBlockLang = line.trim().substring(3).trim();
-            }
-            formatted.push(indentStr + line);
-        }
-        else if (inCodeBlock) {
-            // Preserve code blocks as-is
-            formatted.push(indentStr + line);
-        }
-        else {
-            // Format regular markdown lines
-            if (line.length <= maxWidth) {
-                formatted.push(indentStr + line);
-            }
-            else {
-                // Word wrap for non-code content
-                formatted.push(formatContent(line, { indent, maxWidth: maxWidth + indent }));
-            }
-        }
-    }
-    return formatted.join('\n');
-}
-//# sourceMappingURL=comprehensive-formatter.js.map

package/dist/infrastructure/ux/contextual-feature-discovery.js

@@ -1,10 +0,0 @@
-/**
- * Contextual Feature Discovery (v0.5.0-alpha.0 - Stub)
- * TODO: Implement contextual feature suggestions
- */
-export function shouldShowContextualSuggestion(query, command) {
-    // In alpha, return null (no suggestions)
-    // Can be enhanced later with heuristics
-    return null;
-}
-//# sourceMappingURL=contextual-feature-discovery.js.map