ccmanager 2.8.0 → 2.9.1

package/dist/utils/concurrencyLimit.d.ts

@@ -1,4 +1,9 @@
+import { Effect } from 'effect';
 /**
  * Create a function that limits concurrent executions
  */
 export declare function createConcurrencyLimited<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, maxConcurrent: number): (...args: TArgs) => Promise<TResult>;
+/**
+ * Create a function that limits concurrent Effect executions
+ */
+export declare function createEffectConcurrencyLimited<TArgs extends unknown[], A, E>(fn: (...args: TArgs) => Effect.Effect<A, E>, maxConcurrent: number): (...args: TArgs) => Effect.Effect<A, E>;

package/dist/utils/concurrencyLimit.js

@@ -1,3 +1,4 @@
+import { Effect } from 'effect';
 /**
  * Create a function that limits concurrent executions
  */
@@ -28,3 +29,13 @@ export function createConcurrencyLimited(fn, maxConcurrent) {
         }
     };
 }
+/**
+ * Create a function that limits concurrent Effect executions
+ */
+export function createEffectConcurrencyLimited(fn, maxConcurrent) {
+    if (maxConcurrent < 1) {
+        throw new RangeError('maxConcurrent must be at least 1');
+    }
+    const semaphore = Effect.unsafeMakeSemaphore(maxConcurrent);
+    return (...args) => semaphore.withPermits(1)(fn(...args));
+}

