ccmanager 0.1.1 → 0.1.3

package/README.md

@@ -11,6 +11,7 @@ https://github.com/user-attachments/assets/a6d80e73-dc06-4ef8-849d-e3857f6c7024
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
 - Configurable keyboard shortcuts
+- Status change hooks for automation and notifications
 
 ## Why CCManager over Claude Squad?
 
@@ -76,26 +77,38 @@ The arguments are applied to all Claude Code sessions started by CCManager.
 
 You can customize keyboard shortcuts in two ways:
 
-1. **Through the UI**: Select "Configure Shortcuts" from the main menu
-2. **Configuration file**: Edit `~/.config/ccmanager/shortcuts.json`
+1. **Through the UI**: Select "Configuration" → "Configure Shortcuts" from the main menu
+2. **Configuration file**: Edit `~/.config/ccmanager/config.json` (or legacy `~/.config/ccmanager/shortcuts.json`)
 
 Example configuration:
 ```json
+// config.json (new format)
+{
+  "shortcuts": {
+    "returnToMenu": {
+      "ctrl": true,
+      "key": "r"
+    },
+    "cancel": {
+      "key": "escape"
+    }
+  }
+}
+
+// shortcuts.json (legacy format, still supported)
 {
   "returnToMenu": {
     "ctrl": true,
     "key": "r"
   },
-  "exitApp": {
-    "ctrl": true,
-    "key": "x"
-  },
   "cancel": {
     "key": "escape"
   }
 }
 ```
 
+Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.json` on first use.
+
 ### Restrictions
 
 - Shortcuts must use a modifier key (Ctrl) except for special keys like Escape
@@ -104,6 +117,20 @@ Example configuration:
   - Ctrl+D
   - Ctrl+[ (equivalent to Escape)
 
+## Status Change Hooks
+
+CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.
+
+### Overview
+
+Status hooks allow you to:
+- Get notified when Claude needs your input
+- Track time spent in different states
+- Trigger automations based on session activity
+- Integrate with notification systems like [noti](https://github.com/variadico/noti)
+
+For detailed setup instructions, see [docs/state-hooks.md](docs/state-hooks.md).
+
 ## Development
 
 ```bash

package/dist/components/App.js

@@ -5,7 +5,7 @@ import Session from './Session.js';
 import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
 import MergeWorktree from './MergeWorktree.js';
-import ConfigureShortcuts from './ConfigureShortcuts.js';
+import Configuration from './Configuration.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { shortcutManager } from '../services/shortcutManager.js';
@@ -62,9 +62,9 @@ const App = () => {
             setView('merge-worktree');
             return;
         }
-        // Check if this is the configure shortcuts option
-        if (worktree.path === 'CONFIGURE_SHORTCUTS') {
-            setView('configure-shortcuts');
+        // Check if this is the configuration option
+        if (worktree.path === 'CONFIGURATION') {
+            setView('configuration');
             return;
         }
         // Check if this is the exit application option
@@ -220,8 +220,8 @@ const App = () => {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "green" }, "Merging worktrees...")));
     }
-    if (view === 'configure-shortcuts') {
-        return React.createElement(ConfigureShortcuts, { onComplete: handleReturnToMenu });
+    if (view === 'configuration') {
+        return React.createElement(Configuration, { onComplete: handleReturnToMenu });
     }
     return null;
 };

package/dist/components/Configuration.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigurationProps {
+    onComplete: () => void;
+}
+declare const Configuration: React.FC<ConfigurationProps>;
+export default Configuration;

package/dist/components/Configuration.js

@@ -0,0 +1,49 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import ConfigureShortcuts from './ConfigureShortcuts.js';
+import ConfigureHooks from './ConfigureHooks.js';
+const Configuration = ({ onComplete }) => {
+    const [view, setView] = useState('menu');
+    const menuItems = [
+        {
+            label: '⌨  Configure Shortcuts',
+            value: 'shortcuts',
+        },
+        {
+            label: '🔧  Configure Status Hooks',
+            value: 'hooks',
+        },
+        {
+            label: '← Back to Main Menu',
+            value: 'back',
+        },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onComplete();
+        }
+        else if (item.value === 'shortcuts') {
+            setView('shortcuts');
+        }
+        else if (item.value === 'hooks') {
+            setView('hooks');
+        }
+    };
+    const handleSubMenuComplete = () => {
+        setView('menu');
+    };
+    if (view === 'shortcuts') {
+        return React.createElement(ConfigureShortcuts, { onComplete: handleSubMenuComplete });
+    }
+    if (view === 'hooks') {
+        return React.createElement(ConfigureHooks, { onComplete: handleSubMenuComplete });
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configuration")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Select a configuration option:")),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true })));
+};
+export default Configuration;

