ccmanager 2.8.0 → 2.9.1

package/dist/types/errors.d.ts

@@ -0,0 +1,74 @@
+declare const GitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GitError";
+} & Readonly<A>;
+/**
+ * Git operation errors
+ * Used when git commands fail with non-zero exit codes
+ */
+export declare class GitError extends GitError_base<{
+    readonly command: string;
+    readonly exitCode: number;
+    readonly stderr: string;
+    readonly stdout?: string;
+}> {
+}
+declare const FileSystemError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FileSystemError";
+} & Readonly<A>;
+/**
+ * File system operation errors
+ * Used when file system operations (read, write, delete, mkdir, stat) fail
+ */
+export declare class FileSystemError extends FileSystemError_base<{
+    readonly operation: 'read' | 'write' | 'delete' | 'mkdir' | 'stat';
+    readonly path: string;
+    readonly cause: string;
+}> {
+}
+declare const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigError";
+} & Readonly<A>;
+/**
+ * Configuration errors
+ * Used when configuration operations fail (parsing, validation, migration)
+ */
+export declare class ConfigError extends ConfigError_base<{
+    readonly configPath: string;
+    readonly reason: 'parse' | 'validation' | 'missing' | 'migration';
+    readonly details: string;
+}> {
+}
+declare const ProcessError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProcessError";
+} & Readonly<A>;
+/**
+ * Process/PTY errors
+ * Used when process spawning or PTY operations fail
+ */
+export declare class ProcessError extends ProcessError_base<{
+    readonly processId?: number;
+    readonly command: string;
+    readonly signal?: string;
+    readonly exitCode?: number;
+    readonly message: string;
+}> {
+}
+declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationError";
+} & Readonly<A>;
+/**
+ * Validation errors
+ * Used when input validation fails
+ */
+export declare class ValidationError extends ValidationError_base<{
+    readonly field: string;
+    readonly constraint: string;
+    readonly receivedValue: unknown;
+}> {
+}
+/**
+ * Union type for all application errors
+ * Enables discriminated union type narrowing using _tag property
+ */
+export type AppError = GitError | FileSystemError | ConfigError | ProcessError | ValidationError;
+export {};

package/dist/types/errors.js

@@ -0,0 +1,31 @@
+import { Data } from 'effect';
+/**
+ * Git operation errors
+ * Used when git commands fail with non-zero exit codes
+ */
+export class GitError extends Data.TaggedError('GitError') {
+}
+/**
+ * File system operation errors
+ * Used when file system operations (read, write, delete, mkdir, stat) fail
+ */
+export class FileSystemError extends Data.TaggedError('FileSystemError') {
+}
+/**
+ * Configuration errors
+ * Used when configuration operations fail (parsing, validation, migration)
+ */
+export class ConfigError extends Data.TaggedError('ConfigError') {
+}
+/**
+ * Process/PTY errors
+ * Used when process spawning or PTY operations fail
+ */
+export class ProcessError extends Data.TaggedError('ProcessError') {
+}
+/**
+ * Validation errors
+ * Used when input validation fails
+ */
+export class ValidationError extends Data.TaggedError('ValidationError') {
+}

package/dist/types/errors.test.d.ts

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

