ccmanager 2.8.0 → 2.9.0

package/dist/cli.test.js

@@ -5,6 +5,17 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+// Check if node-pty native module is available
+function isNodePtyAvailable() {
+    try {
+        // Use eval to bypass linter's require() check
+        new Function('return require("node-pty")')();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 describe('CLI', () => {
     let originalEnv;
     beforeEach(() => {
@@ -14,7 +25,7 @@ describe('CLI', () => {
         process.env = originalEnv;
     });
     describe('--multi-project flag', () => {
-        it('should exit with error when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
+        it.skipIf(!isNodePtyAvailable())('should exit with error when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
             // Ensure the env var is not set
             delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
             // Create a wrapper script that mocks TTY
@@ -43,7 +54,7 @@ describe('CLI', () => {
             expect(result.stderr).toContain('CCMANAGER_MULTI_PROJECT_ROOT environment variable must be set');
             expect(result.stderr).toContain('export CCMANAGER_MULTI_PROJECT_ROOT=/path/to/projects');
         });
-        it('should not check for env var when --multi-project is not used', async () => {
+        it.skipIf(!isNodePtyAvailable())('should not check for env var when --multi-project is not used', async () => {
             // Ensure the env var is not set
             delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
             const result = await new Promise(resolve => {

package/dist/components/App.js

@@ -1,5 +1,6 @@
 import React, { useState, useEffect, useCallback } from 'react';
 import { useApp, Box, Text } from 'ink';
+import { Effect } from 'effect';
 import Menu from './Menu.js';
 import ProjectList from './ProjectList.js';
 import Session from './Session.js';
@@ -9,6 +10,7 @@ import MergeWorktree from './MergeWorktree.js';
 import Configuration from './Configuration.js';
 import PresetSelector from './PresetSelector.js';
 import RemoteBranchSelector from './RemoteBranchSelector.js';
+import LoadingSpinner from './LoadingSpinner.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { AmbiguousBranchError, } from '../types/index.js';
@@ -28,6 +30,44 @@ const App = ({ devcontainerConfig, multiProject }) => {
     const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
     // State for remote branch disambiguation
     const [pendingWorktreeCreation, setPendingWorktreeCreation] = useState(null);
+    // State for loading context - track flags for message composition
+    const [loadingContext, setLoadingContext] = useState({});
+    // Helper function to format error messages based on error type using _tag discrimination
+    const formatErrorMessage = (error) => {
+        switch (error._tag) {
+            case 'ProcessError':
+                return `Process error: ${error.message}`;
+            case 'ConfigError':
+                return `Configuration error (${error.reason}): ${error.details}`;
+            case 'GitError':
+                return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+            case 'FileSystemError':
+                return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+            case 'ValidationError':
+                return `Validation failed for ${error.field}: ${error.constraint}`;
+        }
+    };
+    // Helper function to create session with Effect-based error handling
+    const createSessionWithEffect = async (worktreePath, presetId) => {
+        const sessionEffect = devcontainerConfig
+            ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId)
+            : sessionManager.createSessionWithPresetEffect(worktreePath, presetId);
+        // Execute the Effect and handle both success and failure cases
+        const result = await Effect.runPromise(Effect.either(sessionEffect));
+        if (result._tag === 'Left') {
+            // Handle error using pattern matching on _tag
+            const errorMessage = formatErrorMessage(result.left);
+            return {
+                success: false,
+                errorMessage: `Failed to create session: ${errorMessage}`,
+            };
+        }
+        // Success case - extract session from Right
+        return {
+            success: true,
+            session: result.right,
+        };
+    };
     // Helper function to clear terminal screen
     const clearScreen = () => {
         if (process.stdout.isTTY) {
@@ -162,19 +202,16 @@ const App = ({ devcontainerConfig, multiProject }) => {
                 navigateWithClear('preset-selector');
                 return;
             }
-            try {
-                // Use preset-based session creation with default preset
-                if (devcontainerConfig) {
-                    session = await sessionManager.createSessionWithDevcontainer(worktree.path, devcontainerConfig);
-                }
-                else {
-                    session = await sessionManager.createSessionWithPreset(worktree.path);
-                }
-            }
-            catch (error) {
-                setError(`Failed to create session: ${error}`);
+            // Set loading state before async operation
+            setView('creating-session');
+            // Use Effect-based session creation with default preset
+            const result = await createSessionWithEffect(worktree.path);
+            if (!result.success) {
+                setError(result.errorMessage);
+                navigateWithClear('menu');
                 return;
             }
+            session = result.session;
         }
         setActiveSession(session);
         navigateWithClear('session');
@@ -182,24 +219,20 @@ const App = ({ devcontainerConfig, multiProject }) => {
     const handlePresetSelected = async (presetId) => {
         if (!selectedWorktree)
             return;
-        try {
-            // Create session with selected preset
-            let session;
-            if (devcontainerConfig) {
-                session = await sessionManager.createSessionWithDevcontainer(selectedWorktree.path, devcontainerConfig, presetId);
-            }
-            else {
-                session = await sessionManager.createSessionWithPreset(selectedWorktree.path, presetId);
-            }
-            setActiveSession(session);
-            navigateWithClear('session');
-            setSelectedWorktree(null);
-        }
-        catch (error) {
-            setError(`Failed to create session: ${error}`);
+        // Set loading state before async operation
+        setView('creating-session-preset');
+        // Create session with selected preset using Effect
+        const result = await createSessionWithEffect(selectedWorktree.path, presetId);
+        if (!result.success) {
+            setError(result.errorMessage);
             setView('menu');
             setSelectedWorktree(null);
+            return;
         }
+        // Success case
+        setActiveSession(result.session);
+        navigateWithClear('session');
+        setSelectedWorktree(null);
     };
     const handlePresetSelectorCancel = () => {
         setSelectedWorktree(null);
@@ -228,18 +261,22 @@ const App = ({ devcontainerConfig, multiProject }) => {
         });
     };
     const handleCreateWorktree = async (path, branch, baseBranch, copySessionData, copyClaudeDirectory) => {
+        // Set loading context before showing loading view
+        setLoadingContext({ copySessionData });
         setView('creating-worktree');
         setError(null);
-        // Create the worktree
-        const result = await worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
-        // Handle the result using the helper function
-        handleWorktreeCreationResult(result, {
-            path,
-            branch,
-            baseBranch,
-            copySessionData,
-            copyClaudeDirectory,
-        });
+        // Create the worktree using Effect
+        const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(path, branch, baseBranch, copySessionData, copyClaudeDirectory)));
+        // Transform Effect result to legacy format for handleWorktreeCreationResult
+        if (result._tag === 'Left') {
+            // Handle error using pattern matching on _tag
+            const errorMessage = formatErrorMessage(result.left);
+            handleWorktreeCreationResult({ success: false, error: errorMessage }, { path, branch, baseBranch, copySessionData, copyClaudeDirectory });
+        }
+        else {
+            // Success case
+            handleWorktreeCreationResult({ success: true }, { path, branch, baseBranch, copySessionData, copyClaudeDirectory });
+        }
     };
     const handleCancelNewWorktree = () => {
         handleReturnToMenu();
@@ -251,18 +288,21 @@ const App = ({ devcontainerConfig, multiProject }) => {
         const creationData = pendingWorktreeCreation;
         setPendingWorktreeCreation(null);
         // Retry worktree creation with the resolved base branch
+        // Set loading context before showing loading view
+        setLoadingContext({ copySessionData: creationData.copySessionData });
         setView('creating-worktree');
         setError(null);
-        const result = await worktreeService.createWorktree(creationData.path, creationData.branch, selectedRemoteRef, // Use the selected remote reference
-        creationData.copySessionData, creationData.copyClaudeDirectory);
-        if (result.success) {
-            // Success - return to menu
-            handleReturnToMenu();
+        const result = await Effect.runPromise(Effect.either(worktreeService.createWorktreeEffect(creationData.path, creationData.branch, selectedRemoteRef, // Use the selected remote reference
+        creationData.copySessionData, creationData.copyClaudeDirectory)));
+        if (result._tag === 'Left') {
+            // Handle error using pattern matching on _tag
+            const errorMessage = formatErrorMessage(result.left);
+            setError(errorMessage);
+            setView('new-worktree');
         }
         else {
-            // Show error and return to new worktree form
-            setError(result.error || 'Failed to create worktree');
-            setView('new-worktree');
+            // Success - return to menu
+            handleReturnToMenu();
         }
     };
     const handleRemoteBranchSelectorCancel = () => {
@@ -271,15 +311,19 @@ const App = ({ devcontainerConfig, multiProject }) => {
         setView('new-worktree');
     };
     const handleDeleteWorktrees = async (worktreePaths, deleteBranch) => {
+        // Set loading context before showing loading view
+        setLoadingContext({ deleteBranch });
         setView('deleting-worktree');
         setError(null);
-        // Delete the worktrees
+        // Delete the worktrees sequentially using Effect
         let hasError = false;
         for (const path of worktreePaths) {
-            const result = worktreeService.deleteWorktree(path, { deleteBranch });
-            if (!result.success) {
+            const result = await Effect.runPromise(Effect.either(worktreeService.deleteWorktreeEffect(path, { deleteBranch })));
+            if (result._tag === 'Left') {
+                // Handle error using pattern matching on _tag
                 hasError = true;
-                setError(result.error || 'Failed to delete worktree');
+                const errorMessage = formatErrorMessage(result.left);
+                setError(errorMessage);
                 break;
             }
         }
@@ -348,8 +392,12 @@ const App = ({ devcontainerConfig, multiProject }) => {
             React.createElement(NewWorktree, { projectPath: selectedProject?.path || process.cwd(), onComplete: handleCreateWorktree, onCancel: handleCancelNewWorktree })));
     }
     if (view === 'creating-worktree') {
+        // Compose message based on loading context
+        const message = loadingContext.copySessionData
+            ? 'Creating worktree and copying session data...'
+            : 'Creating worktree...';
         return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "green" }, "Creating worktree...")));
+            React.createElement(LoadingSpinner, { message: message, color: "cyan" })));
     }
     if (view === 'delete-worktree') {
         return (React.createElement(Box, { flexDirection: "column" },
@@ -360,8 +408,12 @@ const App = ({ devcontainerConfig, multiProject }) => {
             React.createElement(DeleteWorktree, { onComplete: handleDeleteWorktrees, onCancel: handleCancelDeleteWorktree })));
     }
     if (view === 'deleting-worktree') {
+        // Compose message based on loading context
+        const message = loadingContext.deleteBranch
+            ? 'Deleting worktrees and branches...'
+            : 'Deleting worktrees...';
         return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "red" }, "Deleting worktrees...")));
+            React.createElement(LoadingSpinner, { message: message, color: "cyan" })));
     }
     if (view === 'merge-worktree') {
         return (React.createElement(Box, { flexDirection: "column" },
@@ -380,6 +432,29 @@ const App = ({ devcontainerConfig, multiProject }) => {
     if (view === 'remote-branch-selector' && pendingWorktreeCreation) {
         return (React.createElement(RemoteBranchSelector, { branchName: pendingWorktreeCreation.ambiguousError.branchName, matches: pendingWorktreeCreation.ambiguousError.matches, onSelect: handleRemoteBranchSelected, onCancel: handleRemoteBranchSelectorCancel }));
     }
+    if (view === 'creating-session') {
+        // Compose message based on devcontainerConfig presence
+        // Devcontainer operations take >5 seconds, so indicate extended duration
+        const message = devcontainerConfig
+            ? 'Starting devcontainer (this may take a moment)...'
+            : 'Creating session...';
+        // Use yellow color for devcontainer operations (longer duration),
+        // cyan for standard session creation
+        const color = devcontainerConfig ? 'yellow' : 'cyan';
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(LoadingSpinner, { message: message, color: color })));
+    }
+    if (view === 'creating-session-preset') {
+        // Always display preset-specific message
+        // Devcontainer operations take >5 seconds, so indicate extended duration
+        const message = devcontainerConfig
+            ? 'Creating session with preset (this may take a moment)...'
+            : 'Creating session with preset...';
+        // Use yellow color for devcontainer, cyan for standard
+        const color = devcontainerConfig ? 'yellow' : 'cyan';
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(LoadingSpinner, { message: message, color: color })));
+    }
     if (view === 'clearing') {
         // Render nothing during the clearing phase to ensure clean transition
         return null;

package/dist/components/App.test.js

@@ -0,0 +1,270 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { beforeAll, beforeEach, afterEach, describe, expect, it, vi, } from 'vitest';
+import { Effect } from 'effect';
+import { ENV_VARS } from '../constants/env.js';
+let App;
+let menuProps;
+let newWorktreeProps;
+let deleteWorktreeProps;
+let sessionProps;
+const createWorktreeEffectMock = vi.fn();
+const deleteWorktreeEffectMock = vi.fn();
+const mockSession = {
+    id: 'session-1',
+};
+class MockSessionManager {
+    constructor() {
+        Object.defineProperty(this, "on", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((_, __) => this)
+        });
+        Object.defineProperty(this, "off", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((_, __) => this)
+        });
+        Object.defineProperty(this, "getSession", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((_) => null)
+        });
+        Object.defineProperty(this, "getAllSessions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn(() => [])
+        });
+        Object.defineProperty(this, "createSessionWithPresetEffect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((_, __) => Effect.succeed(mockSession))
+        });
+        Object.defineProperty(this, "createSessionWithDevcontainerEffect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((_, __) => Effect.succeed(mockSession))
+        });
+    }
+}
+const sessionManagers = [];
+const getManagerForProjectMock = vi.fn((_) => {
+    const manager = new MockSessionManager();
+    sessionManagers.push(manager);
+    return manager;
+});
+const configurationManagerMock = {
+    getSelectPresetOnStart: vi.fn(() => false),
+};
+const projectManagerMock = {
+    addRecentProject: vi.fn(),
+};
+function createInkMock(label, onRender) {
+    return async () => {
+        const ReactActual = await vi.importActual('react');
+        const { Text } = await vi.importActual('ink');
+        const Component = (props) => {
+            onRender?.(props);
+            return ReactActual.createElement(Text, null, label);
+        };
+        return {
+            __esModule: true,
+            default: Component,
+        };
+    };
+}
+vi.mock('../services/sessionManager.js', () => ({
+    SessionManager: MockSessionManager,
+}));
+vi.mock('../services/globalSessionOrchestrator.js', () => ({
+    globalSessionOrchestrator: {
+        getManagerForProject: getManagerForProjectMock,
+        destroyAllSessions: vi.fn(),
+    },
+}));
+vi.mock('../services/projectManager.js', () => ({
+    projectManager: projectManagerMock,
+}));
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: configurationManagerMock,
+}));
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn().mockImplementation(() => ({
+        createWorktreeEffect: (...args) => createWorktreeEffectMock(...args),
+        deleteWorktreeEffect: (...args) => deleteWorktreeEffectMock(...args),
+    })),
+}));
+vi.mock('./Menu.js', createInkMock('Menu View', props => (menuProps = props)));
+vi.mock('./ProjectList.js', createInkMock('Project List View', () => { }));
+vi.mock('./NewWorktree.js', createInkMock('New Worktree View', props => {
+    newWorktreeProps = props;
+}));
+vi.mock('./DeleteWorktree.js', createInkMock('Delete Worktree View', props => {
+    deleteWorktreeProps = props;
+}));
+vi.mock('./Session.js', createInkMock('Session View', props => {
+    sessionProps = props;
+}));
+vi.mock('./MergeWorktree.js', createInkMock('Merge Worktree View'));
+vi.mock('./Configuration.js', createInkMock('Configuration View'));
+vi.mock('./PresetSelector.js', createInkMock('Preset Selector View'));
+vi.mock('./RemoteBranchSelector.js', createInkMock('Remote Branch Selector View'));
+vi.mock('./LoadingSpinner.js', async () => {
+    const ReactActual = await vi.importActual('react');
+    const { Text } = await vi.importActual('ink');
+    const Component = ({ message, color }) => {
+        return ReactActual.createElement(Text, null, `${message} [${color}]`);
+    };
+    return {
+        __esModule: true,
+        default: Component,
+    };
+});
+beforeAll(async () => {
+    App = (await import('./App.js')).default;
+});
+const flush = (ms = 0) => new Promise(resolve => setTimeout(resolve, ms));
+const waitForCondition = async (condition, timeout = 200, interval = 5) => {
+    const deadline = Date.now() + timeout;
+    while (!condition()) {
+        if (Date.now() > deadline) {
+            throw new Error('Timed out waiting for condition');
+        }
+        await flush(interval);
+    }
+};
+beforeEach(() => {
+    menuProps = undefined;
+    newWorktreeProps = undefined;
+    deleteWorktreeProps = undefined;
+    sessionProps = undefined;
+    createWorktreeEffectMock.mockReset();
+    deleteWorktreeEffectMock.mockReset();
+    createWorktreeEffectMock.mockImplementation(() => Effect.succeed(undefined));
+    deleteWorktreeEffectMock.mockImplementation(() => Effect.succeed(undefined));
+    sessionManagers.length = 0;
+    getManagerForProjectMock.mockClear();
+    configurationManagerMock.getSelectPresetOnStart.mockReset();
+    configurationManagerMock.getSelectPresetOnStart.mockReturnValue(false);
+    projectManagerMock.addRecentProject.mockReset();
+});
+afterEach(() => {
+    delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+});
+describe('App component view state', () => {
+    it('renders the menu view by default', async () => {
+        const { lastFrame, unmount } = render(React.createElement(App, null));
+        await flush(40);
+        expect(lastFrame()).toContain('Menu View');
+        unmount();
+    });
+    it('renders the project list view first in multi-project mode', async () => {
+        const original = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';
+        const { lastFrame, unmount } = render(React.createElement(App, { multiProject: true }));
+        await flush();
+        expect(lastFrame()).toContain('Project List View');
+        unmount();
+        if (original !== undefined) {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = original;
+        }
+    });
+});
+describe('App component loading state machine', () => {
+    it('displays copying message while creating a worktree with session data', async () => {
+        let resolveWorktree;
+        createWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({
+            try: () => new Promise(resolve => {
+                resolveWorktree = resolve;
+            }),
+            catch: (error) => error,
+        }));
+        const { lastFrame, unmount } = render(React.createElement(App, null));
+        await waitForCondition(() => Boolean(menuProps));
+        const menu = menuProps;
+        const selectPromise = Promise.resolve(menu.onSelectWorktree({
+            path: '',
+            branch: '',
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        await waitForCondition(() => Boolean(newWorktreeProps));
+        const newWorktree = newWorktreeProps;
+        const createPromise = Promise.resolve(newWorktree.onComplete('/tmp/test', 'feature', 'main', true, false));
+        await flush();
+        expect(lastFrame()).toContain('Creating worktree and copying session data...');
+        resolveWorktree?.();
+        await createPromise;
+        await selectPromise;
+        await flush(20);
+        expect(lastFrame()).toContain('Menu View');
+        unmount();
+    });
+    it('displays branch deletion message while deleting worktrees', async () => {
+        let resolveDelete;
+        deleteWorktreeEffectMock.mockImplementation(() => Effect.tryPromise({
+            try: () => new Promise(resolve => {
+                resolveDelete = resolve;
+            }),
+            catch: (error) => error,
+        }));
+        const { lastFrame, unmount } = render(React.createElement(App, null));
+        await waitForCondition(() => Boolean(menuProps));
+        const menu = menuProps;
+        const selectPromise = Promise.resolve(menu.onSelectWorktree({
+            path: 'DELETE_WORKTREE',
+            branch: '',
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        await waitForCondition(() => Boolean(deleteWorktreeProps));
+        const deleteWorktree = deleteWorktreeProps;
+        const deletePromise = Promise.resolve(deleteWorktree.onComplete(['/tmp/test'], true));
+        await flush();
+        expect(lastFrame()).toContain('Deleting worktrees and branches...');
+        resolveDelete?.();
+        await deletePromise;
+        await selectPromise;
+        await flush(20);
+        expect(lastFrame()).toContain('Menu View');
+        unmount();
+    });
+    it('shows devcontainer spinner while creating a session with config', async () => {
+        let resolveSession;
+        const { lastFrame, unmount } = render(React.createElement(App, { devcontainerConfig: {
+                upCommand: 'podman up',
+                execCommand: 'podman exec',
+            } }));
+        await waitForCondition(() => Boolean(menuProps));
+        expect(menuProps).toBeDefined();
+        expect(sessionManagers).toHaveLength(1);
+        const sessionManager = sessionManagers[0];
+        sessionManager.createSessionWithDevcontainerEffect.mockImplementation(() => Effect.tryPromise({
+            try: () => new Promise(resolve => {
+                resolveSession = resolve;
+            }),
+            catch: (error) => error,
+        }));
+        const menu = menuProps;
+        const selectPromise = Promise.resolve(menu.onSelectWorktree({
+            path: '/project/worktree',
+            branch: 'feature',
+            isMainWorktree: false,
+            hasSession: false,
+        }));
+        await flush();
+        expect(lastFrame()).toContain('Starting devcontainer (this may take a moment)...');
+        resolveSession?.(mockSession);
+        await selectPromise;
+        await flush(20);
+        expect(lastFrame()).toContain('Session View');
+        expect(sessionProps?.session).toEqual(mockSession);
+        unmount();
+    });
+});