ccmanager 2.8.0 → 2.9.1

package/dist/components/ConfigureShortcuts.js

@@ -1,12 +1,66 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
+import { Effect } from 'effect';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { configurationManager } from '../services/configurationManager.js';
+/**
+ * Format error using TaggedError discrimination
+ * Pattern matches on _tag for type-safe error display
+ */
+const formatError = (error) => {
+    switch (error._tag) {
+        case 'FileSystemError':
+            return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+        case 'ConfigError':
+            return `Configuration error (${error.reason}): ${error.details}`;
+        case 'ValidationError':
+            return `Validation failed for ${error.field}: ${error.constraint}`;
+        case 'GitError':
+            return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+        case 'ProcessError':
+            return `Process error: ${error.message}`;
+    }
+};
 const ConfigureShortcuts = ({ onComplete, }) => {
     const [step, setStep] = useState('menu');
     const [shortcuts, setShortcuts] = useState(shortcutManager.getShortcuts());
     const [editingShortcut, setEditingShortcut] = useState(null);
     const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    // Load configuration using Effect on component mount
+    useEffect(() => {
+        let cancelled = false;
+        const loadConfig = async () => {
+            const result = await Effect.runPromise(Effect.match(configurationManager.loadConfigEffect(), {
+                onFailure: (err) => ({
+                    type: 'error',
+                    error: err,
+                }),
+                onSuccess: config => ({ type: 'success', data: config }),
+            }));
+            if (!cancelled) {
+                if (result.type === 'error') {
+                    // Display error using TaggedError discrimination
+                    const errorMsg = formatError(result.error);
+                    setError(errorMsg);
+                }
+                else if (result.data.shortcuts) {
+                    setShortcuts(result.data.shortcuts);
+                }
+                setIsLoading(false);
+            }
+        };
+        loadConfig().catch(err => {
+            if (!cancelled) {
+                setError(`Unexpected error loading config: ${String(err)}`);
+                setIsLoading(false);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
     const getShortcutDisplayFromState = (key) => {
         const shortcut = shortcuts[key];
         if (!shortcut)
@@ -93,13 +147,28 @@ const ConfigureShortcuts = ({ onComplete, }) => {
             return;
         }
         if (item.value === 'save') {
-            const success = shortcutManager.saveShortcuts(shortcuts);
-            if (success) {
-                onComplete();
-            }
-            else {
-                setError('Failed to save shortcuts');
-            }
+            // Save shortcuts using Effect-based method
+            const saveConfig = async () => {
+                const result = await Effect.runPromise(Effect.match(configurationManager.setShortcutsEffect(shortcuts), {
+                    onFailure: (err) => ({
+                        type: 'error',
+                        error: err,
+                    }),
+                    onSuccess: () => ({ type: 'success' }),
+                }));
+                if (result.type === 'error') {
+                    // Display error using TaggedError discrimination
+                    const errorMsg = formatError(result.error);
+                    setError(errorMsg);
+                }
+                else {
+                    // Success - call onComplete
+                    onComplete();
+                }
+            };
+            saveConfig().catch(err => {
+                setError(`Unexpected error saving shortcuts: ${String(err)}`);
+            });
             return;
         }
         if (item.value === 'exit') {
@@ -111,6 +180,11 @@ const ConfigureShortcuts = ({ onComplete, }) => {
         setStep('capturing');
         setError(null);
     };
+    // Show loading indicator while loading config
+    if (isLoading) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Loading configuration...")));
+    }
     if (step === 'capturing') {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { bold: true, color: "green" },

package/dist/components/DeleteWorktree.js

@@ -1,6 +1,7 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
+import { Effect } from 'effect';
 import { WorktreeService } from '../services/worktreeService.js';
 import DeleteConfirmation from './DeleteConfirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
@@ -9,12 +10,32 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
     const [selectedIndices, setSelectedIndices] = useState(new Set());
     const [confirmMode, setConfirmMode] = useState(false);
     const [focusedIndex, setFocusedIndex] = useState(0);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
     useEffect(() => {
-        const worktreeService = new WorktreeService();
-        const allWorktrees = worktreeService.getWorktrees();
-        // Filter out main worktree - we shouldn't delete it
-        const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
-        setWorktrees(deletableWorktrees);
+        let cancelled = false;
+        const loadWorktrees = async () => {
+            const worktreeService = new WorktreeService();
+            try {
+                const allWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
+                if (!cancelled) {
+                    // Filter out main worktree - we shouldn't delete it
+                    const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
+                    setWorktrees(deletableWorktrees);
+                    setIsLoading(false);
+                }
+            }
+            catch (err) {
+                if (!cancelled) {
+                    setError(err instanceof Error ? err.message : String(err));
+                    setIsLoading(false);
+                }
+            }
+        };
+        loadWorktrees();
+        return () => {
+            cancelled = true;
+        };
     }, []);
     // Create menu items from worktrees
     const menuItems = worktrees.map((worktree, index) => {
@@ -58,6 +79,19 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
             onCancel();
         }
     });
+    if (isLoading) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "cyan" }, "Loading worktrees...")));
+    }
+    if (error) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "red" }, "Error loading worktrees:"),
+            React.createElement(Text, { color: "red" }, error),
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to return to menu")));
+    }
     if (worktrees.length === 0) {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "yellow" }, "No worktrees available to delete."),

