codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/ux/expectation-management.js

@@ -1,327 +0,0 @@
-/**
- * Infrastructure: Expectation Management System
- *
- * Clearly communicates AI limitations to prevent user frustration
- * Research: Expectation management - clear limitations, "can make mistakes" warnings
- *
- * Features:
- * - Clear capability communication
- * - Limitation warnings
- * - Contextual disclaimers
- * - Error prevention messaging
- * - First-time AI operation disclaimers
- * - Uncertainty indicators
- */
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-export class ExpectationManagement {
-    messages = new Map();
-    shownMessages = new Set(); // Track shown messages
-    disclaimerShown = false;
-    constructor() {
-        this.initializeDefaultMessages();
-        this.loadDisclaimerState();
-    }
-    /**
-     * Assess capability for an operation
-     */
-    assessCapability(operation, context) {
-        const { complexity = 'moderate', domain, uncertainty = 0.5, riskLevel = 'medium' } = context;
-        let capability = 'moderate';
-        let confidence = 0.7;
-        const limitations = [];
-        const warnings = [];
-        // Adjust based on complexity
-        if (complexity === 'simple') {
-            capability = 'confident';
-            confidence = 0.9;
-        }
-        else if (complexity === 'complex') {
-            capability = 'uncertain';
-            confidence = 0.5;
-            limitations.push('Complex operations may require multiple iterations');
-        }
-        // Adjust based on uncertainty
-        if (uncertainty > 0.7) {
-            capability = 'risky';
-            confidence = 0.3;
-            warnings.push('High uncertainty detected - verify output carefully');
-            warnings.push('This may indicate hallucination risk');
-        }
-        // Adjust based on risk level
-        if (riskLevel === 'critical') {
-            warnings.push('Critical operation - human review recommended');
-            capability = 'risky';
-            confidence = Math.min(confidence, 0.4);
-        }
-        else if (riskLevel === 'high') {
-            warnings.push('High-risk operation - please review before applying');
-        }
-        // Domain-specific limitations
-        if (domain === 'security') {
-            limitations.push('Security-sensitive code requires careful review');
-            warnings.push('Always verify security implications manually');
-        }
-        else if (domain === 'financial') {
-            limitations.push('Financial code requires compliance verification');
-            warnings.push('Ensure regulatory compliance before deployment');
-        }
-        const canProceed = capability !== 'risky' || riskLevel !== 'critical';
-        return {
-            operation,
-            capability,
-            confidence,
-            limitations,
-            warnings,
-            canProceed,
-            recommendedApproach: this.generateRecommendedApproach(capability, complexity, riskLevel),
-        };
-    }
-    /**
-     * Get expectation message for operation
-     */
-    getExpectationMessage(operation, context) {
-        // Check for contextual messages first
-        if (context) {
-            for (const message of this.messages.values()) {
-                if (message.contextual && this.matchesContext(message, context)) {
-                    return message;
-                }
-            }
-        }
-        // Check for operation-specific message
-        const operationMessage = this.messages.get(operation);
-        if (operationMessage) {
-            if (operationMessage.showOnce && this.shownMessages.has(operation)) {
-                return null; // Already shown
-            }
-            this.shownMessages.add(operation);
-            return operationMessage;
-        }
-        return null;
-    }
-    /**
-     * Register custom expectation message
-     */
-    registerMessage(message) {
-        this.messages.set(message.operation, message);
-    }
-    /**
-     * Format capability assessment for display
-     */
-    formatAssessment(assessment) {
-        let output = '';
-        // Capability level indicator
-        const capabilityIcons = {
-            confident: '✓',
-            moderate: '◐',
-            uncertain: '⚠',
-            risky: '⚠⚠',
-        };
-        output += `${capabilityIcons[assessment.capability]} ${assessment.operation}\n`;
-        output += `Confidence: ${(assessment.confidence * 100).toFixed(0)}%\n\n`;
-        if (assessment.limitations.length > 0) {
-            output += `Limitations:\n`;
-            for (const limitation of assessment.limitations) {
-                output += `  • ${limitation}\n`;
-            }
-            output += '\n';
-        }
-        if (assessment.warnings.length > 0) {
-            output += `Warnings:\n`;
-            for (const warning of assessment.warnings) {
-                output += `  ⚠ ${warning}\n`;
-            }
-            output += '\n';
-        }
-        if (assessment.recommendedApproach) {
-            output += `Recommended: ${assessment.recommendedApproach}\n`;
-        }
-        if (!assessment.canProceed) {
-            output += `\n⚠️ This operation requires human review before proceeding.\n`;
-        }
-        return output;
-    }
-    // Private helpers
-    initializeDefaultMessages() {
-        // General disclaimer
-        this.registerMessage({
-            type: 'disclaimer',
-            operation: 'general',
-            message: 'AI-generated code may contain errors. Please review and test before deploying.',
-            severity: 'info',
-            showOnce: true,
-        });
-        // Security operations
-        this.registerMessage({
-            type: 'warning',
-            operation: 'security-sensitive',
-            message: 'Security-sensitive operations require careful manual review. The AI may not catch all vulnerabilities.',
-            severity: 'warning',
-            contextual: true,
-        });
-        // Critical operations
-        this.registerMessage({
-            type: 'warning',
-            operation: 'critical',
-            message: 'This is a high-risk operation. Human review is mandatory before proceeding.',
-            severity: 'error',
-            contextual: true,
-        });
-    }
-    matchesContext(message, context) {
-        // Simple context matching logic
-        if (message.operation === 'security-sensitive' && context.domain === 'security') {
-            return true;
-        }
-        if (message.operation === 'critical' && context.riskLevel === 'critical') {
-            return true;
-        }
-        return false;
-    }
-    generateRecommendedApproach(capability, complexity, riskLevel) {
-        if (capability === 'risky' || riskLevel === 'critical') {
-            return 'Review generated code carefully, test thoroughly, and get human approval before deployment';
-        }
-        else if (capability === 'uncertain' || complexity === 'complex') {
-            return 'Review the generated code and test incrementally';
-        }
-        else if (capability === 'moderate') {
-            return 'Review the code before committing';
-        }
-        return undefined;
-    }
-    /**
-     * Check if first-time AI operation disclaimer should be shown
-     */
-    shouldShowFirstTimeDisclaimer() {
-        return !this.disclaimerShown;
-    }
-    /**
-     * Get first-time AI operation disclaimer notice
-     */
-    getFirstTimeDisclaimer() {
-        return `┌────────────────────────────────────────────────────┐
-│ ⚠️  AI Assistant Notice                            │
-│                                                     │
-│ This AI can make mistakes. Please verify:          │
-│ • Generated code correctness                       │
-│ • Security implications                            │
-│ • License compliance                               │
-│ • Output accuracy and completeness                 │
-│                                                     │
-│ Capabilities:                                      │
-│ • Can generate, explain, and modify code           │
-│ • May not catch all edge cases                     │
-│ • May not be aware of latest APIs                  │
-│ • Processing patterns, not "thinking"              │
-│                                                     │
-│ Always review generated code before deploying.     │
-└────────────────────────────────────────────────────┘`;
-    }
-    /**
-     * Mark first-time disclaimer as shown
-     */
-    markDisclaimerShown() {
-        this.disclaimerShown = true;
-        this.saveDisclaimerState();
-    }
-    /**
-     * Get uncertainty indicator message
-     */
-    getUncertaintyIndicator(confidence) {
-        if (confidence < 0.65) {
-            const percent = (confidence * 100).toFixed(0);
-            return `┌────────────────────────────────────────────────────┐
-│ ⚠️  Uncertainty Detected                           │
-│                                                     │
-│ I'm less confident about this answer (${percent}%).        │
-│ Please verify the information carefully.           │
-│                                                     │
-│ This may indicate:                                 │
-│ • Limited context for the query                    │
-│ • Ambiguous or complex requirements                │
-│ • Potential hallucination risk                     │
-│                                                     │
-│ Recommendation: Review output thoroughly.          │
-└────────────────────────────────────────────────────┘`;
-        }
-        return null;
-    }
-    /**
-     * Get capability boundaries notice
-     */
-    getCapabilityBoundaries() {
-        return `Capability Boundaries:
-
-What I CAN do:
-  ✓ Answer questions about your codebase
-  ✓ Generate and modify code
-  ✓ Explain code structure and logic
-  ✓ Suggest improvements and refactorings
-  ✓ Identify potential issues
-
-What I CANNOT do:
-  ✗ Guarantee code correctness
-  ✗ Always detect all security vulnerabilities
-  ✗ Know your specific business requirements
-  ✗ Replace thorough testing
-  ✗ Ensure compliance with all regulations
-
-Important:
-  • Always review generated code
-  • Test thoroughly before deploying
-  • Verify security and compliance requirements
-  • Use as an assistant, not a replacement for expertise`;
-    }
-    /**
-     * Format disclaimer for console display (honest tone, no anthropomorphization)
-     */
-    formatDisclaimerForConsole() {
-        return `⚠️  AI Assistant Notice
-
-This AI assistant processes code patterns and generates suggestions based on training data.
-It can make mistakes and may not understand all context.
-
-Please verify:
-  • Generated code correctness and logic
-  • Security implications (vulnerabilities, data exposure)
-  • License compliance (license conflicts, attribution)
-  • Output accuracy (may miss edge cases or latest APIs)
-
-Remember: The AI is processing patterns, not "thinking" or "understanding"
-in the human sense. Always review and test before deploying.`;
-    }
-    // Private helpers for disclaimer state management
-    loadDisclaimerState() {
-        try {
-            const configDir = join(process.cwd(), 'data');
-            const disclaimerPath = join(configDir, 'ai-disclaimer.json');
-            if (existsSync(disclaimerPath)) {
-                const state = JSON.parse(readFileSync(disclaimerPath, 'utf-8'));
-                this.disclaimerShown = state.shown || false;
-            }
-        }
-        catch {
-            // Ignore errors - will default to not shown
-        }
-    }
-    saveDisclaimerState() {
-        try {
-            const configDir = join(process.cwd(), 'data');
-            if (!existsSync(configDir)) {
-                mkdirSync(configDir, { recursive: true });
-            }
-            const disclaimerPath = join(configDir, 'ai-disclaimer.json');
-            const state = {
-                shown: true,
-                shownDate: new Date().toISOString(),
-            };
-            writeFileSync(disclaimerPath, JSON.stringify(state, null, 2));
-        }
-        catch {
-            // Ignore errors - non-critical
-        }
-    }
-}
-//# sourceMappingURL=expectation-management.js.map

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

