ccmanager 2.8.0 → 2.9.0

package/dist/utils/hookExecutor.js

@@ -1,11 +1,44 @@
 import { spawn } from 'child_process';
+import { Effect } from 'effect';
+import { ProcessError } from '../types/errors.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { configurationManager } from '../services/configurationManager.js';
 /**
- * Execute a hook command with the provided environment variables
+ * Execute a hook command with the provided environment variables using Effect
+ *
+ * Spawns a shell process to run the hook command with custom environment.
+ * Errors are captured but hook failures don't propagate to prevent breaking main flow.
+ *
+ * @param {string} command - Shell command to execute
+ * @param {string} cwd - Working directory for command execution
+ * @param {HookEnvironment} environment - Environment variables for the hook
+ * @returns {Effect.Effect<void, ProcessError, never>} Effect that succeeds on hook completion or fails with ProcessError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {executeHook} from './utils/hookExecutor.js';
+ *
+ * const env = {
+ *   CCMANAGER_WORKTREE_PATH: '/path/to/worktree',
+ *   CCMANAGER_WORKTREE_BRANCH: 'feature-branch',
+ *   CCMANAGER_GIT_ROOT: '/path/to/repo'
+ * };
+ *
+ * // Execute hook with error recovery
+ * const result = await Effect.runPromise(
+ *   Effect.catchAll(
+ *     executeHook('npm install', '/path/to/worktree', env),
+ *     (error) => {
+ *       console.error(`Hook failed: ${error.message}`);
+ *       return Effect.succeed(undefined); // Continue despite error
+ *     }
+ *   )
+ * );
+ * ```
  */
 export function executeHook(command, cwd, environment) {
-    return new Promise((resolve, reject) => {
+    return Effect.async(resume => {
         // Use spawn with shell to execute the command and wait for all child processes
         const child = spawn(command, [], {
             cwd,
@@ -24,29 +57,36 @@ export function executeHook(command, cwd, environment) {
         // Wait for the process and all its children to exit
         child.on('exit', (code, signal) => {
             if (code !== 0 || signal) {
-                let errorMessage = signal
+                const errorMessage = signal
                     ? `Hook terminated by signal ${signal}`
                     : `Hook exited with code ${code}`;
-                // Include stderr in the error message when exit code is not 0
-                if (stderr) {
-                    errorMessage += `\nStderr: ${stderr}`;
-                }
-                reject(new Error(errorMessage));
+                resume(Effect.fail(new ProcessError({
+                    command,
+                    exitCode: code ?? undefined,
+                    signal: signal ?? undefined,
+                    message: stderr
+                        ? `${errorMessage}\nStderr: ${stderr}`
+                        : errorMessage,
+                })));
                 return;
             }
             // When exit code is 0, ignore stderr and resolve successfully
-            resolve();
+            resume(Effect.void);
         });
         // Handle errors in spawning the process
         child.on('error', error => {
-            reject(error);
+            resume(Effect.fail(new ProcessError({
+                command,
+                message: error.message,
+            })));
         });
     });
 }
 /**
- * Execute a worktree post-creation hook
+ * Execute a worktree post-creation hook using Effect
+ * Errors are caught and logged but do not break the main flow
  */
-export async function executeWorktreePostCreationHook(command, worktree, gitRoot, baseBranch) {
+export function executeWorktreePostCreationHook(command, worktree, gitRoot, baseBranch) {
     const environment = {
         CCMANAGER_WORKTREE_PATH: worktree.path,
         CCMANAGER_WORKTREE_BRANCH: worktree.branch || 'unknown',
@@ -55,24 +95,30 @@ export async function executeWorktreePostCreationHook(command, worktree, gitRoot
     if (baseBranch) {
         environment.CCMANAGER_BASE_BRANCH = baseBranch;
     }
-    try {
-        await executeHook(command, worktree.path, environment);
-    }
-    catch (error) {
+    return Effect.catchAll(executeHook(command, worktree.path, environment), error => {
         // Log error but don't throw - hooks should not break the main flow
-        console.error(`Failed to execute post-creation hook: ${error instanceof Error ? error.message : String(error)}`);
-    }
+        console.error(`Failed to execute post-creation hook: ${error.message}`);
+        return Effect.void;
+    });
 }
 /**
- * Execute a session status change hook
+ * Execute a session status change hook using Effect
+ * Errors are caught and logged but do not break the main flow
  */
-export async function executeStatusHook(oldState, newState, session) {
+export function executeStatusHook(oldState, newState, session) {
     const statusHooks = configurationManager.getStatusHooks();
     const hook = statusHooks[newState];
-    if (hook && hook.enabled && hook.command) {
-        // Get branch information
-        const worktreeService = new WorktreeService();
-        const worktrees = worktreeService.getWorktrees();
+    if (!hook || !hook.enabled || !hook.command) {
+        return Effect.void;
+    }
+    const worktreeService = new WorktreeService();
+    return Effect.gen(function* () {
+        // Get branch information using Effect-based method
+        const worktrees = yield* Effect.catchAll(worktreeService.getWorktreesEffect(), error => {
+            // Log error but continue with empty array - hooks should not break main flow
+            console.error(`Failed to get worktrees for status hook: ${error.message || String(error)}`);
+            return Effect.succeed([]);
+        });
         const worktree = worktrees.find(wt => wt.path === session.worktreePath);
         const branch = worktree?.branch || 'unknown';
         // Build environment for status hook
@@ -84,13 +130,10 @@ export async function executeStatusHook(oldState, newState, session) {
             CCMANAGER_NEW_STATE: newState,
             CCMANAGER_SESSION_ID: session.id,
         };
-        // Execute the hook command in the session's worktree directory
-        try {
-            await executeHook(hook.command, session.worktreePath, environment);
-        }
-        catch (error) {
+        yield* Effect.catchAll(executeHook(hook.command, session.worktreePath, environment), error => {
             // Log error but don't throw - hooks should not break the main flow
-            console.error(`Failed to execute ${newState} hook: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
+            console.error(`Failed to execute ${newState} hook: ${error.message}`);
+            return Effect.void;
+        });
+    });
 }

package/dist/utils/hookExecutor.test.js

@@ -1,10 +1,12 @@
 import { describe, it, expect, vi } from 'vitest';
+import { Effect } from 'effect';
 import { executeHook, executeWorktreePostCreationHook, executeStatusHook, } from './hookExecutor.js';
 import { mkdtemp, rm, readFile, realpath } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { configurationManager } from '../services/configurationManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
+import { GitError } from '../types/errors.js';
 // Mock the configurationManager
 vi.mock('../services/configurationManager.js', () => ({
     configurationManager: {
@@ -28,7 +30,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act & Assert - should not throw
-                await expect(executeHook('echo "Test successful"', tmpDir, environment)).resolves.toBeUndefined();
+                await expect(Effect.runPromise(executeHook('echo "Test successful"', tmpDir, environment))).resolves.toBeUndefined();
             }
             finally {
                 // Cleanup
@@ -45,7 +47,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act & Assert
-                await expect(executeHook('exit 1', tmpDir, environment)).rejects.toThrow();
+                await expect(Effect.runPromise(executeHook('exit 1', tmpDir, environment))).rejects.toThrow();
             }
             finally {
                 // Cleanup
@@ -62,7 +64,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act & Assert - command that writes to stderr and exits with error
-                await expect(executeHook('>&2 echo "Error details here"; exit 1', tmpDir, environment)).rejects.toThrow('Hook exited with code 1\nStderr: Error details here\n');
+                await expect(Effect.runPromise(executeHook('>&2 echo "Error details here"; exit 1', tmpDir, environment))).rejects.toThrow('Hook exited with code 1\nStderr: Error details here\n');
             }
             finally {
                 // Cleanup
@@ -80,7 +82,7 @@ describe('hookExecutor Integration Tests', () => {
             try {
                 // Test with multiline stderr
                 try {
-                    await executeHook('>&2 echo "Line 1"; >&2 echo "Line 2"; exit 3', tmpDir, environment);
+                    await Effect.runPromise(executeHook('>&2 echo "Line 1"; >&2 echo "Line 2"; exit 3', tmpDir, environment));
                     expect.fail('Should have thrown');
                 }
                 catch (error) {
@@ -90,7 +92,7 @@ describe('hookExecutor Integration Tests', () => {
                 }
                 // Test with empty stderr
                 try {
-                    await executeHook('exit 4', tmpDir, environment);
+                    await Effect.runPromise(executeHook('exit 4', tmpDir, environment));
                     expect.fail('Should have thrown');
                 }
                 catch (error) {
@@ -114,7 +116,7 @@ describe('hookExecutor Integration Tests', () => {
             try {
                 // Act - command that writes to stderr but exits successfully
                 // Should not throw even though there's stderr output
-                await expect(executeHook('>&2 echo "Warning message"; exit 0', tmpDir, environment)).resolves.toBeUndefined();
+                await expect(Effect.runPromise(executeHook('>&2 echo "Warning message"; exit 0', tmpDir, environment))).resolves.toBeUndefined();
             }
             finally {
                 // Cleanup
@@ -132,7 +134,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act - write current directory to file
-                await executeHook(`pwd > "${outputFile}"`, tmpDir, environment);
+                await Effect.runPromise(executeHook(`pwd > "${outputFile}"`, tmpDir, environment));
                 // Read the output
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
@@ -159,7 +161,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act & Assert - should not throw even with failing command
-                await expect(executeWorktreePostCreationHook('exit 1', worktree, tmpDir, 'main')).resolves.toBeUndefined();
+                await expect(Effect.runPromise(executeWorktreePostCreationHook('exit 1', worktree, tmpDir, 'main'))).resolves.toBeUndefined();
             }
             finally {
                 // Cleanup
@@ -179,7 +181,7 @@ describe('hookExecutor Integration Tests', () => {
             const gitRoot = '/different/git/root';
             try {
                 // Act - write current directory to file
-                await executeWorktreePostCreationHook(`pwd > "${outputFile}"`, worktree, gitRoot, 'main');
+                await Effect.runPromise(executeWorktreePostCreationHook(`pwd > "${outputFile}"`, worktree, gitRoot, 'main'));
                 // Read the output
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
@@ -208,7 +210,7 @@ describe('hookExecutor Integration Tests', () => {
             };
             try {
                 // Act - change to git root and write its path
-                await executeWorktreePostCreationHook(`cd "$CCMANAGER_GIT_ROOT" && pwd > "${outputFile}"`, worktree, tmpGitRootDir, 'main');
+                await Effect.runPromise(executeWorktreePostCreationHook(`cd "$CCMANAGER_GIT_ROOT" && pwd > "${outputFile}"`, worktree, tmpGitRootDir, 'main'));
                 // Read the output
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
@@ -235,7 +237,7 @@ describe('hookExecutor Integration Tests', () => {
                 // Act - execute a command that spawns a background process with a delay
                 // The background process writes to a file after a delay
                 // We use a shell command that creates a background process and then exits
-                await executeWorktreePostCreationHook(`(sleep 0.1 && echo "completed" > "${outputFile}") & wait`, worktree, tmpDir, 'main');
+                await Effect.runPromise(executeWorktreePostCreationHook(`(sleep 0.1 && echo "completed" > "${outputFile}") & wait`, worktree, tmpDir, 'main'));
                 // Read the output - this should exist because we waited for the background process
                 const { readFile } = await import('fs/promises');
                 const output = await readFile(outputFile, 'utf-8');
@@ -273,14 +275,14 @@ describe('hookExecutor Integration Tests', () => {
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktrees: vi.fn(() => [
+                getWorktreesEffect: vi.fn(() => Effect.succeed([
                     {
                         path: tmpDir,
                         branch: 'test-branch',
                         isMainWorktree: false,
                         hasSession: true,
                     },
-                ]),
+                ])),
             }));
             // Configure mock to return a hook that writes to a file with delay
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
@@ -293,7 +295,7 @@ describe('hookExecutor Integration Tests', () => {
             });
             try {
                 // Act - execute the hook and await it
-                await executeStatusHook('idle', 'busy', mockSession);
+                await Effect.runPromise(executeStatusHook('idle', 'busy', mockSession));
                 // Assert - file should exist because we awaited the hook
                 const content = await readFile(outputFile, 'utf-8');
                 expect(content.trim()).toBe('Hook executed');
@@ -326,14 +328,14 @@ describe('hookExecutor Integration Tests', () => {
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktrees: vi.fn(() => [
+                getWorktreesEffect: vi.fn(() => Effect.succeed([
                     {
                         path: tmpDir,
                         branch: 'test-branch',
                         isMainWorktree: false,
                         hasSession: true,
                     },
-                ]),
+                ])),
             }));
             // Configure mock to return a hook that fails
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
@@ -346,7 +348,7 @@ describe('hookExecutor Integration Tests', () => {
             });
             try {
                 // Act & Assert - should not throw even when hook fails
-                await expect(executeStatusHook('idle', 'busy', mockSession)).resolves.toBeUndefined();
+                await expect(Effect.runPromise(executeStatusHook('idle', 'busy', mockSession))).resolves.toBeUndefined();
             }
             finally {
                 // Cleanup
@@ -377,14 +379,14 @@ describe('hookExecutor Integration Tests', () => {
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktrees: vi.fn(() => [
+                getWorktreesEffect: vi.fn(() => Effect.succeed([
                     {
                         path: tmpDir,
                         branch: 'test-branch',
                         isMainWorktree: false,
                         hasSession: true,
                     },
-                ]),
+                ])),
             }));
             // Configure mock to return a disabled hook
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
@@ -397,7 +399,7 @@ describe('hookExecutor Integration Tests', () => {
             });
             try {
                 // Act
-                await executeStatusHook('idle', 'busy', mockSession);
+                await Effect.runPromise(executeStatusHook('idle', 'busy', mockSession));
                 // Assert - file should not exist because hook was disabled
                 await expect(readFile(outputFile, 'utf-8')).rejects.toThrow();
             }
@@ -406,5 +408,56 @@ describe('hookExecutor Integration Tests', () => {
                 await rm(tmpDir, { recursive: true });
             }
         });
+        it('should handle getWorktreesEffect failures gracefully', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'status-hook-test-'));
+            const outputFile = join(tmpDir, 'hook-output.txt');
+            const mockSession = {
+                id: 'test-session-failure',
+                worktreePath: tmpDir,
+                process: {},
+                terminal: {},
+                output: [],
+                outputHistory: [],
+                state: 'idle',
+                stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
+                lastActivity: new Date(),
+                isActive: true,
+            };
+            // Mock WorktreeService to fail with GitError
+            vi.mocked(WorktreeService).mockImplementation(() => ({
+                getWorktreesEffect: vi.fn(() => Effect.fail(new GitError({
+                    command: 'git worktree list --porcelain',
+                    exitCode: 128,
+                    stderr: 'not a git repository',
+                }))),
+            }));
+            // Configure mock to return a hook that should execute despite worktree query failure
+            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+                busy: {
+                    enabled: true,
+                    command: `echo "Hook ran with branch: $CCMANAGER_WORKTREE_BRANCH" > "${outputFile}"`,
+                },
+                idle: { enabled: false, command: '' },
+                waiting_input: { enabled: false, command: '' },
+            });
+            try {
+                // Act - should not throw even when getWorktreesEffect fails
+                await expect(Effect.runPromise(executeStatusHook('idle', 'busy', mockSession))).resolves.toBeUndefined();
+                // Assert - hook should have executed with 'unknown' branch
+                const content = await readFile(outputFile, 'utf-8');
+                expect(content.trim()).toBe('Hook ran with branch: unknown');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
     });
 });

package/dist/utils/terminalCapabilities.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Terminal capabilities detection utilities for CCManager.
+ * Determines terminal feature support for optimal UI rendering.
+ */
+/**
+ * Detect if the current terminal supports Unicode characters.
+ * This function checks various environment variables and platform indicators
+ * to determine if Unicode spinner characters (⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏) will render correctly.
+ *
+ * Detection strategy:
+ * 1. Check TERM environment variable for known Unicode-capable terminals
+ * 2. Check LANG and LC_ALL for UTF-8 encoding
+ * 3. Platform-specific checks (Windows Terminal, etc.)
+ * 4. Fallback to ASCII if no Unicode indicators present
+ *
+ * @returns true if Unicode is supported, false otherwise
+ */
+export declare function supportsUnicode(): boolean;

package/dist/utils/terminalCapabilities.js

@@ -0,0 +1,81 @@
+/**
+ * Terminal capabilities detection utilities for CCManager.
+ * Determines terminal feature support for optimal UI rendering.
+ */
+/**
+ * Detect if the current terminal supports Unicode characters.
+ * This function checks various environment variables and platform indicators
+ * to determine if Unicode spinner characters (⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏) will render correctly.
+ *
+ * Detection strategy:
+ * 1. Check TERM environment variable for known Unicode-capable terminals
+ * 2. Check LANG and LC_ALL for UTF-8 encoding
+ * 3. Platform-specific checks (Windows Terminal, etc.)
+ * 4. Fallback to ASCII if no Unicode indicators present
+ *
+ * @returns true if Unicode is supported, false otherwise
+ */
+export function supportsUnicode() {
+    // Check for explicitly non-Unicode terminals
+    const term = process.env['TERM'];
+    if (term === 'dumb') {
+        return false;
+    }
+    // Windows-specific detection
+    if (process.platform === 'win32') {
+        // Windows Terminal supports Unicode
+        if (process.env['WT_SESSION']) {
+            return true;
+        }
+        // Without Windows Terminal or explicit TERM, assume no Unicode
+        if (!term) {
+            return false;
+        }
+    }
+    // Check TERM for known Unicode-capable terminals
+    if (term) {
+        // xterm variants, screen, alacritty all support Unicode
+        const unicodeTerms = [
+            'xterm',
+            'xterm-256color',
+            'screen',
+            'screen-256color',
+            'alacritty',
+            'vte',
+            'rxvt',
+        ];
+        for (const unicodeTerm of unicodeTerms) {
+            if (term.includes(unicodeTerm)) {
+                return true;
+            }
+        }
+        // Linux console (not linux-utf8) has limited Unicode support
+        if (term === 'linux' && !hasUtf8Locale()) {
+            return false;
+        }
+    }
+    // Check locale settings for UTF-8 encoding
+    if (hasUtf8Locale()) {
+        return true;
+    }
+    // Apple Terminal historically had issues, but with UTF-8 locale it should work
+    if (process.env['TERM_PROGRAM'] === 'Apple_Terminal' && !hasUtf8Locale()) {
+        return false;
+    }
+    // CI environments often support Unicode if locale is set
+    if (process.env['CI'] && hasUtf8Locale()) {
+        return true;
+    }
+    // Default to false if no Unicode indicators found
+    return false;
+}
+/**
+ * Check if the system locale indicates UTF-8 encoding.
+ * Examines LANG and LC_ALL environment variables.
+ *
+ * @returns true if UTF-8 locale is detected
+ */
+function hasUtf8Locale() {
+    const lang = process.env['LANG'] || process.env['LC_ALL'] || '';
+    return /utf-?8/i.test(lang);
+}

package/dist/utils/terminalCapabilities.test.d.ts

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

package/dist/utils/terminalCapabilities.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { supportsUnicode } from './terminalCapabilities.js';
+describe('terminalCapabilities', () => {
+    // Store original environment variables
+    const originalEnv = { ...process.env };
+    const originalStdout = { ...process.stdout };
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        // Reset environment before each test
+        vi.resetModules();
+    });
+    afterEach(() => {
+        // Restore original environment
+        process.env = { ...originalEnv };
+        Object.assign(process.stdout, originalStdout);
+        // Restore platform if it was modified
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            writable: true,
+            configurable: true,
+        });
+        vi.restoreAllMocks();
+    });
+    describe('supportsUnicode', () => {
+        it('should return true when TERM environment variable indicates Unicode support', () => {
+            process.env['TERM'] = 'xterm-256color';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return true when TERM is set to xterm', () => {
+            process.env['TERM'] = 'xterm';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return true when TERM is screen with Unicode support', () => {
+            process.env['TERM'] = 'screen-256color';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return true when TERM is alacritty', () => {
+            process.env['TERM'] = 'alacritty';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return true when LANG indicates UTF-8 encoding', () => {
+            delete process.env['TERM'];
+            process.env['LANG'] = 'en_US.UTF-8';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return true when LC_ALL indicates UTF-8 encoding', () => {
+            delete process.env['TERM'];
+            delete process.env['LANG'];
+            process.env['LC_ALL'] = 'en_US.UTF-8';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return false when TERM is dumb', () => {
+            process.env['TERM'] = 'dumb';
+            expect(supportsUnicode()).toBe(false);
+        });
+        it('should return false when TERM is linux without Unicode support', () => {
+            process.env['TERM'] = 'linux';
+            delete process.env['LANG'];
+            delete process.env['LC_ALL'];
+            expect(supportsUnicode()).toBe(false);
+        });
+        it('should return false when no Unicode indicators are present', () => {
+            delete process.env['TERM'];
+            delete process.env['LANG'];
+            delete process.env['LC_ALL'];
+            expect(supportsUnicode()).toBe(false);
+        });
+        it('should return true on Windows when WT_SESSION is set (Windows Terminal)', () => {
+            Object.defineProperty(process, 'platform', {
+                value: 'win32',
+                writable: true,
+            });
+            process.env['WT_SESSION'] = 'some-session-id';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return false on Windows without Windows Terminal markers', () => {
+            Object.defineProperty(process, 'platform', {
+                value: 'win32',
+                writable: true,
+            });
+            delete process.env['WT_SESSION'];
+            delete process.env['TERM'];
+            expect(supportsUnicode()).toBe(false);
+        });
+        it('should return true when CI environment variable is set and LANG is UTF-8', () => {
+            process.env['CI'] = 'true';
+            process.env['LANG'] = 'en_US.UTF-8';
+            expect(supportsUnicode()).toBe(true);
+        });
+        it('should return false when TERM_PROGRAM is Apple_Terminal on older macOS', () => {
+            // Apple Terminal historically had limited Unicode support
+            process.env['TERM_PROGRAM'] = 'Apple_Terminal';
+            delete process.env['LANG'];
+            delete process.env['LC_ALL'];
+            delete process.env['TERM'];
+            expect(supportsUnicode()).toBe(false);
+        });
+        it('should handle case-insensitive UTF-8 check in LANG', () => {
+            delete process.env['TERM'];
+            process.env['LANG'] = 'en_US.utf-8'; // lowercase
+            expect(supportsUnicode()).toBe(true);
+        });
+    });
+});