ccmanager 0.1.14 → 0.2.0

package/dist/utils/concurrencyLimit.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { createConcurrencyLimited } from './concurrencyLimit.js';
+describe('createConcurrencyLimited', () => {
+    it('should limit concurrent executions', async () => {
+        let running = 0;
+        let maxRunning = 0;
+        const task = async (id) => {
+            running++;
+            maxRunning = Math.max(maxRunning, running);
+            // Simulate work
+            await new Promise(resolve => setTimeout(resolve, 10));
+            running--;
+            return id;
+        };
+        const limitedTask = createConcurrencyLimited(task, 2);
+        // Start 5 tasks
+        const promises = [
+            limitedTask(1),
+            limitedTask(2),
+            limitedTask(3),
+            limitedTask(4),
+            limitedTask(5),
+        ];
+        const results = await Promise.all(promises);
+        // All tasks should complete
+        expect(results).toEqual([1, 2, 3, 4, 5]);
+        // Max concurrent should not exceed limit
+        expect(maxRunning).toBeLessThanOrEqual(2);
+        // All tasks should have finished
+        expect(running).toBe(0);
+    });
+    it('should handle errors without blocking queue', async () => {
+        let callCount = 0;
+        const original = async () => {
+            callCount++;
+            if (callCount === 1) {
+                throw new Error('Task failed');
+            }
+            return 'success';
+        };
+        const limited = createConcurrencyLimited(original, 1);
+        // Start failing task first
+        const promise1 = limited().catch(e => e.message);
+        // Queue successful task
+        const promise2 = limited();
+        const results = await Promise.all([promise1, promise2]);
+        expect(results[0]).toBe('Task failed');
+        expect(results[1]).toBe('success');
+    });
+    it('should preserve function arguments', async () => {
+        const original = async (a, b, c) => {
+            return `${a}-${b}-${c}`;
+        };
+        const limited = createConcurrencyLimited(original, 1);
+        const result = await limited(42, 'test', true);
+        expect(result).toBe('42-test-true');
+    });
+    it('should throw for invalid maxConcurrent', () => {
+        const fn = async () => 'test';
+        expect(() => createConcurrencyLimited(fn, 0)).toThrow('maxConcurrent must be at least 1');
+        expect(() => createConcurrencyLimited(fn, -1)).toThrow('maxConcurrent must be at least 1');
+    });
+});

package/dist/utils/gitStatus.d.ts

@@ -0,0 +1,19 @@
+export interface GitStatus {
+    filesAdded: number;
+    filesDeleted: number;
+    aheadCount: number;
+    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>>;
+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

@@ -0,0 +1,146 @@
+import { promisify } from 'util';
+import { exec, execFile } from 'child_process';
+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
+export function formatGitFileChanges(status) {
+    const parts = [];
+    const colors = {
+        green: '\x1b[32m',
+        red: '\x1b[31m',
+        reset: '\x1b[0m',
+    };
+    // File changes
+    if (status.filesAdded > 0) {
+        parts.push(`${colors.green}+${status.filesAdded}${colors.reset}`);
+    }
+    if (status.filesDeleted > 0) {
+        parts.push(`${colors.red}-${status.filesDeleted}${colors.reset}`);
+    }
+    return parts.join(' ');
+}
+export function formatGitAheadBehind(status) {
+    const parts = [];
+    const colors = {
+        cyan: '\x1b[36m',
+        magenta: '\x1b[35m',
+        reset: '\x1b[0m',
+    };
+    // Ahead/behind - compact format with arrows
+    if (status.aheadCount > 0) {
+        parts.push(`${colors.cyan}↑${status.aheadCount}${colors.reset}`);
+    }
+    if (status.behindCount > 0) {
+        parts.push(`${colors.magenta}↓${status.behindCount}${colors.reset}`);
+    }
+    return parts.join(' ');
+}
+// Keep the original function for backward compatibility
+export function formatGitStatus(status) {
+    const fileChanges = formatGitFileChanges(status);
+    const aheadBehind = formatGitAheadBehind(status);
+    const parts = [];
+    if (fileChanges)
+        parts.push(fileChanges);
+    if (aheadBehind)
+        parts.push(aheadBehind);
+    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 '';
+    }
+    const colors = {
+        dim: '\x1b[90m',
+        reset: '\x1b[0m',
+    };
+    return `${colors.dim}(${parentBranch})${colors.reset}`;
+}
+const EMPTY_EXEC_RESULT = { stdout: '', stderr: '' };
+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);
+    }
+    if (deleteMatch && deleteMatch[1]) {
+        deletions = parseInt(deleteMatch[1], 10);
+    }
+    return { insertions, deletions };
+}
+export const getGitStatusLimited = createConcurrencyLimited(getGitStatus, 10);

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

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

