code-squad-cli 1.2.22 → 1.3.0

package/dist/adapters/GitAdapter.js

@@ -14,8 +14,20 @@ export class GitAdapter {
         }
     }
     async getCurrentBranch(workspaceRoot) {
-        const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
-        return stdout.trim();
+        try {
+            const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+            return stdout.trim();
+        }
+        catch {
+            // No commits yet — fall back to symbolic-ref (e.g. "main" on fresh repos)
+            try {
+                const { stdout } = await exec(`cd "${workspaceRoot}" && git symbolic-ref --short HEAD`, execOptions);
+                return stdout.trim();
+            }
+            catch {
+                return '';
+            }
+        }
     }
     async listWorktrees(workspaceRoot) {
         try {
@@ -57,10 +69,12 @@ export class GitAdapter {
         }
     }
     async createWorktree(worktreePath, branch, workspaceRoot) {
-        // Extract parent directory and create it if needed
+        // Prune stale worktree entries (e.g. directory was deleted but still registered)
+        await exec(`cd "${workspaceRoot}" && git worktree prune`, execOptions).catch(() => { });
+        // Recursively create parent directory
         const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf('/'));
         const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : '';
-        await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add "${worktreePath}" -b "${branch}"`, execOptions);
+        await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add -f "${worktreePath}" -b "${branch}"`, execOptions);
     }
     async removeWorktree(worktreePath, workspaceRoot, force = false) {
         const forceFlag = force ? ' --force' : '';

package/dist/dash/InkDashboard.d.ts

@@ -0,0 +1,13 @@
+import type { TmuxWindowInfo } from './types.js';
+import { TmuxAdapter } from './TmuxAdapter.js';
+interface DashboardProps {
+    workspaceRoot: string;
+    repoName: string;
+    currentBranch: string;
+    initialWindows: TmuxWindowInfo[];
+    tmuxAdapter: TmuxAdapter;
+    dashWindowIndex: number;
+    paneHeight: number;
+}
+export declare function runInkDashboard(config: DashboardProps): Promise<void>;
+export {};

package/dist/dash/InkDashboard.js

@@ -0,0 +1,442 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { render, Box, Text, useInput, useStdin } from 'ink';
+import TextInput from 'ink-text-input';
+import { loadAllWindows, deleteWindowById } from './windowHelpers.js';
+import { createThread, deleteThread } from './threadHelpers.js';
+import { expandTilde } from './pathUtils.js';
+import { useDirectorySuggestions } from './useDirectorySuggestions.js';
+import { usePathValidation } from './usePathValidation.js';
+function parseMouseEvent(data) {
+    const match = data.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+    if (!match)
+        return null;
+    return {
+        button: parseInt(match[1], 10),
+        col: parseInt(match[2], 10),
+        row: parseInt(match[3], 10),
+        release: match[4] === 'm',
+    };
+}
+// 마우스 훅
+function useMouse(onMouseClick, enabled = true) {
+    const { stdin } = useStdin();
+    useEffect(() => {
+        if (!enabled) {
+            process.stdout.write('\x1b[?1006l');
+            process.stdout.write('\x1b[?1000l');
+            return;
+        }
+        process.stdout.write('\x1b[?1000h');
+        process.stdout.write('\x1b[?1006h');
+        const handleData = (data) => {
+            const str = data.toString();
+            if (str.includes('\x1b[<')) {
+                const mouseEvent = parseMouseEvent(str);
+                if (mouseEvent && mouseEvent.button === 0 && !mouseEvent.release) {
+                    onMouseClick(mouseEvent.row, mouseEvent.col);
+                }
+            }
+        };
+        stdin?.on('data', handleData);
+        return () => {
+            process.stdout.write('\x1b[?1006l');
+            process.stdout.write('\x1b[?1000l');
+            stdin?.off('data', handleData);
+        };
+    }, [stdin, onMouseClick, enabled]);
+}
+// Window 카드 컴포넌트
+function WindowCard({ window, isSelected, }) {
+    const borderColor = isSelected ? 'cyan' : 'gray';
+    const nameColor = isSelected ? 'cyan' : 'white';
+    const statusIcon = window.isActive ? '●' : '○';
+    const statusColor = window.isActive ? 'green' : 'gray';
+    const projectName = window.projectRoot
+        ? window.projectRoot.split('/').slice(-1)[0]
+        : window.cwd.split('/').slice(-1)[0];
+    const threadName = window.worktreeBranch ?? window.name;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, paddingX: 1, marginBottom: 0, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsx(Text, { color: nameColor, bold: isSelected, children: window.name }), isSelected && _jsx(Text, { color: "red", children: " \u2715" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: projectName }), _jsx(Text, { color: "gray", children: " \u2192 " }), _jsx(Text, { color: "cyan", children: threadName })] })] }));
+}
+// 새 Window 폼 컴포넌트
+function NewWindowForm({ windowName, onWindowNameChange, rootPath, onRootPathChange, validation, onSubmit, onCancel, }) {
+    const [focusedField, setFocusedField] = useState('name');
+    const dirSuggestions = useDirectorySuggestions();
+    useInput(async (input, key) => {
+        if (key.escape) {
+            if (dirSuggestions.isOpen) {
+                dirSuggestions.clearSuggestions();
+            }
+            else {
+                onCancel();
+            }
+            return;
+        }
+        if (key.return) {
+            if (dirSuggestions.isOpen) {
+                const accepted = dirSuggestions.acceptSelected(rootPath);
+                if (accepted)
+                    onRootPathChange(accepted);
+            }
+            else {
+                onSubmit();
+            }
+            return;
+        }
+        if (key.tab) {
+            if (dirSuggestions.isOpen) {
+                dirSuggestions.clearSuggestions();
+            }
+            setFocusedField(prev => prev === 'name' ? 'root' : 'name');
+            return;
+        }
+        if (key.upArrow) {
+            if (dirSuggestions.isOpen) {
+                dirSuggestions.selectPrev();
+            }
+            else {
+                setFocusedField('name');
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (dirSuggestions.isOpen) {
+                dirSuggestions.selectNext();
+            }
+            else {
+                setFocusedField('root');
+            }
+            return;
+        }
+    });
+    // Auto-trigger suggestions as user types
+    const handleRootPathChange = useCallback(async (value) => {
+        onRootPathChange(value);
+        if (value.endsWith('/')) {
+            const completed = await dirSuggestions.triggerComplete(value);
+            if (completed)
+                onRootPathChange(completed);
+        }
+        else if (value.length > 1 && value.includes('/')) {
+            await dirSuggestions.triggerComplete(value);
+        }
+        else {
+            dirSuggestions.clearSuggestions();
+        }
+    }, [dirSuggestions, onRootPathChange]);
+    // Validation indicator
+    let validationIcon = '';
+    let validationColor;
+    let validationText = '';
+    if (validation) {
+        if (validation.status === 'valid') {
+            if (validation.isGitRepo) {
+                validationIcon = '✓';
+                validationColor = 'green';
+                validationText = 'git repo';
+            }
+            else {
+                validationIcon = '✗';
+                validationColor = 'red';
+                validationText = 'not a git repo';
+            }
+        }
+        else if (validation.status === 'creatable') {
+            validationIcon = '✗';
+            validationColor = 'red';
+            validationText = 'not a git repo';
+        }
+        else {
+            validationIcon = '✗';
+            validationColor = 'red';
+            validationText = 'invalid path';
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: "+ New Window" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: focusedField === 'name' ? 'cyan' : undefined, children: "Name: " }), _jsx(TextInput, { value: windowName, onChange: focusedField === 'name' ? onWindowNameChange : () => { }, placeholder: "window-name", focus: focusedField === 'name' })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: focusedField === 'root' ? 'cyan' : 'gray', children: "Root: " }), focusedField === 'root' ? (_jsx(TextInput, { value: rootPath, onChange: handleRootPathChange, placeholder: "/path/to/dir", focus: true })) : (_jsx(Text, { color: "gray", children: rootPath }))] }), validation && (_jsxs(Box, { children: [_jsx(Text, { children: "  " }), _jsxs(Text, { color: validationColor, children: [validationIcon, " ", validationText] })] })), dirSuggestions.isOpen && dirSuggestions.visibleSuggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [dirSuggestions.visibleSuggestions.map((s) => (_jsx(Box, { children: _jsxs(Text, { color: s.isSelected ? 'cyan' : 'gray', children: [s.isSelected ? ' > ' : '   ', s.name, "/"] }) }, s.name))), dirSuggestions.hasMore && (_jsx(Text, { color: "gray", children: "   \u2191\u2193 for more" }))] })), dirSuggestions.isOpen ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "\u2191\u2193:select Enter:pick Esc:close" }) })) : (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Tab:field Enter:ok Esc:cancel" }) }))] }));
+}
+// 삭제 확인 컴포넌트
+function DeleteConfirm({ windowName, onConfirm, onCancel, }) {
+    useInput((input, key) => {
+        if (input === 'y' || input === 'Y') {
+            onConfirm();
+        }
+        else if (input === 'n' || input === 'N' || key.escape) {
+            onCancel();
+        }
+    });
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsxs(Text, { color: "red", children: ["Delete \"", windowName, "\"? "] }), _jsx(Text, { color: "gray", children: "(y/n)" })] }));
+}
+// 힌트 바 컴포넌트
+function HintBar({ mode }) {
+    if (mode === 'new-window') {
+        return null;
+    }
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "\u2191\u2193/jk: nav  Enter: switch  r: refresh  q: detach" }) }));
+}
+// 메인 대시보드 컴포넌트
+function Dashboard({ workspaceRoot, repoName, currentBranch, initialWindows, tmuxAdapter, dashWindowIndex, paneHeight, }) {
+    const [windows, setWindows] = useState(initialWindows);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [inputMode, setInputMode] = useState('normal');
+    const [newWindowName, setNewWindowName] = useState('');
+    const [rootPath, setRootPath] = useState(workspaceRoot);
+    // Dynamic git repo detection from path validation
+    const { validation, isGitRepo: formIsGitRepo } = usePathValidation(rootPath);
+    // name 변경 핸들러 (공백 제거)
+    const handleWindowNameChange = useCallback((value) => {
+        const sanitized = value.replace(/\s/g, '');
+        setNewWindowName(sanitized);
+    }, []);
+    const [status, setStatus] = useState('');
+    const [isProcessing, setIsProcessing] = useState(false);
+    // Track which window's content is currently shown in the right pane
+    const activeWindowIdRef = useRef(null);
+    const statusTimerRef = useRef(null);
+    // Auto-clear status message after 2 seconds
+    const showStatus = useCallback((msg) => {
+        if (statusTimerRef.current)
+            clearTimeout(statusTimerRef.current);
+        setStatus(msg);
+        statusTimerRef.current = setTimeout(() => setStatus(''), 2000);
+    }, []);
+    // Window 목록 새로고침
+    const refreshWindows = useCallback(async () => {
+        const updatedWindows = await loadAllWindows(tmuxAdapter, dashWindowIndex);
+        setWindows(updatedWindows);
+        return { windows: updatedWindows };
+    }, [tmuxAdapter, dashWindowIndex]);
+    // Auto-select first thread on restore (mount)
+    useEffect(() => {
+        if (initialWindows.length === 0)
+            return;
+        const first = initialWindows[0];
+        if (first) {
+            void handleSelectWindow(first);
+        }
+    }, []);
+    // 레이아웃 행 계산 (마우스 클릭 매핑용)
+    const HEADER_ROWS = 3;
+    const NEW_WINDOW_ROWS = 3;
+    const WINDOW_START_ROW = HEADER_ROWS + NEW_WINDOW_ROWS + 2;
+    const WINDOW_HEIGHT = 4;
+    // 마우스 클릭 핸들러
+    const handleMouseClick = useCallback((row, col) => {
+        if (isProcessing || inputMode !== 'normal')
+            return;
+        // 새 Window 버튼 클릭
+        if (row >= HEADER_ROWS + 1 && row <= HEADER_ROWS + NEW_WINDOW_ROWS + 1) {
+            setInputMode('new-window');
+            setNewWindowName('');
+            setRootPath(workspaceRoot);
+            return;
+        }
+        // Window 리스트 클릭
+        if (row >= WINDOW_START_ROW && windows.length > 0) {
+            const windowIndex = Math.floor((row - WINDOW_START_ROW) / WINDOW_HEIGHT);
+            if (windowIndex >= 0 && windowIndex < windows.length) {
+                setSelectedIndex(windowIndex);
+                // 클릭하면 바로 전환
+                void handleSelectWindow(windows[windowIndex]);
+            }
+        }
+    }, [isProcessing, inputMode, windows, workspaceRoot]);
+    // 마우스 이벤트 (normal 모드에서만 활성화)
+    useMouse(handleMouseClick, inputMode === 'normal');
+    // 오른쪽 pane 찾기 (대시보드 pane index 0 제외)
+    const findRightPane = async () => {
+        const panes = await tmuxAdapter.listPanes();
+        return panes.find(p => p.index !== 0);
+    };
+    // Window 선택 (오른쪽 pane에 swap)
+    const handleSelectWindow = async (win) => {
+        try {
+            // Already showing this window — just focus the right pane
+            if (win.windowId === activeWindowIdRef.current) {
+                const rightPane = await findRightPane();
+                if (rightPane)
+                    await tmuxAdapter.selectPane(rightPane.id);
+                return;
+            }
+            // Swap current right pane back to its original window
+            if (activeWindowIdRef.current) {
+                const rightPane = await findRightPane();
+                if (rightPane) {
+                    try {
+                        await tmuxAdapter.swapPaneWithWindow(activeWindowIdRef.current, rightPane.id);
+                    }
+                    catch {
+                        // Original window may have been killed externally
+                    }
+                }
+            }
+            // Swap selected window's pane into the right position
+            const rightPane = await findRightPane();
+            if (rightPane) {
+                await tmuxAdapter.swapPaneWithWindow(win.windowId, rightPane.id);
+                activeWindowIdRef.current = win.windowId;
+                await tmuxAdapter.selectPane((await findRightPane()).id);
+            }
+            showStatus(`Switched: ${win.name}`);
+        }
+        catch (error) {
+            showStatus(`Error: ${error.message}`);
+        }
+    };
+    // 키보드 입력 처리 (normal 모드)
+    useInput(async (input, key) => {
+        // Allow Escape to cancel during processing
+        if (isProcessing) {
+            if (key.escape) {
+                setIsProcessing(false);
+                setInputMode('normal');
+                showStatus('Cancelled');
+            }
+            return;
+        }
+        if (inputMode !== 'normal')
+            return;
+        if (input === 'j' || key.downArrow) {
+            setSelectedIndex(prev => (prev + 1) % Math.max(windows.length, 1));
+        }
+        else if (input === 'k' || key.upArrow) {
+            setSelectedIndex(prev => (prev - 1 + Math.max(windows.length, 1)) % Math.max(windows.length, 1));
+        }
+        else if (input === 'q') {
+            try {
+                // Swap active pane back to its original window before quitting
+                if (activeWindowIdRef.current) {
+                    const rightPane = await findRightPane();
+                    if (rightPane) {
+                        try {
+                            await tmuxAdapter.swapPaneWithWindow(activeWindowIdRef.current, rightPane.id);
+                        }
+                        catch {
+                            // Original window may have been killed externally
+                        }
+                    }
+                }
+                // Detach + kill dashboard window in one atomic tmux command.
+                // Thread windows stay alive in the detached session.
+                const sessionName = `csq-${repoName}`;
+                await tmuxAdapter.detachAndKillWindow(sessionName, dashWindowIndex);
+            }
+            catch {
+                // Detach/kill may race, ignore
+            }
+        }
+        else if (key.return) {
+            const selected = windows[selectedIndex];
+            if (selected) {
+                await handleSelectWindow(selected);
+            }
+        }
+        else if (input === 'n' || input === '+') {
+            setInputMode('new-window');
+            setNewWindowName('');
+            setRootPath(workspaceRoot);
+        }
+        else if (input === 'd') {
+            if (windows[selectedIndex]) {
+                setInputMode('confirm-delete');
+            }
+        }
+        else if (input === 'r') {
+            process.stdout.write('\x1b[2J\x1b[H');
+            process.stdout.emit('resize');
+            await refreshWindows();
+            showStatus('Refreshed');
+        }
+    });
+    // 새 Window 생성
+    const handleCreateWindow = async () => {
+        if (!newWindowName.trim()) {
+            showStatus('Window name required');
+            return;
+        }
+        if (!validation || !formIsGitRepo) {
+            showStatus('Root must be a git repo');
+            return;
+        }
+        setIsProcessing(true);
+        setStatus(`Creating ${newWindowName}...`);
+        try {
+            const expandedRoot = expandTilde(rootPath);
+            const newThread = await createThread(workspaceRoot, newWindowName.trim(), expandedRoot);
+            const newWindowId = await tmuxAdapter.createNewWindow(newThread.path, newWindowName.trim());
+            const { windows: updatedWindows } = await refreshWindows();
+            setInputMode('normal');
+            setNewWindowName('');
+            showStatus(`Created: ${newWindowName}`);
+            // Auto-select the new window into the right pane
+            const newWin = updatedWindows.find(w => w.windowId === newWindowId);
+            if (newWin) {
+                await handleSelectWindow(newWin);
+            }
+        }
+        catch (error) {
+            showStatus(`Error: ${error.message}`);
+        }
+        setIsProcessing(false);
+    };
+    // Window 삭제
+    const handleDeleteWindow = async () => {
+        const selected = windows[selectedIndex];
+        if (!selected)
+            return;
+        setIsProcessing(true);
+        setStatus(`Deleting ${selected.name}...`);
+        try {
+            // If this window's pane is currently in the right pane, swap it back first
+            if (selected.windowId === activeWindowIdRef.current) {
+                const rightPane = await findRightPane();
+                if (rightPane) {
+                    try {
+                        await tmuxAdapter.swapPaneWithWindow(selected.windowId, rightPane.id);
+                    }
+                    catch { /* ignore */ }
+                }
+                activeWindowIdRef.current = null;
+            }
+            // Kill the tmux window
+            await deleteWindowById(tmuxAdapter, selected.windowId);
+            // If it's a worktree-based window, also remove the worktree + branch
+            if (selected.worktreeBranch) {
+                try {
+                    await deleteThread(workspaceRoot, {
+                        id: selected.cwd,
+                        name: selected.worktreeBranch,
+                        path: selected.cwd,
+                        branch: selected.worktreeBranch,
+                    });
+                }
+                catch {
+                    // Worktree cleanup failed — window is already deleted
+                }
+            }
+            const { windows: updatedWindows } = await refreshWindows();
+            const newIndex = Math.min(selectedIndex, Math.max(0, updatedWindows.length - 1));
+            setSelectedIndex(newIndex);
+            // Auto-select the previous/next window into the right pane
+            const fallbackWin = updatedWindows[newIndex];
+            if (fallbackWin) {
+                await handleSelectWindow(fallbackWin);
+            }
+            setInputMode('normal');
+            showStatus(`Deleted: ${selected.name}`);
+        }
+        catch (error) {
+            showStatus(`Error: ${error.message}`);
+            setInputMode('normal');
+        }
+        setIsProcessing(false);
+    };
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, height: paneHeight, children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "white", children: repoName }), _jsxs(Text, { color: "cyan", children: [" [", currentBranch, "]"] }), _jsxs(Text, { color: "gray", children: [" (", windows.length, ")"] })] }), inputMode === 'new-window' ? (_jsx(NewWindowForm, { windowName: newWindowName, onWindowNameChange: handleWindowNameChange, rootPath: rootPath, onRootPathChange: setRootPath, validation: validation, onSubmit: handleCreateWindow, onCancel: () => {
+                    setInputMode('normal');
+                    setNewWindowName('');
+                } })) : (_jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginBottom: 1, children: _jsx(Text, { color: "gray", children: "+ New Window (press + or n)" }) })), inputMode === 'confirm-delete' && windows[selectedIndex] && (_jsx(DeleteConfirm, { windowName: windows[selectedIndex].name, onConfirm: handleDeleteWindow, onCancel: () => setInputMode('normal') })), _jsx(Box, { flexDirection: "column", marginTop: 1, children: windows.length === 0 ? (_jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(Text, { color: "gray", children: "No windows yet" }) })) : (windows.map((win, i) => (_jsx(WindowCard, { window: win, isSelected: i === selectedIndex }, win.windowId)))) }), _jsx(HintBar, { mode: inputMode }), status && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: status }) }))] }));
+}
+// 대시보드 실행
+export async function runInkDashboard(config) {
+    render(_jsx(Dashboard, { ...config }));
+    await new Promise(() => { });
+}