ccmanager 0.1.0 → 0.1.2

package/dist/services/sessionManager.integration.test.js

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+// Create mock pty process
+const createMockPtyProcess = () => {
+    const handlers = {
+        data: [],
+        exit: [],
+    };
+    return {
+        write: vi.fn(),
+        resize: vi.fn(),
+        onData: vi.fn((handler) => {
+            handlers.data.push(handler);
+        }),
+        onExit: vi.fn((handler) => {
+            handlers.exit.push(handler);
+        }),
+        kill: vi.fn(),
+        _emit: (event, ...args) => {
+            if (event === 'data' && handlers.data.length > 0) {
+                handlers.data.forEach(h => h(args[0]));
+            }
+            else if (event === 'exit' && handlers.exit.length > 0) {
+                handlers.exit.forEach(h => h(args[0]));
+            }
+        },
+    };
+};
+// Mock node-pty
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
+// Mock @xterm/headless
+vi.mock('@xterm/headless', () => ({
+    default: {
+        Terminal: vi.fn().mockImplementation(() => ({
+            buffer: {
+                active: {
+                    length: 10,
+                    cursorY: 0,
+                    cursorX: 0,
+                    getLine: vi.fn(),
+                },
+            },
+            write: vi.fn(),
+            resize: vi.fn(),
+            clear: vi.fn(),
+            onData: vi.fn(),
+        })),
+    },
+}));
+describe('SessionManager - Partial TUI Update Integration', () => {
+    let sessionManager;
+    const mockWorktreePath = '/test/worktree';
+    beforeEach(() => {
+        sessionManager = new SessionManager();
+        vi.clearAllMocks();
+    });
+    it('should not accumulate duplicate content in output history', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        // Create a session
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        expect(session).toBeDefined();
+        // Simulate multiple partial updates from Claude Code
+        const updates = [
+            '+ Exploring... (10s ・ 53 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 57 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 76 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 89 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 102 tokens ・ esc to interrupt)\r',
+        ];
+        // Process each update
+        updates.forEach(update => {
+            // Simulate PTY data event
+            mockProcess._emit('data', update);
+        });
+        // Check that the virtual terminal received all updates
+        expect(session.terminal.write).toHaveBeenCalledTimes(5);
+        // The outputHistory should be empty since we removed that functionality
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should use virtual terminal buffer for session restoration', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Mock the terminal buffer to contain the final state
+        // Type cast is acceptable for test mocks
+        const mockTerminal = session.terminal;
+        mockTerminal.buffer.active.getLine = vi.fn((index) => {
+            const lines = [
+                'Welcome to Claude Code',
+                '+ Exploring... (10s ・ 218 tokens ・ esc to interrupt)',
+                '',
+                'Task completed successfully',
+                '> ',
+            ];
+            if (index < lines.length) {
+                return {
+                    translateToString: () => lines[index],
+                };
+            }
+            return null;
+        });
+        mockTerminal.buffer.active.length = 5;
+        mockTerminal.buffer.active.cursorY = 4;
+        mockTerminal.buffer.active.cursorX = 2;
+        // Emit restore event
+        sessionManager.emit('sessionRestore', session);
+        // The terminal buffer should be used for restoration, not output history
+        // This prevents duplicate content issues
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should handle ANSI escape sequences correctly in virtual terminal', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Simulate data with ANSI escape sequences
+        const dataWithEscapes = [
+            'Line 1\n',
+            'Line 2\n',
+            '\x1B[1A\x1B[KReplaced Line 2\n', // Move up one line, clear line, write new text
+            '\x1B[2J\x1B[H', // Clear screen and move to home
+            'Fresh start\n',
+        ];
+        dataWithEscapes.forEach(data => {
+            mockProcess._emit('data', data);
+        });
+        // Virtual terminal should handle all the escape sequences
+        expect(session.terminal.write).toHaveBeenCalledTimes(5);
+        // No raw output should be stored
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should emit sessionData events for active sessions only', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        const dataHandler = vi.fn();
+        sessionManager.on('sessionData', dataHandler);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Session is not active by default
+        mockProcess._emit('data', 'Test data 1');
+        // Should not emit data when inactive
+        expect(dataHandler).not.toHaveBeenCalled();
+        // Activate session
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Now data should be emitted
+        mockProcess._emit('data', 'Test data 2');
+        expect(dataHandler).toHaveBeenCalledWith(session, 'Test data 2');
+    });
+    it('should restore session without replaying output history', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        const restoreHandler = vi.fn();
+        sessionManager.on('sessionRestore', restoreHandler);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Add some data to the session
+        mockProcess._emit('data', 'Old output that should not be replayed\n');
+        mockProcess._emit('data', 'More old output\n');
+        // Deactivate then reactivate session
+        sessionManager.setSessionActive(mockWorktreePath, false);
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Should emit restore event
+        expect(restoreHandler).toHaveBeenCalledWith(session);
+        // But should not have any output history to replay
+        expect(session.outputHistory).toEqual([]);
+    });
+});

