ccmanager 3.9.0 → 3.11.0

package/dist/services/sessionManager.test.js

@@ -138,6 +138,44 @@ describe('SessionManager', () => {
                 env: process.env,
             });
         });
+        it('passes the initial prompt as the final argument for claude-compatible presets', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--resume'],
+                detectionStrategy: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', undefined, 'implement prompt flow'));
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--teammate-mode', 'in-process', 'implement prompt flow'], expect.any(Object));
+            expect(mockPty.write).not.toHaveBeenCalled();
+        });
+        it('passes the initial prompt with --prompt for opencode presets', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'OpenCode',
+                command: 'opencode',
+                args: ['run'],
+                detectionStrategy: 'opencode',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', undefined, 'implement prompt flow'));
+            expect(spawn).toHaveBeenCalledWith('opencode', ['run', '--prompt', 'implement prompt flow'], expect.any(Object));
+            expect(mockPty.write).not.toHaveBeenCalled();
+        });
+        it('writes the initial prompt to stdin for unknown commands', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Custom',
+                command: 'custom-agent',
+                args: ['--interactive'],
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', undefined, 'implement prompt flow'));
+            expect(spawn).toHaveBeenCalledWith('custom-agent', ['--interactive'], expect.any(Object));
+            expect(mockPty.write).toHaveBeenCalledWith('implement prompt flow\r');
+        });
         it('should fall back to default preset if specified preset not found', async () => {
             // Setup mocks
             vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({

package/dist/services/worktreeNameGenerator.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from 'effect';
+import { ProcessError } from '../types/errors.js';
+export declare const extractBranchNameFromOutput: (stdout: string) => string;
+export declare const deduplicateBranchName: (name: string, existingBranches: string[]) => string;
+export declare class WorktreeNameGenerator {
+    generateBranchNameEffect(userPrompt: string, baseBranch: string, existingBranches?: string[]): Effect.Effect<string, ProcessError, never>;
+}
+export declare const worktreeNameGenerator: WorktreeNameGenerator;

package/dist/services/worktreeNameGenerator.js

@@ -0,0 +1,184 @@
+import { Effect } from 'effect';
+import { execFile } from 'child_process';
+import { ProcessError } from '../types/errors.js';
+import { logger } from '../utils/logger.js';
+const JSON_SCHEMA = JSON.stringify({
+    type: 'object',
+    properties: {
+        branchName: { type: 'string' },
+    },
+    required: ['branchName'],
+    additionalProperties: false,
+});
+const DEFAULT_TIMEOUT_MS = 30_000;
+const buildPrompt = (userPrompt, baseBranch) => `You generate concise git branch names.
+
+Base branch: ${baseBranch}
+Task prompt:
+${userPrompt}
+
+Return a short git branch name using lowercase letters, numbers, hyphens, and forward slashes only.
+Do not include markdown, explanations, refs/heads/, or surrounding quotes.
+Examples: feature/add-prompt-mode, fix/worktree-loading-state`;
+const normalizeBranchName = (branchName) => {
+    const normalized = branchName
+        .trim()
+        .replace(/^```[a-z]*\n?/i, '')
+        .replace(/\n?```$/i, '')
+        .replace(/^refs\/heads\//, '')
+        .replace(/^"+|"+$/g, '')
+        .replace(/^'+|'+$/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/[^a-zA-Z0-9/_-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/\/+/g, '/')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+    if (!normalized) {
+        throw new Error('Generated branch name was empty');
+    }
+    return normalized;
+};
+const extractStringCandidate = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const nested = extractStringCandidate(item);
+            if (nested)
+                return nested;
+        }
+    }
+    if (typeof value === 'object' && value !== null) {
+        const obj = value;
+        for (const key of [
+            'branchName',
+            'result',
+            'text',
+            'content',
+            'message',
+            'completion',
+        ]) {
+            const nested = extractStringCandidate(obj[key]);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+};
+export const extractBranchNameFromOutput = (stdout) => {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        throw new Error('`claude -p` returned empty output');
+    }
+    for (const pattern of [
+        /"branchName"\s*:\s*"([^"]+)"/,
+        /branchName\s*[:=]\s*["']?([A-Za-z0-9/_-]+)["']?/,
+    ]) {
+        const match = trimmed.match(pattern);
+        if (match?.[1]) {
+            return normalizeBranchName(match[1]);
+        }
+    }
+    const jsonLines = trimmed
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    for (const line of [trimmed, ...jsonLines]) {
+        try {
+            const parsed = JSON.parse(line);
+            const candidate = extractStringCandidate(parsed);
+            if (candidate) {
+                return normalizeBranchName(candidate);
+            }
+        }
+        catch {
+            // Fall through to other parsing strategies.
+        }
+    }
+    const firstUsefulLine = trimmed
+        .split('\n')
+        .map(line => line.trim())
+        .find(line => line &&
+        !line.startsWith('{') &&
+        !line.startsWith('[') &&
+        !line.startsWith('```'));
+    if (firstUsefulLine) {
+        return normalizeBranchName(firstUsefulLine);
+    }
+    return normalizeBranchName(trimmed);
+};
+export const deduplicateBranchName = (name, existingBranches) => {
+    const lowerSet = new Set(existingBranches.map(b => b.toLowerCase()));
+    if (!lowerSet.has(name.toLowerCase())) {
+        return name;
+    }
+    for (let i = 2;; i++) {
+        const candidate = `${name}-${i}`;
+        if (!lowerSet.has(candidate.toLowerCase())) {
+            return candidate;
+        }
+    }
+};
+export class WorktreeNameGenerator {
+    generateBranchNameEffect(userPrompt, baseBranch, existingBranches) {
+        return Effect.tryPromise({
+            try: () => new Promise((resolve, reject) => {
+                let settled = false;
+                let child;
+                const settle = (handler) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timeoutId);
+                    handler();
+                };
+                const timeoutId = setTimeout(() => {
+                    settle(() => {
+                        logger.warn('Worktree branch-name generation timed out, terminating claude helper');
+                        child?.kill('SIGKILL');
+                        reject(new Error('Timed out while generating a branch name with `claude -p`'));
+                    });
+                }, DEFAULT_TIMEOUT_MS);
+                child = execFile('claude', ['-p', '--output-format', 'json', '--json-schema', JSON_SCHEMA], {
+                    encoding: 'utf8',
+                    maxBuffer: 1024 * 1024,
+                }, (error, stdout) => {
+                    settle(() => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        const branchName = extractBranchNameFromOutput(stdout);
+                        resolve(existingBranches
+                            ? deduplicateBranchName(branchName, existingBranches)
+                            : branchName);
+                    });
+                });
+                child.on('error', error => {
+                    settle(() => reject(error));
+                });
+                if (!child.stdin) {
+                    settle(() => reject(new Error('claude stdin unavailable')));
+                    return;
+                }
+                child.stdin.write(buildPrompt(userPrompt, baseBranch));
+                child.stdin.end();
+            }),
+            catch: (error) => new ProcessError({
+                command: 'claude -p',
+                message: (typeof error === 'object' &&
+                    error !== null &&
+                    'code' in error &&
+                    error.code === 'ENOENT') ||
+                    (error instanceof Error && error.message.includes('spawn claude'))
+                    ? 'The `claude` command is required for automatic branch naming. Install it and make sure it is available in PATH.'
+                    : error instanceof Error
+                        ? `Failed to generate a branch name with \`claude -p\`: ${error.message}`
+                        : 'Failed to generate branch name with `claude -p`',
+            }),
+        });
+    }
+}
+export const worktreeNameGenerator = new WorktreeNameGenerator();