package/dist/utils/gitStatus.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi } from 'vitest';
+import { formatGitStatus, formatGitFileChanges, formatGitAheadBehind, formatParentBranch, getGitStatus, } from './gitStatus.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Mock worktreeConfigManager
+vi.mock('../services/worktreeConfigManager.js', () => ({
+    worktreeConfigManager: {
+        initialize: vi.fn(),
+        isAvailable: vi.fn(() => true),
+        reset: vi.fn(),
+    },
+}));
+const execAsync = promisify(exec);
+describe('formatGitStatus', () => {
+    it('should format status with ANSI colors', () => {
+        const status = {
+            filesAdded: 42,
+            filesDeleted: 10,
+            aheadCount: 5,
+            behindCount: 3,
+            parentBranch: 'main',
+        };
+        const formatted = formatGitStatus(status);
+        expect(formatted).toBe('\x1b[32m+42\x1b[0m \x1b[31m-10\x1b[0m \x1b[36m↑5\x1b[0m \x1b[35m↓3\x1b[0m');
+    });
+    it('should use formatGitStatusWithColors as alias', () => {
+        const status = {
+            filesAdded: 1,
+            filesDeleted: 2,
+            aheadCount: 3,
+            behindCount: 4,
+            parentBranch: 'main',
+        };
+        const withColors = formatGitStatus(status);
+        const withColorsParam = formatGitStatus(status);
+        expect(withColors).toBe(withColorsParam);
+    });
+});
+describe('GitService Integration Tests', { timeout: 10000 }, () => {
+    it('should handle concurrent calls correctly', async () => {
+        // Create a temporary git repo for testing
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-test-'));
+        try {
+            // Initialize git repo
+            await execAsync('git init', { cwd: tmpDir });
+            await execAsync('git config user.email "test@example.com"', {
+                cwd: tmpDir,
+            });
+            await execAsync('git config user.name "Test User"', { cwd: tmpDir });
+            await execAsync('git config commit.gpgsign false', { cwd: tmpDir });
+            // Create a file and commit
+            fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'Hello World');
+            await execAsync('git add test.txt', { cwd: tmpDir });
+            await execAsync('git commit -m "Initial commit"', { cwd: tmpDir });
+            // Test concurrent calls - all should succeed now without locking
+            // Create abort controllers for each call
+            const controller1 = new AbortController();
+            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),
+            ]);
+            // 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;
+            results.forEach(result => {
+                expect(result.success).toBe(true);
+                expect(result.data).toEqual(firstData);
+            });
+        }
+        finally {
+            // Cleanup
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('formatGitFileChanges', () => {
+    it('should format only file changes', () => {
+        const status = {
+            filesAdded: 10,
+            filesDeleted: 5,
+            aheadCount: 3,
+            behindCount: 2,
+            parentBranch: 'main',
+        };
+        expect(formatGitFileChanges(status)).toBe('\x1b[32m+10\x1b[0m \x1b[31m-5\x1b[0m');
+    });
+    it('should handle zero file changes', () => {
+        const status = {
+            filesAdded: 0,
+            filesDeleted: 0,
+            aheadCount: 3,
+            behindCount: 2,
+            parentBranch: 'main',
+        };
+        expect(formatGitFileChanges(status)).toBe('');
+    });
+});
+describe('formatGitAheadBehind', () => {
+    it('should format only ahead/behind markers', () => {
+        const status = {
+            filesAdded: 10,
+            filesDeleted: 5,
+            aheadCount: 3,
+            behindCount: 2,
+            parentBranch: 'main',
+        };
+        expect(formatGitAheadBehind(status)).toBe('\x1b[36m↑3\x1b[0m \x1b[35m↓2\x1b[0m');
+    });
+    it('should handle zero ahead/behind', () => {
+        const status = {
+            filesAdded: 10,
+            filesDeleted: 5,
+            aheadCount: 0,
+            behindCount: 0,
+            parentBranch: 'main',
+        };
+        expect(formatGitAheadBehind(status)).toBe('');
+    });
+});
+describe('formatParentBranch', () => {
+    it('should return empty string when parent and current branch are the same', () => {
+        expect(formatParentBranch('main', 'main')).toBe('');
+        expect(formatParentBranch('feature', 'feature')).toBe('');
+    });
+    it('should format parent branch when different from current', () => {
+        expect(formatParentBranch('main', 'feature')).toBe('\x1b[90m(main)\x1b[0m');
+        expect(formatParentBranch('develop', 'feature-123')).toBe('\x1b[90m(develop)\x1b[0m');
+    });
+    it('should include color codes', () => {
+        const formatted = formatParentBranch('main', 'feature');
+        expect(formatted).toBe('\x1b[90m(main)\x1b[0m');
+    });
+});

package/dist/utils/worktreeConfig.d.ts

@@ -0,0 +1,3 @@
+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;

package/dist/utils/worktreeConfig.js

@@ -0,0 +1,43 @@
+import { promisify } from 'util';
+import { exec, execSync, execFileSync } from 'child_process';
+import { worktreeConfigManager } from '../services/worktreeConfigManager.js';
+const execp = promisify(exec);
+export function isWorktreeConfigEnabled(gitPath) {
+    try {
+        const result = execSync('git config extensions.worktreeConfig', {
+            cwd: gitPath || process.cwd(),
+            encoding: 'utf8',
+        }).trim();
+        return result === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export async function getWorktreeParentBranch(worktreePath, signal) {
+    // Return null if worktree config extension is not available
+    if (!worktreeConfigManager.isAvailable()) {
+        return null;
+    }
+    try {
+        const result = await execp('git config --worktree ccmanager.parentBranch', {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            signal,
+        });
+        return result.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setWorktreeParentBranch(worktreePath, parentBranch) {
+    // Skip if worktree config extension is not available
+    if (!worktreeConfigManager.isAvailable()) {
+        return;
+    }
+    execFileSync('git', ['config', '--worktree', 'ccmanager.parentBranch', parentBranch], {
+        cwd: worktreePath,
+        encoding: 'utf8',
+    });
+}

package/dist/utils/worktreeUtils.d.ts

@@ -1,5 +1,42 @@
+import { Worktree, Session } from '../types/index.js';
+/**
+ * Worktree item with formatted content for display.
+ */
+interface WorktreeItem {
+    worktree: Worktree;
+    session?: Session;
+    baseLabel: string;
+    fileChanges: string;
+    aheadBehind: string;
+    parentBranch: string;
+    error?: string;
+    lengths: {
+        base: number;
+        fileChanges: number;
+        aheadBehind: number;
+        parentBranch: number;
+    };
+}
+export declare function truncateString(str: string, maxLength: number): string;
 export declare function generateWorktreeDirectory(branchName: string, pattern?: string): string;
 export declare function extractBranchParts(branchName: string): {
     prefix?: string;
     name: string;
 };
+/**
+ * Prepares worktree content for display with plain and colored versions.
+ */
+export declare function prepareWorktreeItems(worktrees: Worktree[], sessions: Session[]): WorktreeItem[];
+/**
+ * Calculates column positions based on content widths.
+ */
+export declare function calculateColumnPositions(items: WorktreeItem[]): {
+    fileChanges: number;
+    aheadBehind: number;
+    parentBranch: number;
+};
+/**
+ * Assembles the final worktree label with proper column alignment
+ */
+export declare function assembleWorktreeLabel(item: WorktreeItem, columns: ReturnType<typeof calculateColumnPositions>): string;
+export {};

package/dist/utils/worktreeUtils.js

@@ -1,4 +1,17 @@
 import path from 'path';
+import { getStatusDisplay } from '../constants/statusIcons.js';
+import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from './gitStatus.js';
+// Constants
+const MAX_BRANCH_NAME_LENGTH = 40; // Maximum characters for branch name display
+const MIN_COLUMN_PADDING = 2; // Minimum spaces between columns
+// Strip ANSI escape codes for length calculation
+const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
+// Utility function to truncate strings with ellipsis
+export function truncateString(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength - 3) + '...';
+}
 export function generateWorktreeDirectory(branchName, pattern) {
     // Default pattern if not specified
     const defaultPattern = '../{branch}';
@@ -27,3 +40,104 @@ export function extractBranchParts(branchName) {
     }
     return { name: branchName };
 }
+/**
+ * Prepares worktree content for display with plain and colored versions.
+ */
+export function prepareWorktreeItems(worktrees, sessions) {
+    return worktrees.map(wt => {
+        const session = sessions.find(s => s.worktreePath === wt.path);
+        const status = session ? ` [${getStatusDisplay(session.state)}]` : '';
+        const fullBranchName = wt.branch
+            ? wt.branch.replace('refs/heads/', '')
+            : 'detached';
+        const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
+        const isMain = wt.isMainWorktree ? ' (main)' : '';
+        const baseLabel = `${branchName}${isMain}${status}`;
+        let fileChanges = '';
+        let aheadBehind = '';
+        let parentBranch = '';
+        let error = '';
+        if (wt.gitStatus) {
+            fileChanges = formatGitFileChanges(wt.gitStatus);
+            aheadBehind = formatGitAheadBehind(wt.gitStatus);
+            parentBranch = formatParentBranch(wt.gitStatus.parentBranch, fullBranchName);
+        }
+        else if (wt.gitStatusError) {
+            // Format error in red
+            error = `\x1b[31m[git error]\x1b[0m`;
+        }
+        else {
+            // Show fetching status in dim gray
+            fileChanges = '\x1b[90m[fetching...]\x1b[0m';
+        }
+        return {
+            worktree: wt,
+            session,
+            baseLabel,
+            fileChanges,
+            aheadBehind,
+            parentBranch,
+            error,
+            lengths: {
+                base: stripAnsi(baseLabel).length,
+                fileChanges: stripAnsi(fileChanges).length,
+                aheadBehind: stripAnsi(aheadBehind).length,
+                parentBranch: stripAnsi(parentBranch).length,
+            },
+        };
+    });
+}
+/**
+ * Calculates column positions based on content widths.
+ */
+export function calculateColumnPositions(items) {
+    // Calculate maximum widths from pre-calculated lengths
+    let maxBranchLength = 0;
+    let maxFileChangesLength = 0;
+    let maxAheadBehindLength = 0;
+    items.forEach(item => {
+        // Skip items with errors for alignment calculation
+        if (item.error)
+            return;
+        maxBranchLength = Math.max(maxBranchLength, item.lengths.base);
+        maxFileChangesLength = Math.max(maxFileChangesLength, item.lengths.fileChanges);
+        maxAheadBehindLength = Math.max(maxAheadBehindLength, item.lengths.aheadBehind);
+    });
+    // Simple column positioning
+    const fileChangesColumn = maxBranchLength + MIN_COLUMN_PADDING;
+    const aheadBehindColumn = fileChangesColumn + maxFileChangesLength + MIN_COLUMN_PADDING + 2;
+    const parentBranchColumn = aheadBehindColumn + maxAheadBehindLength + MIN_COLUMN_PADDING + 2;
+    return {
+        fileChanges: fileChangesColumn,
+        aheadBehind: aheadBehindColumn,
+        parentBranch: parentBranchColumn,
+    };
+}
+// Pad string to column position
+function padTo(str, visibleLength, column) {
+    return str + ' '.repeat(Math.max(0, column - visibleLength));
+}
+/**
+ * Assembles the final worktree label with proper column alignment
+ */
+export function assembleWorktreeLabel(item, columns) {
+    // If there's an error, just show the base label with error appended
+    if (item.error) {
+        return `${item.baseLabel} ${item.error}`;
+    }
+    let label = item.baseLabel;
+    let currentLength = item.lengths.base;
+    if (item.fileChanges) {
+        label = padTo(label, currentLength, columns.fileChanges) + item.fileChanges;
+        currentLength = columns.fileChanges + item.lengths.fileChanges;
+    }
+    if (item.aheadBehind) {
+        label = padTo(label, currentLength, columns.aheadBehind) + item.aheadBehind;
+        currentLength = columns.aheadBehind + item.lengths.aheadBehind;
+    }
+    if (item.parentBranch) {
+        label =
+            padTo(label, currentLength, columns.parentBranch) + item.parentBranch;
+    }
+    return label;
+}