ccmanager 1.4.5 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # CCManager - AI Code Assistant Session Manager
 
-CCManager is a TUI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI) across Git worktrees.
+CCManager is a TUI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI) across Git worktrees and projects.
 
 
 
@@ -11,6 +11,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 ## Features
 
 - Run multiple AI assistant sessions in parallel across different Git worktrees
+- **Multi-project support**: Manage multiple git repositories from a single interface
 - Support for multiple AI coding assistants (Claude Code, Gemini CLI)
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
@@ -243,6 +244,38 @@ The devcontainer integration requires both commands:
 
 For detailed setup and configuration, see [docs/devcontainer.md](docs/devcontainer.md).
 
+## Multi-Project Mode
+
+CCManager can manage multiple git repositories from a single interface, allowing you to organize and navigate between different projects and their worktrees efficiently.
+
+### Quick Start
+
+```bash
+# Set the root directory containing your git projects
+export CCMANAGER_MULTI_PROJECT_ROOT="/path/to/your/projects"
+
+# Run CCManager in multi-project mode
+npx ccmanager --multi-project
+```
+
+### Features
+
+- **Automatic project discovery**: Recursively finds all git repositories
+- **Recent projects**: Frequently used projects appear at the top
+- **Vi-like search**: Press `/` to filter projects or worktrees
+- **Session persistence**: Sessions remain active when switching projects
+- **Visual indicators**: See session counts `[active/busy/waiting]` for each project
+
+### Navigation
+
+1. **Project List**: Select from all discovered git repositories
+2. **Worktree Menu**: Manage worktrees for the selected project
+3. **Session View**: Interact with your AI assistant
+
+Use `B` key to navigate back from worktrees to project list.
+
+For detailed configuration and usage, see [docs/multi-project.md](docs/multi-project.md).
+
 ## Git Worktree Configuration
 
 CCManager can display enhanced git status information for each worktree when Git's worktree configuration extension is enabled.

