ccmanager 2.8.0 → 2.9.1

package/dist/utils/testHelpers.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Test helper utilities for Effect-ts based testing
+ *
+ * This module provides utilities to simplify testing Effect and Either types:
+ * - Synchronous and asynchronous Effect execution
+ * - Assertions for success and failure cases
+ * - Pattern matching for specific error types
+ *
+ * These utilities follow Effect-ts best practices and are designed to work
+ * seamlessly with Vitest test framework.
+ *
+ * @example
+ * ```typescript
+ * // Test successful Effect
+ * const result = expectEffectSuccess(myService.getData());
+ * expect(result).toEqual(expectedData);
+ *
+ * // Test failed Effect
+ * const error = expectEffectFailure(myService.failingOp());
+ * expect(error._tag).toBe('GitError');
+ *
+ * // Pattern match on specific error type
+ * const command = matchEffectError(effect, {
+ *   GitError: (err) => err.command
+ * });
+ * expect(command).toBe('git status');
+ * ```
+ *
+ * @module testHelpers
+ */
+import { Effect, Either } from 'effect';
+import type { AppError } from '../types/errors.js';
+/**
+ * Run an Effect synchronously and return the success value
+ * Throws if the Effect fails
+ *
+ * @param effect - The Effect to run
+ * @returns The success value
+ * @throws Error if the Effect fails
+ */
+export declare function runEffectSync<A, E>(effect: Effect.Effect<A, E, never>): A;
+/**
+ * Run an Effect as a Promise
+ *
+ * @param effect - The Effect to run
+ * @returns Promise that resolves with success value or rejects with error
+ */
+export declare function runEffectPromise<A, E>(effect: Effect.Effect<A, E, never>): Promise<A>;
+/**
+ * Assert that an Effect succeeds and return the success value
+ * Throws an error if the Effect fails
+ *
+ * @param effect - The Effect to test
+ * @returns The success value
+ * @throws Error if the Effect fails
+ */
+export declare function expectEffectSuccess<A, E>(effect: Effect.Effect<A, E, never>): A;
+/**
+ * Assert that an Effect fails and return the error
+ * Throws an error if the Effect succeeds
+ *
+ * @param effect - The Effect to test
+ * @returns The error value
+ * @throws Error if the Effect succeeds
+ */
+export declare function expectEffectFailure<A, E>(effect: Effect.Effect<A, E, never>): E;
+/**
+ * Assert that an Either is Right and return the right value
+ * Throws an error if the Either is Left
+ *
+ * @param either - The Either to test
+ * @returns The right value
+ * @throws Error if the Either is Left
+ */
+export declare function expectEitherRight<A, E>(either: Either.Either<A, E>): A;
+/**
+ * Assert that an Either is Left and return the left value
+ * Throws an error if the Either is Right
+ *
+ * @param either - The Either to test
+ * @returns The left value
+ * @throws Error if the Either is Right
+ */
+export declare function expectEitherLeft<A, E>(either: Either.Either<A, E>): E;
+/**
+ * Pattern match on Effect error and extract specific error type
+ * Useful for testing specific error scenarios
+ *
+ * @param effect - The Effect that should fail
+ * @param matchers - Object mapping error tags to extraction functions
+ * @returns The extracted value from the matched error
+ * @throws Error if the Effect succeeds or error doesn't match
+ *
+ * @example
+ * ```typescript
+ * const result = matchEffectError(effect, {
+ *   GitError: (err) => err.command,
+ *   ValidationError: (err) => err.field
+ * });
+ * ```
+ */
+export declare function matchEffectError<R>(effect: Effect.Effect<unknown, AppError, never>, matchers: {
+    [K in AppError['_tag']]?: (error: Extract<AppError, {
+        _tag: K;
+    }>) => R;
+}): R;

package/dist/utils/testHelpers.js