package/dist/services/sessionManager.js

@@ -1,6 +1,9 @@
 import { spawn } from 'node-pty';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
+import { exec } from 'child_process';
+import { configurationManager } from './configurationManager.js';
+import { WorktreeService } from './worktreeService.js';
 const { Terminal } = pkg;
 export class SessionManager extends EventEmitter {
     stripAnsi(str) {
@@ -101,7 +104,7 @@ export class SessionManager extends EventEmitter {
             process: ptyProcess,
             state: 'busy', // Session starts as busy when created
             output: [],
-            outputHistory: [],
+            outputHistory: [], // Kept for backward compatibility but no longer used
             lastActivity: new Date(),
             isActive: false,
             terminal,
@@ -115,20 +118,10 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {
-            // Write data to virtual terminal
+            // Write data to virtual terminal - this maintains the proper rendered state
             session.terminal.write(data);
-            // Store in output history as Buffer
-            const buffer = Buffer.from(data, 'utf8');
-            session.outputHistory.push(buffer);
-            // Limit memory usage - keep max 10MB of output history
-            const MAX_HISTORY_SIZE = 10 * 1024 * 1024; // 10MB
-            let totalSize = session.outputHistory.reduce((sum, buf) => sum + buf.length, 0);
-            while (totalSize > MAX_HISTORY_SIZE && session.outputHistory.length > 0) {
-                const removed = session.outputHistory.shift();
-                if (removed) {
-                    totalSize -= removed.length;
-                }
-            }
+            // We no longer need to maintain outputHistory since we use the virtual terminal buffer
+            // This prevents duplicate content issues and reduces memory usage
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
@@ -141,6 +134,7 @@ export class SessionManager extends EventEmitter {
             const newState = this.detectTerminalState(session.terminal);
             if (newState !== oldState) {
                 session.state = newState;
+                this.executeStatusHook(oldState, newState, session);
                 this.emit('sessionStateChanged', session);
             }
         }, 100); // Check every 100ms
@@ -163,8 +157,9 @@ export class SessionManager extends EventEmitter {
         const session = this.sessions.get(worktreePath);
         if (session) {
             session.isActive = active;
-            // If becoming active, emit a restore event with the output history
-            if (active && session.outputHistory.length > 0) {
+            // If becoming active, emit a restore event
+            // The Session component will use the virtual terminal buffer instead of outputHistory
+            if (active) {
                 this.emit('sessionRestore', session);
             }
         }
@@ -196,6 +191,36 @@ export class SessionManager extends EventEmitter {
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
+    executeStatusHook(oldState, newState, session) {
+        const statusHooks = configurationManager.getStatusHooks();
+        const hook = statusHooks[newState];
+        if (hook && hook.enabled && hook.command) {
+            // Get branch information
+            const worktreeService = new WorktreeService();
+            const worktrees = worktreeService.getWorktrees();
+            const worktree = worktrees.find(wt => wt.path === session.worktreePath);
+            const branch = worktree?.branch || 'unknown';
+            // Execute the hook command in the session's worktree directory
+            exec(hook.command, {
+                cwd: session.worktreePath,
+                env: {
+                    ...process.env,
+                    CCMANAGER_OLD_STATE: oldState,
+                    CCMANAGER_NEW_STATE: newState,
+                    CCMANAGER_WORKTREE: session.worktreePath,
+                    CCMANAGER_WORKTREE_BRANCH: branch,
+                    CCMANAGER_SESSION_ID: session.id,
+                },
+            }, (error, _stdout, stderr) => {
+                if (error) {
+                    console.error(`Failed to execute ${newState} hook: ${error.message}`);
+                }
+                if (stderr) {
+                    console.error(`Hook stderr: ${stderr}`);
+                }
+            });
+        }
+    }
     destroy() {
         // Clean up all sessions
         for (const worktreePath of this.sessions.keys()) {

package/dist/services/shortcutManager.d.ts

@@ -1,11 +1,8 @@
 import { ShortcutKey, ShortcutConfig } from '../types/index.js';
 import { Key } from 'ink';
 export declare class ShortcutManager {
-    private shortcuts;
-    private configPath;
     private reservedKeys;
     constructor();
-    private loadShortcuts;
     private validateShortcut;
     private isReservedKey;
     saveShortcuts(shortcuts: ShortcutConfig): boolean;

package/dist/services/shortcutManager.js

@@ -1,21 +1,6 @@
-import { DEFAULT_SHORTCUTS, } from '../types/index.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
+import { configurationManager } from './configurationManager.js';
 export class ShortcutManager {
     constructor() {
-        Object.defineProperty(this, "shortcuts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "configPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "reservedKeys", {
             enumerable: true,
             configurable: true,
@@ -27,31 +12,6 @@ export class ShortcutManager {
                 { ctrl: true, key: '[' },
             ]
         });
-        // Use platform-specific config directory
-        const configDir = process.platform === 'win32'
-            ? path.join(process.env['APPDATA'] || os.homedir(), 'ccmanager')
-            : path.join(os.homedir(), '.config', 'ccmanager');
-        this.configPath = path.join(configDir, 'shortcuts.json');
-        this.shortcuts = this.loadShortcuts();
-    }
-    loadShortcuts() {
-        try {
-            if (fs.existsSync(this.configPath)) {
-                const data = fs.readFileSync(this.configPath, 'utf8');
-                const loaded = JSON.parse(data);
-                // Validate loaded shortcuts
-                const validated = {
-                    returnToMenu: this.validateShortcut(loaded.returnToMenu) ||
-                        DEFAULT_SHORTCUTS.returnToMenu,
-                    cancel: this.validateShortcut(loaded.cancel) || DEFAULT_SHORTCUTS.cancel,
-                };
-                return validated;
-            }
-        }
-        catch (error) {
-            console.error('Failed to load shortcuts:', error);
-        }
-        return { ...DEFAULT_SHORTCUTS };
     }
     validateShortcut(shortcut) {
         if (!shortcut || typeof shortcut !== 'object') {
@@ -88,30 +48,21 @@ export class ShortcutManager {
     }
     saveShortcuts(shortcuts) {
         // Validate all shortcuts
+        const currentShortcuts = configurationManager.getShortcuts();
         const validated = {
             returnToMenu: this.validateShortcut(shortcuts.returnToMenu) ||
-                this.shortcuts.returnToMenu,
-            cancel: this.validateShortcut(shortcuts.cancel) || this.shortcuts.cancel,
+                currentShortcuts.returnToMenu,
+            cancel: this.validateShortcut(shortcuts.cancel) || currentShortcuts.cancel,
         };
-        try {
-            const dir = path.dirname(this.configPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(this.configPath, JSON.stringify(validated, null, 2));
-            this.shortcuts = validated;
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to save shortcuts:', error);
-            return false;
-        }
+        configurationManager.setShortcuts(validated);
+        return true;
     }
     getShortcuts() {
-        return { ...this.shortcuts };
+        return configurationManager.getShortcuts();
     }
     matchesShortcut(shortcutName, input, key) {
-        const shortcut = this.shortcuts[shortcutName];
+        const shortcuts = configurationManager.getShortcuts();
+        const shortcut = shortcuts[shortcutName];
         if (!shortcut)
             return false;
         // Handle escape key specially
@@ -129,7 +80,8 @@ export class ShortcutManager {
         return input.toLowerCase() === shortcut.key.toLowerCase();
     }
     getShortcutDisplay(shortcutName) {
-        const shortcut = this.shortcuts[shortcutName];
+        const shortcuts = configurationManager.getShortcuts();
+        const shortcut = shortcuts[shortcutName];
         if (!shortcut)
             return '';
         const parts = [];

package/dist/services/worktreeService.js

@@ -32,7 +32,12 @@ export class WorktreeService {
                     };
                 }
                 else if (line.startsWith('branch ')) {
-                    currentWorktree.branch = line.substring(7);
+                    let branch = line.substring(7);
+                    // Remove refs/heads/ prefix if present
+                    if (branch.startsWith('refs/heads/')) {
+                        branch = branch.substring(11);
+                    }
+                    currentWorktree.branch = branch;
                 }
                 else if (line === 'bare') {
                     currentWorktree.isMainWorktree = true;

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
 import { IPty } from 'node-pty';
+import type pkg from '@xterm/headless';
+export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
 export interface Worktree {
     path: string;
@@ -15,7 +17,7 @@ export interface Session {
     outputHistory: Buffer[];
     lastActivity: Date;
     isActive: boolean;
-    terminal: any;
+    terminal: Terminal;
     stateCheckInterval?: NodeJS.Timeout;
 }
 export interface SessionManager {
@@ -36,3 +38,16 @@ export interface ShortcutConfig {
     cancel: ShortcutKey;
 }
 export declare const DEFAULT_SHORTCUTS: ShortcutConfig;
+export interface StatusHook {
+    command: string;
+    enabled: boolean;
+}
+export interface StatusHookConfig {
+    idle?: StatusHook;
+    busy?: StatusHook;
+    waiting_input?: StatusHook;
+}
+export interface ConfigurationData {
+    shortcuts?: ShortcutConfig;
+    statusHooks?: StatusHookConfig;
+}

package/dist/utils/terminalSerializer.d.ts

@@ -0,0 +1,119 @@
+import type { Terminal } from '../types/index.js';
+/**
+ * TerminalSerializer: Converts terminal screen content to text while preserving colors and formatting.
+ *
+ * Imagine taking a screenshot of your terminal, but instead of an image, you get text that
+ * can recreate the exact same appearance with all colors and styles when displayed again.
+ */
+export declare class TerminalSerializer {
+    /**
+     * ESC: The "magic" prefix that tells the terminal "the next characters are instructions, not text"
+     * '\x1b[' is like saying "Hey terminal, listen up for special commands!"
+     */
+    private static readonly ESC;
+    /**
+     * RESET: The command that tells terminal "go back to normal text" (no colors, no bold, etc.)
+     * Like clicking "clear formatting" in a word processor
+     */
+    private static readonly RESET;
+    /**
+     * Determines which color system is being used for a given color value.
+     *
+     * Terminal supports different color systems:
+     * - Mode 0 (DEFAULT): Basic terminal colors (like white text on black background)
+     * - Mode 1 (P16): 16 basic colors (8 normal + 8 bright versions)
+     * - Mode 2 (P256): 256 colors (used for more variety)
+     * - Mode 3 (RGB): True color with Red, Green, Blue values (16.7 million colors)
+     *
+     * @param colorValue - The packed color information from the terminal
+     * @returns 0, 1, 2, or 3 indicating which color system to use
+     */
+    private static getColorMode;
+    /**
+     * Extracts the actual color value from the packed color information.
+     *
+     * The extraction method depends on the color mode:
+     * - For RGB mode: Extracts all three color components (R, G, B)
+     * - For palette modes: Extracts just the color index number
+     *
+     * Think of it like unpacking a suitcase - different items are packed differently
+     *
+     * @param colorValue - The packed color information from the terminal
+     * @returns The actual color value (either RGB values or palette index)
+     */
+    private static extractColor;
+    /**
+     * Converts a color value into the special text codes that terminals understand.
+     *
+     * Terminals use "ANSI escape sequences" - special character combinations that control
+     * how text appears. It's like HTML tags, but for terminals.
+     *
+     * Examples of what this function produces:
+     * - Red text: "\x1b[31m" (tells terminal "make the following text red")
+     * - Blue background: "\x1b[44m" (tells terminal "make the background blue")
+     * - RGB color: "\x1b[38;2;255;128;0m" (orange text using RGB values)
+     *
+     * @param colorValue - The color to convert (packed number with mode and color data)
+     * @param isBackground - true for background color, false for text color
+     * @returns ANSI escape sequence string that terminals can interpret
+     */
+    private static colorToAnsi;
+    /**
+     * Converts a single line of terminal content into text with color/style codes.
+     *
+     * This function processes each character in a line and:
+     * 1. Extracts the character itself
+     * 2. Checks its color (text and background)
+     * 3. Checks its style (bold, italic, underline, etc.)
+     * 4. Adds the necessary codes to recreate that appearance
+     *
+     * It's like going through a line character by character and noting:
+     * "This letter is red, this one is bold, this one has blue background..."
+     *
+     * @param line - One line from the terminal screen
+     * @param cols - Number of columns (width) of the terminal
+     * @param trimRight - Whether to remove trailing spaces (like right-trim in text editors)
+     * @returns The line as text with embedded color/style codes
+     */
+    private static serializeLine;
+    /**
+     * Converts the entire terminal screen (or part of it) into text with colors preserved.
+     *
+     * This is the main function that processes multiple lines of terminal content.
+     * It's like taking a "text screenshot" of your terminal that can be replayed later
+     * with all the colors and formatting intact.
+     *
+     * @param terminal - The terminal object containing the screen buffer
+     * @param options - Configuration options:
+     *   - startLine: First line to include (default: 0, the top)
+     *   - endLine: Last line to include (default: bottom of screen)
+     *   - trimRight: Remove trailing spaces from each line (default: true)
+     *   - includeEmptyLines: Keep blank lines in output (default: true)
+     * @returns Multi-line string with embedded ANSI codes for colors/styles
+     */
+    static serialize(terminal: Terminal, options?: {
+        startLine?: number;
+        endLine?: number;
+        trimRight?: boolean;
+        includeEmptyLines?: boolean;
+    }): string;
+    /**
+     * Convenience function to get just the last few lines from the terminal.
+     *
+     * Useful when you only need recent output, like:
+     * - Getting the last error message
+     * - Showing recent command output
+     * - Displaying the current prompt
+     *
+     * Example: getLastLines(terminal, 10) gets the last 10 lines
+     *
+     * @param terminal - The terminal object containing the screen buffer
+     * @param lineCount - How many lines from the bottom to include
+     * @param options - Same options as serialize() for controlling output format
+     * @returns The requested lines as text with color/style codes
+     */
+    static getLastLines(terminal: Terminal, lineCount: number, options?: {
+        trimRight?: boolean;
+        includeEmptyLines?: boolean;
+    }): string;
+}