package/dist/cli.d.ts

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 export declare const parsedArgs: import("meow").Result<{
+    multiProject: {
+        type: "boolean";
+        default: false;
+    };
     devcUpCommand: {
         type: "string";
     };

package/dist/cli.js

@@ -4,6 +4,7 @@ import { render } from 'ink';
 import meow from 'meow';
 import App from './components/App.js';
 import { worktreeConfigManager } from './services/worktreeConfigManager.js';
+import { globalSessionOrchestrator } from './services/globalSessionOrchestrator.js';
 const cli = meow(`
 	Usage
 	  $ ccmanager
@@ -11,15 +12,21 @@ const cli = meow(`
 	Options
 	  --help                Show help
 	  --version             Show version
+	  --multi-project       Enable multi-project mode
 	  --devc-up-command     Command to start devcontainer
 	  --devc-exec-command   Command to execute in devcontainer
 
 	Examples
 	  $ ccmanager
+	  $ ccmanager --multi-project
 	  $ ccmanager --devc-up-command "devcontainer up --workspace-folder ." --devc-exec-command "devcontainer exec --workspace-folder ."
 `, {
     importMeta: import.meta,
     flags: {
+        multiProject: {
+            type: 'boolean',
+            default: false,
+        },
         devcUpCommand: {
             type: 'string',
         },
@@ -38,6 +45,13 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
     console.error('Error: ccmanager must be run in an interactive terminal (TTY)');
     process.exit(1);
 }
+// Check for CCMANAGER_MULTI_PROJECT_ROOT when using --multi-project
+if (cli.flags.multiProject && !process.env['CCMANAGER_MULTI_PROJECT_ROOT']) {
+    console.error('Error: CCMANAGER_MULTI_PROJECT_ROOT environment variable must be set when using --multi-project');
+    console.error('Please set it to the root directory containing your projects, e.g.:');
+    console.error('  export CCMANAGER_MULTI_PROJECT_ROOT=/path/to/projects');
+    process.exit(1);
+}
 // Initialize worktree config manager
 worktreeConfigManager.initialize();
 // Prepare devcontainer config
@@ -48,7 +62,21 @@ const devcontainerConfig = cli.flags.devcUpCommand && cli.flags.devcExecCommand
     }
     : undefined;
 // Pass config to App
-const appProps = devcontainerConfig ? { devcontainerConfig } : {};
-render(React.createElement(App, { ...appProps }));
+const appProps = {
+    ...(devcontainerConfig ? { devcontainerConfig } : {}),
+    multiProject: cli.flags.multiProject,
+};
+const app = render(React.createElement(App, { ...appProps }));
+// Clean up sessions on exit
+process.on('SIGINT', () => {
+    globalSessionOrchestrator.destroyAllSessions();
+    app.unmount();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    globalSessionOrchestrator.destroyAllSessions();
+    app.unmount();
+    process.exit(0);
+});
 // Export for testing
 export const parsedArgs = cli;

package/dist/cli.test.d.ts

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

package/dist/cli.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+describe('CLI', () => {
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe('--multi-project flag', () => {
+        it('should exit with error when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
+            // Ensure the env var is not set
+            delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
+            // Create a wrapper script that mocks TTY
+            const wrapperScript = `
+				process.stdin.isTTY = true;
+				process.stdout.isTTY = true;
+				process.stderr.isTTY = true;
+				process.argv = ['node', 'cli.js', '--multi-project'];
+				import('./cli.js');
+			`;
+            const result = await new Promise(resolve => {
+                const proc = spawn('node', ['--input-type=module', '-e', wrapperScript], {
+                    cwd: path.join(__dirname, '../dist'),
+                    env: { ...process.env },
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                let stderr = '';
+                proc.stderr?.on('data', data => {
+                    stderr += data.toString();
+                });
+                proc.on('close', code => {
+                    resolve({ code: code ?? 1, stderr });
+                });
+            });
+            expect(result.code).toBe(1);
+            expect(result.stderr).toContain('CCMANAGER_MULTI_PROJECT_ROOT environment variable must be set');
+            expect(result.stderr).toContain('export CCMANAGER_MULTI_PROJECT_ROOT=/path/to/projects');
+        });
+        it('should not check for env var when --multi-project is not used', async () => {
+            // Ensure the env var is not set
+            delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
+            const result = await new Promise(resolve => {
+                const cliPath = path.join(__dirname, '../dist/cli.js');
+                const proc = spawn('node', [cliPath, '--help'], {
+                    env: { ...process.env },
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                let stderr = '';
+                proc.stderr?.on('data', data => {
+                    stderr += data.toString();
+                });
+                proc.on('close', code => {
+                    resolve({ code: code ?? 1, stderr });
+                });
+            });
+            expect(result.code).toBe(0);
+            expect(result.stderr).not.toContain('CCMANAGER_MULTI_PROJECT_ROOT');
+        });
+    });
+});

package/dist/components/App.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { DevcontainerConfig } from '../types/index.js';
 interface AppProps {
     devcontainerConfig?: DevcontainerConfig;
+    multiProject?: boolean;
 }
 declare const App: React.FC<AppProps>;
 export default App;

package/dist/components/App.js

@@ -1,25 +1,46 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useCallback } from 'react';
 import { useApp, Box, Text } from 'ink';
 import Menu from './Menu.js';
+import ProjectList from './ProjectList.js';
 import Session from './Session.js';
 import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
 import MergeWorktree from './MergeWorktree.js';
 import Configuration from './Configuration.js';
 import PresetSelector from './PresetSelector.js';
-import { SessionManager } from '../services/sessionManager.js';
+import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { configurationManager } from '../services/configurationManager.js';
-const App = ({ devcontainerConfig }) => {
+import { ENV_VARS } from '../constants/env.js';
+import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
+import { projectManager } from '../services/projectManager.js';
+const App = ({ devcontainerConfig, multiProject }) => {
     const { exit } = useApp();
-    const [view, setView] = useState('menu');
-    const [sessionManager] = useState(() => new SessionManager());
-    const [worktreeService] = useState(() => new WorktreeService());
+    const [view, setView] = useState(multiProject ? 'project-list' : 'menu');
+    const [sessionManager, setSessionManager] = useState(() => globalSessionOrchestrator.getManagerForProject());
+    const [worktreeService, setWorktreeService] = useState(() => new WorktreeService());
     const [activeSession, setActiveSession] = useState(null);
     const [error, setError] = useState(null);
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
+    const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
+    // Helper function to clear terminal screen
+    const clearScreen = () => {
+        if (process.stdout.isTTY) {
+            process.stdout.write('\x1B[2J\x1B[H');
+        }
+    };
+    // Helper function to navigate with screen clearing
+    const navigateWithClear = useCallback((newView, callback) => {
+        clearScreen();
+        setView('clearing');
+        setTimeout(() => {
+            setView(newView);
+            if (callback)
+                callback();
+        }, 10); // Small delay to ensure screen clear is processed
+    }, []);
     useEffect(() => {
         // Listen for session exits to return to menu automatically
         const handleSessionExit = (session) => {
@@ -27,53 +48,61 @@ const App = ({ devcontainerConfig }) => {
             setActiveSession(current => {
                 if (current && session.id === current.id) {
                     // Session that exited is the active one, trigger return to menu
-                    setTimeout(() => {
-                        setActiveSession(null);
-                        setError(null);
-                        setView('menu');
+                    setActiveSession(null);
+                    setError(null);
+                    const targetView = multiProject && selectedProject
+                        ? 'menu'
+                        : multiProject
+                            ? 'project-list'
+                            : 'menu';
+                    navigateWithClear(targetView, () => {
                         setMenuKey(prev => prev + 1);
-                        if (process.stdout.isTTY) {
-                            process.stdout.write('\x1B[2J\x1B[H');
-                        }
                         process.stdin.resume();
                         process.stdin.setEncoding('utf8');
-                    }, 0);
+                    });
                 }
                 return current;
             });
         };
         sessionManager.on('sessionExit', handleSessionExit);
-        // Cleanup on unmount
+        // Re-attach listener when session manager changes
         return () => {
             sessionManager.off('sessionExit', handleSessionExit);
-            sessionManager.destroy();
+            // Don't destroy sessions on unmount - they persist in memory
         };
-    }, [sessionManager]);
+    }, [sessionManager, multiProject, selectedProject, navigateWithClear]);
     const handleSelectWorktree = async (worktree) => {
         // Check if this is the new worktree option
         if (worktree.path === '') {
-            setView('new-worktree');
+            navigateWithClear('new-worktree');
             return;
         }
         // Check if this is the delete worktree option
         if (worktree.path === 'DELETE_WORKTREE') {
-            setView('delete-worktree');
+            navigateWithClear('delete-worktree');
             return;
         }
         // Check if this is the merge worktree option
         if (worktree.path === 'MERGE_WORKTREE') {
-            setView('merge-worktree');
+            navigateWithClear('merge-worktree');
             return;
         }
         // Check if this is the configuration option
         if (worktree.path === 'CONFIGURATION') {
-            setView('configuration');
+            navigateWithClear('configuration');
             return;
         }
         // Check if this is the exit application option
         if (worktree.path === 'EXIT_APPLICATION') {
-            sessionManager.destroy();
-            exit();
+            // In multi-project mode with a selected project, go back to project list
+            if (multiProject && selectedProject) {
+                handleBackToProjectList();
+            }
+            else {
+                // Only destroy all sessions when actually exiting the app
+                globalSessionOrchestrator.destroyAllSessions();
+                exit();
+            }
             return;
         }
         // Get or create session for this worktree
@@ -82,7 +111,7 @@ const App = ({ devcontainerConfig }) => {
             // Check if we should show preset selector
             if (configurationManager.getSelectPresetOnStart()) {
                 setSelectedWorktree(worktree);
-                setView('preset-selector');
+                navigateWithClear('preset-selector');
                 return;
             }
             try {
@@ -100,7 +129,7 @@ const App = ({ devcontainerConfig }) => {
             }
         }
         setActiveSession(session);
-        setView('session');
+        navigateWithClear('session');
     };
     const handlePresetSelected = async (presetId) => {
         if (!selectedWorktree)
@@ -115,7 +144,7 @@ const App = ({ devcontainerConfig }) => {
                 session = await sessionManager.createSessionWithPreset(selectedWorktree.path, presetId);
             }
             setActiveSession(session);
-            setView('session');
+            navigateWithClear('session');
             setSelectedWorktree(null);
         }
         catch (error) {
@@ -126,20 +155,20 @@ const App = ({ devcontainerConfig }) => {
     };
     const handlePresetSelectorCancel = () => {
         setSelectedWorktree(null);
-        setView('menu');
-        setMenuKey(prev => prev + 1);
+        navigateWithClear('menu', () => {
+            setMenuKey(prev => prev + 1);
+        });
     };
     const handleReturnToMenu = () => {
         setActiveSession(null);
         // Don't clear error here - let user dismiss it manually
-        // Add a small delay to ensure Session cleanup completes
-        setTimeout(() => {
-            setView('menu');
+        const targetView = multiProject && selectedProject
+            ? 'menu'
+            : multiProject
+                ? 'project-list'
+                : 'menu';
+        navigateWithClear(targetView, () => {
             setMenuKey(prev => prev + 1); // Force menu refresh
-            // Clear the screen when returning to menu
-            if (process.stdout.isTTY) {
-                process.stdout.write('\x1B[2J\x1B[H');
-            }
             // Ensure stdin is in a clean state for Ink components
             if (process.stdin.isTTY) {
                 // Flush any pending input to prevent escape sequences from leaking
@@ -148,7 +177,7 @@ const App = ({ devcontainerConfig }) => {
                 process.stdin.resume();
                 process.stdin.setEncoding('utf8');
             }
-        }, 50); // Small delay to ensure proper cleanup
+        });
     };
     const handleCreateWorktree = async (path, branch, baseBranch, copySessionData, copyClaudeDirectory) => {
         setView('creating-worktree');
@@ -193,8 +222,45 @@ const App = ({ devcontainerConfig }) => {
     const handleCancelDeleteWorktree = () => {
         handleReturnToMenu();
     };
+    const handleSelectProject = (project) => {
+        // Handle special exit case
+        if (project.path === 'EXIT_APPLICATION') {
+            globalSessionOrchestrator.destroyAllSessions();
+            exit();
+            return;
+        }
+        // Set the selected project and update services
+        setSelectedProject(project);
+        setWorktreeService(new WorktreeService(project.path));
+        // Get or create session manager for this project
+        const projectSessionManager = globalSessionOrchestrator.getManagerForProject(project.path);
+        setSessionManager(projectSessionManager);
+        // Add to recent projects
+        projectManager.addRecentProject(project);
+        navigateWithClear('menu');
+    };
+    const handleBackToProjectList = () => {
+        // Sessions persist in their project-specific managers
+        setSelectedProject(null);
+        setWorktreeService(new WorktreeService()); // Reset to default
+        // Reset to global session manager for project list view
+        setSessionManager(globalSessionOrchestrator.getManagerForProject());
+        navigateWithClear('project-list', () => {
+            setMenuKey(prev => prev + 1);
+        });
+    };
+    if (view === 'project-list' && multiProject) {
+        const projectsDir = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        if (!projectsDir) {
+            return (React.createElement(Box, null,
+                React.createElement(Text, { color: "red" },
+                    "Error: ",
+                    MULTI_PROJECT_ERRORS.NO_PROJECTS_DIR)));
+        }
+        return (React.createElement(ProjectList, { projectsDir: projectsDir, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null) }));
+    }
     if (view === 'menu') {
-        return (React.createElement(Menu, { key: menuKey, sessionManager: sessionManager, onSelectWorktree: handleSelectWorktree, error: error, onDismissError: () => setError(null) }));
+        return (React.createElement(Menu, { key: menuKey, sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: handleSelectWorktree, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject }));
     }
     if (view === 'session' && activeSession) {
         return (React.createElement(Box, { flexDirection: "column" },
@@ -243,6 +309,10 @@ const App = ({ devcontainerConfig }) => {
     if (view === 'preset-selector') {
         return (React.createElement(PresetSelector, { onSelect: handlePresetSelected, onCancel: handlePresetSelectorCancel }));
     }
+    if (view === 'clearing') {
+        // Render nothing during the clearing phase to ensure clean transition
+        return null;
+    }
     return null;
 };
 export default App;

package/dist/components/Menu.d.ts

@@ -1,11 +1,16 @@
 import React from 'react';
-import { Worktree } from '../types/index.js';
+import { Worktree, GitProject } from '../types/index.js';
+import { WorktreeService } from '../services/worktreeService.js';
 import { SessionManager } from '../services/sessionManager.js';
 interface MenuProps {
     sessionManager: SessionManager;
+    worktreeService: WorktreeService;
     onSelectWorktree: (worktree: Worktree) => void;
+    onSelectRecentProject?: (project: GitProject) => void;
     error?: string | null;
     onDismissError?: () => void;
+    projectName?: string;
+    multiProject?: boolean;
 }
 declare const Menu: React.FC<MenuProps>;
 export default Menu;