@@ -1,14 +0,0 @@
-/**
- * Feature Discovery (v0.5.0-alpha.0 - Stub)
- * TODO: Implement feature discovery system
- */
-export function trackCommand(command) {
-    // Stub implementation
-}
-export function shouldShowFeatureDiscovery(command) {
-    return null;
-}
-export function markFeatureDiscoveryShown(id) {
-    // Stub implementation
-}
-//# sourceMappingURL=feature-discovery.js.map

package/dist/infrastructure/ux/feedback-prompt.js

@@ -1,45 +0,0 @@
-/**
- * Feedback Prompt
- * Collect and store user feedback for bidirectional learning
- *
- * Phase 1: v0.5.0-alpha.0
- */
-/**
- * Prompt user for feedback (non-blocking, returns null if user skips)
- */
-export async function promptForFeedback(operation, context) {
-    // In alpha, we skip interactive prompts to avoid blocking
-    // This can be enhanced later with readline-based prompts
-    return null;
-}
-/**
- * Store feedback in the learning system
- */
-export function storeFeedback(learningSystem, userId, feedback, metadata) {
-    if (!learningSystem || !feedback) {
-        return;
-    }
-    try {
-        // Store feedback if learning system supports it
-        if (typeof learningSystem.storeFeedback === 'function') {
-            learningSystem.storeFeedback({
-                userId,
-                feedback,
-                metadata,
-                timestamp: new Date().toISOString(),
-            });
-        }
-    }
-    catch (error) {
-        // Silent failure - feedback collection should not break the workflow
-        console.error('Failed to store feedback:', error);
-    }
-}
-/**
- * Display feedback confirmation message
- */
-export function displayFeedbackConfirmation(feedback) {
-    // In alpha, skip confirmation display to keep CLI clean
-    // This can be enhanced later
-}
-//# sourceMappingURL=feedback-prompt.js.map