package/dist/services/worktreeNameGenerator.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { deduplicateBranchName, extractBranchNameFromOutput, worktreeNameGenerator as generator, } from './worktreeNameGenerator.js';
+describe('WorktreeNameGenerator output parsing', () => {
+    it('normalizes direct json branchName responses', async () => {
+        const value = extractBranchNameFromOutput('{"branchName":"feature/add prompt"}');
+        expect(value).toBe('feature/add-prompt');
+        expect(generator).toBeDefined();
+    });
+    it('extracts nested text payloads', async () => {
+        const value = extractBranchNameFromOutput('{"type":"result","result":{"text":"fix/worktree-loading-state"}}');
+        expect(value).toBe('fix/worktree-loading-state');
+    });
+    it('falls back to plain text output', async () => {
+        const value = extractBranchNameFromOutput('```text\nfeature/generated-name\n```');
+        expect(value).toBe('feature/generated-name');
+    });
+    it('extracts branchName from verbose result payloads', () => {
+        const value = extractBranchNameFromOutput('type":"result","subtype":"success","structured_output":{"branchName":"fix/trim-worktree-name"},"uuid":"123"');
+        expect(value).toBe('fix/trim-worktree-name');
+    });
+});
+describe('deduplicateBranchName', () => {
+    it('returns the name unchanged when no conflict exists', () => {
+        expect(deduplicateBranchName('feature/new', ['main', 'develop'])).toBe('feature/new');
+    });
+    it('appends -2 suffix when the name already exists', () => {
+        expect(deduplicateBranchName('feature/new', ['feature/new', 'main'])).toBe('feature/new-2');
+    });
+    it('increments the suffix when multiple conflicts exist', () => {
+        expect(deduplicateBranchName('fix/bug', ['fix/bug', 'fix/bug-2', 'fix/bug-3'])).toBe('fix/bug-4');
+    });
+    it('compares branch names case-insensitively', () => {
+        expect(deduplicateBranchName('Feature/New', ['feature/new'])).toBe('Feature/New-2');
+    });
+});