package/dist/types/errors.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+/**
+ * Tests for structured error types using Effect-ts Data.TaggedError
+ */
+describe('Error Types', () => {
+    describe('GitError', () => {
+        it('should create GitError with required fields', async () => {
+            const { GitError } = await import('./errors.js');
+            const error = new GitError({
+                command: 'git worktree add',
+                exitCode: 1,
+                stderr: 'fatal: invalid reference',
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error._tag).toBe('GitError');
+            expect(error.command).toBe('git worktree add');
+            expect(error.exitCode).toBe(1);
+            expect(error.stderr).toBe('fatal: invalid reference');
+        });
+        it('should create GitError with optional stdout', async () => {
+            const { GitError } = await import('./errors.js');
+            const error = new GitError({
+                command: 'git status',
+                exitCode: 128,
+                stderr: 'not a git repository',
+                stdout: 'some output',
+            });
+            expect(error.stdout).toBe('some output');
+        });
+        it('should have stack trace', async () => {
+            const { GitError } = await import('./errors.js');
+            const error = new GitError({
+                command: 'git log',
+                exitCode: 1,
+                stderr: 'error',
+            });
+            expect(error.stack).toBeDefined();
+        });
+    });
+    describe('FileSystemError', () => {
+        it('should create FileSystemError with required fields', async () => {
+            const { FileSystemError } = await import('./errors.js');
+            const error = new FileSystemError({
+                operation: 'read',
+                path: '/tmp/config.json',
+                cause: 'ENOENT: no such file or directory',
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error._tag).toBe('FileSystemError');
+            expect(error.operation).toBe('read');
+            expect(error.path).toBe('/tmp/config.json');
+            expect(error.cause).toBe('ENOENT: no such file or directory');
+        });
+        it('should support all operation types', async () => {
+            const { FileSystemError } = await import('./errors.js');
+            const operations = ['read', 'write', 'delete', 'mkdir', 'stat'];
+            for (const operation of operations) {
+                const error = new FileSystemError({
+                    operation,
+                    path: '/test',
+                    cause: 'test',
+                });
+                expect(error.operation).toBe(operation);
+            }
+        });
+    });
+    describe('ConfigError', () => {
+        it('should create ConfigError with required fields', async () => {
+            const { ConfigError } = await import('./errors.js');
+            const error = new ConfigError({
+                configPath: '~/.config/ccmanager/config.json',
+                reason: 'parse',
+                details: 'Unexpected token in JSON at position 42',
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error._tag).toBe('ConfigError');
+            expect(error.configPath).toBe('~/.config/ccmanager/config.json');
+            expect(error.reason).toBe('parse');
+            expect(error.details).toBe('Unexpected token in JSON at position 42');
+        });
+        it('should support all reason types', async () => {
+            const { ConfigError } = await import('./errors.js');
+            const reasons = [
+                'parse',
+                'validation',
+                'missing',
+                'migration',
+            ];
+            for (const reason of reasons) {
+                const error = new ConfigError({
+                    configPath: '/test',
+                    reason,
+                    details: 'test',
+                });
+                expect(error.reason).toBe(reason);
+            }
+        });
+    });
+    describe('ProcessError', () => {
+        it('should create ProcessError with required fields', async () => {
+            const { ProcessError } = await import('./errors.js');
+            const error = new ProcessError({
+                command: 'claude',
+                message: 'Failed to spawn process',
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error._tag).toBe('ProcessError');
+            expect(error.command).toBe('claude');
+            expect(error.message).toBe('Failed to spawn process');
+        });
+        it('should create ProcessError with optional fields', async () => {
+            const { ProcessError } = await import('./errors.js');
+            const error = new ProcessError({
+                processId: 1234,
+                command: 'devcontainer exec',
+                signal: 'SIGTERM',
+                exitCode: 143,
+                message: 'Process terminated',
+            });
+            expect(error.processId).toBe(1234);
+            expect(error.signal).toBe('SIGTERM');
+            expect(error.exitCode).toBe(143);
+        });
+    });
+    describe('ValidationError', () => {
+        it('should create ValidationError with required fields', async () => {
+            const { ValidationError } = await import('./errors.js');
+            const error = new ValidationError({
+                field: 'presetId',
+                constraint: 'must be a valid preset ID',
+                receivedValue: 'invalid-id',
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error._tag).toBe('ValidationError');
+            expect(error.field).toBe('presetId');
+            expect(error.constraint).toBe('must be a valid preset ID');
+            expect(error.receivedValue).toBe('invalid-id');
+        });
+        it('should handle null and undefined received values', async () => {
+            const { ValidationError } = await import('./errors.js');
+            const nullError = new ValidationError({
+                field: 'name',
+                constraint: 'required',
+                receivedValue: null,
+            });
+            expect(nullError.receivedValue).toBeNull();
+            const undefinedError = new ValidationError({
+                field: 'name',
+                constraint: 'required',
+                receivedValue: undefined,
+            });
+            expect(undefinedError.receivedValue).toBeUndefined();
+        });
+    });
+    describe('AppError Union Type', () => {
+        it('should support discriminated union via _tag', async () => {
+            const { GitError, FileSystemError, ConfigError, ProcessError, ValidationError, } = await import('./errors.js');
+            const errors = [
+                new GitError({ command: 'git', exitCode: 1, stderr: 'error' }),
+                new FileSystemError({ operation: 'read', path: '/test', cause: 'error' }),
+                new ConfigError({
+                    configPath: '/test',
+                    reason: 'parse',
+                    details: 'error',
+                }),
+                new ProcessError({ command: 'cmd', message: 'error' }),
+                new ValidationError({
+                    field: 'test',
+                    constraint: 'required',
+                    receivedValue: null,
+                }),
+            ];
+            const tags = errors.map(e => e._tag);
+            expect(tags).toEqual([
+                'GitError',
+                'FileSystemError',
+                'ConfigError',
+                'ProcessError',
+                'ValidationError',
+            ]);
+        });
+        it('should be able to narrow types using _tag', async () => {
+            const { GitError } = await import('./errors.js');
+            // Create a GitError which is a valid AppError
+            const error = new GitError({
+                command: 'git log',
+                exitCode: 1,
+                stderr: 'error',
+            });
+            if (error._tag === 'GitError') {
+                // TypeScript should narrow the type here
+                expect(error.command).toBe('git log');
+                expect(error.exitCode).toBe(1);
+                expect(error.stderr).toBe('error');
+            }
+            else {
+                throw new Error('Should be GitError');
+            }
+        });
+    });
+});

package/dist/types/index.d.ts

@@ -127,7 +127,6 @@ export interface IProjectManager {
     setMode(mode: MenuMode): void;
     selectProject(project: GitProject): void;
     getWorktreeService(projectPath?: string): IWorktreeService;
-    refreshProjects(): Promise<void>;
     getRecentProjects(limit?: number): RecentProject[];
     addRecentProject(project: GitProject): void;
     clearRecentProjects(): void;
@@ -144,22 +143,11 @@ export declare class AmbiguousBranchError extends Error {
     constructor(branchName: string, matches: RemoteBranchMatch[]);
 }
 export interface IWorktreeService {
-    getWorktrees(): Worktree[];
+    getWorktreesEffect(): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
     getGitRootPath(): string;
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    deleteWorktree(worktreePath: string, options?: {
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): import('effect').Effect.Effect<Worktree, import('../types/errors.js').GitError | import('../types/errors.js').FileSystemError, never>;
+    deleteWorktreeEffect(worktreePath: string, options?: {
         deleteBranch?: boolean;
-    }): {
-        success: boolean;
-        error?: string;
-    };
-    mergeWorktree(worktreePath: string, targetBranch?: string): {
-        success: boolean;
-        mergedBranch?: string;
-        error?: string;
-        deletedWorktree?: boolean;
-    };
+    }): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
+    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, useRebase?: boolean): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
 }

package/dist/utils/claudeDir.d.ts

@@ -4,19 +4,71 @@
  * CLAUDE_CONFIG_DIR environment variable and convert worktree paths to Claude's
  * project naming convention.
  */
+import { Effect, Either } from 'effect';
+import { ValidationError, FileSystemError } from '../types/errors.js';
 /**
- * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
- * @returns The Claude directory path
+ * Get the Claude directory path using Either for synchronous validation
+ * Returns Either with ValidationError if HOME directory cannot be determined
  */
-export declare function getClaudeDir(): string;
+export declare function getClaudeDir(): Either.Either<string, ValidationError>;
 /**
- * Get the Claude projects directory path
- * @returns The Claude projects directory path
+ * Get the Claude projects directory path using Either
+ *
+ * Propagates ValidationError from getClaudeDir if HOME directory cannot be determined.
+ *
+ * @returns {Either.Either<string, ValidationError>} Either containing projects directory path or ValidationError
+ *
+ * @example
+ * ```typescript
+ * import {Either} from 'effect';
+ * import {getClaudeProjectsDir} from './utils/claudeDir.js';
+ *
+ * const projectsDirEither = getClaudeProjectsDir();
+ *
+ * if (Either.isRight(projectsDirEither)) {
+ *   console.log(`Projects directory: ${projectsDirEither.right}`);
+ * } else {
+ *   console.error(`Failed to get directory: ${projectsDirEither.left.field} ${projectsDirEither.left.constraint}`);
+ * }
+ * ```
  */
-export declare function getClaudeProjectsDir(): string;
+export declare function getClaudeProjectsDir(): Either.Either<string, ValidationError>;
 /**
  * Convert a worktree path to Claude's project naming convention
+ * Pure transformation, cannot fail
  * @param worktreePath The path to the worktree
  * @returns The project name used by Claude
  */
 export declare function pathToClaudeProjectName(worktreePath: string): string;
+/**
+ * Check if Claude project directory exists using Effect
+ *
+ * Returns false for ENOENT (directory doesn't exist), fails with FileSystemError for other errors.
+ *
+ * @param {string} projectName - Claude project name to check
+ * @returns {Effect.Effect<boolean, FileSystemError, never>} Effect containing boolean indicating existence or FileSystemError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {claudeDirExists, pathToClaudeProjectName} from './utils/claudeDir.js';
+ *
+ * const projectName = pathToClaudeProjectName('/path/to/worktree');
+ *
+ * // Check if directory exists with error handling
+ * const exists = await Effect.runPromise(
+ *   Effect.catchAll(
+ *     claudeDirExists(projectName),
+ *     (error) => {
+ *       console.error(`Failed to check directory: ${error.cause}`);
+ *       return Effect.succeed(false); // Assume doesn't exist on error
+ *     }
+ *   )
+ * );
+ *
+ * if (exists) {
+ *   console.log('Claude project directory exists');
+ * }
+ * ```
+ */
+export declare function claudeDirExists(projectName: string): Effect.Effect<boolean, FileSystemError>;

package/dist/utils/claudeDir.js

@@ -6,27 +6,65 @@
  */
 import path from 'path';
 import os from 'os';
+import { promises as fs } from 'fs';
+import { Effect, Either } from 'effect';
+import { ValidationError, FileSystemError } from '../types/errors.js';
 /**
- * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
- * @returns The Claude directory path
+ * Get the Claude directory path using Either for synchronous validation
+ * Returns Either with ValidationError if HOME directory cannot be determined
  */
 export function getClaudeDir() {
     const envConfigDir = process.env['CLAUDE_CONFIG_DIR'];
     if (envConfigDir) {
-        return envConfigDir.trim();
+        return Either.right(envConfigDir.trim());
+    }
+    // Try to get home directory
+    try {
+        const homeDir = os.homedir();
+        if (!homeDir) {
+            return Either.left(new ValidationError({
+                field: 'HOME',
+                constraint: 'must be set',
+                receivedValue: undefined,
+            }));
+        }
+        return Either.right(path.join(homeDir, '.claude'));
+    }
+    catch {
+        return Either.left(new ValidationError({
+            field: 'HOME',
+            constraint: 'must be accessible',
+            receivedValue: undefined,
+        }));
     }
-    // Default to ~/.claude for backward compatibility and when not set
-    return path.join(os.homedir(), '.claude');
 }
 /**
- * Get the Claude projects directory path
- * @returns The Claude projects directory path
+ * Get the Claude projects directory path using Either
+ *
+ * Propagates ValidationError from getClaudeDir if HOME directory cannot be determined.
+ *
+ * @returns {Either.Either<string, ValidationError>} Either containing projects directory path or ValidationError
+ *
+ * @example
+ * ```typescript
+ * import {Either} from 'effect';
+ * import {getClaudeProjectsDir} from './utils/claudeDir.js';
+ *
+ * const projectsDirEither = getClaudeProjectsDir();
+ *
+ * if (Either.isRight(projectsDirEither)) {
+ *   console.log(`Projects directory: ${projectsDirEither.right}`);
+ * } else {
+ *   console.error(`Failed to get directory: ${projectsDirEither.left.field} ${projectsDirEither.left.constraint}`);
+ * }
+ * ```
  */
 export function getClaudeProjectsDir() {
-    return path.join(getClaudeDir(), 'projects');
+    return Either.map(getClaudeDir(), dir => path.join(dir, 'projects'));
 }
 /**
  * Convert a worktree path to Claude's project naming convention
+ * Pure transformation, cannot fail
  * @param worktreePath The path to the worktree
  * @returns The project name used by Claude
  */
@@ -37,3 +75,60 @@ export function pathToClaudeProjectName(worktreePath) {
     // Handle both forward slashes (Linux/macOS) and backslashes (Windows)
     return resolved.replace(/[/\\.]/g, '-');
 }
+/**
+ * Check if Claude project directory exists using Effect
+ *
+ * Returns false for ENOENT (directory doesn't exist), fails with FileSystemError for other errors.
+ *
+ * @param {string} projectName - Claude project name to check
+ * @returns {Effect.Effect<boolean, FileSystemError, never>} Effect containing boolean indicating existence or FileSystemError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {claudeDirExists, pathToClaudeProjectName} from './utils/claudeDir.js';
+ *
+ * const projectName = pathToClaudeProjectName('/path/to/worktree');
+ *
+ * // Check if directory exists with error handling
+ * const exists = await Effect.runPromise(
+ *   Effect.catchAll(
+ *     claudeDirExists(projectName),
+ *     (error) => {
+ *       console.error(`Failed to check directory: ${error.cause}`);
+ *       return Effect.succeed(false); // Assume doesn't exist on error
+ *     }
+ *   )
+ * );
+ *
+ * if (exists) {
+ *   console.log('Claude project directory exists');
+ * }
+ * ```
+ */
+export function claudeDirExists(projectName) {
+    const claudeDirEither = getClaudeProjectsDir();
+    if (Either.isLeft(claudeDirEither)) {
+        // If we can't determine the projects directory, return false
+        return Effect.succeed(false);
+    }
+    const projectPath = path.join(claudeDirEither.right, projectName);
+    return Effect.catchAll(Effect.tryPromise({
+        try: () => fs.stat(projectPath).then(() => true),
+        catch: error => error,
+    }), error => {
+        // ENOENT means directory doesn't exist, which is not an error
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return Effect.succeed(false);
+        }
+        // Other errors are filesystem issues
+        return Effect.fail(new FileSystemError({
+            operation: 'stat',
+            path: projectPath,
+            cause: error instanceof Error ? error.message : String(error),
+        }));
+    });
+}

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

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

package/dist/utils/claudeDir.test.js

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Effect, Either } from 'effect';
+import { getClaudeDir, getClaudeProjectsDir, pathToClaudeProjectName, claudeDirExists, } from './claudeDir.js';
+describe('claudeDir', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe('getClaudeDir', () => {
+        it('should return Either.right with CLAUDE_CONFIG_DIR when set', () => {
+            process.env['CLAUDE_CONFIG_DIR'] = '/custom/claude';
+            const result = getClaudeDir();
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toBe('/custom/claude');
+            }
+        });
+        it('should trim whitespace from CLAUDE_CONFIG_DIR', () => {
+            process.env['CLAUDE_CONFIG_DIR'] = '  /custom/claude  ';
+            const result = getClaudeDir();
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toBe('/custom/claude');
+            }
+        });
+        it('should return Either.right with default ~/.claude when env var not set', () => {
+            delete process.env['CLAUDE_CONFIG_DIR'];
+            const result = getClaudeDir();
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toContain('.claude');
+            }
+        });
+        it('should return Either.right even when HOME vars deleted (os.homedir has fallbacks)', () => {
+            delete process.env['CLAUDE_CONFIG_DIR'];
+            delete process.env['HOME'];
+            delete process.env['USERPROFILE'];
+            const result = getClaudeDir();
+            // os.homedir() has multiple fallback mechanisms, so this will likely still succeed
+            expect(Either.isRight(result)).toBe(true);
+        });
+    });
+    describe('getClaudeProjectsDir', () => {
+        it('should return Either.right with projects subdirectory', () => {
+            process.env['CLAUDE_CONFIG_DIR'] = '/custom/claude';
+            const result = getClaudeProjectsDir();
+            expect(Either.isRight(result)).toBe(true);
+            if (Either.isRight(result)) {
+                expect(result.right).toBe('/custom/claude/projects');
+            }
+        });
+        it('should return Either.right from getClaudeDir fallbacks', () => {
+            delete process.env['CLAUDE_CONFIG_DIR'];
+            delete process.env['HOME'];
+            delete process.env['USERPROFILE'];
+            const result = getClaudeProjectsDir();
+            // Since getClaudeDir has fallbacks, this should succeed
+            expect(Either.isRight(result)).toBe(true);
+        });
+    });
+    describe('pathToClaudeProjectName', () => {
+        it('should convert absolute path to Claude naming convention', () => {
+            const result = pathToClaudeProjectName('/home/user/projects/myapp');
+            expect(result).toBe('-home-user-projects-myapp');
+        });
+        it('should replace forward slashes with dashes', () => {
+            const result = pathToClaudeProjectName('/a/b/c');
+            expect(result).toBe('-a-b-c');
+        });
+        it('should replace backslashes with dashes (Windows)', () => {
+            const result = pathToClaudeProjectName('C:\\Users\\test\\app');
+            expect(result).toContain('-');
+            expect(result).not.toContain('\\');
+        });
+        it('should replace dots with dashes', () => {
+            const result = pathToClaudeProjectName('/home/user/my.app');
+            expect(result).toBe('-home-user-my-app');
+        });
+    });
+    describe('claudeDirExists', () => {
+        it('should return Effect with false for nonexistent directory', async () => {
+            const effect = claudeDirExists('nonexistent-dir-12345-test-project');
+            const result = await Effect.runPromise(effect);
+            expect(result).toBe(false);
+        });
+        it('should check in Claude projects directory', async () => {
+            // This test verifies the path construction, not the existence
+            // Since ~/.claude/projects likely doesn't exist in test environment
+            const effect = claudeDirExists('any-project-name');
+            const result = await Effect.runPromise(effect);
+            // Should return false (directory doesn't exist) not throw an error
+            expect(result).toBe(false);
+        });
+        it('should fail with FileSystemError on access error', async () => {
+            // Mock fs.stat to throw a non-ENOENT error
+            const { promises: fs } = await import('fs');
+            vi.spyOn(fs, 'stat').mockRejectedValue(Object.assign(new Error('Permission denied'), { code: 'EACCES' }));
+            const effect = claudeDirExists('test-project');
+            const exit = await Effect.runPromiseExit(effect);
+            expect(exit._tag).toBe('Failure');
+            // Restore original
+            vi.mocked(fs.stat).mockRestore();
+        });
+    });
+});