@@ -0,0 +1,153 @@
+/**
+ * Test helper utilities for Effect-ts based testing
+ *
+ * This module provides utilities to simplify testing Effect and Either types:
+ * - Synchronous and asynchronous Effect execution
+ * - Assertions for success and failure cases
+ * - Pattern matching for specific error types
+ *
+ * These utilities follow Effect-ts best practices and are designed to work
+ * seamlessly with Vitest test framework.
+ *
+ * @example
+ * ```typescript
+ * // Test successful Effect
+ * const result = expectEffectSuccess(myService.getData());
+ * expect(result).toEqual(expectedData);
+ *
+ * // Test failed Effect
+ * const error = expectEffectFailure(myService.failingOp());
+ * expect(error._tag).toBe('GitError');
+ *
+ * // Pattern match on specific error type
+ * const command = matchEffectError(effect, {
+ *   GitError: (err) => err.command
+ * });
+ * expect(command).toBe('git status');
+ * ```
+ *
+ * @module testHelpers
+ */
+import { Effect, Either, Exit } from 'effect';
+/**
+ * Run an Effect synchronously and return the success value
+ * Throws if the Effect fails
+ *
+ * @param effect - The Effect to run
+ * @returns The success value
+ * @throws Error if the Effect fails
+ */
+export function runEffectSync(effect) {
+    const exit = Effect.runSync(Effect.exit(effect));
+    if (Exit.isFailure(exit)) {
+        // Extract the error from the Cause
+        const cause = exit.cause;
+        if (cause._tag === 'Fail') {
+            throw cause.error;
+        }
+        throw new Error(`Unexpected cause type: ${cause._tag}`);
+    }
+    return exit.value;
+}
+/**
+ * Run an Effect as a Promise
+ *
+ * @param effect - The Effect to run
+ * @returns Promise that resolves with success value or rejects with error
+ */
+export function runEffectPromise(effect) {
+    return Effect.runPromise(effect);
+}
+/**
+ * Assert that an Effect succeeds and return the success value
+ * Throws an error if the Effect fails
+ *
+ * @param effect - The Effect to test
+ * @returns The success value
+ * @throws Error if the Effect fails
+ */
+export function expectEffectSuccess(effect) {
+    const exit = Effect.runSync(Effect.exit(effect));
+    if (Exit.isFailure(exit)) {
+        throw new Error(`Expected Effect to succeed, but it failed with: ${JSON.stringify(exit.cause)}`);
+    }
+    return exit.value;
+}
+/**
+ * Assert that an Effect fails and return the error
+ * Throws an error if the Effect succeeds
+ *
+ * @param effect - The Effect to test
+ * @returns The error value
+ * @throws Error if the Effect succeeds
+ */
+export function expectEffectFailure(effect) {
+    const exit = Effect.runSync(Effect.exit(effect));
+    if (Exit.isSuccess(exit)) {
+        throw new Error(`Expected Effect to fail, but it succeeded with: ${JSON.stringify(exit.value)}`);
+    }
+    // Extract the error from the Cause
+    const failure = exit.cause;
+    if (failure._tag === 'Fail') {
+        return failure.error;
+    }
+    throw new Error(`Expected Fail cause, got: ${failure._tag}`);
+}
+/**
+ * Assert that an Either is Right and return the right value
+ * Throws an error if the Either is Left
+ *
+ * @param either - The Either to test
+ * @returns The right value
+ * @throws Error if the Either is Left
+ */
+export function expectEitherRight(either) {
+    if (Either.isLeft(either)) {
+        throw new Error(`Expected Either to be Right, but it was Left with: ${JSON.stringify(either.left)}`);
+    }
+    return either.right;
+}
+/**
+ * Assert that an Either is Left and return the left value
+ * Throws an error if the Either is Right
+ *
+ * @param either - The Either to test
+ * @returns The left value
+ * @throws Error if the Either is Right
+ */
+export function expectEitherLeft(either) {
+    if (Either.isRight(either)) {
+        throw new Error(`Expected Either to be Left, but it was Right with: ${JSON.stringify(either.right)}`);
+    }
+    return either.left;
+}
+/**
+ * Pattern match on Effect error and extract specific error type
+ * Useful for testing specific error scenarios
+ *
+ * @param effect - The Effect that should fail
+ * @param matchers - Object mapping error tags to extraction functions
+ * @returns The extracted value from the matched error
+ * @throws Error if the Effect succeeds or error doesn't match
+ *
+ * @example
+ * ```typescript
+ * const result = matchEffectError(effect, {
+ *   GitError: (err) => err.command,
+ *   ValidationError: (err) => err.field
+ * });
+ * ```
+ */
+export function matchEffectError(effect, matchers) {
+    const error = expectEffectFailure(effect);
+    const tag = error._tag;
+    const matcher = matchers[tag];
+    if (!matcher) {
+        throw new Error(`No matcher found for error tag: ${error._tag}. Available matchers: ${Object.keys(matchers).join(', ')}`);
+    }
+    // Type assertion is safe here because we've verified the tag matches
+    // We use 'as any' because TypeScript cannot express the constraint that
+    // the error type matches the matcher's expected parameter type
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return matcher(error);
+}

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

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

