@compass-ai/nova 1.0.73 → 1.0.74

package/dist/types/workflow.js

@@ -0,0 +1,46 @@
+/**
+ * Type definitions for the multi-phase workflow system.
+ */
+// =============================================================================
+// Complexity Classification Types (Phase 2A)
+// =============================================================================
+export var ExecutionMode;
+(function (ExecutionMode) {
+    ExecutionMode["DIRECT"] = "direct";
+    ExecutionMode["CLARIFICATION"] = "clarification";
+    ExecutionMode["TODO_LIST"] = "todo_list";
+    ExecutionMode["PLAN"] = "plan";
+    ExecutionMode["PLAN_ADOPT"] = "plan_adopt";
+    ExecutionMode["NO_ACTION"] = "no_action";
+    ExecutionMode["SPAWN_AGENT"] = "spawn_agent";
+})(ExecutionMode || (ExecutionMode = {}));
+// =============================================================================
+// Incremental Execution Types (Phase 4)
+// =============================================================================
+export var TaskExecutionStatus;
+(function (TaskExecutionStatus) {
+    TaskExecutionStatus["PENDING"] = "pending";
+    TaskExecutionStatus["IN_PROGRESS"] = "in_progress";
+    TaskExecutionStatus["PAUSED"] = "paused";
+    TaskExecutionStatus["COMPLETED"] = "completed";
+    TaskExecutionStatus["FAILED"] = "failed";
+    TaskExecutionStatus["SKIPPED"] = "skipped";
+    TaskExecutionStatus["ROLLED_BACK"] = "rolled_back";
+})(TaskExecutionStatus || (TaskExecutionStatus = {}));
+// =============================================================================
+// Workflow Orchestrator Types
+// =============================================================================
+export var WorkflowPhase;
+(function (WorkflowPhase) {
+    WorkflowPhase["IDLE"] = "idle";
+    WorkflowPhase["CONTEXT_GATHERING"] = "context_gathering";
+    WorkflowPhase["COMPLEXITY_ASSESSMENT"] = "complexity_assessment";
+    WorkflowPhase["CLARIFICATION"] = "clarification";
+    WorkflowPhase["PLAN_GENERATION"] = "plan_generation";
+    WorkflowPhase["PLAN_REVIEW"] = "plan_review";
+    WorkflowPhase["EXECUTION"] = "execution";
+    WorkflowPhase["VERIFICATION"] = "verification";
+    WorkflowPhase["COMPLETED"] = "completed";
+    WorkflowPhase["FAILED"] = "failed";
+})(WorkflowPhase || (WorkflowPhase = {}));
+//# sourceMappingURL=workflow.js.map

package/dist/types/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../../src/types/workflow.ts"],"names":[],"mappings":"AAAA;;GAEG;AA4DH,gFAAgF;AAChF,6CAA6C;AAC7C,gFAAgF;AAEhF,MAAM,CAAN,IAAY,aAQX;AARD,WAAY,aAAa;IACvB,kCAAiB,CAAA;IACjB,gDAA+B,CAAA;IAC/B,wCAAuB,CAAA;IACvB,8BAAa,CAAA;IACb,0CAAyB,CAAA;IACzB,wCAAuB,CAAA;IACvB,4CAA2B,CAAA;AAC7B,CAAC,EARW,aAAa,KAAb,aAAa,QAQxB;AAoKD,gFAAgF;AAChF,wCAAwC;AACxC,gFAAgF;AAEhF,MAAM,CAAN,IAAY,mBAQX;AARD,WAAY,mBAAmB;IAC7B,0CAAmB,CAAA;IACnB,kDAA2B,CAAA;IAC3B,wCAAiB,CAAA;IACjB,8CAAuB,CAAA;IACvB,wCAAiB,CAAA;IACjB,0CAAmB,CAAA;IACnB,kDAA2B,CAAA;AAC7B,CAAC,EARW,mBAAmB,KAAnB,mBAAmB,QAQ9B;AAyFD,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF,MAAM,CAAN,IAAY,aAWX;AAXD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,wDAAuC,CAAA;IACvC,gEAA+C,CAAA;IAC/C,gDAA+B,CAAA;IAC/B,oDAAmC,CAAA;IACnC,4CAA2B,CAAA;IAC3B,wCAAuB,CAAA;IACvB,8CAA6B,CAAA;IAC7B,wCAAuB,CAAA;IACvB,kCAAiB,CAAA;AACnB,CAAC,EAXW,aAAa,KAAb,aAAa,QAWxB"}

