ccmanager 0.1.15 → 0.2.1

package/dist/services/configurationManager.test.js

@@ -0,0 +1,313 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { ConfigurationManager } from './configurationManager.js';
+// Mock fs module
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+// Mock os module
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/test'),
+}));
+describe('ConfigurationManager - Command Presets', () => {
+    let configManager;
+    let mockConfigData;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Default mock config data
+        mockConfigData = {
+            shortcuts: {
+                returnToMenu: { ctrl: true, key: 'e' },
+                cancel: { key: 'escape' },
+            },
+            command: {
+                command: 'claude',
+                args: ['--existing'],
+            },
+        };
+        // Mock file system operations
+        existsSync.mockImplementation((path) => {
+            return path.includes('config.json');
+        });
+        readFileSync.mockImplementation(() => {
+            return JSON.stringify(mockConfigData);
+        });
+        mkdirSync.mockImplementation(() => { });
+        writeFileSync.mockImplementation(() => { });
+        // Create new instance for each test
+        configManager = new ConfigurationManager();
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('getCommandPresets', () => {
+        it('should return default presets when no presets are configured', () => {
+            // Remove command config for this test
+            delete mockConfigData.command;
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets).toBeDefined();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            expect(presets.defaultPresetId).toBe('1');
+        });
+        it('should return configured presets', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Development', command: 'claude', args: ['--resume'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(2);
+            expect(presets.defaultPresetId).toBe('2');
+        });
+        it('should migrate legacy command config to presets on first access', () => {
+            // Config has legacy command but no presets
+            mockConfigData.command = {
+                command: 'claude',
+                args: ['--resume'],
+                fallbackArgs: ['--no-mcp'],
+            };
+            delete mockConfigData.commandPresets;
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--resume'],
+                fallbackArgs: ['--no-mcp'],
+            });
+            expect(presets.defaultPresetId).toBe('1');
+            // Verify that writeFileSync was called to save the migration
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+    });
+    describe('setCommandPresets', () => {
+        it('should save new presets configuration', () => {
+            const newPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager.setCommandPresets(newPresets);
+            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.stringContaining('commandPresets'));
+        });
+    });
+    describe('getDefaultPreset', () => {
+        it('should return the default preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            const defaultPreset = configManager.getDefaultPreset();
+            expect(defaultPreset).toEqual({
+                id: '2',
+                name: 'Custom',
+                command: 'claude',
+                args: ['--custom'],
+            });
+        });
+        it('should return first preset if defaultPresetId is invalid', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: 'invalid',
+            };
+            configManager = new ConfigurationManager();
+            const defaultPreset = configManager.getDefaultPreset();
+            expect(defaultPreset).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+        });
+    });
+    describe('getPresetById', () => {
+        it('should return preset by id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const preset = configManager.getPresetById('2');
+            expect(preset).toEqual({
+                id: '2',
+                name: 'Custom',
+                command: 'claude',
+                args: ['--custom'],
+            });
+        });
+        it('should return undefined for non-existent id', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const preset = configManager.getPresetById('999');
+            expect(preset).toBeUndefined();
+        });
+    });
+    describe('addPreset', () => {
+        it('should add a new preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const newPreset = {
+                id: '2',
+                name: 'New Preset',
+                command: 'claude',
+                args: ['--new'],
+            };
+            configManager.addPreset(newPreset);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(2);
+            expect(presets.presets[1]).toEqual(newPreset);
+        });
+        it('should replace preset with same id', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const updatedPreset = {
+                id: '1',
+                name: 'Updated Default',
+                command: 'claude',
+                args: ['--updated'],
+            };
+            configManager.addPreset(updatedPreset);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual(updatedPreset);
+        });
+    });
+    describe('deletePreset', () => {
+        it('should delete preset by id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0].id).toBe('1');
+        });
+        it('should not delete the last preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('1');
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+        });
+        it('should update defaultPresetId if default preset is deleted', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('1');
+        });
+    });
+    describe('setDefaultPreset', () => {
+        it('should update default preset id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.setDefaultPreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('2');
+        });
+        it('should not update if preset id does not exist', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.setDefaultPreset('999');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('1');
+        });
+    });
+    describe('backward compatibility', () => {
+        it('should maintain getCommandConfig for backward compatibility', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude', args: ['--resume'] },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const commandConfig = configManager.getCommandConfig();
+            // Should return the default preset as CommandConfig
+            expect(commandConfig).toEqual({
+                command: 'claude',
+                args: ['--resume'],
+            });
+        });
+        it('should update default preset when setCommandConfig is called', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const newConfig = {
+                command: 'claude',
+                args: ['--new-args'],
+                fallbackArgs: ['--new-fallback'],
+            };
+            configManager.setCommandConfig(newConfig);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--new-args'],
+                fallbackArgs: ['--new-fallback'],
+            });
+        });
+    });
+});

