codehere 0.2.2 → 0.3.0-rc.10

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

@@ -1,167 +0,0 @@
-/**
- * Infrastructure: Telemetry Service
- * Privacy-first, opt-in telemetry for understanding usage patterns
- *
- * Principles:
- * - Opt-in only (CODEHERE_TELEMETRY_ENABLED=true)
- * - No code/content transmitted
- * - Anonymized data only
- * - Local-first (stores locally, syncs if enabled)
- *
- * Clean Architecture: Infrastructure Layer
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export class TelemetryService {
-    telemetryDir;
-    eventsFile;
-    configFile;
-    enabled = false;
-    anonymousId = '';
-    sessionId = '';
-    constructor() {
-        // Find codebase root
-        const codebaseRoot = this.findCodebaseRoot();
-        this.telemetryDir = join(codebaseRoot, '.codehere', 'telemetry');
-        this.eventsFile = join(this.telemetryDir, 'events.jsonl');
-        this.configFile = join(this.telemetryDir, 'config.json');
-        this.sessionId = randomUUID();
-        this.loadConfig();
-    }
-    findCodebaseRoot() {
-        let current = process.cwd();
-        while (current !== '/') {
-            if (existsSync(join(current, '.codehere'))) {
-                return current;
-            }
-            current = join(current, '..');
-        }
-        return process.cwd();
-    }
-    loadConfig() {
-        // Check environment variable first
-        const envEnabled = process.env.CODEHERE_TELEMETRY_ENABLED === 'true';
-        if (existsSync(this.configFile)) {
-            try {
-                const config = JSON.parse(readFileSync(this.configFile, 'utf-8'));
-                this.enabled = config.enabled || envEnabled;
-                this.anonymousId = config.anonymousId || this.generateAnonymousId();
-            }
-            catch {
-                this.enabled = envEnabled;
-                this.anonymousId = this.generateAnonymousId();
-            }
-        }
-        else {
-            this.enabled = envEnabled;
-            this.anonymousId = this.generateAnonymousId();
-        }
-        // Save config
-        this.saveConfig();
-    }
-    generateAnonymousId() {
-        // Generate a persistent anonymous ID (not tied to user identity)
-        return randomUUID();
-    }
-    saveConfig() {
-        if (!existsSync(this.telemetryDir)) {
-            mkdirSync(this.telemetryDir, { recursive: true });
-        }
-        writeFileSync(this.configFile, JSON.stringify({
-            enabled: this.enabled,
-            anonymousId: this.anonymousId,
-            enabledAt: this.enabled ? Date.now() : null,
-        }, null, 2));
-    }
-    /**
-     * Check if telemetry is enabled
-     */
-    isEnabled() {
-        return this.enabled;
-    }
-    /**
-     * Enable telemetry (opt-in)
-     */
-    enable() {
-        this.enabled = true;
-        this.saveConfig();
-        this.track('install', {
-            version: process.env.npm_package_version || 'unknown',
-            os: process.platform,
-            nodeVersion: process.version,
-        });
-    }
-    /**
-     * Disable telemetry
-     */
-    disable() {
-        this.enabled = false;
-        this.saveConfig();
-    }
-    /**
-     * Track an event
-     */
-    track(eventType, data = {}) {
-        if (!this.enabled) {
-            return;
-        }
-        const event = {
-            id: randomUUID(),
-            timestamp: Date.now(),
-            eventType,
-            data: {
-                ...data,
-                version: data.version || process.env.npm_package_version || 'unknown',
-                os: data.os || process.platform,
-                nodeVersion: data.nodeVersion || process.version,
-            },
-            sessionId: this.sessionId,
-            anonymousId: this.anonymousId,
-        };
-        // Write to local file
-        if (!existsSync(this.telemetryDir)) {
-            mkdirSync(this.telemetryDir, { recursive: true });
-        }
-        appendFileSync(this.eventsFile, JSON.stringify(event) + '\n');
-    }
-    /**
-     * Track command usage
-     */
-    trackCommand(command) {
-        this.track('command', { command });
-    }
-    /**
-     * Track error
-     */
-    trackError(errorType) {
-        this.track('error', { errorType });
-    }
-    /**
-     * Track feature usage
-     */
-    trackFeature(feature) {
-        this.track('feature_use', { feature });
-    }
-    /**
-     * Get telemetry status message
-     */
-    getStatusMessage() {
-        if (this.enabled) {
-            return 'Telemetry: Enabled (opt-in)';
-        }
-        return 'Telemetry: Disabled (set CODEHERE_TELEMETRY_ENABLED=true to enable)';
-    }
-}
-// Singleton instance
-let telemetryService = null;
-export function getTelemetryService() {
-    if (!telemetryService) {
-        telemetryService = new TelemetryService();
-    }
-    return telemetryService;
-}
-//# sourceMappingURL=telemetry-service.js.map

