ccmanager 0.2.0 → 0.2.1

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/types/index.d.ts

@@ -61,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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",