ccmanager 3.6.1 → 3.6.4

package/dist/components/Menu.recent-projects.test.js

@@ -126,7 +126,9 @@ describe('Menu - Recent Projects', () => {
             backgroundTasks: 0,
         });
         vi.spyOn(SessionManager, 'formatSessionCounts').mockReturnValue('');
-        const { lastFrame } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        const { lastFrame, rerender } = render(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
+        // Force a rerender to ensure all effects have run
+        rerender(_jsx(Menu, { sessionManager: mockSessionManager, worktreeService: mockWorktreeService, onSelectWorktree: vi.fn(), onSelectRecentProject: vi.fn(), multiProject: true, version: "test" }));
         // Wait for Effect to execute
         await new Promise(resolve => setTimeout(resolve, 100));
         const output = lastFrame();

package/dist/services/stateDetector/base.js

@@ -1,21 +1,10 @@
+import { getTerminalScreenContent } from '../../utils/screenCapture.js';
 export class BaseStateDetector {
     getTerminalLines(terminal, maxLines = 30) {
-        const buffer = terminal.buffer.active;
-        const lines = [];
-        // Start from the bottom and work our way up
-        for (let i = buffer.length - 1; i >= 0 && lines.length < maxLines; i--) {
-            const line = buffer.getLine(i);
-            if (line) {
-                const text = line.translateToString(true);
-                // Skip empty lines at the bottom
-                if (lines.length > 0 || text.trim() !== '') {
-                    lines.unshift(text);
-                }
-            }
-        }
-        return lines;
+        const content = getTerminalScreenContent(terminal, maxLines);
+        return content.split('\n');
     }
     getTerminalContent(terminal, maxLines = 30) {
-        return this.getTerminalLines(terminal, maxLines).join('\n');
+        return getTerminalScreenContent(terminal, maxLines);
     }
 }

package/dist/services/stateDetector/claude.test.js

@@ -221,6 +221,58 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect idle when scrolled past old busy state (baseY > 0)', () => {
+            // Arrange - Simulate scrollback where "esc to interrupt" is in history
+            // but the current viewport (baseY=5, rows=3) shows idle content
+            // Buffer: [0]: "Old content", [1]: "esc to interrupt", [2]: "More busy output",
+            //         [3]: "...", [4]: "...", [5]: "Ready", [6]: "Prompt >", [7]: "idle"
+            // Viewport shows lines 5-7 (baseY=5, rows=3)
+            terminal = createMockTerminal([
+                'Old content',
+                'Previous output with esc to interrupt marker',
+                'More old busy output',
+                'Transition content',
+                'Processing done',
+                'Ready for input',
+                'Prompt >',
+                'idle state here',
+            ], { baseY: 5, rows: 3 });
+            // Act
+            const state = detector.detectState(terminal, 'busy');
+            // Assert - Should detect idle because viewport shows lines 5-7
+            expect(state).toBe('idle');
+        });
+        it('should detect busy when scrolled to busy state (baseY shows busy content)', () => {
+            // Arrange - Viewport shows busy content
+            // Buffer has old idle content at top, busy content in viewport
+            terminal = createMockTerminal([
+                'Old idle content',
+                'Previous prompt',
+                'User input',
+                'Processing request...',
+                'Press esc to interrupt',
+                'Working...',
+            ], { baseY: 3, rows: 3 });
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - Should detect busy because viewport shows lines 3-5
+            expect(state).toBe('busy');
+        });
+        it('should detect waiting_input when viewport shows prompt after scroll', () => {
+            // Arrange - Scrollback has busy markers, but viewport shows waiting prompt
+            terminal = createMockTerminal([
+                'Previous busy content',
+                'esc to interrupt was here',
+                'Old output',
+                'Do you want to continue?',
+                '❯ 1. Yes',
+                '  2. No',
+            ], { baseY: 3, rows: 3 });
+            // Act
+            const state = detector.detectState(terminal, 'busy');
+            // Assert - Should detect waiting_input from viewport
+            expect(state).toBe('waiting_input');
+        });
     });
     describe('detectBackgroundTask', () => {
         it('should return count 1 when "1 background task" is in status bar', () => {

package/dist/services/stateDetector/testUtils.d.ts

@@ -2,6 +2,11 @@ import type { Terminal } from '../../types/index.js';
 /**
  * Creates a mock Terminal object for testing state detectors.
  * @param lines - Array of strings representing terminal output lines
+ * @param options - Optional configuration for rows, cols, and baseY
  * @returns Mock Terminal object with buffer interface
  */
-export declare const createMockTerminal: (lines: string[]) => Terminal;
+export declare const createMockTerminal: (lines: string[], options?: {
+    rows?: number;
+    cols?: number;
+    baseY?: number;
+}) => Terminal;

package/dist/services/stateDetector/testUtils.js

@@ -1,22 +1,28 @@
 /**
  * Creates a mock Terminal object for testing state detectors.
  * @param lines - Array of strings representing terminal output lines
+ * @param options - Optional configuration for rows, cols, and baseY
  * @returns Mock Terminal object with buffer interface
  */
-export const createMockTerminal = (lines) => {
+export const createMockTerminal = (lines, options) => {
+    const rows = options?.rows ?? lines.length;
+    const cols = options?.cols ?? 80;
+    const baseY = options?.baseY ?? 0;
     const buffer = {
         length: lines.length,
         active: {
+            type: 'normal',
             length: lines.length,
+            baseY,
             getLine: (index) => {
                 if (index >= 0 && index < lines.length) {
                     return {
-                        translateToString: () => lines[index],
+                        translateToString: (_trimRight, _startCol, _endCol) => lines[index],
                     };
                 }
                 return null;
             },
         },
     };
-    return { buffer };
+    return { buffer, rows, cols };
 };

package/dist/services/worktreeService.js

@@ -72,6 +72,15 @@ export class WorktreeService {
             const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
                 ? gitCommonDir
                 : path.resolve(this.rootPath, gitCommonDir);
+            // Handle submodule paths: if path contains .git/modules, use --show-toplevel
+            // to get the submodule's actual working directory
+            if (absoluteGitCommonDir.includes('.git/modules')) {
+                const toplevel = execSync('git rev-parse --show-toplevel', {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                }).trim();
+                return toplevel;
+            }
             // Handle worktree paths: if path contains .git/worktrees, we need to find the real .git parent
             if (absoluteGitCommonDir.includes('.git/worktrees')) {
                 // Extract the path up to and including .git
@@ -647,6 +656,12 @@ export class WorktreeService {
                 if (worktrees.length > 0 && !worktrees.some(w => w.isMainWorktree)) {
                     worktrees[0].isMainWorktree = true;
                 }
+                // Handle submodule paths: if the main worktree path contains .git/modules,
+                // replace it with the actual working directory (self.gitRootPath)
+                const mainWorktree = worktrees.find(w => w.isMainWorktree);
+                if (mainWorktree && mainWorktree.path.includes('.git/modules')) {
+                    mainWorktree.path = self.gitRootPath;
+                }
                 // Sort worktrees by last session if requested
                 if (sortByLastSession) {
                     worktrees.sort((a, b) => {

package/dist/services/worktreeService.submodule.test.d.ts

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

package/dist/services/worktreeService.submodule.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { Effect } from 'effect';
+import { WorktreeService } from './worktreeService.js';
+describe('WorktreeService with submodules', () => {
+    // Use os.tmpdir() and unique suffix to avoid conflicts with parallel tests
+    // Use realpathSync to resolve symlinks (e.g., /var -> /private/var on macOS)
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-ws-submodule-test-')));
+    const rootProjectDir = path.join(testDir, 'root-project');
+    const submodule1Dir = path.join(rootProjectDir, 'modules', 'submodule-1');
+    beforeAll(() => {
+        // Allow file:// protocol for local submodule cloning (needed for CI)
+        execSync('git config --global protocol.file.allow always');
+        // Clean up if exists
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        // Create test directory structure
+        fs.mkdirSync(testDir, { recursive: true });
+        // Create submodule source repository
+        const submodule1Source = path.join(testDir, 'submodule-1-source');
+        fs.mkdirSync(submodule1Source, { recursive: true });
+        execSync('git init', { cwd: submodule1Source });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: submodule1Source });
+        execSync('git config user.name "Test User"', { cwd: submodule1Source });
+        fs.writeFileSync(path.join(submodule1Source, 'README.md'), '# Submodule 1');
+        execSync('git add README.md', { cwd: submodule1Source });
+        execSync('git commit -m "Initial commit"', { cwd: submodule1Source });
+        // Create root project
+        fs.mkdirSync(rootProjectDir, { recursive: true });
+        execSync('git init', { cwd: rootProjectDir });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: rootProjectDir });
+        execSync('git config user.name "Test User"', { cwd: rootProjectDir });
+        fs.writeFileSync(path.join(rootProjectDir, 'README.md'), '# Root Project');
+        execSync('git add README.md', { cwd: rootProjectDir });
+        execSync('git commit -m "Initial commit"', { cwd: rootProjectDir });
+        // Add submodule
+        execSync(`git submodule add ${submodule1Source} modules/submodule-1`, {
+            cwd: rootProjectDir,
+        });
+        execSync('git commit -m "Add submodule"', { cwd: rootProjectDir });
+    });
+    afterAll(() => {
+        // Clean up
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('should return the submodule working directory from getGitRootPath()', () => {
+        const service = new WorktreeService(submodule1Dir);
+        const result = service.getGitRootPath();
+        // Should return the submodule's working directory
+        expect(result).toBe(submodule1Dir);
+        // Should NOT return a path containing .git/modules
+        expect(result).not.toContain('.git/modules');
+    });
+    it('should still work for regular repositories', () => {
+        const service = new WorktreeService(rootProjectDir);
+        const result = service.getGitRootPath();
+        expect(result).toBe(rootProjectDir);
+        expect(path.basename(result)).toBe('root-project');
+    });
+    it('should return worktrees with correct paths (not .git/modules paths) for submodules', async () => {
+        const service = new WorktreeService(submodule1Dir);
+        const worktrees = await Effect.runPromise(service.getWorktreesEffect());
+        // Should have at least one worktree
+        expect(worktrees.length).toBeGreaterThan(0);
+        // The main worktree path should be the submodule working directory
+        const mainWorktree = worktrees.find(wt => wt.isMainWorktree);
+        expect(mainWorktree).toBeDefined();
+        expect(mainWorktree.path).toBe(submodule1Dir);
+        // No worktree should have .git/modules in its path
+        for (const wt of worktrees) {
+            expect(wt.path).not.toContain('.git/modules');
+        }
+    });
+});

package/dist/utils/gitUtils.d.ts

@@ -1,6 +1,7 @@
 /**
  * Get the git repository root path from a given directory.
  * For worktrees, this returns the main repository root (parent of .git).
+ * For submodules, this returns the submodule's working directory.
  *
  * @param cwd - The directory to start searching from
  * @returns The absolute path to the git repository root, or null if not in a git repo

package/dist/utils/gitUtils.js

@@ -3,6 +3,7 @@ import { execSync } from 'child_process';
 /**
  * Get the git repository root path from a given directory.
  * For worktrees, this returns the main repository root (parent of .git).
+ * For submodules, this returns the submodule's working directory.
  *
  * @param cwd - The directory to start searching from
  * @returns The absolute path to the git repository root, or null if not in a git repo
@@ -17,6 +18,16 @@ export function getGitRepositoryRoot(cwd) {
         const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
             ? gitCommonDir
             : path.resolve(cwd, gitCommonDir);
+        // Handle submodule paths: if path contains .git/modules, use --show-toplevel
+        // to get the submodule's actual working directory
+        if (absoluteGitCommonDir.includes('.git/modules')) {
+            const toplevel = execSync('git rev-parse --show-toplevel', {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            return toplevel;
+        }
         // Handle worktree paths: if path contains .git/worktrees, find the real .git parent
         if (absoluteGitCommonDir.includes('.git/worktrees')) {
             const gitIndex = absoluteGitCommonDir.indexOf('.git');

package/dist/utils/gitUtils.submodule.test.d.ts

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

package/dist/utils/gitUtils.submodule.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { getGitRepositoryRoot } from './gitUtils.js';
+describe('getGitRepositoryRoot with submodules', () => {
+    // Use os.tmpdir() and unique suffix to avoid conflicts with parallel tests
+    // Use realpathSync to resolve symlinks (e.g., /var -> /private/var on macOS)
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-submodule-test-')));
+    const rootProjectDir = path.join(testDir, 'root-project');
+    const submodule1Dir = path.join(rootProjectDir, 'modules', 'submodule-1');
+    beforeAll(() => {
+        // Allow file:// protocol for local submodule cloning (needed for CI)
+        execSync('git config --global protocol.file.allow always');
+        // Clean up if exists
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        // Create test directory structure
+        fs.mkdirSync(testDir, { recursive: true });
+        // Create submodule source repository
+        const submodule1Source = path.join(testDir, 'submodule-1-source');
+        fs.mkdirSync(submodule1Source, { recursive: true });
+        execSync('git init', { cwd: submodule1Source });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: submodule1Source });
+        execSync('git config user.name "Test User"', { cwd: submodule1Source });
+        fs.writeFileSync(path.join(submodule1Source, 'README.md'), '# Submodule 1');
+        execSync('git add README.md', { cwd: submodule1Source });
+        execSync('git commit -m "Initial commit"', { cwd: submodule1Source });
+        // Create root project
+        fs.mkdirSync(rootProjectDir, { recursive: true });
+        execSync('git init', { cwd: rootProjectDir });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: rootProjectDir });
+        execSync('git config user.name "Test User"', { cwd: rootProjectDir });
+        fs.writeFileSync(path.join(rootProjectDir, 'README.md'), '# Root Project');
+        execSync('git add README.md', { cwd: rootProjectDir });
+        execSync('git commit -m "Initial commit"', { cwd: rootProjectDir });
+        // Add submodule
+        execSync(`git submodule add ${submodule1Source} modules/submodule-1`, {
+            cwd: rootProjectDir,
+        });
+        execSync('git commit -m "Add submodule"', { cwd: rootProjectDir });
+    });
+    afterAll(() => {
+        // Clean up
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('should return the submodule working directory, not the parent .git/modules path', () => {
+        // When running from within a submodule
+        const result = getGitRepositoryRoot(submodule1Dir);
+        // Should return the submodule's working directory
+        expect(result).toBe(submodule1Dir);
+        // Should NOT return a path containing .git/modules
+        expect(result).not.toContain('.git/modules');
+    });
+    it('should still work for regular repositories', () => {
+        const result = getGitRepositoryRoot(rootProjectDir);
+        expect(result).toBe(rootProjectDir);
+        expect(path.basename(result)).toBe('root-project');
+    });
+});

package/dist/utils/screenCapture.js

@@ -15,10 +15,13 @@ function lineToString(line, cols) {
 export function captureScreen(terminal) {
     const buffer = terminal.buffer.active;
     const lines = [];
-    // Capture only the visible screen area (terminal.rows lines)
-    // This works correctly for both normal and alternate screen buffers
+    // baseY is the offset of the viewport within the buffer
+    // For alternate buffer: baseY is always 0
+    // For normal buffer: baseY indicates how much has been scrolled
+    const baseY = buffer.baseY;
+    // Capture the visible viewport (not the beginning of scrollback)
     for (let y = 0; y < terminal.rows; y++) {
-        const line = buffer.getLine(y);
+        const line = buffer.getLine(baseY + y);
         lines.push(lineToString(line, terminal.cols));
     }
     return {

package/dist/utils/worktreeUtils.js

@@ -21,6 +21,15 @@ function getGitRepositoryName(projectPath) {
         const absoluteGitCommonDir = path.isAbsolute(gitCommonDir)
             ? gitCommonDir
             : path.resolve(projectPath, gitCommonDir);
+        // Handle submodule paths: if path contains .git/modules, use --show-toplevel
+        // to get the submodule's actual working directory
+        if (absoluteGitCommonDir.includes('.git/modules')) {
+            const toplevel = execSync('git rev-parse --show-toplevel', {
+                cwd: projectPath,
+                encoding: 'utf8',
+            }).trim();
+            return path.basename(toplevel);
+        }
         const mainWorkingDir = path.dirname(absoluteGitCommonDir);
         return path.basename(mainWorkingDir);
     }

package/dist/utils/worktreeUtils.submodule.test.d.ts

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

package/dist/utils/worktreeUtils.submodule.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { generateWorktreeDirectory } from './worktreeUtils.js';
+describe('generateWorktreeDirectory with submodules', () => {
+    // Use os.tmpdir() and unique suffix to avoid conflicts with parallel tests
+    // Use realpathSync to resolve symlinks (e.g., /var -> /private/var on macOS)
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-wt-submodule-test-')));
+    const rootProjectDir = path.join(testDir, 'root-project');
+    const submodule1Dir = path.join(rootProjectDir, 'modules', 'submodule-1');
+    beforeAll(() => {
+        // Allow file:// protocol for local submodule cloning (needed for CI)
+        execSync('git config --global protocol.file.allow always');
+        // Clean up if exists
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        // Create test directory structure
+        fs.mkdirSync(testDir, { recursive: true });
+        // Create submodule source repository
+        const submodule1Source = path.join(testDir, 'submodule-1-source');
+        fs.mkdirSync(submodule1Source, { recursive: true });
+        execSync('git init', { cwd: submodule1Source });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: submodule1Source });
+        execSync('git config user.name "Test User"', { cwd: submodule1Source });
+        fs.writeFileSync(path.join(submodule1Source, 'README.md'), '# Submodule 1');
+        execSync('git add README.md', { cwd: submodule1Source });
+        execSync('git commit -m "Initial commit"', { cwd: submodule1Source });
+        // Create root project
+        fs.mkdirSync(rootProjectDir, { recursive: true });
+        execSync('git init', { cwd: rootProjectDir });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: rootProjectDir });
+        execSync('git config user.name "Test User"', { cwd: rootProjectDir });
+        fs.writeFileSync(path.join(rootProjectDir, 'README.md'), '# Root Project');
+        execSync('git add README.md', { cwd: rootProjectDir });
+        execSync('git commit -m "Initial commit"', { cwd: rootProjectDir });
+        // Add submodule
+        execSync(`git submodule add ${submodule1Source} modules/submodule-1`, {
+            cwd: rootProjectDir,
+        });
+        execSync('git commit -m "Add submodule"', { cwd: rootProjectDir });
+    });
+    afterAll(() => {
+        // Clean up
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('should use submodule name (not "modules") in {project} placeholder', () => {
+        const result = generateWorktreeDirectory(submodule1Dir, 'feature/test', '../worktrees/{project}-{branch}');
+        // Should contain "submodule-1", not "modules"
+        expect(result).toContain('submodule-1');
+        expect(result).not.toContain('modules-');
+    });
+    it('should work correctly for regular repositories', () => {
+        const result = generateWorktreeDirectory(rootProjectDir, 'feature/test', '../worktrees/{project}-{branch}');
+        expect(result).toContain('root-project');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.6.1",
+	"version": "3.6.4",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.6.1",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.1",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.1",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.6.1",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.6.1"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.6.4",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.4",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.4",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.6.4",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.6.4"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",