package/dist/utils/presetPrompt.d.ts

@@ -0,0 +1,11 @@
+import type { CommandPreset } from '../types/index.js';
+export type PromptInjectionMethod = 'final-arg' | 'flag' | 'stdin';
+export interface PreparedPresetLaunch {
+    args: string[];
+    stdinPayload?: string;
+    method: PromptInjectionMethod;
+}
+export declare const getPromptInjectionMethod: (preset: Pick<CommandPreset, "command" | "detectionStrategy">) => PromptInjectionMethod;
+export declare const getPromptFlag: (preset: Pick<CommandPreset, "command" | "detectionStrategy">) => string | undefined;
+export declare const describePromptInjection: (preset: Pick<CommandPreset, "command" | "detectionStrategy">) => string;
+export declare const preparePresetLaunch: (preset: Pick<CommandPreset, "command" | "args" | "detectionStrategy">, prompt?: string) => PreparedPresetLaunch;

package/dist/utils/presetPrompt.js

@@ -0,0 +1,71 @@
+import { injectTeammateMode } from './commandArgs.js';
+/**
+ * Prompt flag configuration per detectionStrategy.
+ * Sources:
+ * - opencode: `--prompt` https://opencode.ai/docs/cli/
+ * - gemini:   `-i` (--prompt-interactive) https://google-gemini.github.io/gemini-cli/docs/cli/commands.html
+ * - github-copilot: `-i` https://docs.github.com/en/copilot/reference/cli-command-reference
+ * - kimi:     `-p` https://www.kimi-cli.com/en/reference/kimi-command.html
+ */
+const PROMPT_FLAG = {
+    opencode: '--prompt',
+    gemini: '-i',
+    'github-copilot': '-i',
+    kimi: '-p',
+};
+export const getPromptInjectionMethod = (preset) => {
+    if (preset.detectionStrategy && PROMPT_FLAG[preset.detectionStrategy]) {
+        return 'flag';
+    }
+    if (preset.detectionStrategy === 'claude' ||
+        preset.detectionStrategy === 'codex' ||
+        preset.detectionStrategy === 'cursor' ||
+        preset.detectionStrategy === 'cline') {
+        return 'final-arg';
+    }
+    return 'stdin';
+};
+export const getPromptFlag = (preset) => {
+    if (preset.detectionStrategy) {
+        return PROMPT_FLAG[preset.detectionStrategy];
+    }
+    return undefined;
+};
+export const describePromptInjection = (preset) => {
+    const method = getPromptInjectionMethod(preset);
+    if (method === 'flag') {
+        const flag = getPromptFlag(preset) || '--prompt';
+        return `The prompt will be passed as a command flag: \`${flag} "<your prompt>"\`.`;
+    }
+    if (method === 'final-arg') {
+        return 'The prompt will be passed as the final command argument.';
+    }
+    return 'The prompt will be sent via standard input after the session command starts.';
+};
+export const preparePresetLaunch = (preset, prompt) => {
+    const baseArgs = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+    if (!prompt) {
+        return {
+            args: baseArgs,
+            method: getPromptInjectionMethod(preset),
+        };
+    }
+    switch (getPromptInjectionMethod(preset)) {
+        case 'flag':
+            return {
+                args: [...baseArgs, getPromptFlag(preset) || '--prompt', prompt],
+                method: 'flag',
+            };
+        case 'stdin':
+            return {
+                args: baseArgs,
+                method: 'stdin',
+                stdinPayload: `${prompt}\r`,
+            };
+        case 'final-arg':
+            return {
+                args: [...baseArgs, prompt],
+                method: 'final-arg',
+            };
+    }
+};

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

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