package/dist/utils/concurrencyLimit.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { createConcurrencyLimited } from './concurrencyLimit.js';
+import { Effect, Exit } from 'effect';
+import { createConcurrencyLimited, createEffectConcurrencyLimited, } from './concurrencyLimit.js';
 describe('createConcurrencyLimited', () => {
     it('should limit concurrent executions', async () => {
         let running = 0;
@@ -61,3 +62,41 @@ describe('createConcurrencyLimited', () => {
         expect(() => createConcurrencyLimited(fn, -1)).toThrow('maxConcurrent must be at least 1');
     });
 });
+describe('createEffectConcurrencyLimited', () => {
+    it('should limit concurrent Effect executions', async () => {
+        let running = 0;
+        let maxRunning = 0;
+        const task = (id) => Effect.gen(function* () {
+            running++;
+            maxRunning = Math.max(maxRunning, running);
+            yield* Effect.sleep('10 millis');
+            running--;
+            return id;
+        });
+        const limited = createEffectConcurrencyLimited(task, 2);
+        const results = await Promise.all([
+            Effect.runPromise(limited(1)),
+            Effect.runPromise(limited(2)),
+            Effect.runPromise(limited(3)),
+            Effect.runPromise(limited(4)),
+        ]);
+        expect(results).toEqual([1, 2, 3, 4]);
+        expect(maxRunning).toBeLessThanOrEqual(2);
+        expect(running).toBe(0);
+    });
+    it('should release permits after failures', async () => {
+        const original = (shouldFail) => shouldFail ? Effect.fail('Task failed') : Effect.succeed('success');
+        const limited = createEffectConcurrencyLimited(original, 1);
+        const [firstExit, secondExit] = await Promise.all([
+            Effect.runPromiseExit(limited(true)),
+            Effect.runPromiseExit(limited(false)),
+        ]);
+        expect(Exit.isFailure(firstExit)).toBe(true);
+        expect(Exit.isSuccess(secondExit)).toBe(true);
+    });
+    it('should throw for invalid maxConcurrent', () => {
+        const fn = () => Effect.succeed('test');
+        expect(() => createEffectConcurrencyLimited(fn, 0)).toThrow('maxConcurrent must be at least 1');
+        expect(() => createEffectConcurrencyLimited(fn, -1)).toThrow('maxConcurrent must be at least 1');
+    });
+});

package/dist/utils/gitStatus.d.ts

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { GitError } from '../types/errors.js';
 export interface GitStatus {
     filesAdded: number;
     filesDeleted: number;
@@ -5,15 +7,41 @@ export interface GitStatus {
     behindCount: number;
     parentBranch: string | null;
 }
-export interface GitOperationResult<T> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    skipped?: boolean;
-}
-export declare function getGitStatus(worktreePath: string, signal: AbortSignal): Promise<GitOperationResult<GitStatus>>;
+/**
+ * Get comprehensive Git status for a worktree
+ *
+ * Retrieves file changes, ahead/behind counts, and parent branch information
+ * using Effect-based error handling.
+ *
+ * @param {string} worktreePath - Absolute path to the worktree directory
+ * @returns {Effect.Effect<GitStatus, GitError>} Effect containing git status or GitError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {getGitStatus} from './utils/gitStatus.js';
+ *
+ * // Execute with Effect.runPromise
+ * const status = await Effect.runPromise(
+ *   getGitStatus('/path/to/worktree')
+ * );
+ * console.log(`Files added: ${status.filesAdded}, deleted: ${status.filesDeleted}`);
+ * console.log(`Ahead: ${status.aheadCount}, behind: ${status.behindCount}`);
+ *
+ * // Or use Effect.map for transformation
+ * const formatted = await Effect.runPromise(
+ *   Effect.map(
+ *     getGitStatus('/path/to/worktree'),
+ *     (status) => `+${status.filesAdded} -${status.filesDeleted}`
+ *   )
+ * );
+ * ```
+ *
+ * @throws {GitError} When git commands fail or worktree path is invalid
+ */
+export declare const getGitStatus: (worktreePath: string) => Effect.Effect<GitStatus, GitError>;
+export declare const getGitStatusLimited: (worktreePath: string) => Effect.Effect<GitStatus, GitError, never>;
 export declare function formatGitFileChanges(status: GitStatus): string;
 export declare function formatGitAheadBehind(status: GitStatus): string;
 export declare function formatGitStatus(status: GitStatus): string;
 export declare function formatParentBranch(parentBranch: string | null, currentBranch: string): string;
-export declare const getGitStatusLimited: (worktreePath: string, signal: AbortSignal) => Promise<GitOperationResult<GitStatus>>;

package/dist/utils/gitStatus.js

@@ -1,78 +1,67 @@
 import { promisify } from 'util';
-import { exec, execFile } from 'child_process';
+import { execFile } from 'child_process';
+import { Effect, Either } from 'effect';
+import { pipe } from 'effect/Function';
+import { GitError } from '../types/errors.js';
 import { getWorktreeParentBranch } from './worktreeConfig.js';
-import { createConcurrencyLimited } from './concurrencyLimit.js';
-const execp = promisify(exec);
-const execFilePromisified = promisify(execFile);
-export async function getGitStatus(worktreePath, signal) {
-    try {
-        // Get unstaged changes
-        const [diffResult, stagedResult, branchResult, parentBranch] = await Promise.all([
-            execp('git diff --shortstat', { cwd: worktreePath, signal }).catch(() => EMPTY_EXEC_RESULT),
-            execp('git diff --staged --shortstat', {
-                cwd: worktreePath,
-                signal,
-            }).catch(() => EMPTY_EXEC_RESULT),
-            execp('git branch --show-current', { cwd: worktreePath, signal }).catch(() => EMPTY_EXEC_RESULT),
-            getWorktreeParentBranch(worktreePath, signal),
-        ]);
-        // Parse file changes
-        let filesAdded = 0;
-        let filesDeleted = 0;
-        if (diffResult.stdout) {
-            const stats = parseGitStats(diffResult.stdout);
-            filesAdded += stats.insertions;
-            filesDeleted += stats.deletions;
-        }
-        if (stagedResult.stdout) {
-            const stats = parseGitStats(stagedResult.stdout);
-            filesAdded += stats.insertions;
-            filesDeleted += stats.deletions;
-        }
-        // Get ahead/behind counts
-        let aheadCount = 0;
-        let behindCount = 0;
-        const currentBranch = branchResult.stdout.trim();
-        if (currentBranch && parentBranch && currentBranch !== parentBranch) {
-            try {
-                const aheadBehindResult = await execFilePromisified('git', ['rev-list', '--left-right', '--count', `${parentBranch}...HEAD`], { cwd: worktreePath, signal });
-                const [behind, ahead] = aheadBehindResult.stdout
-                    .trim()
-                    .split('\t')
-                    .map(n => parseInt(n, 10));
-                aheadCount = ahead || 0;
-                behindCount = behind || 0;
-            }
-            catch {
-                // Branch comparison might fail
-            }
-        }
-        return {
-            success: true,
-            data: {
-                filesAdded,
-                filesDeleted,
-                aheadCount,
-                behindCount,
-                parentBranch,
-            },
-        };
-    }
-    catch (error) {
-        let errorMessage = '';
-        if (error instanceof Error) {
-            errorMessage = error.message;
-        }
-        else {
-            errorMessage = String(error);
-        }
-        return {
-            success: false,
-            error: errorMessage,
-        };
-    }
-}
-// Split git status formatting into file changes and ahead/behind
+import { createEffectConcurrencyLimited } from './concurrencyLimit.js';
+const execFileAsync = promisify(execFile);
+const DEFAULT_GIT_STATS = { insertions: 0, deletions: 0 };
+/**
+ * Get comprehensive Git status for a worktree
+ *
+ * Retrieves file changes, ahead/behind counts, and parent branch information
+ * using Effect-based error handling.
+ *
+ * @param {string} worktreePath - Absolute path to the worktree directory
+ * @returns {Effect.Effect<GitStatus, GitError>} Effect containing git status or GitError
+ *
+ * @example
+ * ```typescript
+ * import {Effect} from 'effect';
+ * import {getGitStatus} from './utils/gitStatus.js';
+ *
+ * // Execute with Effect.runPromise
+ * const status = await Effect.runPromise(
+ *   getGitStatus('/path/to/worktree')
+ * );
+ * console.log(`Files added: ${status.filesAdded}, deleted: ${status.filesDeleted}`);
+ * console.log(`Ahead: ${status.aheadCount}, behind: ${status.behindCount}`);
+ *
+ * // Or use Effect.map for transformation
+ * const formatted = await Effect.runPromise(
+ *   Effect.map(
+ *     getGitStatus('/path/to/worktree'),
+ *     (status) => `+${status.filesAdded} -${status.filesDeleted}`
+ *   )
+ * );
+ * ```
+ *
+ * @throws {GitError} When git commands fail or worktree path is invalid
+ */
+export const getGitStatus = (worktreePath) => Effect.gen(function* () {
+    const diffResult = yield* runGit(['diff', '--shortstat'], worktreePath);
+    const stagedResult = yield* runGit(['diff', '--staged', '--shortstat'], worktreePath);
+    const branchResult = yield* runGit(['branch', '--show-current'], worktreePath);
+    const parentBranch = yield* fetchParentBranch(worktreePath);
+    const diffStats = decodeGitStats(diffResult.stdout);
+    const stagedStats = decodeGitStats(stagedResult.stdout);
+    const filesAdded = diffStats.insertions + stagedStats.insertions;
+    const filesDeleted = diffStats.deletions + stagedStats.deletions;
+    const { aheadCount, behindCount } = yield* computeAheadBehind({
+        worktreePath,
+        currentBranch: branchResult.stdout.trim(),
+        parentBranch,
+    });
+    return {
+        filesAdded,
+        filesDeleted,
+        aheadCount,
+        behindCount,
+        parentBranch,
+    };
+});
+export const getGitStatusLimited = createEffectConcurrencyLimited((worktreePath) => getGitStatus(worktreePath), 10);
 export function formatGitFileChanges(status) {
     const parts = [];
     const colors = {
@@ -80,7 +69,6 @@ export function formatGitFileChanges(status) {
         red: '\x1b[31m',
         reset: '\x1b[0m',
     };
-    // File changes
     if (status.filesAdded > 0) {
         parts.push(`${colors.green}+${status.filesAdded}${colors.reset}`);
     }
@@ -96,7 +84,6 @@ export function formatGitAheadBehind(status) {
         magenta: '\x1b[35m',
         reset: '\x1b[0m',
     };
-    // Ahead/behind - compact format with arrows
     if (status.aheadCount > 0) {
         parts.push(`${colors.cyan}↑${status.aheadCount}${colors.reset}`);
     }
@@ -105,7 +92,6 @@ export function formatGitAheadBehind(status) {
     }
     return parts.join(' ');
 }
-// Keep the original function for backward compatibility
 export function formatGitStatus(status) {
     const fileChanges = formatGitFileChanges(status);
     const aheadBehind = formatGitAheadBehind(status);
@@ -117,7 +103,6 @@ export function formatGitStatus(status) {
     return parts.join(' ');
 }
 export function formatParentBranch(parentBranch, currentBranch) {
-    // Only show parent branch if it exists and is different from current branch
     if (!parentBranch || parentBranch === currentBranch) {
         return '';
     }
@@ -127,20 +112,117 @@ export function formatParentBranch(parentBranch, currentBranch) {
     };
     return `${colors.dim}(${parentBranch})${colors.reset}`;
 }
-const EMPTY_EXEC_RESULT = { stdout: '', stderr: '' };
+function runGit(args, worktreePath) {
+    const command = `git ${args.join(' ')}`.trim();
+    return Effect.catchAll(Effect.tryPromise({
+        try: signal => execFileAsync('git', args, {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            maxBuffer: 5 * 1024 * 1024,
+            signal,
+        }),
+        catch: error => error,
+    }), error => handleExecFailure(command, error));
+}
+function fetchParentBranch(worktreePath) {
+    return Effect.catchAll(getWorktreeParentBranch(worktreePath), () => Effect.succeed(null));
+}
+function computeAheadBehind({ worktreePath, currentBranch, parentBranch, }) {
+    if (!currentBranch || !parentBranch || currentBranch === parentBranch) {
+        return Effect.succeed({ aheadCount: 0, behindCount: 0 });
+    }
+    return Effect.map(Effect.catchAll(runGit(['rev-list', '--left-right', '--count', `${parentBranch}...HEAD`], worktreePath), () => Effect.succeed({ stdout: '', stderr: '' })), result => decodeAheadBehind(result.stdout));
+}
 function parseGitStats(statLine) {
-    let insertions = 0;
-    let deletions = 0;
-    // Parse git diff --shortstat output
-    // Example: " 3 files changed, 42 insertions(+), 10 deletions(-)"
     const insertMatch = statLine.match(/(\d+) insertion/);
     const deleteMatch = statLine.match(/(\d+) deletion/);
-    if (insertMatch && insertMatch[1]) {
-        insertions = parseInt(insertMatch[1], 10);
+    const insertions = insertMatch?.[1]
+        ? Number.parseInt(insertMatch[1], 10)
+        : 0;
+    const deletions = deleteMatch?.[1] ? Number.parseInt(deleteMatch[1], 10) : 0;
+    if (Number.isNaN(insertions) || Number.isNaN(deletions)) {
+        return Either.left(`Unable to parse git diff stats from "${statLine.trim()}"`);
+    }
+    return Either.right({ insertions, deletions });
+}
+function decodeGitStats(statLine) {
+    return pipe(parseGitStats(statLine), Either.getOrElse(() => DEFAULT_GIT_STATS));
+}
+function parseAheadBehind(stats) {
+    const trimmed = stats.trim();
+    if (!trimmed) {
+        return Either.right({ aheadCount: 0, behindCount: 0 });
+    }
+    const [behindRaw, aheadRaw] = trimmed.split('\t');
+    const behind = behindRaw ? Number.parseInt(behindRaw, 10) : 0;
+    const ahead = aheadRaw ? Number.parseInt(aheadRaw, 10) : 0;
+    if (Number.isNaN(behind) || Number.isNaN(ahead)) {
+        return Either.left(`Unable to parse ahead/behind stats from "${trimmed}"`);
+    }
+    return Either.right({
+        aheadCount: Math.max(ahead, 0),
+        behindCount: Math.max(behind, 0),
+    });
+}
+function decodeAheadBehind(stats) {
+    return pipe(parseAheadBehind(stats), Either.getOrElse(() => ({ aheadCount: 0, behindCount: 0 })));
+}
+function handleExecFailure(command, error) {
+    if (isAbortError(error)) {
+        return Effect.interrupt;
+    }
+    return Effect.fail(toGitError(command, error));
+}
+function isExecError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        'code' in 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;
+    }
+    if (isExecError(error)) {
+        return Boolean(error.killed && error.signal);
+    }
+    return false;
+}
+function toGitError(command, error) {
+    if (error instanceof GitError) {
+        return error;
+    }
+    if (isExecError(error)) {
+        const exitCodeRaw = error.code;
+        const exitCode = typeof exitCodeRaw === 'number'
+            ? exitCodeRaw
+            : Number.parseInt(String(exitCodeRaw ?? '-1'), 10) || -1;
+        const stderr = typeof error.stderr === 'string' ? error.stderr : (error.message ?? '');
+        return new GitError({
+            command,
+            exitCode,
+            stderr,
+            stdout: typeof error.stdout === 'string' && error.stdout.length > 0
+                ? error.stdout
+                : undefined,
+        });
     }
-    if (deleteMatch && deleteMatch[1]) {
-        deletions = parseInt(deleteMatch[1], 10);
+    if (error instanceof Error) {
+        return new GitError({
+            command,
+            exitCode: -1,
+            stderr: error.message,
+        });
     }
-    return { insertions, deletions };
+    return new GitError({
+        command,
+        exitCode: -1,
+        stderr: String(error),
+    });
 }
-export const getGitStatusLimited = createConcurrencyLimited(getGitStatus, 10);

package/dist/utils/gitStatus.test.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
+import { Effect } from 'effect';
 import { formatGitStatus, formatGitFileChanges, formatGitAheadBehind, formatParentBranch, getGitStatus, } from './gitStatus.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -61,18 +62,20 @@ describe('GitService Integration Tests', { timeout: 10000 }, () => {
             const controller2 = new AbortController();
             const controller3 = new AbortController();
             const results = await Promise.all([
-                getGitStatus(tmpDir, controller1.signal),
-                getGitStatus(tmpDir, controller2.signal),
-                getGitStatus(tmpDir, controller3.signal),
+                Effect.runPromise(getGitStatus(tmpDir), {
+                    signal: controller1.signal,
+                }),
+                Effect.runPromise(getGitStatus(tmpDir), {
+                    signal: controller2.signal,
+                }),
+                Effect.runPromise(getGitStatus(tmpDir), {
+                    signal: controller3.signal,
+                }),
             ]);
-            // All should succeed
-            const successCount = results.filter(r => r.success).length;
-            expect(successCount).toBe(3);
             // All results should have the same data
-            const firstData = results[0].data;
+            const firstData = results[0];
             results.forEach(result => {
-                expect(result.success).toBe(true);
-                expect(result.data).toEqual(firstData);
+                expect(result).toEqual(firstData);
             });
         }
         finally {

package/dist/utils/hookExecutor.d.ts

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { ProcessError } from '../types/errors.js';
 import { Worktree, Session, SessionState } from '../types/index.js';
 export interface HookEnvironment {
     CCMANAGER_WORKTREE_PATH: string;
@@ -7,14 +9,47 @@ export interface HookEnvironment {
     [key: string]: string | undefined;
 }
 /**
- * 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 declare function executeHook(command: string, cwd: string, environment: HookEnvironment): Promise<void>;
+export declare function executeHook(command: string, cwd: string, environment: HookEnvironment): Effect.Effect<void, ProcessError>;
 /**
- * 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 declare function executeWorktreePostCreationHook(command: string, worktree: Worktree, gitRoot: string, baseBranch?: string): Promise<void>;
+export declare function executeWorktreePostCreationHook(command: string, worktree: Worktree, gitRoot: string, baseBranch?: string): Effect.Effect<void, never>;
 /**
- * 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 declare function executeStatusHook(oldState: SessionState, newState: SessionState, session: Session): Promise<void>;
+export declare function executeStatusHook(oldState: SessionState, newState: SessionState, session: Session): Effect.Effect<void, never>;