package/dist/infrastructure/ux/hitl-validation.js

@@ -1,297 +0,0 @@
-/**
- * Infrastructure: Human-in-the-Loop (HITL) Validation System
- *
- * Architecturally embedded human intervention points for supervision and decision-making
- * Research: Human-in-the-Loop (HITL) validation mandatory, prevents automation bias
- *
- * Features:
- * - Mandatory validation checkpoints
- * - Centralized review hub
- * - Review queue management
- * - Approval workflow
- */
-/**
- * Human-in-the-Loop Validation System
- * Manages mandatory validation checkpoints for critical operations
- * Task 4.2: Adaptive HITL - Supports mandatory vs optional checkpoints based on risk
- */
-export class HITLValidation {
-    checkpoints = new Map();
-    reviewQueue = []; // Checkpoint IDs in review order
-    config;
-    constructor(config) {
-        this.config = config || {
-            strictness: 'balanced',
-            allowAutoProceed: true,
-            mandatoryRiskLevels: ['critical', 'high'],
-        };
-    }
-    /**
-     * Set HITL configuration (user preferences)
-     */
-    setConfiguration(config) {
-        this.config = config;
-    }
-    /**
-     * Get current HITL configuration
-     */
-    getConfiguration() {
-        return { ...this.config };
-    }
-    /**
-     * Create review checkpoint
-     * Task 4.2: Determines if checkpoint is mandatory or optional based on risk and user preferences
-     */
-    createCheckpoint(operation, changes, context, metadata) {
-        const checkpointId = `checkpoint-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        // Determine priority based on risk level
-        const priority = context.riskLevel === 'critical' ? 'critical' :
-            context.riskLevel === 'high' ? 'high' :
-                context.riskLevel === 'medium' ? 'normal' :
-                    'low';
-        // Task 4.2: Determine if checkpoint is mandatory or optional
-        const isMandatory = this.isMandatoryCheckpoint(context);
-        const checkpoint = {
-            checkpointId,
-            operation,
-            description: this.generateDescription(operation, changes, context),
-            priority,
-            status: 'pending',
-            createdAt: Date.now(),
-            isMandatory,
-            changes,
-            context,
-            metadata: metadata || {},
-        };
-        this.checkpoints.set(checkpointId, checkpoint);
-        this.addToReviewQueue(checkpointId, priority);
-        return checkpoint;
-    }
-    /**
-     * Task 4.2: Determine if checkpoint requires mandatory approval
-     * Low-risk operations can be optional (auto-proceed if user preference allows)
-     * High-risk operations are always mandatory
-     */
-    isMandatoryCheckpoint(context) {
-        const { riskLevel, isDestructive = false, modifiesSecuritySensitiveCode = false, affectsMultipleFiles = false, uncertainty = 0.5, } = context;
-        // Always mandatory for critical operations
-        if (riskLevel === 'critical') {
-            return true;
-        }
-        // Always mandatory for destructive operations
-        if (isDestructive) {
-            return true;
-        }
-        // Always mandatory for security-sensitive modifications
-        if (modifiesSecuritySensitiveCode) {
-            return true;
-        }
-        // Check user-configured mandatory risk levels
-        if (this.config.mandatoryRiskLevels?.includes(riskLevel)) {
-            return true;
-        }
-        // Apply strictness-based rules
-        // Note: 'critical' is already handled above, so riskLevel here is 'low' | 'medium' | 'high'
-        const strictness = this.config.strictness;
-        if (strictness === 'strict') {
-            // Strict: All medium+ risk operations are mandatory
-            return riskLevel !== 'low';
-        }
-        else if (strictness === 'balanced') {
-            // Balanced: High+ risk operations are mandatory, medium is optional
-            return riskLevel === 'high' || (affectsMultipleFiles && riskLevel === 'medium') || uncertainty > 0.8;
-        }
-        else if (strictness === 'minimal') {
-            // Minimal: Only high-risk operations are mandatory (critical already handled above)
-            return riskLevel === 'high' || (isDestructive && riskLevel === 'medium');
-        }
-        else {
-            // Default: High+ risk operations are mandatory
-            return riskLevel === 'high';
-        }
-    }
-    /**
-     * Task 4.2: Check if checkpoint can auto-proceed (optional checkpoint with user preference)
-     */
-    canAutoProceed(checkpoint) {
-        // Never auto-proceed mandatory checkpoints
-        if (checkpoint.isMandatory) {
-            return false;
-        }
-        // Check if user allows auto-proceed
-        if (!this.config.allowAutoProceed) {
-            return false;
-        }
-        // Optional checkpoints can auto-proceed if:
-        // 1. Not mandatory
-        // 2. User preference allows auto-proceed
-        // 3. Risk level is low or medium (not high/critical)
-        return checkpoint.context.riskLevel === 'low' || checkpoint.context.riskLevel === 'medium';
-    }
-    /**
-     * Check if operation requires HITL validation
-     */
-    requiresValidation(context) {
-        const { riskLevel, isDestructive = false, modifiesSecuritySensitiveCode = false, affectsMultipleFiles = false, uncertainty = 0.5, } = context;
-        // Always require validation for critical operations
-        if (riskLevel === 'critical') {
-            return true;
-        }
-        // Require validation for destructive operations
-        if (isDestructive) {
-            return true;
-        }
-        // Require validation for security-sensitive modifications
-        if (modifiesSecuritySensitiveCode) {
-            return true;
-        }
-        // Require validation for high-risk multi-file operations
-        if (affectsMultipleFiles && riskLevel === 'high') {
-            return true;
-        }
-        // Require validation if uncertainty is very high
-        if (uncertainty > 0.8) {
-            return true;
-        }
-        // Require validation for high-risk operations
-        if (riskLevel === 'high') {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get next checkpoint in review queue
-     */
-    getNextCheckpoint() {
-        if (this.reviewQueue.length === 0) {
-            return null;
-        }
-        const checkpointId = this.reviewQueue[0];
-        return this.checkpoints.get(checkpointId) || null;
-    }
-    /**
-     * Submit review decision
-     */
-    submitDecision(decision) {
-        const checkpoint = this.checkpoints.get(decision.checkpointId);
-        if (!checkpoint) {
-            throw new Error(`Checkpoint ${decision.checkpointId} not found`);
-        }
-        checkpoint.status =
-            decision.decision === 'approve' ? 'approved' :
-                decision.decision === 'reject' ? 'rejected' :
-                    'needs_changes';
-        checkpoint.reviewedAt = decision.timestamp;
-        checkpoint.reviewedBy = decision.reviewer;
-        // Remove from review queue
-        const index = this.reviewQueue.indexOf(decision.checkpointId);
-        if (index !== -1) {
-            this.reviewQueue.splice(index, 1);
-        }
-    }
-    /**
-     * Get checkpoint by ID
-     */
-    getCheckpoint(checkpointId) {
-        return this.checkpoints.get(checkpointId) || null;
-    }
-    /**
-     * Get all pending checkpoints
-     */
-    getPendingCheckpoints(priority) {
-        const pending = [];
-        for (const checkpointId of this.reviewQueue) {
-            const checkpoint = this.checkpoints.get(checkpointId);
-            if (checkpoint && checkpoint.status === 'pending') {
-                if (!priority || checkpoint.priority === priority) {
-                    pending.push(checkpoint);
-                }
-            }
-        }
-        return pending;
-    }
-    /**
-     * Get review queue status
-     */
-    getReviewQueueStatus() {
-        const byPriority = {
-            low: 0,
-            normal: 0,
-            high: 0,
-            critical: 0,
-        };
-        let pending = 0;
-        for (const checkpointId of this.reviewQueue) {
-            const checkpoint = this.checkpoints.get(checkpointId);
-            if (checkpoint && checkpoint.status === 'pending') {
-                pending++;
-                byPriority[checkpoint.priority]++;
-            }
-        }
-        return {
-            total: this.checkpoints.size,
-            pending,
-            byPriority,
-        };
-    }
-    /**
-     * Format checkpoint for review
-     */
-    formatCheckpoint(checkpoint) {
-        let output = '';
-        output += `\n${'═'.repeat(80)}\n`;
-        output += `Review Checkpoint: ${checkpoint.checkpointId}\n`;
-        output += `${'═'.repeat(80)}\n\n`;
-        output += `Operation: ${checkpoint.operation}\n`;
-        output += `Priority: ${checkpoint.priority.toUpperCase()}\n`;
-        output += `Status: ${checkpoint.status}\n`;
-        output += `Created: ${new Date(checkpoint.createdAt).toISOString()}\n\n`;
-        output += `Description:\n${checkpoint.description}\n\n`;
-        output += `Changes (${checkpoint.changes.length}):\n`;
-        for (const change of checkpoint.changes) {
-            output += `  • ${change.type}: ${change.summary}\n`;
-            if (change.filepath) {
-                output += `    File: ${change.filepath}\n`;
-            }
-        }
-        output += '\n';
-        output += `Context:\n`;
-        output += `  Query: ${checkpoint.context.query}\n`;
-        output += `  Risk Level: ${checkpoint.context.riskLevel}\n`;
-        if (checkpoint.context.uncertainty) {
-            output += `  Uncertainty: ${(checkpoint.context.uncertainty * 100).toFixed(1)}%\n`;
-        }
-        if (checkpoint.context.securityFindings && checkpoint.context.securityFindings.length > 0) {
-            output += `  ⚠️ Security Findings: ${checkpoint.context.securityFindings.length}\n`;
-        }
-        if (checkpoint.context.licenseFindings && checkpoint.context.licenseFindings.length > 0) {
-            output += `  ⚠️ License Findings: ${checkpoint.context.licenseFindings.length}\n`;
-        }
-        output += `\n${'═'.repeat(80)}\n`;
-        return output;
-    }
-    // Private helpers
-    addToReviewQueue(checkpointId, priority) {
-        // Insert based on priority (critical first)
-        const priorityOrder = ['critical', 'high', 'normal', 'low'];
-        const priorityIndex = priorityOrder.indexOf(priority);
-        let insertIndex = 0;
-        for (let i = 0; i < this.reviewQueue.length; i++) {
-            const existingCheckpoint = this.checkpoints.get(this.reviewQueue[i]);
-            if (existingCheckpoint) {
-                const existingPriorityIndex = priorityOrder.indexOf(existingCheckpoint.priority);
-                if (priorityIndex <= existingPriorityIndex) {
-                    insertIndex = i;
-                    break;
-                }
-            }
-            insertIndex = i + 1;
-        }
-        this.reviewQueue.splice(insertIndex, 0, checkpointId);
-    }
-    generateDescription(operation, changes, context) {
-        const changeSummary = changes.map(c => `${c.type} ${c.filepath || ''}`).join(', ');
-        return `${operation}: ${changeSummary}. Risk level: ${context.riskLevel}.`;
-    }
-}
-//# sourceMappingURL=hitl-validation.js.map