package/dist/ui/App.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Main React/ink application component
+ * Orchestrates UI state and routing between setup wizard and interactive session modes.
+ * Handles initialization, consent checking, and API key validation.
+ */
+import React from 'react';
+/**
+ * Props for the App component
+ */
+interface AppProps {
+    /** Application version string to display */
+    version: string;
+    /** Whether to skip the setup wizard even if not configured */
+    skipSetup?: boolean;
+    /** Optional project root directory override */
+    projectRoot?: string;
+    /** Whether to show the ASCII art banner */
+    showBanner?: boolean;
+    /** Whether to enable SMART mode with session auto-approval */
+    smartMode?: boolean;
+    /** Initial prompt to auto-submit when session starts */
+    initialPrompt?: string;
+    /** Whether to continue the previous conversation (don't clear history) */
+    continueSession?: boolean;
+    /** CLI agents JSON string for initialization */
+    cliAgentsJson?: string;
+    /** Whether to start in unguarded mode (removes safety guardrails) */
+    unleashMode?: boolean;
+    /** Initial attachments to add to session */
+    initialAttachments?: import('../types/session.js').Attachment[];
+}
+/**
+ * Main App component for the Compass CLI application.
+ *
+ * This component serves as the root of the React/Ink application tree and handles:
+ * - Application initialization and dependency loading
+ * - Consent status verification (GDPR compliance)
+ * - API key presence checking
+ * - Routing between setup wizard and interactive session
+ * - Error state management and display
+ *
+ * The application flow is:
+ * 1. Loading state - Initialize services and check configuration
+ * 2. Setup state - Show setup wizard if consent or API key is missing
+ * 3. Session state - Show interactive session for normal operation
+ * 4. Error state - Display error message if initialization fails
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <App version="1.0.0" />
+ *
+ * // Skip setup wizard
+ * <App version="1.0.0" skipSetup />
+ *
+ * // Custom project root
+ * <App version="1.0.0" projectRoot="/path/to/project" />
+ * ```
+ */
+export declare const App: React.FC<AppProps>;
+export default App;
+//# sourceMappingURL=App.d.ts.map

package/dist/ui/App.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../src/ui/App.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAA2C,MAAM,OAAO,CAAC;AAwBhE;;GAEG;AACH,UAAU,QAAQ;IAChB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gDAAgD;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4CAA4C;IAC5C,kBAAkB,CAAC,EAAE,OAAO,qBAAqB,EAAE,UAAU,EAAE,CAAC;CACjE;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,QAAQ,CAolBlC,CAAC;AAEF,eAAe,GAAG,CAAC"}

package/dist/ui/App.js

