ccmanager 3.6.3 → 3.6.5

package/dist/services/stateDetector/claude.js

@@ -28,7 +28,7 @@ export class ClaudeStateDetector extends BaseStateDetector {
         const lines = this.getTerminalLines(terminal, 3);
         const content = lines.join('\n').toLowerCase();
         // Check for "N background task(s)" pattern first (content already lowercased)
-        const countMatch = content.match(/(\d+)\s+background\s+task/);
+        const countMatch = content.match(/(\d+)\s+(?:background\s+task|local\s+agent)/);
         if (countMatch?.[1]) {
             return parseInt(countMatch[1], 10);
         }

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

@@ -387,6 +387,49 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(count).toBe(1);
         });
+        it('should return count 3 when "3 local agents" is in status bar', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                'More output',
+                'bypass permissions on - 3 local agents',
+            ]);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(3);
+        });
+        it('should return count 1 when "1 local agent" is in status bar', () => {
+            // Arrange
+            terminal = createMockTerminal(['Some output', '1 local agent']);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(1);
+        });
+        it('should detect local agent count case-insensitively', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Output line 1',
+                'Output line 2',
+                '2 LOCAL AGENTS running',
+            ]);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(2);
+        });
+        it('should prioritize explicit count from "N local agents" over "(running)"', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                '3 local agents | task1 (running)',
+            ]);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(3);
+        });
         it('should prioritize count from "N background task" over "(running)"', () => {
             // Arrange - both patterns present, count should be from explicit pattern
             terminal = createMockTerminal([

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/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.3",
+	"version": "3.6.5",
 	"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.3",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.3",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.3",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.6.3",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.6.3"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.6.5",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.5",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.5",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.6.5",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.6.5"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",