package/dist/utils/testHelpers.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { Effect, Either } from 'effect';
+import { runEffectSync, runEffectPromise, expectEffectSuccess, expectEffectFailure, expectEitherRight, expectEitherLeft, matchEffectError, } from './testHelpers.js';
+import { GitError, ValidationError } from '../types/errors.js';
+describe('testHelpers', () => {
+    describe('runEffectSync', () => {
+        it('should run Effect synchronously and return success value', () => {
+            const effect = Effect.succeed(42);
+            const result = runEffectSync(effect);
+            expect(result).toBe(42);
+        });
+        it('should throw error when Effect fails', () => {
+            const effect = Effect.fail(new Error('test error'));
+            expect(() => runEffectSync(effect)).toThrow('test error');
+        });
+    });
+    describe('runEffectPromise', () => {
+        it('should run Effect as Promise and resolve with success value', async () => {
+            const effect = Effect.succeed(42);
+            const result = await runEffectPromise(effect);
+            expect(result).toBe(42);
+        });
+        it('should reject when Effect fails', async () => {
+            const effect = Effect.fail(new Error('async error'));
+            await expect(runEffectPromise(effect)).rejects.toThrow('async error');
+        });
+    });
+    describe('expectEffectSuccess', () => {
+        it('should return success value when Effect succeeds', () => {
+            const effect = Effect.succeed('success');
+            const result = expectEffectSuccess(effect);
+            expect(result).toBe('success');
+        });
+        it('should throw when Effect fails', () => {
+            const effect = Effect.fail(new GitError({ command: 'git test', exitCode: 1, stderr: 'error' }));
+            expect(() => expectEffectSuccess(effect)).toThrow();
+        });
+    });
+    describe('expectEffectFailure', () => {
+        it('should return error when Effect fails', () => {
+            const gitError = new GitError({
+                command: 'git test',
+                exitCode: 1,
+                stderr: 'error',
+            });
+            const effect = Effect.fail(gitError);
+            const error = expectEffectFailure(effect);
+            expect(error).toBe(gitError);
+        });
+        it('should throw when Effect succeeds', () => {
+            const effect = Effect.succeed(42);
+            expect(() => expectEffectFailure(effect)).toThrow();
+        });
+    });
+    describe('expectEitherRight', () => {
+        it('should return right value when Either is Right', () => {
+            const either = Either.right('success');
+            const result = expectEitherRight(either);
+            expect(result).toBe('success');
+        });
+        it('should throw when Either is Left', () => {
+            const either = Either.left('error');
+            expect(() => expectEitherRight(either)).toThrow();
+        });
+    });
+    describe('expectEitherLeft', () => {
+        it('should return left value when Either is Left', () => {
+            const either = Either.left('error');
+            const result = expectEitherLeft(either);
+            expect(result).toBe('error');
+        });
+        it('should throw when Either is Right', () => {
+            const either = Either.right('success');
+            expect(() => expectEitherLeft(either)).toThrow();
+        });
+    });
+    describe('matchEffectError', () => {
+        it('should match GitError and return extracted value', () => {
+            const gitError = new GitError({
+                command: 'git test',
+                exitCode: 1,
+                stderr: 'error',
+            });
+            const effect = Effect.fail(gitError);
+            const result = matchEffectError(effect, {
+                GitError: err => err.command,
+            });
+            expect(result).toBe('git test');
+        });
+        it('should match ValidationError and return extracted value', () => {
+            const validationError = new ValidationError({
+                field: 'test',
+                constraint: 'required',
+                receivedValue: null,
+            });
+            const effect = Effect.fail(validationError);
+            const result = matchEffectError(effect, {
+                ValidationError: err => err.field,
+            });
+            expect(result).toBe('test');
+        });
+        it('should throw when error type does not match', () => {
+            const gitError = new GitError({
+                command: 'git test',
+                exitCode: 1,
+                stderr: 'error',
+            });
+            const effect = Effect.fail(gitError);
+            expect(() => matchEffectError(effect, {
+                ValidationError: err => err.field,
+            })).toThrow();
+        });
+    });
+});