package/dist/utils/presetPrompt.test.js

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest';
+import { describePromptInjection, getPromptInjectionMethod, preparePresetLaunch, } from './presetPrompt.js';
+describe('presetPrompt', () => {
+    it('uses the final argument for claude presets', () => {
+        expect(preparePresetLaunch({ command: 'claude', args: ['--resume'], detectionStrategy: 'claude' }, 'fix the tests')).toEqual({
+            args: ['--resume', '--teammate-mode', 'in-process', 'fix the tests'],
+            method: 'final-arg',
+        });
+    });
+    it('uses the final argument for codex presets', () => {
+        expect(preparePresetLaunch({ command: 'codex', args: [], detectionStrategy: 'codex' }, 'refactor utils')).toEqual({
+            args: ['refactor utils'],
+            method: 'final-arg',
+        });
+    });
+    it('uses the final argument for cursor presets', () => {
+        expect(preparePresetLaunch({ command: 'agent', args: [], detectionStrategy: 'cursor' }, 'review code')).toEqual({
+            args: ['review code'],
+            method: 'final-arg',
+        });
+    });
+    it('uses the final argument for cline presets', () => {
+        expect(preparePresetLaunch({ command: 'cline', args: [], detectionStrategy: 'cline' }, 'fix bug')).toEqual({
+            args: ['fix bug'],
+            method: 'final-arg',
+        });
+    });
+    it('uses --prompt for opencode presets', () => {
+        expect(preparePresetLaunch({ command: 'opencode', args: ['run'], detectionStrategy: 'opencode' }, 'implement feature')).toEqual({
+            args: ['run', '--prompt', 'implement feature'],
+            method: 'flag',
+        });
+    });
+    it('uses -i for gemini presets', () => {
+        expect(preparePresetLaunch({ command: 'gemini', args: [], detectionStrategy: 'gemini' }, 'explain code')).toEqual({
+            args: ['-i', 'explain code'],
+            method: 'flag',
+        });
+    });
+    it('uses -i for github-copilot presets', () => {
+        expect(preparePresetLaunch({ command: 'copilot', args: [], detectionStrategy: 'github-copilot' }, 'create readme')).toEqual({
+            args: ['-i', 'create readme'],
+            method: 'flag',
+        });
+    });
+    it('uses -p for kimi presets', () => {
+        expect(preparePresetLaunch({ command: 'kimi', args: [], detectionStrategy: 'kimi' }, 'summarize')).toEqual({
+            args: ['-p', 'summarize'],
+            method: 'flag',
+        });
+    });
+    it('falls back to stdin for unknown commands', () => {
+        expect(preparePresetLaunch({ command: 'custom-agent', args: ['--interactive'] }, 'hello')).toEqual({
+            args: ['--interactive'],
+            method: 'stdin',
+            stdinPayload: 'hello\r',
+        });
+    });
+    describe('describePromptInjection', () => {
+        it('describes final-arg for claude', () => {
+            expect(describePromptInjection({
+                command: 'claude',
+                detectionStrategy: 'claude',
+            })).toContain('final command argument');
+        });
+        it('describes final-arg for codex', () => {
+            expect(describePromptInjection({
+                command: 'codex',
+                detectionStrategy: 'codex',
+            })).toContain('final command argument');
+        });
+        it('describes final-arg for cursor', () => {
+            expect(describePromptInjection({
+                command: 'agent',
+                detectionStrategy: 'cursor',
+            })).toContain('final command argument');
+        });
+        it('describes final-arg for cline', () => {
+            expect(describePromptInjection({
+                command: 'cline',
+                detectionStrategy: 'cline',
+            })).toContain('final command argument');
+        });
+        it('describes --prompt flag for opencode', () => {
+            expect(describePromptInjection({
+                command: 'opencode',
+                detectionStrategy: 'opencode',
+            })).toContain('--prompt');
+        });
+        it('describes -i flag for gemini', () => {
+            expect(describePromptInjection({
+                command: 'gemini',
+                detectionStrategy: 'gemini',
+            })).toContain('-i');
+        });
+        it('describes -i flag for github-copilot', () => {
+            expect(describePromptInjection({
+                command: 'copilot',
+                detectionStrategy: 'github-copilot',
+            })).toContain('-i');
+        });
+        it('describes -p flag for kimi', () => {
+            expect(describePromptInjection({
+                command: 'kimi',
+                detectionStrategy: 'kimi',
+            })).toContain('-p');
+        });
+        it('describes stdin for unknown strategy', () => {
+            expect(describePromptInjection({ command: 'custom-agent' })).toContain('standard input');
+        });
+    });
+    describe('getPromptInjectionMethod', () => {
+        it('returns final-arg for claude', () => {
+            expect(getPromptInjectionMethod({
+                command: 'claude',
+                detectionStrategy: 'claude',
+            })).toBe('final-arg');
+        });
+        it('returns final-arg for codex', () => {
+            expect(getPromptInjectionMethod({
+                command: 'codex',
+                detectionStrategy: 'codex',
+            })).toBe('final-arg');
+        });
+        it('returns final-arg for cursor', () => {
+            expect(getPromptInjectionMethod({
+                command: 'agent',
+                detectionStrategy: 'cursor',
+            })).toBe('final-arg');
+        });
+        it('returns final-arg for cline', () => {
+            expect(getPromptInjectionMethod({
+                command: 'cline',
+                detectionStrategy: 'cline',
+            })).toBe('final-arg');
+        });
+        it('returns flag for opencode', () => {
+            expect(getPromptInjectionMethod({
+                command: 'opencode',
+                detectionStrategy: 'opencode',
+            })).toBe('flag');
+        });
+        it('returns flag for gemini', () => {
+            expect(getPromptInjectionMethod({
+                command: 'gemini',
+                detectionStrategy: 'gemini',
+            })).toBe('flag');
+        });
+        it('returns flag for github-copilot', () => {
+            expect(getPromptInjectionMethod({
+                command: 'copilot',
+                detectionStrategy: 'github-copilot',
+            })).toBe('flag');
+        });
+        it('returns flag for kimi', () => {
+            expect(getPromptInjectionMethod({
+                command: 'kimi',
+                detectionStrategy: 'kimi',
+            })).toBe('flag');
+        });
+        it('returns stdin when detectionStrategy is not set', () => {
+            expect(getPromptInjectionMethod({ command: 'claude' })).toBe('stdin');
+            expect(getPromptInjectionMethod({ command: 'opencode' })).toBe('stdin');
+            expect(getPromptInjectionMethod({ command: 'custom-agent' })).toBe('stdin');
+        });
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -2,7 +2,7 @@ import { Worktree, Session } from '../types/index.js';
 /**
  * Worktree item with formatted content for display.
  */
-interface WorktreeItem {
+export interface WorktreeItem {
     worktree: Worktree;
     session?: Session;
     baseLabel: string;
@@ -39,4 +39,3 @@ export declare function calculateColumnPositions(items: WorktreeItem[]): {
  * Assembles the final worktree label with proper column alignment
  */
 export declare function assembleWorktreeLabel(item: WorktreeItem, columns: ReturnType<typeof calculateColumnPositions>): string;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.9.0",
+	"version": "3.11.0",
 	"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.9.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.9.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.9.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.9.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.9.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.11.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.11.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.11.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",

package/dist/components/ProjectList.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { GitProject } from '../types/index.js';
-interface ProjectListProps {
-    projectsDir: string;
-    onSelectProject: (project: GitProject) => void;
-    error: string | null;
-    onDismissError: () => void;
-}
-declare const ProjectList: React.FC<ProjectListProps>;
-export default ProjectList;