package/dist/infrastructure/ux/appropriate-friction.js

@@ -1,213 +0,0 @@
-/**
- * Infrastructure: Appropriate Friction System
- *
- * Intentionally inserts slowdowns at critical junctures to encourage human review
- * Research: Appropriate friction at high-risk moments prevents rubber-stamp reviews
- *
- * Features:
- * - Risk-based friction points
- * - Review checkpoints before critical operations
- * - Pause for reflection on high-risk changes
- * - Confirmation dialogs for destructive actions
- */
-/**
- * Appropriate Friction System
- * Manages friction points to ensure human review at critical moments
- */
-export class AppropriateFriction {
-    frictionPoints = new Map();
-    frictionHistory = [];
-    constructor() {
-        this.initializeDefaultFrictionPoints();
-    }
-    /**
-     * Check if friction is needed for an operation
-     */
-    needsFriction(operation, context) {
-        const { riskLevel = 'medium', isDestructive = false, affectsMultipleFiles = false, modifiesSecuritySensitiveCode = false, uncertainty = 0.5, } = context;
-        // Critical operations always need friction
-        if (riskLevel === 'critical') {
-            return this.createFrictionPoint({
-                id: `${operation}-critical`,
-                type: 'review_checkpoint',
-                level: 'heavy',
-                operation,
-                message: '⚠️ CRITICAL OPERATION: This requires mandatory human review before proceeding.',
-                requiresExplicitConfirmation: true,
-                options: ['review', 'cancel'],
-            });
-        }
-        // Destructive operations need confirmation
-        if (isDestructive) {
-            return this.createFrictionPoint({
-                id: `${operation}-destructive`,
-                type: 'confirmation',
-                level: 'moderate',
-                operation,
-                message: '⚠️ Destructive operation detected. This action cannot be easily undone. Please confirm.',
-                requiresExplicitConfirmation: true,
-                options: ['proceed', 'cancel'],
-            });
-        }
-        // High-risk operations need pause
-        if (riskLevel === 'high') {
-            return this.createFrictionPoint({
-                id: `${operation}-high-risk`,
-                type: 'pause',
-                level: 'moderate',
-                operation,
-                message: '⏸️ High-risk operation detected. Pausing for review (3 seconds)...',
-                requiresExplicitConfirmation: false,
-                timeout: 3000,
-                options: ['proceed', 'review'],
-            });
-        }
-        // Multi-file operations need review checkpoint
-        if (affectsMultipleFiles && riskLevel !== 'low') {
-            return this.createFrictionPoint({
-                id: `${operation}-multi-file`,
-                type: 'review_checkpoint',
-                level: 'moderate',
-                operation,
-                message: '📝 Multi-file operation detected. Review the plan before proceeding.',
-                requiresExplicitConfirmation: true,
-                options: ['proceed', 'review', 'cancel'],
-            });
-        }
-        // Security-sensitive operations need heavy friction
-        if (modifiesSecuritySensitiveCode) {
-            return this.createFrictionPoint({
-                id: `${operation}-security`,
-                type: 'review_checkpoint',
-                level: 'heavy',
-                operation,
-                message: '🔒 Security-sensitive code modification. Mandatory review required.',
-                requiresExplicitConfirmation: true,
-                options: ['review', 'cancel'],
-            });
-        }
-        // High uncertainty needs warning
-        if (uncertainty > 0.7 && riskLevel !== 'low') {
-            return this.createFrictionPoint({
-                id: `${operation}-uncertainty`,
-                type: 'warning_display',
-                level: 'light',
-                operation,
-                message: '⚠️ High uncertainty detected. Verify output carefully.',
-                requiresExplicitConfirmation: false,
-                timeout: 2000,
-                options: ['proceed'],
-            });
-        }
-        return null; // No friction needed
-    }
-    /**
-     * Apply friction point (in real implementation, this would be UI-based)
-     * For CLI, we simulate with prompts and pauses
-     */
-    async applyFriction(frictionPoint, autoProceed = false) {
-        // In production, this would:
-        // - Display UI dialog for confirmation
-        // - Show review checkpoint
-        // - Pause execution
-        // - Wait for user input
-        // For CLI/simulation, we log and return decision
-        const result = {
-            proceed: autoProceed || frictionPoint.type === 'warning_display',
-            action: autoProceed ? 'auto-proceed' : 'pending',
-            timestamp: Date.now(),
-        };
-        // Store in history
-        this.frictionHistory.push({
-            point: frictionPoint,
-            result,
-        });
-        // Store friction point
-        this.frictionPoints.set(frictionPoint.id, frictionPoint);
-        return result;
-    }
-    /**
-     * Format friction point for display
-     */
-    formatFrictionPoint(frictionPoint) {
-        let output = '';
-        output += `\n${'═'.repeat(80)}\n`;
-        output += `${frictionPoint.message}\n`;
-        output += `${'═'.repeat(80)}\n`;
-        if (frictionPoint.options && frictionPoint.options.length > 1) {
-            output += `\nAvailable actions: ${frictionPoint.options.join(', ')}\n`;
-        }
-        if (frictionPoint.timeout) {
-            output += `(Auto-proceeding in ${frictionPoint.timeout / 1000}s if no response)\n`;
-        }
-        if (frictionPoint.requiresExplicitConfirmation) {
-            output += `⚠️ Explicit confirmation required\n`;
-        }
-        output += `${'═'.repeat(80)}\n`;
-        return output;
-    }
-    /**
-     * Get friction history for audit
-     */
-    getFrictionHistory(filter) {
-        let filtered = [...this.frictionHistory];
-        if (filter?.operation) {
-            filtered = filtered.filter(item => item.point.operation === filter.operation);
-        }
-        if (filter?.type) {
-            filtered = filtered.filter(item => item.point.type === filter.type);
-        }
-        if (filter?.startTime) {
-            filtered = filtered.filter(item => item.result.timestamp >= filter.startTime);
-        }
-        if (filter?.endTime) {
-            filtered = filtered.filter(item => item.result.timestamp <= filter.endTime);
-        }
-        return filtered.sort((a, b) => b.result.timestamp - a.result.timestamp);
-    }
-    /**
-     * Register custom friction point
-     */
-    registerFrictionPoint(point) {
-        this.frictionPoints.set(point.id, point);
-    }
-    // Private helpers
-    createFrictionPoint(point) {
-        return {
-            ...point,
-        };
-    }
-    initializeDefaultFrictionPoints() {
-        // Critical operations
-        this.registerFrictionPoint({
-            id: 'default-critical',
-            type: 'review_checkpoint',
-            level: 'heavy',
-            operation: 'critical',
-            message: 'Critical operation detected - human review required',
-            requiresExplicitConfirmation: true,
-            options: ['review', 'cancel'],
-        });
-        // Destructive operations
-        this.registerFrictionPoint({
-            id: 'default-destructive',
-            type: 'confirmation',
-            level: 'moderate',
-            operation: 'destructive',
-            message: 'Destructive operation - cannot be easily undone',
-            requiresExplicitConfirmation: true,
-            options: ['proceed', 'cancel'],
-        });
-        // Security modifications
-        this.registerFrictionPoint({
-            id: 'default-security',
-            type: 'review_checkpoint',
-            level: 'heavy',
-            operation: 'security',
-            message: 'Security-sensitive code modification - mandatory review',
-            requiresExplicitConfirmation: true,
-            options: ['review', 'cancel'],
-        });
-    }
-}
-//# sourceMappingURL=appropriate-friction.js.map