ccmanager 0.0.1

package/dist/services/worktreeService.js

@@ -0,0 +1,220 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+export class WorktreeService {
+    constructor(rootPath) {
+        Object.defineProperty(this, "rootPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rootPath = rootPath || process.cwd();
+    }
+    getWorktrees() {
+        try {
+            const output = execSync('git worktree list --porcelain', {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            const worktrees = [];
+            const lines = output.trim().split('\n');
+            let currentWorktree = {};
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    if (currentWorktree.path) {
+                        worktrees.push(currentWorktree);
+                    }
+                    currentWorktree = {
+                        path: line.substring(9),
+                        isMainWorktree: false,
+                        hasSession: false,
+                    };
+                }
+                else if (line.startsWith('branch ')) {
+                    currentWorktree.branch = line.substring(7);
+                }
+                else if (line === 'bare') {
+                    currentWorktree.isMainWorktree = true;
+                }
+            }
+            if (currentWorktree.path) {
+                worktrees.push(currentWorktree);
+            }
+            // Mark the first worktree as main if none are marked
+            if (worktrees.length > 0 && !worktrees.some(w => w.isMainWorktree)) {
+                worktrees[0].isMainWorktree = true;
+            }
+            return worktrees;
+        }
+        catch (_error) {
+            // If git worktree command fails, assume we're in a regular git repo
+            return [
+                {
+                    path: this.rootPath,
+                    branch: this.getCurrentBranch(),
+                    isMainWorktree: true,
+                    hasSession: false,
+                },
+            ];
+        }
+    }
+    getCurrentBranch() {
+        try {
+            const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            }).trim();
+            return branch;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    isGitRepository() {
+        return existsSync(path.join(this.rootPath, '.git'));
+    }
+    createWorktree(worktreePath, branch) {
+        try {
+            // Check if branch exists
+            let branchExists = false;
+            try {
+                execSync(`git rev-parse --verify ${branch}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                branchExists = true;
+            }
+            catch {
+                // Branch doesn't exist
+            }
+            // Create the worktree
+            const command = branchExists
+                ? `git worktree add "${worktreePath}" "${branch}"`
+                : `git worktree add -b "${branch}" "${worktreePath}"`;
+            execSync(command, {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to create worktree',
+            };
+        }
+    }
+    deleteWorktree(worktreePath) {
+        try {
+            // Get the worktree info to find the branch
+            const worktrees = this.getWorktrees();
+            const worktree = worktrees.find(wt => wt.path === worktreePath);
+            if (!worktree) {
+                return {
+                    success: false,
+                    error: 'Worktree not found',
+                };
+            }
+            if (worktree.isMainWorktree) {
+                return {
+                    success: false,
+                    error: 'Cannot delete the main worktree',
+                };
+            }
+            // Remove the worktree
+            execSync(`git worktree remove "${worktreePath}" --force`, {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            // Delete the branch if it exists
+            const branchName = worktree.branch.replace('refs/heads/', '');
+            try {
+                execSync(`git branch -D "${branchName}"`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+            }
+            catch {
+                // Branch might not exist or might be checked out elsewhere
+                // This is not a fatal error
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to delete worktree',
+            };
+        }
+    }
+    mergeWorktree(sourceBranch, targetBranch, useRebase = false) {
+        try {
+            // Get worktrees to find the target worktree path
+            const worktrees = this.getWorktrees();
+            const targetWorktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === targetBranch);
+            if (!targetWorktree) {
+                return {
+                    success: false,
+                    error: 'Target branch worktree not found',
+                };
+            }
+            // Perform the merge or rebase in the target worktree
+            if (useRebase) {
+                // For rebase, we need to checkout source branch and rebase it onto target
+                const sourceWorktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === sourceBranch);
+                if (!sourceWorktree) {
+                    return {
+                        success: false,
+                        error: 'Source branch worktree not found',
+                    };
+                }
+                // Rebase source branch onto target branch
+                execSync(`git rebase "${targetBranch}"`, {
+                    cwd: sourceWorktree.path,
+                    encoding: 'utf8',
+                });
+            }
+            else {
+                // Regular merge
+                execSync(`git merge --no-ff "${sourceBranch}"`, {
+                    cwd: targetWorktree.path,
+                    encoding: 'utf8',
+                });
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error
+                    ? error.message
+                    : useRebase
+                        ? 'Failed to rebase branches'
+                        : 'Failed to merge branches',
+            };
+        }
+    }
+    deleteWorktreeByBranch(branch) {
+        try {
+            // Get worktrees to find the worktree by branch
+            const worktrees = this.getWorktrees();
+            const worktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === branch);
+            if (!worktree) {
+                return {
+                    success: false,
+                    error: 'Worktree not found for branch',
+                };
+            }
+            return this.deleteWorktree(worktree.path);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error
+                    ? error.message
+                    : 'Failed to delete worktree by branch',
+            };
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,36 @@
+import { IPty } from 'node-pty';
+export type SessionState = 'idle' | 'busy' | 'waiting_input';
+export interface Worktree {
+    path: string;
+    branch: string;
+    isMainWorktree: boolean;
+    hasSession: boolean;
+}
+export interface Session {
+    id: string;
+    worktreePath: string;
+    process: IPty;
+    state: SessionState;
+    output: string[];
+    outputHistory: Buffer[];
+    lastActivity: Date;
+    isActive: boolean;
+}
+export interface SessionManager {
+    sessions: Map<string, Session>;
+    createSession(worktreePath: string): Session;
+    getSession(worktreePath: string): Session | undefined;
+    destroySession(worktreePath: string): void;
+    getAllSessions(): Session[];
+}
+export interface ShortcutKey {
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    key: string;
+}
+export interface ShortcutConfig {
+    returnToMenu: ShortcutKey;
+    cancel: ShortcutKey;
+}
+export declare const DEFAULT_SHORTCUTS: ShortcutConfig;

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export const DEFAULT_SHORTCUTS = {
+    returnToMenu: { ctrl: true, key: 'e' },
+    cancel: { key: 'escape' },
+};

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export declare const log: {
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+export declare const logger: {
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,21 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { format } from 'util';
+const LOG_FILE = path.join(process.cwd(), 'ccmanager.log');
+// Clear log file on startup
+fs.writeFileSync(LOG_FILE, '', 'utf8');
+function writeLog(level, args) {
+    const timestamp = new Date().toISOString();
+    const message = format(...args);
+    const logLine = `[${timestamp}] [${level}] ${message}\n`;
+    fs.appendFileSync(LOG_FILE, logLine, 'utf8');
+}
+export const log = {
+    log: (...args) => writeLog('LOG', args),
+    info: (...args) => writeLog('INFO', args),
+    warn: (...args) => writeLog('WARN', args),
+    error: (...args) => writeLog('ERROR', args),
+    debug: (...args) => writeLog('DEBUG', args),
+};
+// Alias for console.log style usage
+export const logger = log;

package/dist/utils/promptDetector.d.ts

@@ -0,0 +1 @@
+export declare function includesPromptBoxBottomBorder(output: string): boolean;

package/dist/utils/promptDetector.js

@@ -0,0 +1,20 @@
+export function includesPromptBoxBottomBorder(output) {
+    // Check if the output includes a prompt box bottom border
+    return output
+        .trim()
+        .split('\n')
+        .some(line => {
+        // Accept patterns:
+        // - `──╯` (ends with ╯)
+        // - `╰───╯` (starts with ╰ and ends with ╯)
+        // Reject if:
+        // - vertical line exists after ╯
+        // - line starts with ╰ but doesn't end with ╯
+        // Check if line ends with ╯ but not followed by │
+        if (line.endsWith('╯') && !line.includes('╯ │')) {
+            // Accept if it's just ──╯ or ╰───╯ pattern
+            return /─+╯$/.test(line) || /^╰─+╯$/.test(line);
+        }
+        return false;
+    });
+}

package/dist/utils/promptDetector.test.d.ts

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

package/dist/utils/promptDetector.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { includesPromptBoxBottomBorder } from './promptDetector.js';
+describe('includesPromptBoxBottomBorder', () => {
+    it('should return false for empty output', () => {
+        expect(includesPromptBoxBottomBorder('')).toBe(false);
+        expect(includesPromptBoxBottomBorder('   ')).toBe(false);
+        expect(includesPromptBoxBottomBorder('\n\n')).toBe(false);
+    });
+    it('should accept lines ending with ╯', () => {
+        // Basic pattern
+        expect(includesPromptBoxBottomBorder('──╯')).toBe(true);
+        expect(includesPromptBoxBottomBorder('────────╯')).toBe(true);
+        expect(includesPromptBoxBottomBorder('─╯')).toBe(true);
+    });
+    it('should accept complete bottom border (╰───╯)', () => {
+        expect(includesPromptBoxBottomBorder('╰───╯')).toBe(true);
+        expect(includesPromptBoxBottomBorder('╰─────────────╯')).toBe(true);
+        expect(includesPromptBoxBottomBorder('╰─╯')).toBe(true);
+    });
+    it('should accept when part of multi-line output', () => {
+        const output1 = `Some text
+──╯
+More text`;
+        expect(includesPromptBoxBottomBorder(output1)).toBe(true);
+        const output2 = `First line
+╰─────────────╯
+Last line`;
+        expect(includesPromptBoxBottomBorder(output2)).toBe(true);
+    });
+    it('should accept with leading/trailing whitespace', () => {
+        expect(includesPromptBoxBottomBorder('  ──╯  ')).toBe(true);
+        expect(includesPromptBoxBottomBorder('\t╰───╯\t')).toBe(true);
+        expect(includesPromptBoxBottomBorder('\n──╯\n')).toBe(true);
+    });
+    it('should reject when ╯ is followed by │', () => {
+        expect(includesPromptBoxBottomBorder('──╯ │')).toBe(false);
+        expect(includesPromptBoxBottomBorder('╰───╯ │')).toBe(false);
+        expect(includesPromptBoxBottomBorder('──╯ │ more text')).toBe(false);
+    });
+    it('should reject when line starts with ╰ but does not end with ╯', () => {
+        expect(includesPromptBoxBottomBorder('╰───')).toBe(false);
+        expect(includesPromptBoxBottomBorder('╰─────────')).toBe(false);
+        expect(includesPromptBoxBottomBorder('╰─── some text')).toBe(false);
+    });
+    it('should reject lines that do not match the pattern', () => {
+        // Missing ─ characters
+        expect(includesPromptBoxBottomBorder('╯')).toBe(false);
+        expect(includesPromptBoxBottomBorder('╰╯')).toBe(false);
+        // Wrong characters
+        expect(includesPromptBoxBottomBorder('===╯')).toBe(false);
+        expect(includesPromptBoxBottomBorder('╰===╯')).toBe(false);
+        expect(includesPromptBoxBottomBorder('---╯')).toBe(false);
+        // Top border pattern
+        expect(includesPromptBoxBottomBorder('╭───╮')).toBe(false);
+        // Middle line pattern
+        expect(includesPromptBoxBottomBorder('│ > │')).toBe(false);
+        // Random text
+        expect(includesPromptBoxBottomBorder('Some random text')).toBe(false);
+        expect(includesPromptBoxBottomBorder('Exit code: 0')).toBe(false);
+    });
+    it('should handle complex multi-line scenarios correctly', () => {
+        const validOutput = `
+╭────────────────────╮
+│ > hello            │
+╰────────────────────╯
+Some status text`;
+        expect(includesPromptBoxBottomBorder(validOutput)).toBe(true);
+        const invalidOutput = `
+╭────────────────────╮
+│ > hello            │
+╰──────────────────── 
+Some other text`;
+        expect(includesPromptBoxBottomBorder(invalidOutput)).toBe(false);
+    });
+    it('should handle partial border at end of line', () => {
+        const partialBorder = `Some output text ──╯`;
+        expect(includesPromptBoxBottomBorder(partialBorder)).toBe(true);
+        const partialInvalid = `Some output text ──╯ │`;
+        expect(includesPromptBoxBottomBorder(partialInvalid)).toBe(false);
+    });
+});

package/package.json

@@ -0,0 +1,70 @@
+{
+	"name": "ccmanager",
+	"version": "0.0.1",
+	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
+	"license": "MIT",
+	"author": "Kodai Kabasawa",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/kbwo/ccmanager.git"
+	},
+	"keywords": [
+		"claude",
+		"code",
+		"worktree",
+		"git",
+		"tui",
+		"cli"
+	],
+	"bin": {
+		"ccmanager": "dist/cli.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"start": "node dist/cli.js",
+		"test": "vitest",
+		"test:run": "vitest run",
+		"lint": "eslint src",
+		"lint:fix": "eslint src --fix",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "npm run lint && npm run typecheck && npm run test:run && npm run build",
+		"prepare": "npm run build"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"ink": "^4.1.0",
+		"ink-select-input": "^5.0.0",
+		"ink-text-input": "^5.0.1",
+		"meow": "^11.0.0",
+		"node-pty": "^1.0.0",
+		"react": "^18.2.0"
+	},
+	"devDependencies": {
+		"@eslint/js": "^9.28.0",
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/node": "^20.0.0",
+		"@types/react": "^18.0.32",
+		"@typescript-eslint/eslint-plugin": "^8.33.1",
+		"@typescript-eslint/parser": "^8.33.1",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"chalk": "^5.2.0",
+		"eslint": "^9.28.0",
+		"eslint-config-prettier": "^10.1.5",
+		"eslint-plugin-prettier": "^5.4.1",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^5.2.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^3.0.0",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"vitest": "^3.2.2"
+	},
+	"prettier": "@vdemedes/prettier-config"
+}