@@ -0,0 +1,511 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Main React/ink application component
+ * Orchestrates UI state and routing between setup wizard and interactive session modes.
+ * Handles initialization, consent checking, and API key validation.
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { AsciiArt } from './components/AsciiArt.js';
+import { SetupWizard } from './SetupWizard.js';
+import { InteractiveSession } from './InteractiveSession.js';
+import { getConsentManager } from '../services/consent-manager.js';
+import { getCredentialStore } from '../services/credential-store.js';
+import { getConfigManager } from '../services/config-manager.js';
+import { getSessionManager } from '../services/session-manager.js';
+import { getTokenTracker } from '../services/token-tracker.js';
+import { getAnthropicClient } from '../services/anthropic-client.js';
+import { getMCPToolIntegration } from '../services/mcp-tool-integration.js';
+import { getMCPConfigManager } from '../services/mcp-config-manager.js';
+import { getMCPServerManager } from '../services/mcp-server-manager.js';
+import { MCPApprovalPrompt } from './MCPApprovalPrompt.js';
+import { isMCPStdioConfig } from '../types/mcp.js';
+import { ensureDir } from '../utils/file-system.js';
+import { getGlobalCompassDir, getProjectCompassDir } from '../utils/path.js';
+import { logger } from '../utils/logger.js';
+import { getEventEmitter } from '../core/event-emitter.js';
+import { getSystemUtilityDetector } from '../services/system-utility-detector.js';
+import { getCompassAuthService } from '../services/compass-auth-service.js';
+/**
+ * Main App component for the Compass CLI application.
+ *
+ * This component serves as the root of the React/Ink application tree and handles:
+ * - Application initialization and dependency loading
+ * - Consent status verification (GDPR compliance)
+ * - API key presence checking
+ * - Routing between setup wizard and interactive session
+ * - Error state management and display
+ *
+ * The application flow is:
+ * 1. Loading state - Initialize services and check configuration
+ * 2. Setup state - Show setup wizard if consent or API key is missing
+ * 3. Session state - Show interactive session for normal operation
+ * 4. Error state - Display error message if initialization fails
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <App version="1.0.0" />
+ *
+ * // Skip setup wizard
+ * <App version="1.0.0" skipSetup />
+ *
+ * // Custom project root
+ * <App version="1.0.0" projectRoot="/path/to/project" />
+ * ```
+ */
+export const App = ({ version, skipSetup = false, projectRoot = process.cwd(), showBanner = true, smartMode = false, initialPrompt, continueSession = false, unleashMode = false, initialAttachments, }) => {
+    const [state, setState] = useState('loading');
+    const [error, setError] = useState(null);
+    const [initStatus, setInitStatus] = useState({
+        configLoaded: false,
+        consentValid: false,
+        apiKeyPresent: false,
+        clientInitialized: false,
+        subscriptionChecked: false,
+        mcpLoaded: false,
+    });
+    // Track whether Compass API key is configured
+    const [hasCompassKey, setHasCompassKey] = useState(false);
+    // MCP approval state
+    const [unapprovedServers, setUnapprovedServers] = useState([]);
+    const [currentServerIndex, setCurrentServerIndex] = useState(0);
+    // Subscription plan status
+    const [planStatus, setPlanStatus] = useState(undefined);
+    const [planType, setPlanType] = useState(null);
+    const [orgName, setOrgName] = useState(null);
+    const { exit } = useApp();
+    /** Transitions to the interactive session state */
+    const enterSession = useCallback(() => {
+        setState('session');
+    }, []);
+    /**
+     * Initializes the application by loading configuration,
+     * checking consent status, and verifying API key presence.
+     */
+    useEffect(() => {
+        let mounted = true;
+        async function initialize() {
+            try {
+                logger.debug('Starting application initialization');
+                // Ensure directories, load config, check consent, and initialize credentials in parallel
+                const [, , , consentStatus, credentialStore] = await Promise.all([
+                    ensureDir(getGlobalCompassDir()),
+                    ensureDir(getProjectCompassDir(projectRoot)),
+                    getConfigManager().load(projectRoot).then(() => getConfigManager()),
+                    getConsentManager().then(cm => cm.getStatus()),
+                    getCredentialStore(),
+                ]);
+                if (!mounted)
+                    return;
+                setInitStatus((prev) => ({ ...prev, configLoaded: true }));
+                logger.debug('Configuration loaded');
+                setInitStatus((prev) => ({ ...prev, consentValid: consentStatus.isValid }));
+                logger.debug(`Consent status: ${consentStatus.isValid ? 'valid' : 'invalid'}`);
+                // Check for API keys (both Compass and Anthropic) — credential store already initialized
+                const [hasCompassApiKey, hasApiKey] = await Promise.all([
+                    credentialStore.hasCompassApiKey(),
+                    credentialStore.hasApiKey(),
+                ]);
+                if (!mounted)
+                    return;
+                setHasCompassKey(hasCompassApiKey);
+                setInitStatus((prev) => ({ ...prev, apiKeyPresent: hasApiKey && hasCompassApiKey }));
+                logger.debug(`Compass API key present: ${hasCompassApiKey}`);
+                logger.debug(`Anthropic API key present: ${hasApiKey}`);
+                // Determine if setup is needed
+                // Skip setup if either API key is present (Compass API key can fetch Anthropic key,
+                // or user may have set Anthropic key directly)
+                const needsSetup = !consentStatus.isValid || (!hasCompassApiKey && !hasApiKey);
+                if (!skipSetup && needsSetup) {
+                    logger.debug('Setup required - showing setup wizard');
+                    setState('setup');
+                    return;
+                }
+                // Run independent initialization tasks in parallel:
+                // - Anthropic client init (if consent + API key present)
+                // - Token tracker
+                // - MCP tool integration + config loading
+                const anthropicInitPromise = (consentStatus.isValid && hasApiKey)
+                    ? getAnthropicClient()
+                        .then(client => client.initialize())
+                        .catch(err => { logger.warn('Error initializing Anthropic client', err); return false; })
+                    : Promise.resolve(false);
+                const tokenTrackerPromise = getTokenTracker()
+                    .then(tracker => { tracker.startSession(); logger.debug('Token tracker initialized'); })
+                    .catch(err => { logger.warn('Failed to initialize token tracker', err); });
+                const mcpInitPromise = (async () => {
+                    try {
+                        const mcpToolIntegration = getMCPToolIntegration();
+                        await mcpToolIntegration.initialize(projectRoot);
+                        logger.debug('MCP tool integration initialized');
+                    }
+                    catch (mcpError) {
+                        logger.warn('Failed to initialize MCP tool integration', mcpError);
+                    }
+                    const mcpConfigManager = getMCPConfigManager();
+                    await mcpConfigManager.load(projectRoot);
+                    return { mcpConfigManager, pendingServers: mcpConfigManager.getUnapprovedProjectServers(projectRoot) };
+                })();
+                // Fire subscription validation in background — it's a network call that
+                // doesn't gate session entry. InteractiveSession reads plan status from
+                // compassAuthService directly when needed.
+                (async () => {
+                    try {
+                        const compassAuth = getCompassAuthService();
+                        const compassKey = await credentialStore.getCompassApiKey();
+                        if (compassKey) {
+                            await compassAuth.validateApiKey(compassKey);
+                        }
+                        if (!mounted)
+                            return;
+                        setPlanStatus(compassAuth.getPlanStatus());
+                        setPlanType(compassAuth.getPlanType());
+                        setOrgName(compassAuth.getOrgName());
+                        setInitStatus((prev) => ({ ...prev, subscriptionChecked: true }));
+                        logger.debug(`Plan status: ${compassAuth.getPlanStatus()}, org: ${compassAuth.getOrgName()}`);
+                    }
+                    catch (planError) {
+                        logger.warn('Failed to fetch plan status', planError);
+                        if (!mounted)
+                            return;
+                        setPlanStatus('no_subscription');
+                        setInitStatus((prev) => ({ ...prev, subscriptionChecked: true }));
+                    }
+                })();
+                const [clientInitialized, , mcpResult] = await Promise.all([
+                    anthropicInitPromise,
+                    tokenTrackerPromise,
+                    mcpInitPromise,
+                ]);
+                if (!mounted)
+                    return;
+                setInitStatus((prev) => ({ ...prev, clientInitialized: !!clientInitialized }));
+                const { mcpConfigManager, pendingServers } = mcpResult;
+                if (!mounted)
+                    return;
+                setInitStatus((prev) => ({ ...prev, mcpLoaded: true }));
+                // Auto-approve and connect silent servers without prompting the user
+                const silentServers = pendingServers.filter((s) => s.silent);
+                const nonSilentServers = pendingServers.filter((s) => !s.silent);
+                for (const server of silentServers) {
+                    const configHash = mcpConfigManager.generateConfigHash(server);
+                    await mcpConfigManager.setProjectServerApproval(projectRoot, server.name, true, configHash);
+                    logger.debug(`Auto-approved silent MCP server '${server.name}'`);
+                    await connectToMCPServer(server);
+                }
+                if (nonSilentServers.length > 0) {
+                    // Show MCP approval UI for non-silent servers
+                    setUnapprovedServers(nonSilentServers);
+                    setCurrentServerIndex(0);
+                    setState('mcp-approval');
+                }
+                else {
+                    enterSession();
+                }
+                logger.debug('Application initialized successfully');
+            }
+            catch (err) {
+                if (!mounted)
+                    return;
+                const errorMessage = err instanceof Error ? err.message : 'Unknown initialization error';
+                logger.error('Application initialization failed', err);
+                setError(errorMessage);
+                setState('error');
+            }
+        }
+        initialize();
+        return () => {
+            mounted = false;
+        };
+    }, [skipSetup, projectRoot]);
+    /**
+     * Sets unguarded mode when --unleash flag is passed at startup.
+     * This runs when transitioning to session state.
+     * Pre-warms the system utility detection cache so tools are ready for the first prompt.
+     */
+    useEffect(() => {
+        if (state === 'session' && unleashMode) {
+            const sessionManager = getSessionManager();
+            sessionManager.setUnguardedMode(true);
+            logger.info('Unguarded mode enabled via --unleash flag (transient)');
+            // Pre-warm the system utility detection cache in background
+            // This ensures utilities are detected before the first prompt is submitted
+            getSystemUtilityDetector().detect().catch((err) => {
+                logger.debug('Background utility detection failed', err);
+            });
+        }
+    }, [state, unleashMode]);
+    /**
+     * Adds initial attachments to session manager when transitioning to session state.
+     * This runs when transitioning to session state and initialAttachments are provided.
+     */
+    useEffect(() => {
+        if (state === 'session' && initialAttachments && initialAttachments.length > 0) {
+            const sessionManager = getSessionManager();
+            sessionManager.addPendingAttachments(initialAttachments);
+            logger.info(`Added ${initialAttachments.length} initial attachments to session`);
+        }
+    }, [state, initialAttachments]);
+    /**
+     * Sets up event listeners for MCP OAuth authentication flow.
+     * Displays auth URL and status messages during OAuth.
+     */
+    useEffect(() => {
+        const eventEmitter = getEventEmitter();
+        // Handle OAuth authentication required - display the auth URL
+        const unsubAuthRequired = eventEmitter.on('mcp-auth-required', ({ serverName, authUrl }) => {
+            logger.output('');
+            logger.output(`✗ '${serverName}' requires authentication`);
+            logger.output('');
+            logger.output('  Open this URL in your browser to authenticate:');
+            logger.output('');
+            logger.output(`  ${authUrl}`);
+            logger.output('');
+            logger.output('  ⟳ Waiting for authentication...');
+        });
+        // Handle OAuth authentication success
+        const unsubAuthSuccess = eventEmitter.on('mcp-auth-success', ({ serverName }) => {
+            logger.output(`✓ Authenticated with '${serverName}'`);
+        });
+        // Handle OAuth authentication failure
+        const unsubAuthFailed = eventEmitter.on('mcp-auth-failed', ({ serverName, error }) => {
+            logger.output(`✗ Authentication failed for '${serverName}': ${error}`);
+        });
+        return () => {
+            unsubAuthRequired();
+            unsubAuthSuccess();
+            unsubAuthFailed();
+        };
+    }, []);
+    /**
+     * Handles completion of the setup wizard.
+     * Transitions to MCP approval or interactive session state.
+     */
+    const handleSetupComplete = useCallback(async () => {
+        logger.debug('Setup completed, checking for MCP approvals');
+        try {
+            // Re-initialize the Anthropic client with the new API key
+            const client = await getAnthropicClient();
+            const initialized = await client.initialize();
+            setInitStatus((prev) => ({
+                ...prev,
+                consentValid: true,
+                apiKeyPresent: true,
+                clientInitialized: initialized,
+            }));
+            // Initialize token tracker for the new session
+            const tokenTracker = await getTokenTracker();
+            tokenTracker.startSession();
+            // Initialize MCP tool integration
+            try {
+                const mcpToolIntegration = getMCPToolIntegration();
+                await mcpToolIntegration.initialize(projectRoot);
+                logger.debug('MCP tool integration initialized');
+            }
+            catch (mcpError) {
+                logger.warn('Failed to initialize MCP tool integration', mcpError);
+            }
+            // Check for unapproved MCP servers
+            const mcpConfigManager = getMCPConfigManager();
+            await mcpConfigManager.load(projectRoot);
+            const pendingServers = mcpConfigManager.getUnapprovedProjectServers(projectRoot);
+            setInitStatus((prev) => ({ ...prev, mcpLoaded: true }));
+            // Auto-approve and connect silent servers without prompting the user
+            const silentServers = pendingServers.filter((s) => s.silent);
+            const nonSilentServers = pendingServers.filter((s) => !s.silent);
+            for (const server of silentServers) {
+                const configHash = mcpConfigManager.generateConfigHash(server);
+                await mcpConfigManager.setProjectServerApproval(projectRoot, server.name, true, configHash);
+                logger.debug(`Auto-approved silent MCP server '${server.name}'`);
+                await connectToMCPServer(server);
+            }
+            if (nonSilentServers.length > 0) {
+                // Show MCP approval UI for non-silent servers
+                setUnapprovedServers(nonSilentServers);
+                setCurrentServerIndex(0);
+                setState('mcp-approval');
+            }
+            else {
+                enterSession();
+            }
+        }
+        catch (err) {
+            logger.error('Failed to initialize after setup', err);
+            // Still transition to session - errors will be handled there
+            enterSession();
+        }
+    }, [projectRoot, enterSession]);
+    /**
+     * Handles cancellation of the setup wizard.
+     * Exits the application.
+     */
+    const handleSetupCancel = useCallback(() => {
+        logger.debug('Setup cancelled by user');
+        exit();
+    }, [exit]);
+    /**
+     * Connects to an MCP server and logs the result.
+     */
+    const connectToMCPServer = useCallback(async (server) => {
+        logger.output('');
+        logger.output(`⟳ Connecting to '${server.name}'...`);
+        if (isMCPStdioConfig(server) && server.command === 'npx') {
+            logger.output('   First run may take up to 60 seconds to download packages...');
+        }
+        try {
+            const serverManager = getMCPServerManager();
+            const state = await serverManager.connectServer(server.name);
+            if (state.status === 'connected') {
+                logger.output(`✓ Connected to '${server.name}' - ${state.tools.length} tool(s), ${state.resources.length} resource(s)`);
+            }
+            else if (state.error) {
+                logger.output(`⚠ Connection issue: ${state.error}`);
+            }
+            else {
+                logger.output(`⚠ Connected but status unknown`);
+            }
+        }
+        catch (connectError) {
+            const errorMsg = connectError instanceof Error ? connectError.message : String(connectError);
+            logger.output(`✗ Failed to connect: ${errorMsg}`);
+            logger.warn(`Failed to connect to '${server.name}'`, connectError);
+        }
+    }, []);
+    /**
+     * Handles MCP server approval choices.
+     */
+    const handleMCPApprovalChoice = useCallback(async (choice) => {
+        const configManager = getMCPConfigManager();
+        const currentServer = unapprovedServers[currentServerIndex];
+        if (choice === 'trust_all') {
+            // Trust all servers in this project
+            await configManager.setProjectTrusted(projectRoot);
+            logger.output('✓ Trusted all MCP servers in this project');
+            // Connect to all unapproved servers
+            for (const server of unapprovedServers) {
+                await connectToMCPServer(server);
+            }
+            // Done with approvals
+            enterSession();
+        }
+        else if (choice === 'approve_one') {
+            // Approve this server only
+            const configHash = configManager.generateConfigHash(currentServer);
+            await configManager.setProjectServerApproval(projectRoot, currentServer.name, true, configHash);
+            logger.output(`✓ Approved '${currentServer.name}'`);
+            // Connect to this server
+            await connectToMCPServer(currentServer);
+            // Move to next server or finish
+            if (currentServerIndex < unapprovedServers.length - 1) {
+                setCurrentServerIndex(currentServerIndex + 1);
+            }
+            else {
+                enterSession();
+            }
+        }
+        else {
+            // Deny this server
+            await configManager.setProjectServerApproval(projectRoot, currentServer.name, false);
+            logger.output(`✗ Skipped '${currentServer.name}'`);
+            // Move to next server or finish
+            if (currentServerIndex < unapprovedServers.length - 1) {
+                setCurrentServerIndex(currentServerIndex + 1);
+            }
+            else {
+                enterSession();
+            }
+        }
+    }, [unapprovedServers, currentServerIndex, projectRoot, connectToMCPServer, enterSession]);
+    /**
+     * Handles exit from the interactive session.
+     * Saves session state and exits the application.
+     */
+    const handleSessionExit = useCallback(async () => {
+        logger.debug('Exiting application');
+        // Set a hard timeout to force exit if cleanup hangs.
+        // Call exit() first to trigger Ink's graceful unmount, then force process.exit
+        // after a brief delay so yoga nodes are fully freed before signal-exit fires.
+        const forceExitTimeout = setTimeout(() => {
+            logger.warn('Cleanup timed out, forcing exit');
+            try {
+                exit();
+            }
+            catch { /* already unmounted */ }
+            setTimeout(() => process.exit(0), 100);
+        }, 2000); // 2 second timeout
+        try {
+            // Disconnect all MCP servers before exiting
+            try {
+                const { getMCPServerManager } = await import('../services/mcp-server-manager.js');
+                const mcpServerManager = getMCPServerManager();
+                await mcpServerManager.disconnectAllServers();
+                logger.debug('MCP servers disconnected');
+            }
+            catch (mcpError) {
+                logger.debug('Failed to disconnect MCP servers', mcpError);
+                // Continue with exit anyway
+            }
+            // Save session state before exiting
+            const sessionManager = getSessionManager();
+            await sessionManager.save();
+            logger.debug('Session saved');
+            // End token tracking session
+            const tokenTracker = await getTokenTracker();
+            await tokenTracker.endSession();
+            logger.debug('Token tracking session ended');
+        }
+        catch (err) {
+            logger.warn('Error during exit cleanup', err);
+            // Continue with exit anyway
+        }
+        clearTimeout(forceExitTimeout);
+        exit();
+    }, [exit]);
+    /**
+     * Renders the loading state with ASCII art and initialization progress
+     */
+    const renderLoadingState = () => (_jsxs(Box, { flexDirection: "column", children: [showBanner && _jsx(AsciiArt, { version: version, animated: true, planStatus: planStatus, orgName: orgName }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Initializing Compass..." }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsxs(Text, { color: initStatus.configLoaded ? 'green' : 'gray', children: [initStatus.configLoaded ? '✓' : '○', " Loading configuration"] }), _jsxs(Text, { color: initStatus.consentValid ? 'green' : 'gray', children: [initStatus.consentValid ? '✓' : '○', " Checking consent status"] }), _jsxs(Text, { color: initStatus.apiKeyPresent ? 'green' : 'gray', children: [initStatus.apiKeyPresent ? '✓' : '○', " Verifying API key"] }), hasCompassKey && (_jsxs(Box, { children: [_jsxs(Text, { color: initStatus.subscriptionChecked ? 'green' : 'gray', children: [initStatus.subscriptionChecked ? '✓' : '○', " Checking subscription"] }), initStatus.subscriptionChecked && planStatus && (_jsxs(Text, { color: planStatus === 'active' ? 'green' : planStatus === 'trial' ? 'yellow' : 'red', children: [' ', "(", planStatus === 'active' ? 'Active' : planStatus === 'trial' ? 'Trial' : planStatus === 'expired' ? 'Expired' : 'No subscription', planType ? ` — ${planType}` : '', ")"] }))] })), _jsxs(Text, { color: initStatus.mcpLoaded ? 'green' : 'gray', children: [initStatus.mcpLoaded ? '✓' : '○', " Loading Tools"] })] })] }));
+    /**
+     * Renders the error state with error message and recovery instructions
+     */
+    const renderErrorState = () => (_jsxs(Box, { flexDirection: "column", children: [showBanner && _jsx(AsciiArt, { version: version, mini: true, planStatus: planStatus, orgName: orgName }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "red", bold: true, children: "\u274C Initialization Error" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", children: error }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Possible solutions:" }), _jsx(Text, { dimColor: true, children: "  \u2022 Run \"compass setup\" to reconfigure" }), _jsx(Text, { dimColor: true, children: "  \u2022 Check your internet connection" }), _jsx(Text, { dimColor: true, children: "  \u2022 Verify your API key is valid" }), _jsx(Text, { dimColor: true, children: "  \u2022 Run \"compass reset --force\" to start fresh" })] })] })] }));
+    /**
+     * Renders the setup wizard state
+     */
+    const renderSetupState = () => (_jsxs(Box, { flexDirection: "column", children: [showBanner && _jsx(AsciiArt, { version: version, planStatus: planStatus, orgName: orgName }), _jsx(SetupWizard, { onComplete: handleSetupComplete, onCancel: handleSetupCancel })] }));
+    /**
+     * Renders the MCP approval state
+     */
+    const renderMCPApprovalState = () => {
+        const currentServer = unapprovedServers[currentServerIndex];
+        if (!currentServer) {
+            // No more servers, transition to session
+            enterSession();
+            return null;
+        }
+        return (_jsxs(Box, { flexDirection: "column", children: [showBanner && _jsx(AsciiArt, { version: version, mini: true, planStatus: planStatus, orgName: orgName }), _jsx(MCPApprovalPrompt, { server: currentServer, onChoice: handleMCPApprovalChoice })] }));
+    };
+    /**
+     * Renders the interactive session state
+     */
+    const renderSessionState = () => (_jsx(Box, { flexDirection: "column", children: _jsx(InteractiveSession, { onExit: handleSessionExit, projectRoot: projectRoot, showWelcome: showBanner, smartMode: smartMode, initialPrompt: initialPrompt, continueSession: continueSession, initialAttachments: initialAttachments, planStatus: planStatus, orgName: orgName }) }));
+    // Render based on current application state
+    switch (state) {
+        case 'loading':
+            return renderLoadingState();
+        case 'error':
+            return renderErrorState();
+        case 'setup':
+            return renderSetupState();
+        case 'mcp-approval':
+            return renderMCPApprovalState();
+        case 'session':
+            return renderSessionState();
+        default:
+            // Exhaustive check - should never reach here
+            return (_jsx(Box, { children: _jsx(Text, { color: "red", children: "Unknown application state" }) }));
+    }
+};
+export default App;
+//# sourceMappingURL=App.js.map