package/dist/utils/worktreeConfig.d.ts

@@ -1,3 +1,78 @@
+import { Effect } from 'effect';
+import { GitError } from '../types/errors.js';
 export declare function isWorktreeConfigEnabled(gitPath?: string): boolean;
-export declare function getWorktreeParentBranch(worktreePath: string, signal?: AbortSignal): Promise<string | null>;
-export declare function setWorktreeParentBranch(worktreePath: string, parentBranch: string): void;
+/**
+ * Get parent branch for worktree using Effect
+ * Returns null if config doesn't exist or worktree config is not available
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @returns {Effect.Effect<string | null, never>} Effect containing parent branch name or null
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {getWorktreeParentBranch} from './utils/worktreeConfig.js';
+ *
+ * // This function never fails - returns null on error
+ * const parentBranch = await Effect.runPromise(
+ *   getWorktreeParentBranch('/path/to/worktree')
+ * );
+ *
+ * if (parentBranch) {
+ *   console.log(`Parent branch: ${parentBranch}`);
+ * } else {
+ *   console.log('No parent branch configured');
+ * }
+ *
+ * // Use with Effect.flatMap for chaining
+ * const status = await Effect.runPromise(
+ *   Effect.flatMap(
+ *     getWorktreeParentBranch('/path/to/worktree'),
+ *     (branch) => branch
+ *       ? Effect.succeed(`Tracking ${branch}`)
+ *       : Effect.succeed('No tracking')
+ *   )
+ * );
+ * ```
+ */
+export declare function getWorktreeParentBranch(worktreePath: string): Effect.Effect<string | null, never>;
+/**
+ * Set parent branch for worktree using Effect
+ * Succeeds silently if worktree config is not available
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} parentBranch - Name of the parent branch to track
+ * @returns {Effect.Effect<void, GitError>} Effect that succeeds or fails with GitError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {setWorktreeParentBranch} from './utils/worktreeConfig.js';
+ *
+ * // Set parent branch with error handling
+ * await Effect.runPromise(
+ *   Effect.catchTag(
+ *     setWorktreeParentBranch('/path/to/worktree', 'main'),
+ *     'GitError',
+ *     (error) => {
+ *       console.error(`Failed to set parent branch: ${error.stderr}`);
+ *       return Effect.void; // Continue despite error
+ *     }
+ *   )
+ * );
+ *
+ * // Or use Effect.orElse for fallback
+ * await Effect.runPromise(
+ *   Effect.orElse(
+ *     setWorktreeParentBranch('/path/to/worktree', 'develop'),
+ *     () => {
+ *       console.log('Using fallback - no parent tracking');
+ *       return Effect.void;
+ *     }
+ *   )
+ * );
+ * ```
+ *
+ * @throws {GitError} When git config command fails
+ */
+export declare function setWorktreeParentBranch(worktreePath: string, parentBranch: string): Effect.Effect<void, GitError>;

