@akiojin/gwt 4.10.0 → 4.12.0

package/dist/cli/ui/components/App.js

@@ -1,1006 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState, } from "react";
-import { useApp } from "ink";
-import { ErrorBoundary } from "./common/ErrorBoundary.js";
-import { BranchListScreen, } from "./screens/BranchListScreen.js";
-import { LogListScreen } from "./screens/LogListScreen.js";
-import { LogDetailScreen } from "./screens/LogDetailScreen.js";
-import { LogDatePickerScreen } from "./screens/LogDatePickerScreen.js";
-import { BranchCreatorScreen } from "./screens/BranchCreatorScreen.js";
-import { BranchActionSelectorScreen } from "../screens/BranchActionSelectorScreen.js";
-import { CodingAgentSelectorScreen } from "./screens/CodingAgentSelectorScreen.js";
-import { ExecutionModeSelectorScreen } from "./screens/ExecutionModeSelectorScreen.js";
-import { BranchQuickStartScreen } from "./screens/BranchQuickStartScreen.js";
-import { ModelSelectorScreen, } from "./screens/ModelSelectorScreen.js";
-import { EnvironmentProfileScreen } from "./screens/EnvironmentProfileScreen.js";
-import { useGitData } from "../hooks/useGitData.js";
-import { useProfiles } from "../hooks/useProfiles.js";
-import { useScreenState } from "../hooks/useScreenState.js";
-import { useToolStatus } from "../hooks/useToolStatus.js";
-import { formatBranchItems } from "../utils/branchFormatter.js";
-import { calculateStatistics } from "../utils/statisticsCalculator.js";
-import { copyToClipboard } from "../utils/clipboard.js";
-import { parseLogLines, } from "../../../logging/formatter.js";
-import { buildLogFilePath, getTodayLogDate, listRecentLogFiles, readLogFileLines, resolveLogDir, } from "../../../logging/reader.js";
-import { getRepositoryRoot, deleteBranch } from "../../../git.js";
-import { loadSession } from "../../../config/index.js";
-import { createWorktree, generateWorktreePath, isProtectedBranchName, removeWorktree, switchToProtectedBranch, } from "../../../worktree.js";
-import { getPackageVersion } from "../../../utils.js";
-import { resolveBaseBranchLabel, resolveBaseBranchRef, } from "../utils/baseBranch.js";
-import { getDefaultInferenceForModel, getDefaultModelOption, normalizeModelId, } from "../utils/modelOptions.js";
-import { resolveContinueSessionId, findLatestBranchSessionsByTool, } from "../utils/continueSession.js";
-import { findLatestCodexSession, findLatestCodexSessionId, findLatestClaudeSession, findLatestGeminiSession, findLatestOpenCodeSession, } from "../../../utils/session.js";
-const COMPLETION_HOLD_DURATION_MS = 3000;
-const PROTECTED_BRANCH_WARNING = "Root branches operate directly in the repository root. Create a new branch if you need a dedicated worktree.";
-/**
- * App - Top-level component for Ink.js UI
- * Integrates ErrorBoundary, data fetching, screen navigation, and all screens
- */
-export function App({ onExit, loadingIndicatorDelay = 300 }) {
-    const { exit } = useApp();
-    // 起動ディレクトリの取得
-    const workingDirectory = process.cwd();
-    const { branches, worktrees, loading, error, refresh, lastUpdated } = useGitData({
-        enableAutoRefresh: false, // Manual refresh with 'r' key
-    });
-    const { currentScreen, navigateTo, goBack } = useScreenState();
-    // Profile state
-    const { activeProfileName, refresh: refreshProfiles } = useProfiles();
-    // Tool status state (FR-017: 起動時に検出してキャッシュ)
-    const { tools: toolStatuses } = useToolStatus();
-    // Version state
-    const [version, setVersion] = useState(null);
-    const [repoRoot, setRepoRoot] = useState(null);
-    const [continueSessionId, setContinueSessionId] = useState(null);
-    const [branchQuickStart, setBranchQuickStart] = useState([]);
-    const [branchQuickStartLoading, setBranchQuickStartLoading] = useState(false);
-    // Log viewer state
-    const logDir = useMemo(() => resolveLogDir(workingDirectory), [workingDirectory]);
-    const [logEntries, setLogEntries] = useState([]);
-    const [logLoading, setLogLoading] = useState(false);
-    const [logError, setLogError] = useState(null);
-    const [logSelectedDate, setLogSelectedDate] = useState(getTodayLogDate());
-    const [logDates, setLogDates] = useState([]);
-    const [logSelectedEntry, setLogSelectedEntry] = useState(null);
-    const [logNotification, setLogNotification] = useState(null);
-    const logNotificationTimerRef = useRef(null);
-    // Selection state (for branch → tool → mode flow)
-    const [selectedBranch, setSelectedBranch] = useState(null);
-    const [creationSourceBranch, setCreationSourceBranch] = useState(null);
-    const [selectedTool, setSelectedTool] = useState(null);
-    const [selectedModel, setSelectedModel] = useState(null);
-    const [lastModelByTool, setLastModelByTool] = useState({});
-    const [preferredToolId, setPreferredToolId] = useState(null);
-    // PR cleanup feedback
-    const [cleanupIndicators, setCleanupIndicators] = useState({});
-    const [_cleanupProcessingBranch, setCleanupProcessingBranch] = useState(null);
-    const [cleanupInputLocked, setCleanupInputLocked] = useState(false);
-    const [cleanupFooterMessage, setCleanupFooterMessage] = useState(null);
-    const [hiddenBranches, setHiddenBranches] = useState([]);
-    const [selectedBranches, setSelectedBranches] = useState([]);
-    const completionTimerRef = useRef(null);
-    // Fetch version on mount
-    useEffect(() => {
-        getPackageVersion()
-            .then(setVersion)
-            .catch(() => setVersion(null));
-    }, []);
-    // Fetch repository root once for session lookups
-    useEffect(() => {
-        getRepositoryRoot()
-            .then(setRepoRoot)
-            .catch(() => setRepoRoot(null));
-    }, []);
-    const showLogNotification = useCallback((message, tone = "success") => {
-        setLogNotification({ message, tone });
-        if (logNotificationTimerRef.current) {
-            clearTimeout(logNotificationTimerRef.current);
-        }
-        logNotificationTimerRef.current = setTimeout(() => {
-            setLogNotification(null);
-        }, 2000);
-    }, []);
-    useEffect(() => {
-        return () => {
-            if (logNotificationTimerRef.current) {
-                clearTimeout(logNotificationTimerRef.current);
-            }
-        };
-    }, []);
-    const loadLogEntries = useCallback(async (date) => {
-        const targetDate = date ?? getTodayLogDate();
-        setLogLoading(true);
-        setLogError(null);
-        try {
-            const filePath = buildLogFilePath(logDir, targetDate);
-            const lines = await readLogFileLines(filePath);
-            const parsed = parseLogLines(lines, { limit: 100 });
-            setLogEntries(parsed);
-        }
-        catch (error) {
-            setLogEntries([]);
-            setLogError(error instanceof Error ? error.message : "Failed to load logs");
-        }
-        finally {
-            setLogLoading(false);
-        }
-    }, [logDir]);
-    const loadLogDates = useCallback(async () => {
-        try {
-            const files = await listRecentLogFiles(logDir, 7);
-            setLogDates(files);
-        }
-        catch {
-            setLogDates([]);
-        }
-    }, [logDir]);
-    useEffect(() => {
-        if (currentScreen === "log-list") {
-            void loadLogEntries(logSelectedDate);
-        }
-    }, [currentScreen, loadLogEntries, logSelectedDate]);
-    useEffect(() => {
-        if (currentScreen === "log-date-picker") {
-            void loadLogDates();
-        }
-    }, [currentScreen, loadLogDates]);
-    useEffect(() => {
-        if (!hiddenBranches.length) {
-            return;
-        }
-        const existing = new Set(branches.map((branch) => branch.name));
-        const filtered = hiddenBranches.filter((name) => existing.has(name));
-        if (filtered.length !== hiddenBranches.length) {
-            setHiddenBranches(filtered);
-        }
-    }, [branches, hiddenBranches]);
-    // Remove selections that no longer exist (hidden or disappeared)
-    useEffect(() => {
-        setSelectedBranches((prev) => prev.filter((name) => branches.some((b) => b.name === name) &&
-            !hiddenBranches.includes(name)));
-    }, [branches, hiddenBranches]);
-    // Load quick start options for selected branch (latest per tool)
-    useEffect(() => {
-        if (!selectedBranch) {
-            setBranchQuickStart([]);
-            return;
-        }
-        let cancelled = false;
-        setBranchQuickStartLoading(true);
-        (async () => {
-            try {
-                const root = repoRoot ?? (await getRepositoryRoot());
-                if (!repoRoot && root) {
-                    setRepoRoot(root);
-                }
-                if (!root) {
-                    if (!cancelled)
-                        setBranchQuickStart([]);
-                    return;
-                }
-                const sessionData = await loadSession(root);
-                const history = sessionData?.history ?? [];
-                const combinedHistory = [...history];
-                if (sessionData?.lastSessionId &&
-                    sessionData.lastBranch === selectedBranch.name &&
-                    sessionData.lastUsedTool) {
-                    const synthetic = {
-                        branch: sessionData.lastBranch,
-                        worktreePath: sessionData.lastWorktreePath ?? null,
-                        toolId: sessionData.lastUsedTool,
-                        toolLabel: sessionData.toolLabel ?? sessionData.lastUsedTool,
-                        sessionId: sessionData.lastSessionId,
-                        mode: sessionData.mode ?? null,
-                        model: sessionData.model ?? null,
-                        reasoningLevel: sessionData.reasoningLevel ?? null,
-                        skipPermissions: sessionData.skipPermissions ?? null,
-                        timestamp: sessionData.timestamp ?? Date.now(),
-                    };
-                    combinedHistory.push(synthetic);
-                }
-                const latestPerTool = findLatestBranchSessionsByTool(combinedHistory, selectedBranch.name, selectedWorktreePath);
-                const mapped = await Promise.all(latestPerTool.map(async (entry) => {
-                    let sessionId = entry.sessionId ?? null;
-                    const worktree = selectedWorktreePath ?? workingDirectory;
-                    // For Codex, prefer a newer filesystem session over stale history
-                    if (!sessionId && entry.toolId === "codex-cli") {
-                        try {
-                            const historyTs = entry.timestamp ?? null;
-                            const latestCodex = await findLatestCodexSession({
-                                ...(historyTs
-                                    ? {
-                                        since: historyTs - 60_000,
-                                        preferClosestTo: historyTs,
-                                        windowMs: 60 * 60 * 1000,
-                                    }
-                                    : {}),
-                                cwd: worktree,
-                            });
-                            sessionId =
-                                latestCodex?.id ??
-                                    (await findLatestCodexSessionId({ cwd: worktree })) ??
-                                    null;
-                        }
-                        catch {
-                            // ignore lookup failure
-                        }
-                    }
-                    // For Claude Code, prefer the newest session file in the worktree even if history is stale.
-                    if (!sessionId && entry.toolId === "claude-code") {
-                        try {
-                            // Always resolve freshest on-disk session for this worktree (no window restriction)
-                            const latestAny = await findLatestClaudeSession(worktree);
-                            sessionId = latestAny?.id ?? null;
-                        }
-                        catch {
-                            // ignore lookup failure
-                        }
-                    }
-                    // For Gemini, prefer newest session file (Gemini keeps per-project chats)
-                    if (!sessionId && entry.toolId === "gemini-cli") {
-                        try {
-                            const gemOptions = {
-                                windowMs: 60 * 60 * 1000,
-                                cwd: worktree,
-                            };
-                            if (entry.timestamp !== null && entry.timestamp !== undefined) {
-                                gemOptions.since = entry.timestamp - 60_000;
-                                gemOptions.preferClosestTo = entry.timestamp;
-                            }
-                            const gemSession = await findLatestGeminiSession(gemOptions);
-                            sessionId = gemSession?.id ?? null;
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                    // For OpenCode, prefer newest session file
-                    if (!sessionId && entry.toolId === "opencode") {
-                        try {
-                            const openCodeOptions = {
-                                windowMs: 60 * 60 * 1000,
-                                cwd: worktree,
-                            };
-                            if (entry.timestamp !== null && entry.timestamp !== undefined) {
-                                openCodeOptions.since = entry.timestamp - 60_000;
-                                openCodeOptions.preferClosestTo = entry.timestamp;
-                            }
-                            const openCodeSession = await findLatestOpenCodeSession(openCodeOptions);
-                            sessionId = openCodeSession?.id ?? null;
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                    const normalizedModel = normalizeModelId(entry.toolId, entry.model ?? null);
-                    return {
-                        toolId: entry.toolId,
-                        toolLabel: entry.toolLabel,
-                        model: normalizedModel ?? null,
-                        inferenceLevel: (entry.reasoningLevel ??
-                            sessionData?.reasoningLevel ??
-                            null),
-                        sessionId,
-                        skipPermissions: entry.skipPermissions ?? sessionData?.skipPermissions ?? null,
-                        timestamp: entry.timestamp ?? null,
-                    };
-                }));
-                if (!cancelled) {
-                    setBranchQuickStart(mapped);
-                }
-            }
-            catch {
-                if (!cancelled)
-                    setBranchQuickStart([]);
-            }
-            finally {
-                if (!cancelled)
-                    setBranchQuickStartLoading(false);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [selectedBranch, repoRoot]);
-    // Load last session ID for "Continue" label when entering execution mode selector
-    useEffect(() => {
-        if (currentScreen !== "execution-mode-selector") {
-            return;
-        }
-        if (!selectedTool || !selectedBranch) {
-            setContinueSessionId(null);
-            return;
-        }
-        (async () => {
-            try {
-                const root = repoRoot ?? (await getRepositoryRoot());
-                if (!repoRoot && root) {
-                    setRepoRoot(root);
-                }
-                const sessionData = root ? await loadSession(root) : null;
-                const history = sessionData?.history ?? [];
-                const found = await resolveContinueSessionId({
-                    history,
-                    sessionData,
-                    branch: selectedBranch.name,
-                    toolId: selectedTool,
-                    repoRoot: root,
-                });
-                setContinueSessionId(found ?? null);
-            }
-            catch {
-                setContinueSessionId(null);
-            }
-        })();
-    }, [currentScreen, selectedTool, selectedBranch, repoRoot]);
-    // Update preferred tool when branch or data changes
-    useEffect(() => {
-        if (!selectedBranch)
-            return;
-        const branchMatch = branches.find((b) => b.name === selectedBranch.name) ||
-            branches.find((b) => selectedBranch.branchType === "remote" &&
-                b.name === selectedBranch.displayName);
-        setPreferredToolId(branchMatch?.lastToolUsage?.toolId ?? null);
-    }, [branches, selectedBranch]);
-    useEffect(() => () => {
-        if (completionTimerRef.current) {
-            clearTimeout(completionTimerRef.current);
-            completionTimerRef.current = null;
-        }
-    }, []);
-    const visibleBranches = useMemo(() => branches.filter((branch) => !hiddenBranches.includes(branch.name)), [branches, hiddenBranches]);
-    const selectedWorktreePath = useMemo(() => {
-        if (!selectedBranch)
-            return null;
-        const wt = worktrees.find((w) => w.branch === selectedBranch.name);
-        return wt?.path ?? null;
-    }, [selectedBranch, worktrees]);
-    // Helper function to create content-based hash for branches
-    const branchHash = useMemo(() => visibleBranches
-        .map((b) => `${b.name}-${b.type}-${b.isCurrent}`)
-        .join(","), [visibleBranches]);
-    // Helper function to create content-based hash for worktrees
-    const worktreeHash = useMemo(() => worktrees.map((w) => `${w.branch}-${w.path}`).join(","), [worktrees]);
-    // Format branches to BranchItems (memoized for performance with content-based dependencies)
-    const branchItems = useMemo(() => {
-        // Build worktreeMap for sorting
-        const worktreeMap = new Map();
-        for (const wt of worktrees) {
-            worktreeMap.set(wt.branch, {
-                path: wt.path,
-                locked: false,
-                prunable: wt.isAccessible === false,
-                isAccessible: wt.isAccessible ?? true,
-                ...(wt.hasUncommittedChanges !== undefined
-                    ? { hasUncommittedChanges: wt.hasUncommittedChanges }
-                    : {}),
-            });
-        }
-        const baseItems = formatBranchItems(visibleBranches, worktreeMap);
-        return baseItems.map((item) => {
-            const hasUncommitted = item.worktree?.hasUncommittedChanges ?? false;
-            const hasUnpushed = Boolean(item.hasUnpushedCommits);
-            const isMerged = Boolean(item.mergedPR);
-            const safeToCleanup = item.type === "local" && isMerged && !hasUncommitted && !hasUnpushed;
-            return { ...item, safeToCleanup };
-        });
-    }, [branchHash, worktreeHash, visibleBranches, worktrees]);
-    // Calculate statistics (memoized for performance)
-    const stats = useMemo(() => calculateStatistics(visibleBranches), [visibleBranches]);
-    const resolveBaseBranch = useCallback(() => {
-        const localMain = branches.find((branch) => branch.type === "local" &&
-            (branch.name === "main" || branch.name === "master"));
-        if (localMain) {
-            return localMain.name;
-        }
-        const develop = branches.find((branch) => branch.type === "local" &&
-            (branch.name === "develop" || branch.name === "dev"));
-        if (develop) {
-            return develop.name;
-        }
-        return "main";
-    }, [branches]);
-    const baseBranchLabel = useMemo(() => resolveBaseBranchLabel(creationSourceBranch, selectedBranch, resolveBaseBranch), [creationSourceBranch, resolveBaseBranch, selectedBranch]);
-    // Handle branch selection
-    const toLocalBranchName = useCallback((remoteName) => {
-        const segments = remoteName.split("/");
-        if (segments.length <= 1) {
-            return remoteName;
-        }
-        return segments.slice(1).join("/");
-    }, []);
-    const inferBranchCategory = useCallback((branchName) => {
-        const matched = branches.find((branch) => branch.name === branchName);
-        if (matched) {
-            return matched.branchType;
-        }
-        if (branchName === "main" || branchName === "master") {
-            return "main";
-        }
-        if (branchName === "develop" || branchName === "dev") {
-            return "develop";
-        }
-        if (branchName.startsWith("feature/")) {
-            return "feature";
-        }
-        if (branchName.startsWith("hotfix/")) {
-            return "hotfix";
-        }
-        if (branchName.startsWith("release/")) {
-            return "release";
-        }
-        return "other";
-    }, [branches]);
-    const isProtectedSelection = useCallback((branch) => {
-        if (!branch) {
-            return false;
-        }
-        return (isProtectedBranchName(branch.name) ||
-            isProtectedBranchName(branch.displayName) ||
-            (branch.remoteBranch
-                ? isProtectedBranchName(branch.remoteBranch)
-                : false) ||
-            branch.branchCategory === "main" ||
-            branch.branchCategory === "develop");
-    }, [isProtectedBranchName]);
-    const toggleBranchSelection = useCallback((branchName) => {
-        const branch = branches.find((b) => b.name === branchName);
-        if (!branch || branch.type === "remote") {
-            return;
-        }
-        if (isProtectedBranchName(branch.name) ||
-            branch.branchType === "main" ||
-            branch.branchType === "develop") {
-            return;
-        }
-        setSelectedBranches((prev) => {
-            const set = new Set(prev);
-            if (set.has(branchName)) {
-                set.delete(branchName);
-            }
-            else {
-                set.add(branchName);
-            }
-            return Array.from(set);
-        });
-    }, [branches, isProtectedBranchName]);
-    const protectedBranchInfo = useMemo(() => {
-        if (!selectedBranch) {
-            return null;
-        }
-        if (!isProtectedSelection(selectedBranch)) {
-            return null;
-        }
-        const label = selectedBranch.displayName ?? selectedBranch.name;
-        return {
-            label,
-            message: `${label} is a root branch. Switch within the repository root instead of creating a worktree.`,
-        };
-    }, [selectedBranch, isProtectedSelection]);
-    const handleSelect = useCallback((item) => {
-        const selection = item.type === "remote"
-            ? {
-                name: toLocalBranchName(item.name),
-                displayName: item.name,
-                branchType: "remote",
-                branchCategory: item.branchType,
-                remoteBranch: item.name,
-            }
-            : {
-                name: item.name,
-                displayName: item.name,
-                branchType: "local",
-                branchCategory: item.branchType,
-            };
-        const protectedSelected = isProtectedSelection(selection);
-        setSelectedBranch(selection);
-        setSelectedTool(null);
-        setSelectedModel(null);
-        setCreationSourceBranch(null);
-        setPreferredToolId(item.lastToolUsage?.toolId ?? null);
-        if (protectedSelected) {
-            setCleanupFooterMessage({
-                text: PROTECTED_BRANCH_WARNING,
-                color: "yellow",
-            });
-        }
-        else {
-            setCleanupFooterMessage(null);
-        }
-        navigateTo("branch-action-selector");
-    }, [
-        isProtectedSelection,
-        navigateTo,
-        setCleanupFooterMessage,
-        setCreationSourceBranch,
-        setSelectedTool,
-        toLocalBranchName,
-    ]);
-    // Handle branch action selection
-    const handleProtectedBranchSwitch = useCallback(async () => {
-        if (!selectedBranch) {
-            return;
-        }
-        try {
-            setCleanupFooterMessage({
-                text: `Preparing root branch '${selectedBranch.displayName ?? selectedBranch.name}'...`,
-                color: "cyan",
-            });
-            const repoRoot = await getRepositoryRoot();
-            const remoteRef = selectedBranch.remoteBranch ??
-                (selectedBranch.branchType === "remote"
-                    ? (selectedBranch.displayName ?? selectedBranch.name)
-                    : null);
-            const result = await switchToProtectedBranch({
-                branchName: selectedBranch.name,
-                repoRoot,
-                remoteRef: remoteRef ?? null,
-            });
-            let successMessage = `'${selectedBranch.displayName ?? selectedBranch.name}' will use the repository root.`;
-            if (result === "remote") {
-                successMessage = `Created a local tracking branch for '${selectedBranch.displayName ?? selectedBranch.name}' and switched to the protected branch.`;
-            }
-            else if (result === "local") {
-                successMessage = `Checked out '${selectedBranch.displayName ?? selectedBranch.name}' in the repository root.`;
-            }
-            setCleanupFooterMessage({
-                text: successMessage,
-                color: "green",
-            });
-            refresh();
-            const nextScreen = branchQuickStart.length || branchQuickStartLoading
-                ? "branch-quick-start"
-                : "coding-agent-selector";
-            navigateTo(nextScreen);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            setCleanupFooterMessage({
-                text: `Failed to switch root branch: ${message}`,
-                color: "red",
-            });
-            console.error("Failed to switch protected branch:", error);
-        }
-    }, [
-        branchQuickStart,
-        branchQuickStartLoading,
-        navigateTo,
-        refresh,
-        selectedBranch,
-        setCleanupFooterMessage,
-    ]);
-    const handleUseExistingBranch = useCallback(() => {
-        if (selectedBranch && isProtectedSelection(selectedBranch)) {
-            void handleProtectedBranchSwitch();
-            return;
-        }
-        if (branchQuickStart.length) {
-            navigateTo("branch-quick-start");
-        }
-        else {
-            navigateTo("coding-agent-selector");
-        }
-    }, [
-        handleProtectedBranchSwitch,
-        isProtectedSelection,
-        navigateTo,
-        branchQuickStart.length,
-        selectedBranch,
-    ]);
-    const handleCreateNewBranch = useCallback(() => {
-        setCreationSourceBranch(selectedBranch);
-        navigateTo("branch-creator");
-    }, [navigateTo, selectedBranch]);
-    // Handle quit
-    const handleQuit = useCallback(() => {
-        onExit();
-        exit();
-    }, [onExit, exit]);
-    const handleOpenLogs = useCallback(() => {
-        setLogSelectedDate(getTodayLogDate());
-        setLogSelectedEntry(null);
-        navigateTo("log-list");
-    }, [navigateTo]);
-    const handleSelectLogEntry = useCallback((entry) => {
-        setLogSelectedEntry(entry);
-        navigateTo("log-detail");
-    }, [navigateTo]);
-    const handleCopyLogEntry = useCallback(async (entry) => {
-        try {
-            await copyToClipboard(entry.json);
-            showLogNotification("Copied to clipboard.", "success");
-        }
-        catch {
-            showLogNotification("Failed to copy to clipboard.", "error");
-        }
-    }, [showLogNotification]);
-    const handleOpenLogDates = useCallback(() => {
-        navigateTo("log-date-picker");
-    }, [navigateTo]);
-    const handleSelectLogDate = useCallback((date) => {
-        setLogSelectedDate(date);
-        setLogSelectedEntry(null);
-        navigateTo("log-list");
-    }, [navigateTo]);
-    // Handle branch creation
-    const handleCreate = useCallback(async (branchName) => {
-        try {
-            const repoRoot = await getRepositoryRoot();
-            const worktreePath = await generateWorktreePath(repoRoot, branchName);
-            // Use selectedBranch as base if available, otherwise resolve from repo
-            const baseBranch = resolveBaseBranchRef(creationSourceBranch, selectedBranch, resolveBaseBranch);
-            await createWorktree({
-                branchName,
-                worktreePath,
-                repoRoot,
-                isNewBranch: true,
-                baseBranch,
-            });
-            refresh();
-            setCreationSourceBranch(null);
-            setSelectedBranch({
-                name: branchName,
-                displayName: branchName,
-                branchType: "local",
-                branchCategory: inferBranchCategory(branchName),
-            });
-            setSelectedTool(null);
-            setSelectedModel(null);
-            setPreferredToolId(null);
-            setCleanupFooterMessage(null);
-            navigateTo("coding-agent-selector");
-        }
-        catch (error) {
-            // On error, go back to branch list
-            console.error("Failed to create branch:", error);
-            goBack();
-            refresh();
-        }
-    }, [
-        navigateTo,
-        goBack,
-        refresh,
-        resolveBaseBranch,
-        selectedBranch,
-        creationSourceBranch,
-        inferBranchCategory,
-        setCleanupFooterMessage,
-    ]);
-    const handleCleanupCommand = useCallback(async () => {
-        if (cleanupInputLocked) {
-            return;
-        }
-        if (completionTimerRef.current) {
-            clearTimeout(completionTimerRef.current);
-            completionTimerRef.current = null;
-        }
-        if (selectedBranches.length === 0) {
-            setCleanupIndicators({});
-            setCleanupFooterMessage({
-                text: "No cleanup targets selected.",
-                color: "yellow",
-            });
-            setCleanupInputLocked(false);
-            completionTimerRef.current = setTimeout(() => {
-                setCleanupFooterMessage(null);
-                completionTimerRef.current = null;
-            }, COMPLETION_HOLD_DURATION_MS);
-            return;
-        }
-        const succeededBranches = [];
-        const resetAfterWait = () => {
-            setCleanupIndicators({});
-            setCleanupInputLocked(false);
-            setCleanupFooterMessage(null);
-            if (succeededBranches.length > 0) {
-                setHiddenBranches((prev) => {
-                    const merged = new Set(prev);
-                    succeededBranches.forEach((branch) => merged.add(branch));
-                    return Array.from(merged);
-                });
-                setSelectedBranches((prev) => prev.filter((name) => !succeededBranches.includes(name)));
-            }
-            refresh();
-            completionTimerRef.current = null;
-        };
-        // Provide immediate feedback before fetching targets
-        setCleanupInputLocked(true);
-        setCleanupIndicators({});
-        setCleanupFooterMessage({
-            text: "Processing...",
-            isSpinning: true,
-            color: "cyan",
-        });
-        setCleanupProcessingBranch(null);
-        const branchMap = new Map(branches.map((branch) => [branch.name, branch]));
-        const worktreeMap = new Map(worktrees.map((worktree) => [worktree.branch, worktree]));
-        const targets = selectedBranches.reduce((acc, name) => {
-            const branch = branchMap.get(name);
-            if (!branch || branch.type === "remote") {
-                return acc;
-            }
-            if (isProtectedBranchName(branch.name) ||
-                branch.branchType === "main" ||
-                branch.branchType === "develop") {
-                return acc;
-            }
-            const worktree = worktreeMap.get(branch.name);
-            const hasRemoteBranch = typeof branch.hasRemoteCounterpart === "boolean"
-                ? branch.hasRemoteCounterpart
-                : undefined;
-            const isAccessible = typeof worktree?.isAccessible === "boolean"
-                ? worktree.isAccessible
-                : undefined;
-            acc.push({
-                branch: branch.name,
-                pullRequest: null,
-                worktreePath: worktree?.path ?? null,
-                cleanupType: worktree ? "worktree-and-branch" : "branch-only",
-                hasUncommittedChanges: worktree?.hasUncommittedChanges ?? false,
-                hasUnpushedCommits: Boolean(branch.hasUnpushedCommits),
-                ...(hasRemoteBranch !== undefined ? { hasRemoteBranch } : {}),
-                ...(isAccessible !== undefined ? { isAccessible } : {}),
-            });
-            return acc;
-        }, []);
-        if (targets.length === 0) {
-            setCleanupIndicators({});
-            setCleanupFooterMessage({
-                text: "⚠️ No cleanup candidates among selected branches.",
-                color: "yellow",
-            });
-            setCleanupInputLocked(false);
-            completionTimerRef.current = setTimeout(() => {
-                setCleanupFooterMessage(null);
-                completionTimerRef.current = null;
-            }, COMPLETION_HOLD_DURATION_MS);
-            return;
-        }
-        // Reset hidden branches that may already be gone
-        setHiddenBranches((prev) => prev.filter((name) => targets.find((t) => t.branch === name) === undefined));
-        const initialIndicators = targets.reduce((acc, target, index) => {
-            if (index === 0) {
-                acc[target.branch] = { icon: "", isSpinning: true, color: "cyan" };
-            }
-            else {
-                acc[target.branch] = { icon: "⏳", color: "yellow" };
-            }
-            return acc;
-        }, {});
-        setCleanupIndicators(initialIndicators);
-        const firstTarget = targets.length > 0 ? targets[0] : undefined;
-        setCleanupProcessingBranch(firstTarget ? firstTarget.branch : null);
-        setCleanupFooterMessage({
-            text: "Processing...",
-            isSpinning: true,
-            color: "cyan",
-        });
-        for (let index = 0; index < targets.length; index += 1) {
-            const currentTarget = targets[index];
-            if (!currentTarget) {
-                continue;
-            }
-            const target = currentTarget;
-            setCleanupProcessingBranch(target.branch);
-            setCleanupIndicators((prev) => {
-                const updated = { ...prev };
-                updated[target.branch] = { icon: "", isSpinning: true, color: "cyan" };
-                for (const pending of targets.slice(index + 1)) {
-                    const current = updated[pending.branch];
-                    if (!current || current.icon !== "⏳") {
-                        updated[pending.branch] = { icon: "⏳", color: "yellow" };
-                    }
-                }
-                return updated;
-            });
-            const shouldSkip = target.hasUncommittedChanges ||
-                target.hasUnpushedCommits ||
-                (target.cleanupType === "worktree-and-branch" &&
-                    (!target.worktreePath || target.isAccessible === false));
-            if (shouldSkip) {
-                setCleanupIndicators((prev) => ({
-                    ...prev,
-                    [target.branch]: { icon: "⏭️", color: "yellow" },
-                }));
-                setCleanupProcessingBranch(null);
-                continue;
-            }
-            try {
-                if (target.cleanupType === "worktree-and-branch" &&
-                    target.worktreePath) {
-                    await removeWorktree(target.worktreePath, true);
-                }
-                await deleteBranch(target.branch, true);
-                // 自動クリーンアップではリモートブランチは削除しない
-                // リモートブランチはユーザーが明示的に削除する必要がある
-                succeededBranches.push(target.branch);
-                setCleanupIndicators((prev) => ({
-                    ...prev,
-                    [target.branch]: { icon: "✅", color: "green" },
-                }));
-            }
-            catch {
-                const icon = "❌";
-                setCleanupIndicators((prev) => ({
-                    ...prev,
-                    [target.branch]: { icon, color: "red" },
-                }));
-            }
-            setCleanupProcessingBranch(null);
-        }
-        setCleanupProcessingBranch(null);
-        setCleanupInputLocked(false);
-        setCleanupFooterMessage({
-            text: "Cleanup completed. Finalizing...",
-            color: "green",
-        });
-        const holdDuration = typeof process !== "undefined" && process.env?.NODE_ENV === "test"
-            ? 0
-            : COMPLETION_HOLD_DURATION_MS;
-        completionTimerRef.current = setTimeout(resetAfterWait, holdDuration);
-    }, [
-        cleanupInputLocked,
-        branches,
-        deleteBranch,
-        refresh,
-        removeWorktree,
-        selectedBranches,
-        worktrees,
-    ]);
-    // Handle AI tool selection
-    const handleToolSelect = useCallback((tool) => {
-        setSelectedTool(tool);
-        setSelectedModel(lastModelByTool[tool] ?? null);
-        navigateTo("model-selector");
-    }, [lastModelByTool, navigateTo]);
-    const handleModelSelect = useCallback((selection) => {
-        setSelectedModel(selection);
-        setLastModelByTool((prev) => ({
-            ...prev,
-            ...(selectedTool ? { [selectedTool]: selection } : {}),
-        }));
-        navigateTo("execution-mode-selector");
-    }, [navigateTo, selectedTool]);
-    const completeSelection = useCallback((executionMode, skip, sessionId) => {
-        if (selectedBranch && selectedTool) {
-            const defaultModel = getDefaultModelOption(selectedTool);
-            const resolvedModel = selectedModel?.model ?? defaultModel?.id ?? null;
-            const normalizedModel = normalizeModelId(selectedTool, resolvedModel);
-            const resolvedInference = selectedModel?.inferenceLevel ??
-                getDefaultInferenceForModel(defaultModel ?? undefined);
-            const payload = {
-                branch: selectedBranch.name,
-                displayName: selectedBranch.displayName,
-                branchType: selectedBranch.branchType,
-                tool: selectedTool,
-                mode: executionMode,
-                skipPermissions: skip,
-                ...(normalizedModel !== undefined ? { model: normalizedModel } : {}),
-                ...(resolvedInference !== undefined
-                    ? { inferenceLevel: resolvedInference }
-                    : {}),
-                ...(selectedBranch.remoteBranch
-                    ? { remoteBranch: selectedBranch.remoteBranch }
-                    : {}),
-                ...(sessionId ? { sessionId } : {}),
-            };
-            onExit(payload);
-            exit();
-        }
-    }, [
-        selectedBranch,
-        selectedTool,
-        selectedModel,
-        onExit,
-        exit,
-        getDefaultModelOption,
-        getDefaultInferenceForModel,
-    ]);
-    const handleQuickStartSelect = useCallback((action, toolId) => {
-        if (action === "manual" || !branchQuickStart.length) {
-            navigateTo("coding-agent-selector");
-            return;
-        }
-        const selected = branchQuickStart.find((opt) => opt.toolId === toolId) ??
-            branchQuickStart[0];
-        if (!selected) {
-            navigateTo("coding-agent-selector");
-            return;
-        }
-        setSelectedTool(selected.toolId);
-        setPreferredToolId(selected.toolId);
-        const normalizedQuickStartModel = normalizeModelId(selected.toolId, selected.model ?? null);
-        setSelectedModel(normalizedQuickStartModel
-            ? {
-                model: normalizedQuickStartModel,
-                inferenceLevel: selected.inferenceLevel ?? undefined,
-            }
-            : null);
-        const skip = selected.skipPermissions ?? false;
-        if (action === "reuse-continue") {
-            const hasSession = Boolean(selected.sessionId);
-            const mode = hasSession ? "resume" : "continue";
-            completeSelection(mode, skip, selected.sessionId ?? null);
-            return;
-        }
-        // "Start new with previous settings" skips the execution mode screen and launches immediately
-        completeSelection("normal", skip, null);
-    }, [
-        branchQuickStart,
-        navigateTo,
-        setPreferredToolId,
-        setSelectedModel,
-        setSelectedTool,
-        completeSelection,
-    ]);
-    // Handle execution mode and skipPermissions selection
-    const handleModeSelect = useCallback((result) => {
-        completeSelection(result.mode, result.skipPermissions, null);
-    }, [completeSelection]);
-    // Render screen based on currentScreen
-    const renderScreen = () => {
-        const renderBranchListScreen = (additionalProps) => (React.createElement(BranchListScreen, { branches: branchItems, stats: stats, onSelect: handleSelect, onQuit: handleQuit, onRefresh: refresh, loading: loading, error: error, lastUpdated: lastUpdated, loadingIndicatorDelay: loadingIndicatorDelay, version: version, workingDirectory: workingDirectory, activeProfile: activeProfileName, onOpenProfiles: () => navigateTo("environment-profile"), onOpenLogs: handleOpenLogs, toolStatuses: toolStatuses, ...additionalProps }));
-        switch (currentScreen) {
-            case "branch-list":
-                return renderBranchListScreen({
-                    onCleanupCommand: handleCleanupCommand,
-                    cleanupUI: {
-                        indicators: cleanupIndicators,
-                        footerMessage: cleanupFooterMessage,
-                        inputLocked: cleanupInputLocked,
-                    },
-                    selectedBranches,
-                    onToggleSelect: toggleBranchSelection,
-                });
-            case "log-list":
-                return (React.createElement(LogListScreen, { entries: logEntries, loading: logLoading, error: logError, onBack: goBack, onSelect: handleSelectLogEntry, onCopy: handleCopyLogEntry, onPickDate: handleOpenLogDates, notification: logNotification, version: version, selectedDate: logSelectedDate }));
-            case "log-detail":
-                return (React.createElement(LogDetailScreen, { entry: logSelectedEntry, onBack: goBack, onCopy: handleCopyLogEntry, notification: logNotification, version: version }));
-            case "log-date-picker":
-                return (React.createElement(LogDatePickerScreen, { dates: logDates, onBack: goBack, onSelect: handleSelectLogDate, version: version }));
-            case "branch-creator":
-                return (React.createElement(BranchCreatorScreen, { onBack: goBack, onCreate: handleCreate, baseBranch: baseBranchLabel, version: version }));
-            case "branch-action-selector": {
-                const isProtected = Boolean(protectedBranchInfo);
-                const baseProps = {
-                    selectedBranch: selectedBranch?.displayName ?? "",
-                    onUseExisting: handleUseExistingBranch,
-                    onCreateNew: handleCreateNewBranch,
-                    onBack: goBack,
-                    canCreateNew: Boolean(selectedBranch),
-                };
-                if (isProtected) {
-                    return (React.createElement(BranchActionSelectorScreen, { ...baseProps, mode: "protected", infoMessage: protectedBranchInfo?.message ?? null, primaryLabel: "Use root branch (no worktree)", secondaryLabel: "Create new branch from this branch" }));
-                }
-                return React.createElement(BranchActionSelectorScreen, { ...baseProps });
-            }
-            case "branch-quick-start":
-                return (React.createElement(BranchQuickStartScreen, { branchName: selectedBranch?.displayName ?? "", previousOptions: branchQuickStart.map((opt) => ({
-                        toolId: opt.toolId,
-                        toolLabel: opt.toolLabel,
-                        model: opt.model ?? null,
-                        inferenceLevel: opt.inferenceLevel ?? null,
-                        skipPermissions: opt.skipPermissions ?? null,
-                        sessionId: opt.sessionId ?? null,
-                    })), loading: branchQuickStartLoading, onBack: goBack, onSelect: handleQuickStartSelect, version: version }));
-            case "coding-agent-selector":
-                return (React.createElement(CodingAgentSelectorScreen, { onBack: goBack, onSelect: handleToolSelect, version: version, initialAgentId: selectedTool ?? preferredToolId ?? null }));
-            case "model-selector":
-                if (!selectedTool) {
-                    goBack();
-                    return null;
-                }
-                return (React.createElement(ModelSelectorScreen, { tool: selectedTool, onBack: goBack, onSelect: handleModelSelect, version: version, initialSelection: selectedModel }));
-            case "execution-mode-selector":
-                return (React.createElement(ExecutionModeSelectorScreen, { onBack: goBack, onSelect: handleModeSelect, version: version, continueSessionId: continueSessionId }));
-            case "environment-profile":
-                return (React.createElement(EnvironmentProfileScreen, { onBack: () => {
-                        void refreshProfiles();
-                        goBack();
-                    }, version: version }));
-            default:
-                return renderBranchListScreen();
-        }
-    };
-    return React.createElement(ErrorBoundary, null, renderScreen());
-}
-//# sourceMappingURL=App.js.map