ccmanager 0.1.3 → 0.1.5

package/dist/components/Configuration.js

@@ -3,6 +3,7 @@ import { Box, Text } from 'ink';
 import SelectInput from 'ink-select-input';
 import ConfigureShortcuts from './ConfigureShortcuts.js';
 import ConfigureHooks from './ConfigureHooks.js';
+import ConfigureWorktree from './ConfigureWorktree.js';
 const Configuration = ({ onComplete }) => {
     const [view, setView] = useState('menu');
     const menuItems = [
@@ -14,6 +15,10 @@ const Configuration = ({ onComplete }) => {
             label: '🔧  Configure Status Hooks',
             value: 'hooks',
         },
+        {
+            label: '📁  Configure Worktree Settings',
+            value: 'worktree',
+        },
         {
             label: '← Back to Main Menu',
             value: 'back',
@@ -29,6 +34,9 @@ const Configuration = ({ onComplete }) => {
         else if (item.value === 'hooks') {
             setView('hooks');
         }
+        else if (item.value === 'worktree') {
+            setView('worktree');
+        }
     };
     const handleSubMenuComplete = () => {
         setView('menu');
@@ -39,6 +47,9 @@ const Configuration = ({ onComplete }) => {
     if (view === 'hooks') {
         return React.createElement(ConfigureHooks, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'worktree') {
+        return React.createElement(ConfigureWorktree, { onComplete: handleSubMenuComplete });
+    }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configuration")),

package/dist/components/ConfigureWorktree.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureWorktreeProps {
+    onComplete: () => void;
+}
+declare const ConfigureWorktree: React.FC<ConfigureWorktreeProps>;
+export default ConfigureWorktree;

package/dist/components/ConfigureWorktree.js

@@ -0,0 +1,99 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInput from 'ink-text-input';
+import { configurationManager } from '../services/configurationManager.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const ConfigureWorktree = ({ onComplete }) => {
+    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
+    const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
+    const [editMode, setEditMode] = useState('menu');
+    const [tempPattern, setTempPattern] = useState(pattern);
+    useInput((input, key) => {
+        if (editMode === 'menu' &&
+            shortcutManager.matchesShortcut('cancel', input, key)) {
+            onComplete();
+        }
+    });
+    const menuItems = [
+        {
+            label: `Auto Directory: ${autoDirectory ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggle',
+        },
+        {
+            label: `Pattern: ${pattern}`,
+            value: 'pattern',
+        },
+        {
+            label: '💾 Save Changes',
+            value: 'save',
+        },
+        {
+            label: '← Cancel',
+            value: 'cancel',
+        },
+    ];
+    const handleMenuSelect = (item) => {
+        switch (item.value) {
+            case 'toggle':
+                setAutoDirectory(!autoDirectory);
+                break;
+            case 'pattern':
+                setTempPattern(pattern);
+                setEditMode('pattern');
+                break;
+            case 'save':
+                // Save the configuration
+                configurationManager.setWorktreeConfig({
+                    autoDirectory,
+                    autoDirectoryPattern: pattern,
+                });
+                onComplete();
+                break;
+            case 'cancel':
+                onComplete();
+                break;
+        }
+    };
+    const handlePatternSubmit = (value) => {
+        if (value.trim()) {
+            setPattern(value.trim());
+        }
+        setEditMode('menu');
+    };
+    if (editMode === 'pattern') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Configure Directory Pattern")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Enter the pattern for automatic directory generation:")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Available placeholders: ",
+                    '{branch}',
+                    " - full branch name")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: tempPattern, onChange: setTempPattern, onSubmit: handlePatternSubmit, placeholder: "../{branch}" })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to save or Escape to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Settings")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Configure automatic worktree directory generation")),
+        autoDirectory && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null,
+                "Example: branch \"feature/my-feature\" \u2192 directory \"",
+                pattern.replace('{branch}', 'feature-my-feature'),
+                "\""))),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleMenuSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel without saving"))));
+};
+export default ConfigureWorktree;

package/dist/components/NewWorktree.js

@@ -1,11 +1,17 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { configurationManager } from '../services/configurationManager.js';
+import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 const NewWorktree = ({ onComplete, onCancel }) => {
-    const [step, setStep] = useState('path');
+    const worktreeConfig = configurationManager.getWorktreeConfig();
+    const isAutoDirectory = worktreeConfig.autoDirectory;
+    // Adjust initial step based on auto directory mode
+    const [step, setStep] = useState(isAutoDirectory ? 'branch' : 'path');
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
+    const [generatedPath, setGeneratedPath] = useState('');
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
@@ -20,18 +26,32 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const handleBranchSubmit = (value) => {
         if (value.trim()) {
             setBranch(value.trim());
-            onComplete(path, value.trim());
+            if (isAutoDirectory) {
+                // Generate path from branch name
+                const autoPath = generateWorktreeDirectory(value.trim(), worktreeConfig.autoDirectoryPattern);
+                onComplete(autoPath, value.trim());
+            }
+            else {
+                onComplete(path, value.trim());
+            }
         }
     };
+    // Update generated path preview when branch changes in auto mode
+    useEffect(() => {
+        if (isAutoDirectory && branch) {
+            const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
+            setGeneratedPath(autoPath);
+        }
+    }, [branch, isAutoDirectory, worktreeConfig.autoDirectoryPattern]);
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Create New Worktree")),
-        step === 'path' ? (React.createElement(Box, { flexDirection: "column" },
+        step === 'path' && !isAutoDirectory ? (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Enter worktree path (relative to repository root):")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInput, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(TextInput, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : step === 'branch' && !isAutoDirectory ? (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,
                     "Enter branch name for worktree at ",
@@ -39,7 +59,17 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     ":")),
             React.createElement(Box, null,
                 React.createElement(Text, { color: "cyan" }, '> '),
-                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))),
+                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))) : (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Enter branch name (directory will be auto-generated):")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })),
+            generatedPath && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Worktree will be created at:",
+                    ' ',
+                    React.createElement(Text, { color: "green" }, generatedPath)))))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

package/dist/components/Session.js

@@ -1,7 +1,6 @@
 import { useEffect, useState } from 'react';
 import { useStdout } from 'ink';
 import { shortcutManager } from '../services/shortcutManager.js';
-import { TerminalSerializer } from '../utils/terminalSerializer.js';
 const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     const { stdout } = useStdout();
     const [isExiting, setIsExiting] = useState(false);
@@ -13,24 +12,24 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // Handle session restoration
         const handleSessionRestore = (restoredSession) => {
             if (restoredSession.id === session.id) {
-                // Instead of replaying all history, use the virtual terminal's current buffer
-                // This avoids duplicate content issues
-                const terminal = restoredSession.terminal;
-                if (terminal) {
-                    // Use the TerminalSerializer to preserve ANSI escape sequences (colors, styles)
-                    const serializedOutput = TerminalSerializer.serialize(terminal, {
-                        trimRight: true,
-                        includeEmptyLines: true,
-                    });
-                    // Write the serialized terminal state with preserved formatting
-                    if (serializedOutput) {
-                        stdout.write(serializedOutput);
-                        // Position cursor at the correct location
-                        const buffer = terminal.buffer.active;
-                        const cursorY = buffer.cursorY;
-                        const cursorX = buffer.cursorX;
-                        // Move cursor to the saved position
-                        stdout.write(`\x1B[${cursorY + 1};${cursorX + 1}H`);
+                // Replay all buffered output, but skip the initial clear if present
+                for (let i = 0; i < restoredSession.outputHistory.length; i++) {
+                    const buffer = restoredSession.outputHistory[i];
+                    if (!buffer)
+                        continue;
+                    const str = buffer.toString('utf8');
+                    // Skip clear screen sequences at the beginning
+                    if (i === 0 && (str.includes('\x1B[2J') || str.includes('\x1B[H'))) {
+                        // Skip this buffer or remove the clear sequence
+                        const cleaned = str
+                            .replace(/\x1B\[2J/g, '')
+                            .replace(/\x1B\[H/g, '');
+                        if (cleaned.length > 0) {
+                            stdout.write(Buffer.from(cleaned, 'utf8'));
+                        }
+                    }
+                    else {
+                        stdout.write(buffer);
                     }
                 }
             }

package/dist/services/configurationManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, ShortcutConfig } from '../types/index.js';
+import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig } from '../types/index.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -13,5 +13,7 @@ export declare class ConfigurationManager {
     setStatusHooks(hooks: StatusHookConfig): void;
     getConfiguration(): ConfigurationData;
     setConfiguration(config: ConfigurationData): void;
+    getWorktreeConfig(): WorktreeConfig;
+    setWorktreeConfig(worktreeConfig: WorktreeConfig): void;
 }
 export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -63,6 +63,11 @@ export class ConfigurationManager {
         if (!this.config.statusHooks) {
             this.config.statusHooks = {};
         }
+        if (!this.config.worktree) {
+            this.config.worktree = {
+                autoDirectory: false,
+            };
+        }
     }
     migrateLegacyShortcuts() {
         if (existsSync(this.legacyShortcutsPath)) {
@@ -111,5 +116,14 @@ export class ConfigurationManager {
         this.config = config;
         this.saveConfig();
     }
+    getWorktreeConfig() {
+        return (this.config.worktree || {
+            autoDirectory: false,
+        });
+    }
+    setWorktreeConfig(worktreeConfig) {
+        this.config.worktree = worktreeConfig;
+        this.saveConfig();
+    }
 }
 export const configurationManager = new ConfigurationManager();

package/dist/services/sessionManager.js

@@ -104,7 +104,7 @@ export class SessionManager extends EventEmitter {
             process: ptyProcess,
             state: 'busy', // Session starts as busy when created
             output: [],
-            outputHistory: [], // Kept for backward compatibility but no longer used
+            outputHistory: [],
             lastActivity: new Date(),
             isActive: false,
             terminal,
@@ -118,10 +118,20 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {
-            // Write data to virtual terminal - this maintains the proper rendered state
+            // Write data to virtual terminal
             session.terminal.write(data);
-            // We no longer need to maintain outputHistory since we use the virtual terminal buffer
-            // This prevents duplicate content issues and reduces memory usage
+            // 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;
+                }
+            }
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
@@ -157,9 +167,8 @@ export class SessionManager extends EventEmitter {
         const session = this.sessions.get(worktreePath);
         if (session) {
             session.isActive = active;
-            // If becoming active, emit a restore event
-            // The Session component will use the virtual terminal buffer instead of outputHistory
-            if (active) {
+            // If becoming active, emit a restore event with the output history
+            if (active && session.outputHistory.length > 0) {
                 this.emit('sessionRestore', session);
             }
         }

package/dist/services/worktreeService.js

@@ -179,6 +179,11 @@ export class WorktreeService {
                     cwd: sourceWorktree.path,
                     encoding: 'utf8',
                 });
+                // After rebase, merge the rebased source branch into target branch
+                execSync(`git merge --ff-only "${sourceBranch}"`, {
+                    cwd: targetWorktree.path,
+                    encoding: 'utf8',
+                });
             }
             else {
                 // Regular merge

package/dist/types/index.d.ts

@@ -47,7 +47,12 @@ export interface StatusHookConfig {
     busy?: StatusHook;
     waiting_input?: StatusHook;
 }
+export interface WorktreeConfig {
+    autoDirectory: boolean;
+    autoDirectoryPattern?: string;
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
+    worktree?: WorktreeConfig;
 }

package/dist/utils/worktreeUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function generateWorktreeDirectory(branchName: string, pattern?: string): string;
+export declare function extractBranchParts(branchName: string): {
+    prefix?: string;
+    name: string;
+};

package/dist/utils/worktreeUtils.js

@@ -0,0 +1,29 @@
+import path from 'path';
+export function generateWorktreeDirectory(branchName, pattern) {
+    // Default pattern if not specified
+    const defaultPattern = '../{branch}';
+    const activePattern = pattern || defaultPattern;
+    // Sanitize branch name for filesystem
+    // Replace slashes with dashes, remove special characters
+    const sanitizedBranch = branchName
+        .replace(/\//g, '-') // Replace forward slashes with dashes
+        .replace(/[^a-zA-Z0-9-_.]/g, '') // Remove special characters except dash, dot, underscore
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing dashes
+        .toLowerCase(); // Convert to lowercase for consistency
+    // Replace placeholders in pattern
+    const directory = activePattern
+        .replace('{branch}', sanitizedBranch)
+        .replace('{branch-name}', sanitizedBranch);
+    // Ensure the path is relative to the repository root
+    return path.normalize(directory);
+}
+export function extractBranchParts(branchName) {
+    const parts = branchName.split('/');
+    if (parts.length > 1) {
+        return {
+            prefix: parts[0],
+            name: parts.slice(1).join('/'),
+        };
+    }
+    return { name: branchName };
+}

package/dist/utils/worktreeUtils.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { generateWorktreeDirectory, extractBranchParts, } from './worktreeUtils.js';
+describe('generateWorktreeDirectory', () => {
+    describe('with default pattern', () => {
+        it('should generate directory with sanitized branch name', () => {
+            expect(generateWorktreeDirectory('feature/my-feature')).toBe('../feature-my-feature');
+            expect(generateWorktreeDirectory('bugfix/fix-123')).toBe('../bugfix-fix-123');
+            expect(generateWorktreeDirectory('release/v1.0.0')).toBe('../release-v1.0.0');
+        });
+        it('should handle branch names without slashes', () => {
+            expect(generateWorktreeDirectory('main')).toBe('../main');
+            expect(generateWorktreeDirectory('develop')).toBe('../develop');
+            expect(generateWorktreeDirectory('my-feature')).toBe('../my-feature');
+        });
+        it('should remove special characters', () => {
+            expect(generateWorktreeDirectory('feature/my@feature!')).toBe('../feature-myfeature');
+            expect(generateWorktreeDirectory('bugfix/#123')).toBe('../bugfix-123');
+            expect(generateWorktreeDirectory('release/v1.0.0-beta')).toBe('../release-v1.0.0-beta');
+        });
+        it('should handle edge cases', () => {
+            expect(generateWorktreeDirectory('//feature//')).toBe('../feature');
+            expect(generateWorktreeDirectory('-feature-')).toBe('../feature');
+            expect(generateWorktreeDirectory('FEATURE/UPPERCASE')).toBe('../feature-uppercase');
+        });
+    });
+    describe('with custom patterns', () => {
+        it('should use custom pattern with {branch} placeholder', () => {
+            expect(generateWorktreeDirectory('feature/my-feature', '../worktrees/{branch}')).toBe('../worktrees/feature-my-feature');
+            expect(generateWorktreeDirectory('bugfix/123', '/tmp/{branch}-wt')).toBe('/tmp/bugfix-123-wt');
+        });
+        it('should handle patterns without placeholders', () => {
+            expect(generateWorktreeDirectory('feature/test', '../fixed-directory')).toBe('../fixed-directory');
+        });
+        it('should normalize paths', () => {
+            expect(generateWorktreeDirectory('feature/test', '../foo/../bar/{branch}')).toBe('../bar/feature-test');
+            expect(generateWorktreeDirectory('feature/test', './worktrees/{branch}')).toBe('worktrees/feature-test');
+        });
+    });
+});
+describe('extractBranchParts', () => {
+    it('should extract prefix and name from branch with slash', () => {
+        expect(extractBranchParts('feature/my-feature')).toEqual({
+            prefix: 'feature',
+            name: 'my-feature',
+        });
+        expect(extractBranchParts('bugfix/fix-123')).toEqual({
+            prefix: 'bugfix',
+            name: 'fix-123',
+        });
+    });
+    it('should handle branches with multiple slashes', () => {
+        expect(extractBranchParts('feature/user/profile-page')).toEqual({
+            prefix: 'feature',
+            name: 'user/profile-page',
+        });
+        expect(extractBranchParts('release/v1.0/final')).toEqual({
+            prefix: 'release',
+            name: 'v1.0/final',
+        });
+    });
+    it('should handle branches without slashes', () => {
+        expect(extractBranchParts('main')).toEqual({
+            name: 'main',
+        });
+        expect(extractBranchParts('develop')).toEqual({
+            name: 'develop',
+        });
+    });
+    it('should handle empty branch name', () => {
+        expect(extractBranchParts('')).toEqual({
+            name: '',
+        });
+    });
+});

package/package.json

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

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

@@ -1,142 +0,0 @@
-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(),
-}));
-// Don't mock @xterm/headless - let it use the real implementation
-// since we need actual terminal functionality for color testing
-describe('SessionManager - Color Restoration', () => {
-    let sessionManager;
-    const mockWorktreePath = '/test/worktree';
-    beforeEach(() => {
-        sessionManager = new SessionManager();
-        vi.clearAllMocks();
-    });
-    it('should preserve ANSI colors when switching between sessions', async () => {
-        // Create a mock PTY process
-        const mockProcess = createMockPtyProcess();
-        vi.mocked(spawn).mockReturnValue(mockProcess);
-        sessionManager.createSession(mockWorktreePath);
-        const session = sessionManager.sessions.get(mockWorktreePath);
-        expect(session).toBeDefined();
-        // Simulate colorful output from Claude Code
-        const colorfulData = [
-            '\x1b[32m✓\x1b[0m File created successfully\n',
-            '\x1b[1;34mRunning tests...\x1b[0m\n',
-            '\x1b[38;5;196mError:\x1b[0m Test failed\n',
-            '\x1b[38;2;255;165;0mWarning:\x1b[0m Deprecated API\n',
-        ];
-        // Activate session first
-        sessionManager.setSessionActive(mockWorktreePath, true);
-        // Send colored data to the terminal
-        for (const data of colorfulData) {
-            mockProcess._emit('data', data);
-            // Wait for terminal to process the data
-            await new Promise(resolve => setTimeout(resolve, 10));
-        }
-        // Deactivate session
-        sessionManager.setSessionActive(mockWorktreePath, false);
-        // Set up listener to capture restore event
-        let restoredContent = null;
-        sessionManager.on('sessionRestore', restoredSession => {
-            // In real usage, the Session component would use TerminalSerializer here
-            // For this test, we'll verify the terminal buffer contains the data
-            const terminal = restoredSession.terminal;
-            if (terminal) {
-                // Access the terminal buffer to verify colors are preserved
-                const buffer = terminal.buffer.active;
-                restoredContent = '';
-                // Simple check: verify buffer has content
-                for (let i = 0; i < buffer.length; i++) {
-                    const line = buffer.getLine(i);
-                    if (line) {
-                        // Check if line has colored cells
-                        for (let x = 0; x < terminal.cols; x++) {
-                            const cell = line.getCell(x);
-                            if (cell && cell.getChars()) {
-                                const fgColorMode = cell.getFgColorMode();
-                                const bgColorMode = cell.getBgColorMode();
-                                // If any cell has non-default color, we know colors are preserved
-                                if (fgColorMode !== 0 || bgColorMode !== 0) {
-                                    restoredContent = 'has-colors';
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        // Reactivate session (simulating switching back)
-        sessionManager.setSessionActive(mockWorktreePath, true);
-        // Verify that colors were preserved in the terminal buffer
-        expect(restoredContent).toBe('has-colors');
-    });
-    it('should handle complex color sequences during restoration', async () => {
-        // Create a mock PTY process
-        const mockProcess = createMockPtyProcess();
-        vi.mocked(spawn).mockReturnValue(mockProcess);
-        sessionManager.createSession(mockWorktreePath);
-        const session = sessionManager.sessions.get(mockWorktreePath);
-        // Activate session
-        sessionManager.setSessionActive(mockWorktreePath, true);
-        // Send a complex sequence with cursor movements and color changes
-        const complexSequence = [
-            'Line 1: Normal text\n',
-            '\x1b[32mLine 2: Green text\x1b[0m\n',
-            '\x1b[1A\x1b[K\x1b[31mLine 2: Now red text\x1b[0m\n', // Move up, clear line, write red
-            '\x1b[1;33mLine 3: Bold yellow\x1b[0m\n',
-            '\x1b[48;5;17m\x1b[38;5;231mWhite on dark blue background\x1b[0m\n',
-        ];
-        for (const data of complexSequence) {
-            mockProcess._emit('data', data);
-            await new Promise(resolve => setTimeout(resolve, 10));
-        }
-        // Check terminal has processed the sequences correctly
-        const terminal = session.terminal;
-        expect(terminal).toBeDefined();
-        // Verify buffer contains content (actual color verification would require
-        // checking individual cells, which is done in terminalSerializer.test.ts)
-        const buffer = terminal.buffer.active;
-        let hasContent = false;
-        for (let i = 0; i < buffer.length; i++) {
-            const line = buffer.getLine(i);
-            if (line) {
-                const text = line.translateToString(true);
-                if (text.trim()) {
-                    hasContent = true;
-                    break;
-                }
-            }
-        }
-        expect(hasContent).toBe(true);
-    });
-});

package/dist/services/sessionManager.integration.test.d.ts

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