package/dist/services/sessionManager.d.ts

@@ -10,6 +10,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     detectTerminalState(terminal: InstanceType<typeof Terminal>): SessionState;
     constructor();
     createSession(worktreePath: string): Promise<Session>;
+    createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
     private setupDataHandler;
     private setupExitHandler;
     private setupBackgroundHandler;

package/dist/services/sessionManager.js

@@ -108,6 +108,75 @@ export class SessionManager extends EventEmitter {
         this.emit('sessionCreated', session);
         return session;
     }
+    async createSessionWithPreset(worktreePath, presetId) {
+        // Check if session already exists
+        const existing = this.sessions.get(worktreePath);
+        if (existing) {
+            return existing;
+        }
+        const id = `session-${Date.now()}-${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
+        // Get preset configuration
+        let preset = presetId ? configurationManager.getPresetById(presetId) : null;
+        if (!preset) {
+            preset = configurationManager.getDefaultPreset();
+        }
+        const command = preset.command;
+        const args = preset.args || [];
+        const commandConfig = {
+            command: preset.command,
+            args: preset.args,
+            fallbackArgs: preset.fallbackArgs,
+        };
+        // Try to spawn the process
+        let ptyProcess;
+        let isPrimaryCommand = true;
+        try {
+            ptyProcess = await this.spawn(command, args, worktreePath);
+        }
+        catch (error) {
+            // If primary command fails and we have fallback args, try them
+            if (preset.fallbackArgs) {
+                try {
+                    ptyProcess = await this.spawn(command, preset.fallbackArgs, worktreePath);
+                    isPrimaryCommand = false;
+                }
+                catch (_fallbackError) {
+                    // Both attempts failed, throw the original error
+                    throw error;
+                }
+            }
+            else {
+                // No fallback args, throw the error
+                throw error;
+            }
+        }
+        // Create virtual terminal for state detection
+        const terminal = new Terminal({
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            allowProposedApi: true,
+        });
+        const session = {
+            id,
+            worktreePath,
+            process: ptyProcess,
+            state: 'busy', // Session starts as busy when created
+            output: [],
+            outputHistory: [],
+            lastActivity: new Date(),
+            isActive: false,
+            terminal,
+            isPrimaryCommand,
+            commandConfig,
+        };
+        // Set up persistent background data handler for state detection
+        this.setupBackgroundHandler(session);
+        this.sessions.set(worktreePath, session);
+        this.emit('sessionCreated', session);
+        return session;
+    }
     setupDataHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {

package/dist/services/sessionManager.test.js

@@ -10,6 +10,8 @@ vi.mock('./configurationManager.js', () => ({
     configurationManager: {
         getCommandConfig: vi.fn(),
         getStatusHooks: vi.fn(() => ({})),
+        getDefaultPreset: vi.fn(),
+        getPresetById: vi.fn(),
     },
 }));
 // Mock Terminal
@@ -257,4 +259,105 @@ describe('SessionManager', () => {
             expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
         });
     });
+    describe('createSession with presets', () => {
+        it('should use default preset when no preset ID specified', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--preset-arg'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with preset
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg'], {
+                name: 'xterm-color',
+                cols: expect.any(Number),
+                rows: expect.any(Number),
+                cwd: '/test/worktree',
+                env: process.env,
+            });
+        });
+        it('should use specific preset when ID provided', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+                id: '2',
+                name: 'Development',
+                command: 'claude',
+                args: ['--resume', '--dev'],
+                fallbackArgs: ['--no-mcp'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with specific preset
+            await sessionManager.createSessionWithPreset('/test/worktree', '2');
+            // Verify getPresetById was called with correct ID
+            expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev'], {
+                name: 'xterm-color',
+                cols: expect.any(Number),
+                rows: expect.any(Number),
+                cwd: '/test/worktree',
+                env: process.env,
+            });
+        });
+        it('should fall back to default preset if specified preset not found', async () => {
+            // Setup mocks
+            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with non-existent preset
+            await sessionManager.createSessionWithPreset('/test/worktree', 'invalid');
+            // Verify fallback to default preset
+            expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
+            expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
+        });
+        it('should try fallback args with preset if main command fails', async () => {
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
+            });
+            // Mock spawn to fail first, succeed second
+            let callCount = 0;
+            vi.mocked(spawn).mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    throw new Error('Command failed');
+                }
+                return mockPty;
+            });
+            // Create session
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify both attempts were made
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(1, 'claude', ['--bad-flag'], expect.any(Object));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--good-flag'], expect.any(Object));
+        });
+        it('should maintain backward compatibility with createSession', async () => {
+            // Setup legacy config
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+                args: ['--legacy'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session using legacy method
+            await sessionManager.createSession('/test/worktree');
+            // Verify legacy method still works
+            expect(spawn).toHaveBeenCalledWith('claude', ['--legacy'], expect.any(Object));
+        });
+    });
 });

package/dist/services/worktreeConfigManager.d.ts

@@ -0,0 +1,10 @@
+declare class WorktreeConfigManager {
+    private static instance;
+    private isExtensionAvailable;
+    private constructor();
+    static getInstance(): WorktreeConfigManager;
+    initialize(gitPath?: string): void;
+    isAvailable(): boolean;
+}
+export declare const worktreeConfigManager: WorktreeConfigManager;
+export {};

package/dist/services/worktreeConfigManager.js

@@ -0,0 +1,27 @@
+import { isWorktreeConfigEnabled } from '../utils/worktreeConfig.js';
+class WorktreeConfigManager {
+    constructor() {
+        Object.defineProperty(this, "isExtensionAvailable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    static getInstance() {
+        if (!WorktreeConfigManager.instance) {
+            WorktreeConfigManager.instance = new WorktreeConfigManager();
+        }
+        return WorktreeConfigManager.instance;
+    }
+    initialize(gitPath) {
+        this.isExtensionAvailable = isWorktreeConfigEnabled(gitPath);
+    }
+    isAvailable() {
+        if (this.isExtensionAvailable === null) {
+            throw new Error('WorktreeConfigManager not initialized');
+        }
+        return this.isExtensionAvailable;
+    }
+}
+export const worktreeConfigManager = WorktreeConfigManager.getInstance();

package/dist/services/worktreeService.js

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import path from 'path';
+import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 export class WorktreeService {
     constructor(rootPath) {
         Object.defineProperty(this, "rootPath", {
@@ -201,6 +202,13 @@ export class WorktreeService {
                 cwd: this.gitRootPath, // Execute from git root to ensure proper resolution
                 encoding: 'utf8',
             });
+            // Store the parent branch in worktree config
+            try {
+                setWorktreeParentBranch(resolvedPath, baseBranch);
+            }
+            catch (error) {
+                console.error('Warning: Failed to set parent branch in worktree config:', error);
+            }
             return { success: true };
         }
         catch (error) {

package/dist/services/worktreeService.test.js

@@ -3,6 +3,14 @@ import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 // Mock child_process module
 vi.mock('child_process');
+// Mock worktreeConfigManager
+vi.mock('./worktreeConfigManager.js', () => ({
+    worktreeConfigManager: {
+        initialize: vi.fn(),
+        isAvailable: vi.fn(() => true),
+        reset: vi.fn(),
+    },
+}));
 // Get the mocked function with proper typing
 const mockedExecSync = vi.mocked(execSync);
 describe('WorktreeService', () => {

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import { IPty } from 'node-pty';
 import type pkg from '@xterm/headless';
+import { GitStatus } from '../utils/gitStatus.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
 export interface Worktree {
@@ -7,6 +8,8 @@ export interface Worktree {
     branch?: string;
     isMainWorktree: boolean;
     hasSession: boolean;
+    gitStatus?: GitStatus;
+    gitStatusError?: string;
 }
 export interface Session {
     id: string;
@@ -58,9 +61,22 @@ export interface CommandConfig {
     args?: string[];
     fallbackArgs?: string[];
 }
+export interface CommandPreset {
+    id: string;
+    name: string;
+    command: string;
+    args?: string[];
+    fallbackArgs?: string[];
+}
+export interface CommandPresetsConfig {
+    presets: CommandPreset[];
+    defaultPresetId: string;
+    selectPresetOnStart?: boolean;
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
     worktree?: WorktreeConfig;
     command?: CommandConfig;
+    commandPresets?: CommandPresetsConfig;
 }

package/dist/utils/concurrencyLimit.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 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>;

package/dist/utils/concurrencyLimit.js

@@ -0,0 +1,30 @@
+/**
+ * Create a function that limits concurrent executions
+ */
+export function createConcurrencyLimited(fn, maxConcurrent) {
+    if (maxConcurrent < 1) {
+        throw new RangeError('maxConcurrent must be at least 1');
+    }
+    let activeCount = 0;
+    const queue = [];
+    return async (...args) => {
+        // Wait for a slot if at capacity
+        if (activeCount >= maxConcurrent) {
+            await new Promise(resolve => {
+                queue.push(resolve);
+            });
+        }
+        activeCount++;
+        try {
+            return await fn(...args);
+        }
+        finally {
+            activeCount--;
+            // Release the next waiter in queue
+            const next = queue.shift();
+            if (next) {
+                next();
+            }
+        }
+    };
+}

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

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