@compass-ai/nova 1.0.73 → 1.0.74

package/dist/services/approval-manager.js

@@ -0,0 +1,1044 @@
+/**
+ * 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