ccmanager 3.11.0 → 3.11.1

package/dist/components/App.js

@@ -53,26 +53,24 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
     };
     // Helper function to create session with Effect-based error handling
-    const createSessionWithEffect = async (worktreePath, presetId, initialPrompt) => {
+    const createSessionWithEffect = useCallback(async (worktreePath, presetId, initialPrompt) => {
         const sessionEffect = devcontainerConfig
             ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt)
             : sessionManager.createSessionWithPresetEffect(worktreePath, presetId, initialPrompt);
         // Execute the Effect and handle both success and failure cases
         const result = await Effect.runPromise(Effect.either(sessionEffect));
         if (result._tag === 'Left') {
-            // Handle error using pattern matching on _tag
             const errorMessage = formatErrorMessage(result.left);
             return {
                 success: false,
                 errorMessage: `Failed to create session: ${errorMessage}`,
             };
         }
-        // Success case - extract session from Right
         return {
             success: true,
             session: result.right,
         };
-    };
+    }, [sessionManager, devcontainerConfig]);
     // Helper function to clear terminal screen
     const clearScreen = () => {
         if (process.stdout.isTTY) {
@@ -115,7 +113,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             session = result.session;
         }
         navigateToSession(session);
-    }, [sessionManager, navigateWithClear, navigateToSession]);
+    }, [
+        sessionManager,
+        navigateWithClear,
+        navigateToSession,
+        createSessionWithEffect,
+    ]);
     useEffect(() => {
         // Listen for session exits to return to menu automatically
         const handleSessionExit = (session) => {

package/dist/components/TextInputWrapper.d.ts

@@ -5,9 +5,6 @@ interface TextInputWrapperProps {
     onSubmit?: (value: string) => void;
     placeholder?: string;
     focus?: boolean;
-    mask?: string;
-    showCursor?: boolean;
-    highlightPastedText?: boolean;
 }
 declare const TextInputWrapper: React.FC<TextInputWrapperProps>;
 export default TextInputWrapper;

package/dist/components/TextInputWrapper.js

@@ -1,15 +1,124 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import TextInput from 'ink-text-input';
+import { useReducer, useEffect, useRef, useMemo, } from 'react';
+import { Text, useInput } from 'ink';
+import chalk from 'chalk';
 import stripAnsi from 'strip-ansi';
-const TextInputWrapper = ({ value, onChange, ...props }) => {
-    const handleChange = (newValue) => {
-        // First strip all ANSI escape sequences
-        let cleanedValue = stripAnsi(newValue);
-        // Then specifically remove bracketed paste mode markers that might remain
-        // These sometimes appear as literal text after ANSI stripping
-        cleanedValue = cleanedValue.replace(/\[200~/g, '').replace(/\[201~/g, '');
-        onChange(cleanedValue);
-    };
-    return _jsx(TextInput, { value: value, onChange: handleChange, ...props });
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'move-cursor-left': {
+            return {
+                ...state,
+                cursorOffset: Math.max(0, state.cursorOffset - 1),
+            };
+        }
+        case 'move-cursor-right': {
+            return {
+                ...state,
+                cursorOffset: Math.min(state.value.length, state.cursorOffset + 1),
+            };
+        }
+        case 'insert': {
+            return {
+                value: state.value.slice(0, state.cursorOffset) +
+                    action.text +
+                    state.value.slice(state.cursorOffset),
+                cursorOffset: state.cursorOffset + action.text.length,
+            };
+        }
+        case 'delete': {
+            if (state.cursorOffset === 0)
+                return state;
+            const newOffset = state.cursorOffset - 1;
+            return {
+                value: state.value.slice(0, newOffset) + state.value.slice(newOffset + 1),
+                cursorOffset: newOffset,
+            };
+        }
+        case 'set': {
+            return {
+                value: action.value,
+                cursorOffset: action.value.length,
+            };
+        }
+    }
+};
+function cleanInput(input) {
+    let cleaned = stripAnsi(input);
+    cleaned = cleaned.replace(/\[200~/g, '').replace(/\[201~/g, '');
+    return cleaned;
+}
+const cursor = chalk.inverse(' ');
+const TextInputWrapper = ({ value, onChange, onSubmit, placeholder = '', focus = true, }) => {
+    const [state, dispatch] = useReducer(reducer, {
+        value,
+        cursorOffset: value.length,
+    });
+    const lastReportedValue = useRef(value);
+    // Sync external value changes into internal state
+    useEffect(() => {
+        if (value !== lastReportedValue.current) {
+            lastReportedValue.current = value;
+            dispatch({ type: 'set', value });
+        }
+    }, [value]);
+    // Report internal state changes to parent
+    useEffect(() => {
+        if (state.value !== lastReportedValue.current) {
+            lastReportedValue.current = state.value;
+            onChange(state.value);
+        }
+    }, [state.value, onChange]);
+    useInput((input, key) => {
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === 'c') ||
+            key.tab ||
+            (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            onSubmit?.(state.value);
+            return;
+        }
+        if (key.leftArrow) {
+            dispatch({ type: 'move-cursor-left' });
+        }
+        else if (key.rightArrow) {
+            dispatch({ type: 'move-cursor-right' });
+        }
+        else if (key.backspace || key.delete) {
+            dispatch({ type: 'delete' });
+        }
+        else {
+            const cleaned = cleanInput(input);
+            if (cleaned) {
+                dispatch({ type: 'insert', text: cleaned });
+            }
+        }
+    }, { isActive: focus });
+    const renderedPlaceholder = useMemo(() => {
+        if (!focus) {
+            return placeholder ? chalk.dim(placeholder) : '';
+        }
+        return placeholder.length > 0
+            ? chalk.inverse(placeholder[0]) + chalk.dim(placeholder.slice(1))
+            : cursor;
+    }, [focus, placeholder]);
+    const renderedValue = useMemo(() => {
+        if (!focus) {
+            return state.value;
+        }
+        let result = state.value.length > 0 ? '' : cursor;
+        let index = 0;
+        for (const char of state.value) {
+            result += index === state.cursorOffset ? chalk.inverse(char) : char;
+            index++;
+        }
+        if (state.value.length > 0 && state.cursorOffset === state.value.length) {
+            result += cursor;
+        }
+        return result;
+    }, [focus, state.value, state.cursorOffset]);
+    return (_jsx(Text, { children: state.value.length > 0 ? renderedValue : renderedPlaceholder }));
 };
 export default TextInputWrapper;

package/dist/services/sessionManager.test.js

@@ -164,18 +164,6 @@ describe('SessionManager', () => {
             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.js

@@ -141,7 +141,15 @@ export class WorktreeNameGenerator {
                         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], {
+                child = execFile('claude', [
+                    '-p',
+                    '--model',
+                    'haiku',
+                    '--output-format',
+                    'json',
+                    '--json-schema',
+                    JSON_SCHEMA,
+                ], {
                     encoding: 'utf8',
                     maxBuffer: 1024 * 1024,
                 }, (error, stdout) => {

package/dist/utils/presetPrompt.js

@@ -13,14 +13,16 @@ const PROMPT_FLAG = {
     'github-copilot': '-i',
     kimi: '-p',
 };
+const DEFAULT_DETECTION_STRATEGY = 'claude';
 export const getPromptInjectionMethod = (preset) => {
-    if (preset.detectionStrategy && PROMPT_FLAG[preset.detectionStrategy]) {
+    const strategy = preset.detectionStrategy ?? DEFAULT_DETECTION_STRATEGY;
+    if (PROMPT_FLAG[strategy]) {
         return 'flag';
     }
-    if (preset.detectionStrategy === 'claude' ||
-        preset.detectionStrategy === 'codex' ||
-        preset.detectionStrategy === 'cursor' ||
-        preset.detectionStrategy === 'cline') {
+    if (strategy === 'claude' ||
+        strategy === 'codex' ||
+        strategy === 'cursor' ||
+        strategy === 'cline') {
         return 'final-arg';
     }
     return 'stdin';

package/dist/utils/presetPrompt.test.js

@@ -49,13 +49,6 @@ describe('presetPrompt', () => {
             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({
@@ -105,9 +98,6 @@ describe('presetPrompt', () => {
                 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', () => {
@@ -158,10 +148,8 @@ describe('presetPrompt', () => {
                 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');
+        it('falls back to claude strategy when detectionStrategy is not set', () => {
+            expect(getPromptInjectionMethod({ command: 'claude' })).toBe('final-arg');
         });
     });
 });

package/package.json

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