package/dist/components/DeleteWorktree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/DeleteWorktree.test.js

@@ -0,0 +1,128 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Effect } from 'effect';
+import DeleteWorktree from './DeleteWorktree.js';
+import { WorktreeService } from '../services/worktreeService.js';
+import { GitError } from '../types/errors.js';
+vi.mock('../services/worktreeService.js');
+vi.mock('../services/shortcutManager.js', () => ({
+    shortcutManager: {
+        matchesShortcut: vi.fn(),
+        getShortcutDisplay: vi.fn(() => 'Esc'),
+    },
+}));
+// Mock stdin to avoid useInput errors
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => {
+            return React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label)));
+        },
+    };
+});
+describe('DeleteWorktree - Effect Integration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should load worktrees using Effect-based method', async () => {
+        // GIVEN: Mock worktrees returned by Effect
+        const mockWorktrees = [
+            {
+                path: '/test/worktree1',
+                branch: 'feature-1',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+            {
+                path: '/test/worktree2',
+                branch: 'feature-2',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        const mockEffect = Effect.succeed(mockWorktrees);
+        const mockGetWorktreesEffect = vi.fn(() => mockEffect);
+        vi.mocked(WorktreeService).mockImplementation(() => ({
+            getWorktreesEffect: mockGetWorktreesEffect,
+        }));
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        // WHEN: Component is rendered
+        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // THEN: Effect method should be called
+        expect(mockGetWorktreesEffect).toHaveBeenCalled();
+        // AND: Worktrees should be displayed
+        const output = lastFrame();
+        expect(output).toContain('feature-1');
+        expect(output).toContain('feature-2');
+    });
+    it('should handle GitError from getWorktreesEffect gracefully', async () => {
+        // GIVEN: Effect that fails with GitError
+        const mockError = new GitError({
+            command: 'git worktree list --porcelain',
+            exitCode: 128,
+            stderr: 'not a git repository',
+        });
+        const mockEffect = Effect.fail(mockError);
+        const mockGetWorktreesEffect = vi.fn(() => mockEffect);
+        vi.mocked(WorktreeService).mockImplementation(() => ({
+            getWorktreesEffect: mockGetWorktreesEffect,
+        }));
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        // WHEN: Component is rendered
+        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // THEN: Error should be displayed
+        const output = lastFrame();
+        const hasError = output?.includes('error') ||
+            output?.includes('Error') ||
+            output?.includes('not a git repository');
+        expect(hasError).toBe(true);
+    });
+    it('should filter out main worktree from deletable list', async () => {
+        // GIVEN: Mock worktrees including main worktree
+        const mockWorktrees = [
+            {
+                path: '/test/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+            {
+                path: '/test/feature',
+                branch: 'feature-1',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        const mockEffect = Effect.succeed(mockWorktrees);
+        const mockGetWorktreesEffect = vi.fn(() => mockEffect);
+        vi.mocked(WorktreeService).mockImplementation(() => ({
+            getWorktreesEffect: mockGetWorktreesEffect,
+        }));
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        // WHEN: Component is rendered
+        const { lastFrame } = render(React.createElement(DeleteWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // THEN: Only non-main worktree should be shown
+        const output = lastFrame();
+        expect(output).toContain('feature-1');
+        expect(output).not.toContain('main');
+    });
+});

package/dist/components/LoadingSpinner.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface LoadingSpinnerProps {
+    message: string;
+    spinnerType?: 'dots' | 'line';
+    color?: 'cyan' | 'yellow' | 'green';
+}
+declare const LoadingSpinner: React.FC<LoadingSpinnerProps>;
+export default LoadingSpinner;

package/dist/components/LoadingSpinner.js

@@ -0,0 +1,37 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { supportsUnicode } from '../utils/terminalCapabilities.js';
+const LoadingSpinner = ({ message, spinnerType, color = 'cyan', }) => {
+    const [frameIndex, setFrameIndex] = useState(0);
+    // Unicode frames for "dots" spinner type
+    const unicodeFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    // ASCII frames for "line" spinner type (fallback for limited terminal support)
+    const asciiFrames = ['-', '\\', '|', '/'];
+    // Determine effective spinner type:
+    // 1. If explicit spinnerType is provided, use it
+    // 2. Otherwise, detect terminal capabilities automatically
+    const effectiveSpinnerType = spinnerType !== undefined
+        ? spinnerType
+        : supportsUnicode()
+            ? 'dots'
+            : 'line';
+    // Select frames based on effective spinner type
+    const frames = effectiveSpinnerType === 'line' ? asciiFrames : unicodeFrames;
+    useEffect(() => {
+        // Set up animation interval - update frame every 120ms
+        const interval = setInterval(() => {
+            setFrameIndex(prevIndex => (prevIndex + 1) % frames.length);
+        }, 120);
+        // Cleanup interval on component unmount to prevent memory leaks
+        return () => {
+            clearInterval(interval);
+        };
+    }, [frames.length]);
+    const currentFrame = frames[frameIndex];
+    return (React.createElement(Box, { flexDirection: "row" },
+        React.createElement(Text, { color: color },
+            currentFrame,
+            " "),
+        React.createElement(Text, null, message)));
+};
+export default LoadingSpinner;

package/dist/components/LoadingSpinner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/LoadingSpinner.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import React from 'react';
+import { render } from 'ink-testing-library';
+import LoadingSpinner from './LoadingSpinner.js';
+describe('LoadingSpinner', () => {
+    // Store original environment variables for restoration
+    const originalEnv = { ...process.env };
+    const originalPlatform = process.platform;
+    afterEach(() => {
+        // Restore original environment
+        process.env = { ...originalEnv };
+        // Restore platform if it was modified
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            writable: true,
+            configurable: true,
+        });
+        vi.restoreAllMocks();
+    });
+    describe('Core LoadingSpinner component with Unicode animation', () => {
+        it('should render with default props and display message with cyan spinner', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            expect(output).toContain('Loading...');
+            // Should contain one of the Unicode spinner frames
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should render with custom color prop (yellow for devcontainer operations)', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Starting devcontainer...", color: "yellow" }));
+            const output = lastFrame();
+            expect(output).toContain('Starting devcontainer...');
+            // Verify spinner is present
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should use ASCII fallback frames when spinnerType is "line"', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Processing...", spinnerType: "line" }));
+            const output = lastFrame();
+            expect(output).toContain('Processing...');
+            // Should contain one of the ASCII spinner frames
+            expect(output).toMatch(/[-\\|/]/);
+        });
+        it('should set up animation interval with 120ms timing', () => {
+            const setIntervalSpy = vi.spyOn(global, 'setInterval');
+            render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            // Verify setInterval was called with 120ms timing
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120);
+        });
+        it('should cleanup interval on component unmount to prevent memory leaks', () => {
+            const { unmount } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            // Verify unmount completes without errors (cleanup function runs properly)
+            expect(() => unmount()).not.toThrow();
+        });
+        it('should preserve message text', () => {
+            const message = 'Creating session...';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: message }));
+            // Check message is rendered
+            expect(lastFrame()).toContain(message);
+        });
+        it('should render in flexDirection="row" layout with spinner and message', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test message" }));
+            const output = lastFrame();
+            // Verify both spinner and message are present
+            // ANSI color codes may be present between spinner and message
+            expect(output).toContain('Test message');
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+    });
+    describe('Component variations and edge cases', () => {
+        it('should accept "green" color option', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Success loading...", color: "green" }));
+            const output = lastFrame();
+            expect(output).toContain('Success loading...');
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should render Unicode frames correctly', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const output = lastFrame();
+            // Should contain one of the Unicode frames
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should render ASCII frames when using "line" spinner type', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test", spinnerType: "line" }));
+            const output = lastFrame();
+            // Should contain one of the ASCII frames
+            expect(output).toMatch(/[-\\|/]/);
+        });
+        it('should handle empty message string', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "" }));
+            const output = lastFrame();
+            // Should still render spinner even with empty message
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should handle long message text without breaking layout', () => {
+            const longMessage = 'This is a very long loading message that might wrap on narrow terminals';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: longMessage }));
+            const output = lastFrame();
+            expect(output).toContain(longMessage);
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should use cyan as default color', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const output = lastFrame();
+            // Just verify it renders successfully with default color
+            expect(output).toContain('Test');
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should use dots as default spinner type', () => {
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Test" }));
+            const output = lastFrame();
+            // Default should be Unicode dots, not ASCII line
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+    });
+    describe('Terminal compatibility detection', () => {
+        it('should automatically detect Unicode support and use Unicode frames', () => {
+            // Set up environment for Unicode support
+            process.env['TERM'] = 'xterm-256color';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            // Should use Unicode frames when terminal supports it
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+            expect(output).toContain('Loading...');
+        });
+        it('should automatically fallback to ASCII when terminal does not support Unicode', () => {
+            // Set up environment without Unicode support
+            process.env['TERM'] = 'dumb';
+            delete process.env['LANG'];
+            delete process.env['LC_ALL'];
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            // Should use ASCII frames when terminal doesn't support Unicode
+            expect(output).toMatch(/[-\\|/]/);
+            expect(output).toContain('Loading...');
+        });
+        it('should respect explicit spinnerType prop over automatic detection', () => {
+            // Even with Unicode support, explicit "line" should use ASCII
+            process.env['TERM'] = 'xterm-256color';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading...", spinnerType: "line" }));
+            const output = lastFrame();
+            // Explicit spinnerType should override detection
+            expect(output).toMatch(/[-\\|/]/);
+        });
+        it('should detect Unicode support on Windows with Windows Terminal', () => {
+            // Mock Windows platform
+            Object.defineProperty(process, 'platform', {
+                value: 'win32',
+                writable: true,
+                configurable: true,
+            });
+            process.env['WT_SESSION'] = 'some-session-id';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            // Should use Unicode on Windows Terminal
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should fallback to ASCII on Windows without Windows Terminal', () => {
+            // Mock Windows platform without Windows Terminal
+            Object.defineProperty(process, 'platform', {
+                value: 'win32',
+                writable: true,
+                configurable: true,
+            });
+            delete process.env['WT_SESSION'];
+            delete process.env['TERM'];
+            delete process.env['LANG'];
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            // Should use ASCII on Windows without WT
+            expect(output).toMatch(/[-\\|/]/);
+        });
+        it('should detect Unicode support from LANG environment variable', () => {
+            delete process.env['TERM'];
+            process.env['LANG'] = 'en_US.UTF-8';
+            const { lastFrame } = render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            const output = lastFrame();
+            // Should use Unicode when LANG indicates UTF-8
+            expect(output).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+        });
+        it('should detect Unicode support with appropriate frame rate', () => {
+            process.env['TERM'] = 'xterm-256color';
+            const setIntervalSpy = vi.spyOn(global, 'setInterval');
+            render(React.createElement(LoadingSpinner, { message: "Loading..." }));
+            // Verify frame rate is 120ms regardless of detection
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120);
+        });
+    });
+});