package/dist/components/ConfigureHooks.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureHooksProps {
+    onComplete: () => void;
+}
+declare const ConfigureHooks: React.FC<ConfigureHooksProps>;
+export default ConfigureHooks;

package/dist/components/ConfigureHooks.js

@@ -0,0 +1,133 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import SelectInput from 'ink-select-input';
+import { configurationManager } from '../services/configurationManager.js';
+const STATUS_LABELS = {
+    idle: 'Idle',
+    busy: 'Busy',
+    waiting_input: 'Waiting for Input',
+};
+const ConfigureHooks = ({ onComplete }) => {
+    const [view, setView] = useState('menu');
+    const [selectedStatus, setSelectedStatus] = useState('idle');
+    const [hooks, setHooks] = useState({});
+    const [currentCommand, setCurrentCommand] = useState('');
+    const [currentEnabled, setCurrentEnabled] = useState(false);
+    const [showSaveMessage, setShowSaveMessage] = useState(false);
+    useEffect(() => {
+        setHooks(configurationManager.getStatusHooks());
+    }, []);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (view === 'edit') {
+                setView('menu');
+            }
+            else {
+                onComplete();
+            }
+        }
+        else if (key.tab && view === 'edit') {
+            toggleEnabled();
+        }
+    });
+    const getMenuItems = () => {
+        const items = [];
+        // Add status hook items
+        ['idle', 'busy', 'waiting_input'].forEach(status => {
+            const hook = hooks[status];
+            const enabled = hook?.enabled ? '✓' : '✗';
+            const command = hook?.command || '(not set)';
+            items.push({
+                label: `${STATUS_LABELS[status]}: ${enabled} ${command}`,
+                value: status,
+            });
+        });
+        items.push({
+            label: '─────────────',
+            value: 'separator',
+        });
+        items.push({
+            label: '💾 Save and Return',
+            value: 'save',
+        });
+        items.push({
+            label: '← Cancel',
+            value: 'cancel',
+        });
+        return items;
+    };
+    const handleMenuSelect = (item) => {
+        if (item.value === 'save') {
+            configurationManager.setStatusHooks(hooks);
+            setShowSaveMessage(true);
+            setTimeout(() => {
+                onComplete();
+            }, 1000);
+        }
+        else if (item.value === 'cancel') {
+            onComplete();
+        }
+        else if (item.value !== 'separator') {
+            const status = item.value;
+            setSelectedStatus(status);
+            const hook = hooks[status];
+            setCurrentCommand(hook?.command || '');
+            setCurrentEnabled(hook?.enabled ?? true); // Default to true if not set
+            setView('edit');
+        }
+    };
+    const handleCommandSubmit = (value) => {
+        setHooks(prev => ({
+            ...prev,
+            [selectedStatus]: {
+                command: value,
+                enabled: currentEnabled,
+            },
+        }));
+        setView('menu');
+    };
+    const toggleEnabled = () => {
+        setCurrentEnabled(prev => !prev);
+    };
+    if (showSaveMessage) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "\u2713 Configuration saved successfully!")));
+    }
+    if (view === 'edit') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" },
+                    "Configure ",
+                    STATUS_LABELS[selectedStatus],
+                    " Hook")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Command to execute when status changes to",
+                    ' ',
+                    STATUS_LABELS[selectedStatus],
+                    ":")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(TextInput, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., notify-send 'Claude is idle')" })),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Enabled: ",
+                    currentEnabled ? '✓' : '✗',
+                    " (Press Tab to toggle)")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Environment variables available: CCMANAGER_OLD_STATE, CCMANAGER_NEW_STATE,")),
+            React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true }, "CCMANAGER_WORKTREE, CCMANAGER_WORKTREE_BRANCH, CCMANAGER_SESSION_ID")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to save, Tab to toggle enabled, Esc to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Status Change Hooks")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Set commands to run when Claude Code session status changes:")),
+        React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Esc to go back"))));
+};
+export default ConfigureHooks;