package/dist/utils/worktreeConfig.js

@@ -1,7 +1,9 @@
 import { promisify } from 'util';
-import { exec, execSync, execFileSync } from 'child_process';
+import { execSync, execFile } from 'child_process';
+import { Effect } from 'effect';
+import { GitError } from '../types/errors.js';
 import { worktreeConfigManager } from '../services/worktreeConfigManager.js';
-const execp = promisify(exec);
+const execFileAsync = promisify(execFile);
 export function isWorktreeConfigEnabled(gitPath) {
     try {
         const result = execSync('git config extensions.worktreeConfig', {
@@ -14,30 +16,168 @@ export function isWorktreeConfigEnabled(gitPath) {
         return false;
     }
 }
-export async function getWorktreeParentBranch(worktreePath, signal) {
+/**
+ * Get parent branch for worktree using Effect
+ * Returns null if config doesn't exist or worktree config is not available
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @returns {Effect.Effect<string | null, never>} Effect containing parent branch name or null
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {getWorktreeParentBranch} from './utils/worktreeConfig.js';
+ *
+ * // This function never fails - returns null on error
+ * const parentBranch = await Effect.runPromise(
+ *   getWorktreeParentBranch('/path/to/worktree')
+ * );
+ *
+ * if (parentBranch) {
+ *   console.log(`Parent branch: ${parentBranch}`);
+ * } else {
+ *   console.log('No parent branch configured');
+ * }
+ *
+ * // Use with Effect.flatMap for chaining
+ * const status = await Effect.runPromise(
+ *   Effect.flatMap(
+ *     getWorktreeParentBranch('/path/to/worktree'),
+ *     (branch) => branch
+ *       ? Effect.succeed(`Tracking ${branch}`)
+ *       : Effect.succeed('No tracking')
+ *   )
+ * );
+ * ```
+ */
+export function getWorktreeParentBranch(worktreePath) {
     // Return null if worktree config extension is not available
     if (!worktreeConfigManager.isAvailable()) {
-        return null;
+        return Effect.succeed(null);
     }
-    try {
-        const result = await execp('git config --worktree ccmanager.parentBranch', {
+    return Effect.catchAll(Effect.tryPromise({
+        try: signal => execFileAsync('git', ['config', '--worktree', 'ccmanager.parentBranch'], {
             cwd: worktreePath,
             encoding: 'utf8',
             signal,
-        });
-        return result.stdout.trim() || null;
-    }
-    catch {
-        return null;
-    }
+        }).then(result => result.stdout.trim() || null),
+        catch: error => error,
+    }), error => {
+        // Abort errors should interrupt
+        if (isAbortError(error)) {
+            return Effect.interrupt;
+        }
+        // Config not existing is not an error, return null
+        return Effect.succeed(null);
+    });
 }
+/**
+ * Set parent branch for worktree using Effect
+ * Succeeds silently if worktree config is not available
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} parentBranch - Name of the parent branch to track
+ * @returns {Effect.Effect<void, GitError>} Effect that succeeds or fails with GitError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {setWorktreeParentBranch} from './utils/worktreeConfig.js';
+ *
+ * // Set parent branch with error handling
+ * await Effect.runPromise(
+ *   Effect.catchTag(
+ *     setWorktreeParentBranch('/path/to/worktree', 'main'),
+ *     'GitError',
+ *     (error) => {
+ *       console.error(`Failed to set parent branch: ${error.stderr}`);
+ *       return Effect.void; // Continue despite error
+ *     }
+ *   )
+ * );
+ *
+ * // Or use Effect.orElse for fallback
+ * await Effect.runPromise(
+ *   Effect.orElse(
+ *     setWorktreeParentBranch('/path/to/worktree', 'develop'),
+ *     () => {
+ *       console.log('Using fallback - no parent tracking');
+ *       return Effect.void;
+ *     }
+ *   )
+ * );
+ * ```
+ *
+ * @throws {GitError} When git config command fails
+ */
 export function setWorktreeParentBranch(worktreePath, parentBranch) {
     // Skip if worktree config extension is not available
     if (!worktreeConfigManager.isAvailable()) {
-        return;
+        return Effect.void;
+    }
+    const command = `git config --worktree ccmanager.parentBranch ${parentBranch}`;
+    return Effect.catchAll(Effect.tryPromise({
+        try: signal => execFileAsync('git', ['config', '--worktree', 'ccmanager.parentBranch', parentBranch], {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            signal,
+        }).then(() => undefined),
+        catch: error => error,
+    }), error => {
+        // Abort errors should interrupt
+        if (isAbortError(error)) {
+            return Effect.interrupt;
+        }
+        // Other errors are git failures
+        return Effect.fail(toGitError(command, error));
+    });
+}
+function isAbortError(error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+        return true;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ABORT_ERR') {
+        return true;
+    }
+    return false;
+}
+function toGitError(command, error) {
+    if (error instanceof GitError) {
+        return error;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        'stderr' in error) {
+        const execError = error;
+        const exitCode = typeof execError.code === 'number'
+            ? execError.code
+            : Number.parseInt(String(execError.code ?? '-1'), 10) || -1;
+        const stderr = typeof execError.stderr === 'string'
+            ? execError.stderr
+            : (execError.message ?? '');
+        return new GitError({
+            command,
+            exitCode,
+            stderr,
+            stdout: typeof execError.stdout === 'string' && execError.stdout.length > 0
+                ? execError.stdout
+                : undefined,
+        });
+    }
+    if (error instanceof Error) {
+        return new GitError({
+            command,
+            exitCode: -1,
+            stderr: error.message,
+        });
     }
-    execFileSync('git', ['config', '--worktree', 'ccmanager.parentBranch', parentBranch], {
-        cwd: worktreePath,
-        encoding: 'utf8',
+    return new GitError({
+        command,
+        exitCode: -1,
+        stderr: String(error),
     });
 }

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

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

package/dist/utils/worktreeConfig.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { isWorktreeConfigEnabled } from './worktreeConfig.js';
+import * as cp from 'child_process';
+vi.mock('child_process');
+vi.mock('../services/worktreeConfigManager.js', () => ({
+    worktreeConfigManager: {
+        isAvailable: vi.fn(() => true),
+    },
+}));
+describe('worktreeConfig', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('isWorktreeConfigEnabled', () => {
+        it('should return true when worktree config is enabled', () => {
+            vi.mocked(cp.execSync).mockReturnValue('true\n');
+            const result = isWorktreeConfigEnabled('/test/path');
+            expect(result).toBe(true);
+            expect(cp.execSync).toHaveBeenCalledWith('git config extensions.worktreeConfig', {
+                cwd: '/test/path',
+                encoding: 'utf8',
+            });
+        });
+        it('should return false when worktree config is disabled', () => {
+            vi.mocked(cp.execSync).mockReturnValue('false\n');
+            const result = isWorktreeConfigEnabled('/test/path');
+            expect(result).toBe(false);
+        });
+        it('should return false when git config command fails', () => {
+            vi.mocked(cp.execSync).mockImplementation(() => {
+                throw new Error('Command failed');
+            });
+            const result = isWorktreeConfigEnabled('/test/path');
+            expect(result).toBe(false);
+        });
+    });
+    // Note: getWorktreeParentBranch and setWorktreeParentBranch are tested
+    // in integration tests since they use Effect.tryPromise with real execFile
+});