@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/approval-manager.js

@@ -1,1044 +0,0 @@
-/**
- * Approval system service implementing three-tier approval flow
- *
- * This service manages the approval workflow for file modifications and other
- * operations that require user consent. It supports three approval modes:
- * - MANUAL: Requires explicit approval for each operation
- * - AUTO: Automatically approves safe operations based on patterns and thresholds
- * - STRICT: Requires approval for all operations including low-risk ones
- *
- * Features:
- * - Three-tier approval system (manual, auto, strict)
- * - Risk level assessment for operations
- * - Pattern-based auto-approval configuration
- * - Audit logging of all approval requests and responses
- * - Event emission for UI integration
- */
-import { v4 as uuidv4 } from 'uuid';
-import { ApprovalMode, } from '../types/approval.js';
-import { logger } from '../utils/logger.js';
-import { formatTimestamp } from '../utils/format.js';
-import { matchesPattern } from '../utils/path.js';
-import { getEventEmitter } from '../core/event-emitter.js';
-import { getSystemEventLogger } from './system-event-logger.js';
-/**
- * Default configuration values for the approval manager
- */
-const DEFAULT_MAX_AUTO_APPROVE_FILES = 5;
-const DEFAULT_MAX_AUTO_APPROVE_LINES = 100;
-/**
- * ApprovalManager handles the three-tier approval system for operations
- * that modify files, execute commands, or perform other potentially
- * destructive actions.
- */
-class ApprovalManager {
-    /** Current approval mode */
-    mode = ApprovalMode.MANUAL;
-    /** History of all approval requests and responses */
-    history = { requests: [], responses: [] };
-    /** Patterns for files that can be auto-approved */
-    autoApprovePatterns = [];
-    /** Patterns for files that always require approval */
-    requireApprovalPatterns = [];
-    /** Maximum number of files that can be auto-approved in one operation */
-    maxAutoApproveFiles = DEFAULT_MAX_AUTO_APPROVE_FILES;
-    /** Maximum number of lines changed that can be auto-approved */
-    maxAutoApproveLines = DEFAULT_MAX_AUTO_APPROVE_LINES;
-    /** Event emitter for UI communication */
-    eventEmitter;
-    /** Currently pending approval request */
-    pendingRequest = null;
-    /** Resolver function for pending approval promise */
-    resolveApproval = null;
-    /** Current complexity context for SMART mode decisions */
-    currentComplexityMode = null;
-    /** Confidence of the current complexity classification */
-    currentComplexityConfidence = 0;
-    /** Minimum confidence threshold for SMART mode auto-approval (0-100) */
-    smartModeConfidenceThreshold = 70;
-    /** Session-wide auto-approval flag (set via [A] option in approval dialog) */
-    sessionAutoApprovalEnabled = false;
-    /** Auto-approve file edits, writes, and command executions (set via plan approval dialog) */
-    fileEditsAutoApprovalEnabled = false;
-    /** Currently pending plan approval request */
-    pendingPlanApproval = null;
-    /** Resolver function for pending plan approval promise */
-    resolvePlanApprovalPromise = null;
-    /** Set of approved command prefixes (e.g., 'npm', 'git', 'yarn') */
-    approvedCommandPrefixes = new Set();
-    /** Currently pending clarification wizard request */
-    pendingClarificationWizard = null;
-    /** Resolver function for pending clarification wizard promise */
-    resolveClarificationWizardPromise = null;
-    /**
-     * Creates a new ApprovalManager instance
-     */
-    constructor() {
-        this.eventEmitter = getEventEmitter();
-    }
-    /**
-     * Gets the current approval mode
-     * @returns The current ApprovalMode
-     */
-    getMode() {
-        return this.mode;
-    }
-    /**
-     * Enables session-wide auto-approval.
-     * When enabled, all subsequent operations will be auto-approved for this session.
-     * This is typically triggered by selecting [A] in the approval dialog.
-     */
-    enableSessionAutoApproval() {
-        this.sessionAutoApprovalEnabled = true;
-        logger.info('Session auto-approval enabled - all subsequent operations will be auto-approved');
-    }
-    /**
-     * Disables session-wide auto-approval.
-     */
-    disableSessionAutoApproval() {
-        this.sessionAutoApprovalEnabled = false;
-        logger.info('Session auto-approval disabled');
-    }
-    /**
-     * Checks if session-wide auto-approval is enabled.
-     * @returns True if session auto-approval is enabled
-     */
-    isSessionAutoApprovalEnabled() {
-        return this.sessionAutoApprovalEnabled;
-    }
-    /**
-     * Enables auto-approval for file edits, writes, and command executions.
-     * File creates, modifies, and shell commands will be auto-approved;
-     * high-risk/critical shell commands still require manual approval.
-     */
-    enableFileEditsAutoApproval() {
-        this.fileEditsAutoApprovalEnabled = true;
-        logger.info('File edits auto-approval enabled - file writes, edits, and commands will be auto-approved');
-    }
-    /**
-     * Disables auto-approval for file edits and writes.
-     */
-    disableFileEditsAutoApproval() {
-        this.fileEditsAutoApprovalEnabled = false;
-        logger.info('File edits auto-approval disabled');
-    }
-    /**
-     * Extracts the command prefix from a shell command.
-     * Examples: "npm install" -> "npm", "git status" -> "git"
-     *
-     * @param command - The full command string
-     * @returns The command prefix (first word)
-     */
-    getCommandPrefix(command) {
-        const trimmed = command.trim();
-        // Handle common shell prefixes like sudo, env, etc.
-        const parts = trimmed.split(/\s+/);
-        const skipPrefixes = ['sudo', 'env', 'npx', 'pnpm', 'yarn', 'bunx'];
-        for (const part of parts) {
-            if (!skipPrefixes.includes(part.toLowerCase())) {
-                return part.toLowerCase();
-            }
-        }
-        return parts[0]?.toLowerCase() || '';
-    }
-    /**
-     * Checks if a command's prefix has been approved for auto-execution.
-     *
-     * @param command - The command to check
-     * @returns True if the command prefix is approved
-     */
-    isCommandPrefixApproved(command) {
-        const prefix = this.getCommandPrefix(command);
-        return this.approvedCommandPrefixes.has(prefix);
-    }
-    /**
-     * Approves a command prefix for auto-execution in this session.
-     * Future commands starting with this prefix will be auto-approved.
-     *
-     * @param command - The command whose prefix should be approved
-     */
-    approveCommandPrefix(command) {
-        const prefix = this.getCommandPrefix(command);
-        this.approvedCommandPrefixes.add(prefix);
-        logger.info(`Command prefix approved for session: ${prefix}`);
-    }
-    /**
-     * Gets all approved command prefixes.
-     *
-     * @returns Array of approved command prefixes
-     */
-    getApprovedCommandPrefixes() {
-        return Array.from(this.approvedCommandPrefixes);
-    }
-    /**
-     * Clears all approved command prefixes.
-     */
-    clearApprovedCommandPrefixes() {
-        this.approvedCommandPrefixes.clear();
-        logger.debug('Approved command prefixes cleared');
-    }
-    /**
-     * Sets the complexity context for SMART mode decisions.
-     * This should be called before file operations when complexity classification is available.
-     *
-     * @param mode - The complexity mode from the classifier (direct, clarification, plan)
-     * @param confidence - The confidence score (0-100) of the classification
-     */
-    setComplexityContext(mode, confidence = 0) {
-        this.currentComplexityMode = mode;
-        this.currentComplexityConfidence = confidence;
-        logger.debug(`Complexity context set: mode=${mode}, confidence=${confidence}`);
-    }
-    /**
-     * Gets the current complexity context
-     * @returns Object with mode and confidence, or null if not set
-     */
-    getComplexityContext() {
-        return {
-            mode: this.currentComplexityMode,
-            confidence: this.currentComplexityConfidence,
-        };
-    }
-    /**
-     * Clears the complexity context (call after workflow completion)
-     */
-    clearComplexityContext() {
-        this.currentComplexityMode = null;
-        this.currentComplexityConfidence = 0;
-        logger.debug('Complexity context cleared');
-    }
-    /**
-     * Sets the confidence threshold for SMART mode auto-approval
-     * @param threshold - Minimum confidence (0-100) required for auto-approval
-     */
-    setSmartModeConfidenceThreshold(threshold) {
-        this.smartModeConfidenceThreshold = Math.max(0, Math.min(100, threshold));
-        logger.debug(`SMART mode confidence threshold set to: ${this.smartModeConfidenceThreshold}`);
-    }
-    /**
-     * Quick classification of a user request for SMART mode.
-     * This is a lightweight heuristic-based classification that runs before LLM calls.
-     * It sets the complexity context based on the request text.
-     *
-     * @param userRequest - The user's request text
-     * @returns The determined complexity mode and confidence
-     */
-    quickClassifyRequest(userRequest) {
-        const request = userRequest.toLowerCase();
-        // Keywords indicating complex operations (PLAN mode)
-        const complexKeywords = [
-            'refactor', 'redesign', 'migrate', 'architecture', 'rewrite',
-            'restructure', 'overhaul', 'major', 'breaking change', 'system',
-            'framework', 'infrastructure', 'database schema', 'api redesign',
-            'authentication system', 'authorization', 'security overhaul',
-        ];
-        // Keywords indicating medium complexity (CLARIFICATION mode)
-        const mediumKeywords = [
-            'implement', 'feature', 'add functionality', 'integrate',
-            'connect', 'setup', 'configure', 'multi-file', 'across files',
-            'multiple components', 'service', 'module', 'api endpoint',
-        ];
-        // Keywords indicating simple operations (DIRECT mode)
-        const simpleKeywords = [
-            'create', 'simple', 'basic', 'hello world', 'example',
-            'add file', 'new file', 'write', 'make', 'generate',
-            'readme', 'config', 'single', 'quick', 'small',
-            'fix typo', 'update text', 'change string', 'rename',
-        ];
-        // Check for complex patterns first (highest priority)
-        const hasComplexKeyword = complexKeywords.some(keyword => request.includes(keyword));
-        if (hasComplexKeyword) {
-            logger.debug(`Quick classify: PLAN (complex keyword found)`);
-            return { mode: 'plan', confidence: 80 };
-        }
-        // Check for medium complexity
-        const hasMediumKeyword = mediumKeywords.some(keyword => request.includes(keyword));
-        const hasMultipleFiles = /multiple|several|all|many|across/i.test(request);
-        if (hasMediumKeyword || hasMultipleFiles) {
-            logger.debug(`Quick classify: CLARIFICATION (medium keyword found)`);
-            return { mode: 'clarification', confidence: 70 };
-        }
-        // Check for simple patterns
-        const hasSimpleKeyword = simpleKeywords.some(keyword => request.includes(keyword));
-        // Additional simple indicators
-        const isShortRequest = request.length < 100;
-        const mentionsSingleFile = /\b(a|one|single|the)\s+(file|page|document)\b/i.test(request);
-        const isCreationRequest = /^(create|make|write|add|generate)\b/i.test(request.trim());
-        if (hasSimpleKeyword || (isShortRequest && (mentionsSingleFile || isCreationRequest))) {
-            const confidence = hasSimpleKeyword ? 85 : 75;
-            logger.debug(`Quick classify: DIRECT (simple indicators, confidence: ${confidence})`);
-            return { mode: 'direct', confidence };
-        }
-        // Default to clarification for ambiguous requests
-        logger.debug(`Quick classify: CLARIFICATION (default for ambiguous request)`);
-        return { mode: 'clarification', confidence: 60 };
-    }
-    /**
-     * Classifies a user request and sets the complexity context.
-     * Call this before tool execution to enable SMART mode decisions.
-     *
-     * @param userRequest - The user's request text
-     */
-    classifyAndSetContext(userRequest) {
-        const { mode, confidence } = this.quickClassifyRequest(userRequest);
-        this.setComplexityContext(mode, confidence);
-        logger.info(`Request classified: mode=${mode}, confidence=${confidence}%`);
-    }
-    /**
-     * Sets the approval mode
-     * @param mode - The new approval mode to set
-     */
-    setMode(mode) {
-        const previousMode = this.mode;
-        this.mode = mode;
-        logger.info(`Approval mode changed from ${previousMode} to ${mode}`);
-    }
-    /**
-     * Toggles between manual and auto approval modes
-     * If currently in STRICT mode, toggles to MANUAL
-     * @returns The new approval mode after toggling
-     */
-    toggleMode() {
-        if (this.mode === ApprovalMode.MANUAL) {
-            this.mode = ApprovalMode.AUTO;
-        }
-        else {
-            this.mode = ApprovalMode.MANUAL;
-        }
-        logger.info(`Approval mode toggled to: ${this.mode}`);
-        return this.mode;
-    }
-    /**
-     * Configures the approval manager with custom settings
-     * @param options - Configuration options for auto-approval behavior
-     */
-    configure(options) {
-        if (options.autoApprovePatterns !== undefined) {
-            this.autoApprovePatterns = options.autoApprovePatterns;
-        }
-        if (options.requireApprovalPatterns !== undefined) {
-            this.requireApprovalPatterns = options.requireApprovalPatterns;
-        }
-        if (options.maxAutoApproveFiles !== undefined) {
-            this.maxAutoApproveFiles = options.maxAutoApproveFiles;
-        }
-        if (options.maxAutoApproveLines !== undefined) {
-            this.maxAutoApproveLines = options.maxAutoApproveLines;
-        }
-        logger.debug('Approval manager configured', options);
-    }
-    /**
-     * Gets the current configuration
-     * @returns The current approval configuration
-     */
-    getConfig() {
-        return {
-            mode: this.mode,
-            autoApprovePatterns: [...this.autoApprovePatterns],
-            requireApprovalPatterns: [...this.requireApprovalPatterns],
-            maxAutoApproveFiles: this.maxAutoApproveFiles,
-            maxAutoApproveLines: this.maxAutoApproveLines,
-        };
-    }
-    /**
-     * Requests approval for an operation
-     *
-     * This method creates an approval request, assesses its risk level,
-     * and either auto-approves it (based on mode and patterns) or
-     * waits for user input.
-     *
-     * @param type - The type of operation requiring approval
-     * @param description - Human-readable description of the operation
-     * @param details - Detailed information about the operation
-     * @returns Promise resolving to the approval response
-     */
-    async requestApproval(type, description, details) {
-        const request = {
-            id: uuidv4(),
-            type,
-            timestamp: formatTimestamp(),
-            description,
-            details,
-            riskLevel: this.assessRiskLevel(type, details),
-            estimatedImpact: this.estimateImpact(type, details),
-        };
-        this.history.requests.push(request);
-        this.pendingRequest = request;
-        logger.debug(`Approval requested: ${request.id}`, {
-            type,
-            riskLevel: request.riskLevel,
-        });
-        // Log approval request to system events
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logApprovalRequested({
-            approvalId: request.id,
-            actionType: type,
-            actionDescription: description,
-            reason: `Risk level: ${request.riskLevel}`,
-        });
-        // Check if auto-approval is possible based on risk and patterns
-        if (this.canAutoApprove(request)) {
-            const response = this.createResponse(request, true, 'Auto-approved based on configuration');
-            this.history.responses.push(response);
-            this.pendingRequest = null;
-            logger.info(`Request ${request.id} auto-approved`);
-            // Log auto-approval to system events
-            systemEventLogger.logApprovalGranted({
-                approvalId: request.id,
-                actionType: type,
-                actionDescription: description,
-                decidedBy: 'system',
-                reason: 'Auto-approved based on configuration',
-            });
-            return response;
-        }
-        // In strict mode, always require explicit approval
-        if (this.mode === ApprovalMode.STRICT) {
-            return this.waitForUserApproval(request);
-        }
-        // In manual mode, always require approval
-        if (this.mode === ApprovalMode.MANUAL) {
-            return this.waitForUserApproval(request);
-        }
-        // In auto mode, check if this specific request should require approval
-        if (this.shouldRequireApproval(request)) {
-            return this.waitForUserApproval(request);
-        }
-        // Auto-approve in auto mode for safe operations
-        const response = this.createResponse(request, true, 'Auto-approved (auto mode)');
-        this.history.responses.push(response);
-        this.pendingRequest = null;
-        logger.info(`Request ${request.id} auto-approved in auto mode`);
-        // Log auto-approval to system events
-        systemEventLogger.logApprovalGranted({
-            approvalId: request.id,
-            actionType: type,
-            actionDescription: description,
-            decidedBy: 'system',
-            reason: 'Auto-approved (auto mode)',
-        });
-        return response;
-    }
-    /**
-     * Resolves a pending approval request with the user's choice
-     *
-     * @param choice - The user's approval choice
-     * @param reason - Optional reason for the decision
-     */
-    resolveRequest(choice, reason) {
-        if (!this.pendingRequest || !this.resolveApproval) {
-            logger.warn('No pending approval request to resolve');
-            return;
-        }
-        const approved = choice === 'approve';
-        const response = this.createResponse(this.pendingRequest, approved, reason);
-        this.history.responses.push(response);
-        logger.info(`Request ${this.pendingRequest.id} ${approved ? 'approved' : 'rejected'}`, {
-            choice,
-            reason,
-        });
-        // Log approval decision to system events
-        const systemEventLogger = getSystemEventLogger();
-        const approvalData = {
-            approvalId: this.pendingRequest.id,
-            actionType: this.pendingRequest.type,
-            actionDescription: this.pendingRequest.description,
-            decidedBy: 'user',
-            reason,
-        };
-        if (approved) {
-            systemEventLogger.logApprovalGranted(approvalData);
-        }
-        else {
-            systemEventLogger.logApprovalDenied(approvalData);
-        }
-        this.resolveApproval(response);
-        this.pendingRequest = null;
-        this.resolveApproval = null;
-    }
-    /**
-     * Gets the currently pending approval request
-     * @returns The pending request or null if none
-     */
-    getPendingRequest() {
-        return this.pendingRequest;
-    }
-    /**
-     * Checks if there is a pending approval request
-     * @returns True if there is a pending request
-     */
-    hasPendingRequest() {
-        return this.pendingRequest !== null;
-    }
-    /**
-     * Cancels the pending approval request
-     */
-    cancelPendingRequest() {
-        if (this.pendingRequest && this.resolveApproval) {
-            const response = this.createResponse(this.pendingRequest, false, 'Cancelled by user');
-            this.history.responses.push(response);
-            // Log cancellation to system events
-            const systemEventLogger = getSystemEventLogger();
-            systemEventLogger.logApprovalDenied({
-                approvalId: this.pendingRequest.id,
-                actionType: this.pendingRequest.type,
-                actionDescription: this.pendingRequest.description,
-                decidedBy: 'user',
-                reason: 'Cancelled by user',
-            });
-            this.resolveApproval(response);
-        }
-        this.pendingRequest = null;
-        this.resolveApproval = null;
-    }
-    /**
-     * Gets the approval history
-     * @returns A copy of the approval history
-     */
-    getHistory() {
-        return {
-            requests: [...this.history.requests],
-            responses: [...this.history.responses],
-        };
-    }
-    /**
-     * Gets statistics about approval history
-     * @returns Object containing approval statistics
-     */
-    getStatistics() {
-        const approved = this.history.responses.filter((r) => r.approved).length;
-        const autoApproved = this.history.responses.filter((r) => r.approved && r.reason?.includes('Auto-approved')).length;
-        return {
-            totalRequests: this.history.requests.length,
-            approved,
-            rejected: this.history.responses.filter((r) => !r.approved).length,
-            autoApproved,
-        };
-    }
-    /**
-     * Clears the approval history
-     */
-    clearHistory() {
-        this.history = { requests: [], responses: [] };
-        logger.debug('Approval history cleared');
-    }
-    // ==========================================================================
-    // Plan Approval Methods
-    // ==========================================================================
-    /**
-     * Requests approval for an implementation plan.
-     * Emits 'plan-approval-required' event and waits for user response.
-     *
-     * @param plan - The implementation plan requiring approval
-     * @param context - The gathered project context
-     * @param complexity - The complexity classification result
-     * @returns Promise resolving to the plan approval response
-     */
-    async requestPlanApproval(plan, context, complexity, completedTaskIds) {
-        const request = {
-            id: uuidv4(),
-            timestamp: formatTimestamp(),
-            plan,
-            context,
-            complexity,
-            completedTaskIds,
-        };
-        this.pendingPlanApproval = request;
-        logger.info('Plan approval requested', {
-            planId: plan.id,
-            taskCount: plan.tasks.length,
-            totalComplexity: plan.totalComplexity,
-        });
-        // Log to system events
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logPlanApprovalRequested(plan.id);
-        // Emit event for UI to display the plan approval dialog
-        this.eventEmitter.emit('plan-approval-required', { request });
-        // Wait for user response
-        return new Promise((resolve) => {
-            this.resolvePlanApprovalPromise = resolve;
-        });
-    }
-    /**
-     * Resolves a pending plan approval request with the user's choice.
-     *
-     * @param choice - The user's approval choice
-     * @param modifications - Optional modifications if choice is 'edit'
-     * @param clarifications - Optional clarifications if choice is 'clarify'
-     */
-    resolvePlanApproval(choice, modifications, clarifications) {
-        if (!this.pendingPlanApproval || !this.resolvePlanApprovalPromise) {
-            logger.warn('No pending plan approval request to resolve');
-            return;
-        }
-        const response = {
-            requestId: this.pendingPlanApproval.id,
-            approved: choice === 'approve' || choice === 'approve-compact' || choice === 'approve-auto-edits',
-            timestamp: formatTimestamp(),
-            choice,
-            modifications,
-            clarifications,
-        };
-        logger.info('Plan approval resolved', {
-            planId: this.pendingPlanApproval.plan.id,
-            choice,
-            approved: response.approved,
-        });
-        // Log to system events
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logPlanApprovalResolved(this.pendingPlanApproval.plan.id, choice);
-        // Emit resolution event
-        this.eventEmitter.emit('plan-approval-resolved', {
-            requestId: this.pendingPlanApproval.id,
-            choice,
-            modifications,
-            clarifications,
-        });
-        this.resolvePlanApprovalPromise(response);
-        this.pendingPlanApproval = null;
-        this.resolvePlanApprovalPromise = null;
-    }
-    /**
-     * Gets the currently pending plan approval request.
-     * @returns The pending plan approval request or null
-     */
-    getPendingPlanApproval() {
-        return this.pendingPlanApproval;
-    }
-    /**
-     * Checks if there is a pending plan approval request.
-     * @returns True if there is a pending plan approval
-     */
-    hasPendingPlanApproval() {
-        return this.pendingPlanApproval !== null;
-    }
-    /**
-     * Cancels the pending plan approval request.
-     */
-    cancelPendingPlanApproval() {
-        if (this.pendingPlanApproval && this.resolvePlanApprovalPromise) {
-            const response = {
-                requestId: this.pendingPlanApproval.id,
-                approved: false,
-                timestamp: formatTimestamp(),
-                choice: 'reject',
-            };
-            logger.info('Plan approval cancelled', {
-                planId: this.pendingPlanApproval.plan.id,
-            });
-            // Log to system events
-            const systemEventLogger = getSystemEventLogger();
-            systemEventLogger.logPlanApprovalResolved(this.pendingPlanApproval.plan.id, 'reject');
-            this.resolvePlanApprovalPromise(response);
-        }
-        this.pendingPlanApproval = null;
-        this.resolvePlanApprovalPromise = null;
-    }
-    // ==========================================================================
-    // Clarification Wizard Methods
-    // ==========================================================================
-    /**
-     * Requests clarification from the user via the wizard UI.
-     * Used when complexity classifier determines CLARIFICATION mode.
-     *
-     * @param taskSummary - Brief description of the task
-     * @param questions - The clarification questions to ask
-     * @param reasoning - The reasoning from complexity classifier
-     * @returns Promise resolving to the clarification wizard response
-     */
-    async requestClarification(taskSummary, questions, reasoning) {
-        const request = {
-            id: uuidv4(),
-            timestamp: formatTimestamp(),
-            taskSummary,
-            questions,
-            reasoning,
-        };
-        this.pendingClarificationWizard = request;
-        logger.info('Clarification wizard requested', {
-            requestId: request.id,
-            questionCount: questions.length,
-        });
-        // Emit event for UI to display the clarification wizard
-        this.eventEmitter.emit('clarification-required', { request });
-        // Wait for user response
-        return new Promise((resolve) => {
-            this.resolveClarificationWizardPromise = resolve;
-        });
-    }
-    /**
-     * Resolves a pending clarification wizard request with the user's answers.
-     *
-     * @param answers - The user's answers to questions (null if cancelled)
-     */
-    resolveClarificationWizard(answers) {
-        if (!this.pendingClarificationWizard || !this.resolveClarificationWizardPromise) {
-            logger.warn('No pending clarification wizard request to resolve');
-            return;
-        }
-        const completed = answers !== null;
-        const request = this.pendingClarificationWizard;
-        // Build ClarificationResult if completed
-        let result;
-        if (completed && answers) {
-            const qaRecords = request.questions.map((question, index) => ({
-                question,
-                answer: answers[index] || {
-                    questionId: question.id,
-                    answer: '',
-                    answeredAt: formatTimestamp(),
-                },
-            }));
-            // Generate decision summary from answers
-            const decisionParts = answers.map((a, i) => {
-                const q = request.questions[i];
-                const answerText = Array.isArray(a.answer) ? a.answer.join(', ') : a.answer;
-                return `${q.category}: ${answerText}`;
-            });
-            result = {
-                qaRecords,
-                completedAt: formatTimestamp(),
-                duration: 0, // Could track actual duration if needed
-                decisionSummary: decisionParts.join('; '),
-            };
-        }
-        const response = {
-            requestId: request.id,
-            completed,
-            timestamp: formatTimestamp(),
-            answers: answers || undefined,
-            result,
-        };
-        logger.info('Clarification wizard resolved', {
-            requestId: request.id,
-            completed,
-            answerCount: answers?.length || 0,
-        });
-        this.resolveClarificationWizardPromise(response);
-        this.pendingClarificationWizard = null;
-        this.resolveClarificationWizardPromise = null;
-    }
-    /**
-     * Gets the currently pending clarification wizard request.
-     * @returns The pending request or null
-     */
-    getPendingClarificationWizard() {
-        return this.pendingClarificationWizard;
-    }
-    /**
-     * Checks if there is a pending clarification wizard request.
-     * @returns True if there is a pending request
-     */
-    hasPendingClarificationWizard() {
-        return this.pendingClarificationWizard !== null;
-    }
-    /**
-     * Cancels the pending clarification wizard request.
-     */
-    cancelPendingClarificationWizard() {
-        if (this.pendingClarificationWizard && this.resolveClarificationWizardPromise) {
-            const response = {
-                requestId: this.pendingClarificationWizard.id,
-                completed: false,
-                timestamp: formatTimestamp(),
-            };
-            logger.info('Clarification wizard cancelled', {
-                requestId: this.pendingClarificationWizard.id,
-            });
-            this.resolveClarificationWizardPromise(response);
-        }
-        this.pendingClarificationWizard = null;
-        this.resolveClarificationWizardPromise = null;
-    }
-    /**
-     * Gets a specific approval request by ID
-     * @param requestId - The ID of the request to find
-     * @returns The request or undefined if not found
-     */
-    getRequest(requestId) {
-        return this.history.requests.find((r) => r.id === requestId);
-    }
-    /**
-     * Gets the response for a specific request
-     * @param requestId - The ID of the request
-     * @returns The response or undefined if not found
-     */
-    getResponse(requestId) {
-        return this.history.responses.find((r) => r.requestId === requestId);
-    }
-    /**
-     * Waits for user approval by emitting an event and returning a promise
-     * @param request - The approval request
-     * @returns Promise resolving to the approval response
-     */
-    async waitForUserApproval(request) {
-        // Emit event for UI to handle
-        this.eventEmitter.emit('approval-required', { request });
-        return new Promise((resolve) => {
-            this.resolveApproval = resolve;
-        });
-    }
-    /**
-     * Determines if a request can be auto-approved based on configuration
-     * @param request - The approval request to evaluate
-     * @returns True if the request can be auto-approved
-     */
-    canAutoApprove(request) {
-        // Session auto-approval takes precedence (user selected [A] in approval dialog)
-        // Only skip critical operations for safety
-        if (this.sessionAutoApprovalEnabled) {
-            if (request.riskLevel === 'critical') {
-                logger.debug('Session auto-approval: Skipping critical operation, requiring manual approval');
-                return false;
-            }
-            logger.debug('Session auto-approval: Auto-approving operation');
-            return true;
-        }
-        // File edits auto-approval: auto-approve file creates, modifies, and shell commands
-        if (this.fileEditsAutoApprovalEnabled) {
-            const autoApprovedOperations = ['file_create', 'file_modify', 'shell_command'];
-            if (autoApprovedOperations.includes(request.type)) {
-                // Still require manual approval for high-risk/critical shell commands (e.g., rm, delete)
-                if (request.type === 'shell_command' && (request.riskLevel === 'high' || request.riskLevel === 'critical')) {
-                    logger.debug('File edits auto-approval: Skipping high-risk shell command, requiring manual approval');
-                }
-                else {
-                    logger.debug('File edits auto-approval: Auto-approving operation');
-                    return true;
-                }
-            }
-        }
-        // Check if this is a shell command with an approved prefix
-        if (request.type === 'shell_command' && request.details.command) {
-            if (this.isCommandPrefixApproved(request.details.command)) {
-                const prefix = this.getCommandPrefix(request.details.command);
-                logger.debug(`Command prefix '${prefix}' is approved, auto-approving`);
-                return true;
-            }
-        }
-        // Never auto-approve high-risk or critical operations
-        if (request.riskLevel === 'high' || request.riskLevel === 'critical') {
-            return false;
-        }
-        // Never auto-approve in strict mode
-        if (this.mode === ApprovalMode.STRICT) {
-            return false;
-        }
-        // Check file count threshold
-        if (request.details.affectedFiles !== undefined &&
-            request.details.affectedFiles > this.maxAutoApproveFiles) {
-            return false;
-        }
-        // Check line count threshold
-        const totalLines = (request.details.linesAdded || 0) + (request.details.linesRemoved || 0);
-        if (totalLines > this.maxAutoApproveLines) {
-            return false;
-        }
-        // Check if any file matches require-approval patterns
-        if (request.details.filePaths) {
-            for (const filePath of request.details.filePaths) {
-                if (matchesPattern(filePath, this.requireApprovalPatterns)) {
-                    return false;
-                }
-            }
-        }
-        // SMART mode: auto-approve DIRECT complexity tasks with low risk and high confidence
-        if (this.mode === ApprovalMode.SMART) {
-            return this.canSmartAutoApprove(request);
-        }
-        // In manual mode, don't auto-approve unless explicitly configured
-        if (this.mode === ApprovalMode.MANUAL) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Determines if a request can be auto-approved in SMART mode.
-     * SMART mode auto-approves when:
-     * - Complexity mode is DIRECT
-     * - Confidence is above threshold
-     * - Risk level is low
-     * - Operation is simple (file create, small modifications)
-     *
-     * @param request - The approval request to evaluate
-     * @returns True if SMART mode should auto-approve
-     */
-    canSmartAutoApprove(request) {
-        // Get complexity context from the request details or the stored context
-        const complexityMode = request.details.complexityMode || this.currentComplexityMode;
-        const complexityConfidence = request.details.complexityConfidence ?? this.currentComplexityConfidence;
-        // If no complexity context available, fall back to requiring approval
-        if (!complexityMode) {
-            logger.debug('SMART mode: No complexity context available, requiring approval');
-            return false;
-        }
-        // Only auto-approve DIRECT mode tasks
-        if (complexityMode !== 'direct') {
-            logger.debug(`SMART mode: Complexity mode is ${complexityMode}, requiring approval`);
-            return false;
-        }
-        // Check confidence threshold
-        if (complexityConfidence < this.smartModeConfidenceThreshold) {
-            logger.debug(`SMART mode: Confidence ${complexityConfidence} below threshold ${this.smartModeConfidenceThreshold}, requiring approval`);
-            return false;
-        }
-        // Only auto-approve low-risk operations
-        if (request.riskLevel !== 'low') {
-            logger.debug(`SMART mode: Risk level is ${request.riskLevel}, requiring approval`);
-            return false;
-        }
-        // Additional safety: only auto-approve file creation and small modifications
-        const safeOperations = ['file_create', 'file_modify', 'file_rename'];
-        if (!safeOperations.includes(request.type)) {
-            logger.debug(`SMART mode: Operation type ${request.type} not safe for auto-approval`);
-            return false;
-        }
-        logger.info(`SMART mode: Auto-approving ${request.type} (complexity: ${complexityMode}, ` +
-            `confidence: ${complexityConfidence}%, risk: ${request.riskLevel})`);
-        return true;
-    }
-    /**
-     * Determines if a request should require explicit approval in auto mode
-     * @param request - The approval request to evaluate
-     * @returns True if the request should require approval
-     */
-    shouldRequireApproval(request) {
-        // Check if any file matches require-approval patterns
-        if (request.details.filePaths) {
-            for (const filePath of request.details.filePaths) {
-                if (matchesPattern(filePath, this.requireApprovalPatterns)) {
-                    return true;
-                }
-                // If not in auto-approve patterns and we have patterns configured, require approval
-                if (this.autoApprovePatterns.length > 0 &&
-                    !matchesPattern(filePath, this.autoApprovePatterns)) {
-                    return true;
-                }
-            }
-        }
-        // Medium risk operations should require approval
-        if (request.riskLevel === 'medium') {
-            return true;
-        }
-        // Shell commands always require approval unless explicitly auto-approved
-        if (request.type === 'shell_command') {
-            return true;
-        }
-        // Git operations that push changes require approval
-        if (request.type === 'git_push') {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Assesses the risk level of an operation
-     * @param type - The type of operation
-     * @param details - The operation details
-     * @returns The assessed risk level
-     */
-    assessRiskLevel(type, details) {
-        // Critical operations
-        if (type === 'git_push') {
-            return 'critical';
-        }
-        // High-risk operations
-        if (type === 'file_delete') {
-            return 'high';
-        }
-        // Multi-file operations scale with file count
-        if (type === 'multi_file_operation') {
-            const fileCount = details.affectedFiles || 0;
-            if (fileCount > 10)
-                return 'high';
-            if (fileCount > 5)
-                return 'medium';
-        }
-        // Shell commands are medium risk by default
-        if (type === 'shell_command') {
-            // Check for potentially dangerous commands
-            const command = details.command?.toLowerCase() || '';
-            if (command.includes('rm ') ||
-                command.includes('delete') ||
-                command.includes('drop') ||
-                command.includes('truncate')) {
-                return 'high';
-            }
-            return 'medium';
-        }
-        // Git commits are medium risk
-        if (type === 'git_commit') {
-            return 'medium';
-        }
-        // File modifications scale with change size
-        if (type === 'file_modify') {
-            const totalLines = (details.linesAdded || 0) + (details.linesRemoved || 0);
-            if (totalLines > 200)
-                return 'medium';
-            if (totalLines > 100)
-                return 'low';
-        }
-        // File creation and rename are generally low risk
-        if (type === 'file_create' || type === 'file_rename') {
-            return 'low';
-        }
-        return 'low';
-    }
-    /**
-     * Estimates the impact of an operation for display
-     * @param type - The type of operation
-     * @param details - The operation details
-     * @returns A human-readable impact description
-     */
-    estimateImpact(_type, details) {
-        const parts = [];
-        if (details.affectedFiles !== undefined) {
-            parts.push(`${details.affectedFiles} file${details.affectedFiles === 1 ? '' : 's'}`);
-        }
-        if (details.linesAdded !== undefined && details.linesAdded > 0) {
-            parts.push(`+${details.linesAdded} line${details.linesAdded === 1 ? '' : 's'}`);
-        }
-        if (details.linesRemoved !== undefined && details.linesRemoved > 0) {
-            parts.push(`-${details.linesRemoved} line${details.linesRemoved === 1 ? '' : 's'}`);
-        }
-        if (details.command) {
-            const truncatedCommand = details.command.length > 50
-                ? details.command.substring(0, 47) + '...'
-                : details.command;
-            parts.push(`Command: ${truncatedCommand}`);
-        }
-        if (parts.length === 0) {
-            return 'Minimal impact';
-        }
-        return parts.join(', ');
-    }
-    /**
-     * Creates an approval response object
-     * @param request - The original request
-     * @param approved - Whether the request was approved
-     * @param reason - Optional reason for the decision
-     * @returns The approval response
-     */
-    createResponse(request, approved, reason) {
-        return {
-            requestId: request.id,
-            approved,
-            timestamp: formatTimestamp(),
-            mode: this.mode,
-            reason,
-        };
-    }
-}
-// Singleton instance
-let approvalManagerInstance = null;
-/**
- * Gets the singleton ApprovalManager instance
- * @returns The ApprovalManager instance
- */
-export function getApprovalManager() {
-    if (!approvalManagerInstance) {
-        approvalManagerInstance = new ApprovalManager();
-    }
-    return approvalManagerInstance;
-}
-export { ApprovalManager };
-//# sourceMappingURL=approval-manager.js.map