package/dist/components/Menu.js

@@ -67,8 +67,8 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             value: 'delete-worktree',
         });
         menuItems.push({
-            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configure Shortcuts`,
-            value: 'configure-shortcuts',
+            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configuration`,
+            value: 'configuration',
         });
         menuItems.push({
             label: `${MENU_ICONS.EXIT} Exit`,
@@ -107,10 +107,10 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
                 hasSession: false,
             });
         }
-        else if (item.value === 'configure-shortcuts') {
+        else if (item.value === 'configuration') {
             // Handle in parent component - use special marker
             onSelectWorktree({
-                path: 'CONFIGURE_SHORTCUTS',
+                path: 'CONFIGURATION',
                 branch: '',
                 isMainWorktree: false,
                 hasSession: false,

package/dist/components/Session.js

@@ -39,6 +39,15 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         sessionManager.on('sessionRestore', handleSessionRestore);
         // Mark session as active (this will trigger the restore event)
         sessionManager.setSessionActive(session.worktreePath, true);
+        // Immediately resize the PTY and terminal to current dimensions
+        // This fixes rendering issues when terminal width changed while in menu
+        // https://github.com/kbwo/ccmanager/issues/2
+        const currentCols = process.stdout.columns || 80;
+        const currentRows = process.stdout.rows || 24;
+        session.process.resize(currentCols, currentRows);
+        if (session.terminal) {
+            session.terminal.resize(currentCols, currentRows);
+        }
         // Listen for session data events
         const handleSessionData = (activeSession, data) => {
             // Only handle data for our session

package/dist/services/configurationManager.d.ts

@@ -0,0 +1,17 @@
+import { ConfigurationData, StatusHookConfig, ShortcutConfig } from '../types/index.js';
+export declare class ConfigurationManager {
+    private configPath;
+    private legacyShortcutsPath;
+    private config;
+    constructor();
+    private loadConfig;
+    private migrateLegacyShortcuts;
+    private saveConfig;
+    getShortcuts(): ShortcutConfig;
+    setShortcuts(shortcuts: ShortcutConfig): void;
+    getStatusHooks(): StatusHookConfig;
+    setStatusHooks(hooks: StatusHookConfig): void;
+    getConfiguration(): ConfigurationData;
+    setConfiguration(config: ConfigurationData): void;
+}
+export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -0,0 +1,115 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_SHORTCUTS, } from '../types/index.js';
+export class ConfigurationManager {
+    constructor() {
+        Object.defineProperty(this, "configPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "legacyShortcutsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Determine config directory based on platform
+        const homeDir = homedir();
+        const configDir = process.platform === 'win32'
+            ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+            : join(homeDir, '.config', 'ccmanager');
+        // Ensure config directory exists
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        this.configPath = join(configDir, 'config.json');
+        this.legacyShortcutsPath = join(configDir, 'shortcuts.json');
+        this.loadConfig();
+    }
+    loadConfig() {
+        // Try to load the new config file
+        if (existsSync(this.configPath)) {
+            try {
+                const configData = readFileSync(this.configPath, 'utf-8');
+                this.config = JSON.parse(configData);
+            }
+            catch (error) {
+                console.error('Failed to load configuration:', error);
+                this.config = {};
+            }
+        }
+        else {
+            // If new config doesn't exist, check for legacy shortcuts.json
+            this.migrateLegacyShortcuts();
+        }
+        // Check if shortcuts need to be loaded from legacy file
+        // This handles the case where config.json exists but doesn't have shortcuts
+        if (!this.config.shortcuts && existsSync(this.legacyShortcutsPath)) {
+            this.migrateLegacyShortcuts();
+        }
+        // Ensure default values
+        if (!this.config.shortcuts) {
+            this.config.shortcuts = DEFAULT_SHORTCUTS;
+        }
+        if (!this.config.statusHooks) {
+            this.config.statusHooks = {};
+        }
+    }
+    migrateLegacyShortcuts() {
+        if (existsSync(this.legacyShortcutsPath)) {
+            try {
+                const shortcutsData = readFileSync(this.legacyShortcutsPath, 'utf-8');
+                const shortcuts = JSON.parse(shortcutsData);
+                // Validate that it's a valid shortcuts config
+                if (shortcuts && typeof shortcuts === 'object') {
+                    this.config.shortcuts = shortcuts;
+                    // Save to new config format
+                    this.saveConfig();
+                    console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                }
+            }
+            catch (error) {
+                console.error('Failed to migrate legacy shortcuts:', error);
+            }
+        }
+    }
+    saveConfig() {
+        try {
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save configuration:', error);
+        }
+    }
+    getShortcuts() {
+        return this.config.shortcuts || DEFAULT_SHORTCUTS;
+    }
+    setShortcuts(shortcuts) {
+        this.config.shortcuts = shortcuts;
+        this.saveConfig();
+    }
+    getStatusHooks() {
+        return this.config.statusHooks || {};
+    }
+    setStatusHooks(hooks) {
+        this.config.statusHooks = hooks;
+        this.saveConfig();
+    }
+    getConfiguration() {
+        return this.config;
+    }
+    setConfiguration(config) {
+        this.config = config;
+        this.saveConfig();
+    }
+}
+export const configurationManager = new ConfigurationManager();

package/dist/services/sessionManager.d.ts

@@ -15,6 +15,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
+    private executeStatusHook;
     destroy(): void;
 }
 export {};

package/dist/services/sessionManager.js

@@ -1,6 +1,9 @@
 import { spawn } from 'node-pty';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
+import { exec } from 'child_process';
+import { configurationManager } from './configurationManager.js';
+import { WorktreeService } from './worktreeService.js';
 const { Terminal } = pkg;
 export class SessionManager extends EventEmitter {
     stripAnsi(str) {
@@ -131,6 +134,7 @@ export class SessionManager extends EventEmitter {
             const newState = this.detectTerminalState(session.terminal);
             if (newState !== oldState) {
                 session.state = newState;
+                this.executeStatusHook(oldState, newState, session);
                 this.emit('sessionStateChanged', session);
             }
         }, 100); // Check every 100ms
@@ -187,6 +191,36 @@ export class SessionManager extends EventEmitter {
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
+    executeStatusHook(oldState, newState, session) {
+        const statusHooks = configurationManager.getStatusHooks();
+        const hook = statusHooks[newState];
+        if (hook && hook.enabled && hook.command) {
+            // Get branch information
+            const worktreeService = new WorktreeService();
+            const worktrees = worktreeService.getWorktrees();
+            const worktree = worktrees.find(wt => wt.path === session.worktreePath);
+            const branch = worktree?.branch || 'unknown';
+            // Execute the hook command in the session's worktree directory
+            exec(hook.command, {
+                cwd: session.worktreePath,
+                env: {
+                    ...process.env,
+                    CCMANAGER_OLD_STATE: oldState,
+                    CCMANAGER_NEW_STATE: newState,
+                    CCMANAGER_WORKTREE: session.worktreePath,
+                    CCMANAGER_WORKTREE_BRANCH: branch,
+                    CCMANAGER_SESSION_ID: session.id,
+                },
+            }, (error, _stdout, stderr) => {
+                if (error) {
+                    console.error(`Failed to execute ${newState} hook: ${error.message}`);
+                }
+                if (stderr) {
+                    console.error(`Hook stderr: ${stderr}`);
+                }
+            });
+        }
+    }
     destroy() {
         // Clean up all sessions
         for (const worktreePath of this.sessions.keys()) {

package/dist/services/shortcutManager.d.ts

@@ -1,11 +1,8 @@
 import { ShortcutKey, ShortcutConfig } from '../types/index.js';
 import { Key } from 'ink';
 export declare class ShortcutManager {
-    private shortcuts;
-    private configPath;
     private reservedKeys;
     constructor();
-    private loadShortcuts;
     private validateShortcut;
     private isReservedKey;
     saveShortcuts(shortcuts: ShortcutConfig): boolean;

package/dist/services/shortcutManager.js

@@ -1,21 +1,6 @@
-import { DEFAULT_SHORTCUTS, } from '../types/index.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
+import { configurationManager } from './configurationManager.js';
 export class ShortcutManager {
     constructor() {
-        Object.defineProperty(this, "shortcuts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "configPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "reservedKeys", {
             enumerable: true,
             configurable: true,
@@ -27,31 +12,6 @@ export class ShortcutManager {
                 { ctrl: true, key: '[' },
             ]
         });
-        // Use platform-specific config directory
-        const configDir = process.platform === 'win32'
-            ? path.join(process.env['APPDATA'] || os.homedir(), 'ccmanager')
-            : path.join(os.homedir(), '.config', 'ccmanager');
-        this.configPath = path.join(configDir, 'shortcuts.json');
-        this.shortcuts = this.loadShortcuts();
-    }
-    loadShortcuts() {
-        try {
-            if (fs.existsSync(this.configPath)) {
-                const data = fs.readFileSync(this.configPath, 'utf8');
-                const loaded = JSON.parse(data);
-                // Validate loaded shortcuts
-                const validated = {
-                    returnToMenu: this.validateShortcut(loaded.returnToMenu) ||
-                        DEFAULT_SHORTCUTS.returnToMenu,
-                    cancel: this.validateShortcut(loaded.cancel) || DEFAULT_SHORTCUTS.cancel,
-                };
-                return validated;
-            }
-        }
-        catch (error) {
-            console.error('Failed to load shortcuts:', error);
-        }
-        return { ...DEFAULT_SHORTCUTS };
     }
     validateShortcut(shortcut) {
         if (!shortcut || typeof shortcut !== 'object') {
@@ -88,30 +48,21 @@ export class ShortcutManager {
     }
     saveShortcuts(shortcuts) {
         // Validate all shortcuts
+        const currentShortcuts = configurationManager.getShortcuts();
         const validated = {
             returnToMenu: this.validateShortcut(shortcuts.returnToMenu) ||
-                this.shortcuts.returnToMenu,
-            cancel: this.validateShortcut(shortcuts.cancel) || this.shortcuts.cancel,
+                currentShortcuts.returnToMenu,
+            cancel: this.validateShortcut(shortcuts.cancel) || currentShortcuts.cancel,
         };
-        try {
-            const dir = path.dirname(this.configPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(this.configPath, JSON.stringify(validated, null, 2));
-            this.shortcuts = validated;
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to save shortcuts:', error);
-            return false;
-        }
+        configurationManager.setShortcuts(validated);
+        return true;
     }
     getShortcuts() {
-        return { ...this.shortcuts };
+        return configurationManager.getShortcuts();
     }
     matchesShortcut(shortcutName, input, key) {
-        const shortcut = this.shortcuts[shortcutName];
+        const shortcuts = configurationManager.getShortcuts();
+        const shortcut = shortcuts[shortcutName];
         if (!shortcut)
             return false;
         // Handle escape key specially
@@ -129,7 +80,8 @@ export class ShortcutManager {
         return input.toLowerCase() === shortcut.key.toLowerCase();
     }
     getShortcutDisplay(shortcutName) {
-        const shortcut = this.shortcuts[shortcutName];
+        const shortcuts = configurationManager.getShortcuts();
+        const shortcut = shortcuts[shortcutName];
         if (!shortcut)
             return '';
         const parts = [];

package/dist/services/worktreeService.js

@@ -32,7 +32,12 @@ export class WorktreeService {
                     };
                 }
                 else if (line.startsWith('branch ')) {
-                    currentWorktree.branch = line.substring(7);
+                    let branch = line.substring(7);
+                    // Remove refs/heads/ prefix if present
+                    if (branch.startsWith('refs/heads/')) {
+                        branch = branch.substring(11);
+                    }
+                    currentWorktree.branch = branch;
                 }
                 else if (line === 'bare') {
                     currentWorktree.isMainWorktree = true;

package/dist/types/index.d.ts

@@ -38,3 +38,16 @@ export interface ShortcutConfig {
     cancel: ShortcutKey;
 }
 export declare const DEFAULT_SHORTCUTS: ShortcutConfig;
+export interface StatusHook {
+    command: string;
+    enabled: boolean;
+}
+export interface StatusHookConfig {
+    idle?: StatusHook;
+    busy?: StatusHook;
+    waiting_input?: StatusHook;
+}
+export interface ConfigurationData {
+    shortcuts?: ShortcutConfig;
+    statusHooks?: StatusHookConfig;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",