@xelauvas/xela-cli 0.1.0

package/src/components/WorkflowMultiselectDialog.tsx

@@ -0,0 +1,128 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useState } from 'react';
+import type { Workflow } from '../commands/install-github-app/types.js';
+import type { ExitState } from '../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Link, Text } from '../ink.js';
+import { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js';
+import { SelectMulti } from './CustomSelect/SelectMulti.js';
+import { Byline } from './design-system/Byline.js';
+import { Dialog } from './design-system/Dialog.js';
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
+type WorkflowOption = {
+  value: Workflow;
+  label: string;
+};
+type Props = {
+  onSubmit: (selectedWorkflows: Workflow[]) => void;
+  defaultSelections: Workflow[];
+};
+const WORKFLOWS: WorkflowOption[] = [{
+  value: 'claude' as const,
+  label: '@Claude Code - Tag @claude in issues and PR comments'
+}, {
+  value: 'claude-review' as const,
+  label: 'Claude Code Review - Automated code review on new PRs'
+}];
+function renderInputGuide(exitState: ExitState): React.ReactNode {
+  if (exitState.pending) {
+    return <Text>Press {exitState.keyName} again to exit</Text>;
+  }
+  return <Byline>
+      <KeyboardShortcutHint shortcut="↑↓" action="navigate" />
+      <KeyboardShortcutHint shortcut="Space" action="toggle" />
+      <KeyboardShortcutHint shortcut="Enter" action="confirm" />
+      <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />
+    </Byline>;
+}
+export function WorkflowMultiselectDialog(t0) {
+  const $ = _c(14);
+  const {
+    onSubmit,
+    defaultSelections
+  } = t0;
+  const [showError, setShowError] = useState(false);
+  let t1;
+  if ($[0] !== onSubmit) {
+    t1 = selectedValues => {
+      if (selectedValues.length === 0) {
+        setShowError(true);
+        return;
+      }
+      setShowError(false);
+      onSubmit(selectedValues);
+    };
+    $[0] = onSubmit;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const handleSubmit = t1;
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => {
+      setShowError(false);
+    };
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleChange = t2;
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = () => {
+      setShowError(true);
+    };
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const handleCancel = t3;
+  let t4;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = <Box><Text dimColor={true}>More workflow examples (issue triage, CI fixes, etc.) at:{" "}<Link url="https://github.com/anthropics/claude-code-action/blob/main/examples/">https://github.com/anthropics/claude-code-action/blob/main/examples/</Link></Text></Box>;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = WORKFLOWS.map(_temp);
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  let t6;
+  if ($[6] !== defaultSelections || $[7] !== handleSubmit) {
+    t6 = <SelectMulti options={t5} defaultValue={defaultSelections} onSubmit={handleSubmit} onChange={handleChange} onCancel={handleCancel} hideIndexes={true} />;
+    $[6] = defaultSelections;
+    $[7] = handleSubmit;
+    $[8] = t6;
+  } else {
+    t6 = $[8];
+  }
+  let t7;
+  if ($[9] !== showError) {
+    t7 = showError && <Box><Text color="error">You must select at least one workflow to continue</Text></Box>;
+    $[9] = showError;
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== t6 || $[12] !== t7) {
+    t8 = <Dialog title="Select GitHub workflows to install" subtitle="We'll create a workflow file in your repository for each one you select." onCancel={handleCancel} inputGuide={renderInputGuide}>{t4}{t6}{t7}</Dialog>;
+    $[11] = t6;
+    $[12] = t7;
+    $[13] = t8;
+  } else {
+    t8 = $[13];
+  }
+  return t8;
+}
+function _temp(workflow) {
+  return {
+    label: workflow.label,
+    value: workflow.value
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","Workflow","ExitState","Box","Link","Text","ConfigurableShortcutHint","SelectMulti","Byline","Dialog","KeyboardShortcutHint","WorkflowOption","value","label","Props","onSubmit","selectedWorkflows","defaultSelections","WORKFLOWS","const","renderInputGuide","exitState","ReactNode","pending","keyName","WorkflowMultiselectDialog","t0","$","_c","showError","setShowError","t1","selectedValues","length","handleSubmit","t2","Symbol","for","handleChange","t3","handleCancel","t4","t5","map","_temp","t6","t7","t8","workflow"],"sources":["WorkflowMultiselectDialog.tsx"],"sourcesContent":["import React, { useCallback, useState } from 'react'\nimport type { Workflow } from '../commands/install-github-app/types.js'\nimport type { ExitState } from '../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { Box, Link, Text } from '../ink.js'\nimport { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js'\nimport { SelectMulti } from './CustomSelect/SelectMulti.js'\nimport { Byline } from './design-system/Byline.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'\n\ntype WorkflowOption = {\n  value: Workflow\n  label: string\n}\n\ntype Props = {\n  onSubmit: (selectedWorkflows: Workflow[]) => void\n  defaultSelections: Workflow[]\n}\n\nconst WORKFLOWS: WorkflowOption[] = [\n  {\n    value: 'claude' as const,\n    label: '@Claude Code - Tag @claude in issues and PR comments',\n  },\n  {\n    value: 'claude-review' as const,\n    label: 'Claude Code Review - Automated code review on new PRs',\n  },\n]\n\nfunction renderInputGuide(exitState: ExitState): React.ReactNode {\n  if (exitState.pending) {\n    return <Text>Press {exitState.keyName} again to exit</Text>\n  }\n  return (\n    <Byline>\n      <KeyboardShortcutHint shortcut=\"↑↓\" action=\"navigate\" />\n      <KeyboardShortcutHint shortcut=\"Space\" action=\"toggle\" />\n      <KeyboardShortcutHint shortcut=\"Enter\" action=\"confirm\" />\n      <ConfigurableShortcutHint\n        action=\"confirm:no\"\n        context=\"Confirmation\"\n        fallback=\"Esc\"\n        description=\"cancel\"\n      />\n    </Byline>\n  )\n}\n\nexport function WorkflowMultiselectDialog({\n  onSubmit,\n  defaultSelections,\n}: Props): React.ReactNode {\n  const [showError, setShowError] = useState(false)\n\n  const handleSubmit = useCallback(\n    (selectedValues: Workflow[]) => {\n      if (selectedValues.length === 0) {\n        setShowError(true)\n        return\n      }\n      setShowError(false)\n      onSubmit(selectedValues)\n    },\n    [onSubmit],\n  )\n\n  const handleChange = useCallback(() => {\n    setShowError(false)\n  }, [])\n\n  // Cancel just shows the error - user must select at least one workflow\n  const handleCancel = useCallback(() => {\n    setShowError(true)\n  }, [])\n\n  return (\n    <Dialog\n      title=\"Select GitHub workflows to install\"\n      subtitle=\"We'll create a workflow file in your repository for each one you select.\"\n      onCancel={handleCancel}\n      inputGuide={renderInputGuide}\n    >\n      <Box>\n        <Text dimColor>\n          More workflow examples (issue triage, CI fixes, etc.) at:{' '}\n          <Link url=\"https://github.com/anthropics/claude-code-action/blob/main/examples/\">\n            https://github.com/anthropics/claude-code-action/blob/main/examples/\n          </Link>\n        </Text>\n      </Box>\n\n      <SelectMulti\n        options={WORKFLOWS.map(workflow => ({\n          label: workflow.label,\n          value: workflow.value,\n        }))}\n        defaultValue={defaultSelections}\n        onSubmit={handleSubmit}\n        onChange={handleChange}\n        onCancel={handleCancel}\n        hideIndexes\n      />\n\n      {showError && (\n        <Box>\n          <Text color=\"error\">\n            You must select at least one workflow to continue\n          </Text>\n        </Box>\n      )}\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/WorktreeExitDialog.tsx

@@ -0,0 +1,231 @@
+import React, { useEffect, useState } from 'react';
+import type { CommandResultDisplay } from 'src/commands.js';
+import { logEvent } from 'src/services/analytics/index.js';
+import { logForDebugging } from 'src/utils/debug.js';
+import { Box, Text } from '../ink.js';
+import { execFileNoThrow } from '../utils/execFileNoThrow.js';
+import { getPlansDirectory } from '../utils/plans.js';
+import { setCwd } from '../utils/Shell.js';
+import { cleanupWorktree, getCurrentWorktreeSession, keepWorktree, killTmuxSession } from '../utils/worktree.js';
+import { Select } from './CustomSelect/select.js';
+import { Dialog } from './design-system/Dialog.js';
+import { Spinner } from './Spinner.js';
+
+// Inline require breaks the cycle this file would otherwise close:
+// sessionStorage → commands → exit → ExitFlow → here. All call sites
+// are inside callbacks, so the lazy require never sees an undefined import.
+function recordWorktreeExit(): void {
+  /* eslint-disable @typescript-eslint/no-require-imports */
+  ;
+  (require('../utils/sessionStorage.js') as typeof import('../utils/sessionStorage.js')).saveWorktreeState(null);
+  /* eslint-enable @typescript-eslint/no-require-imports */
+}
+type Props = {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+  onCancel?: () => void;
+};
+export function WorktreeExitDialog({
+  onDone,
+  onCancel
+}: Props): React.ReactNode {
+  const [status, setStatus] = useState<'loading' | 'asking' | 'keeping' | 'removing' | 'done'>('loading');
+  const [changes, setChanges] = useState<string[]>([]);
+  const [commitCount, setCommitCount] = useState<number>(0);
+  const [resultMessage, setResultMessage] = useState<string | undefined>();
+  const worktreeSession = getCurrentWorktreeSession();
+  useEffect(() => {
+    async function loadChanges() {
+      let changeLines: string[] = [];
+      const gitStatus = await execFileNoThrow('git', ['status', '--porcelain']);
+      if (gitStatus.stdout) {
+        changeLines = gitStatus.stdout.split('\n').filter(_ => _.trim() !== '');
+        setChanges(changeLines);
+      }
+
+      // Check for commits to eject
+      if (worktreeSession) {
+        // Get commits in worktree that are not in original branch
+        const {
+          stdout: commitsStr
+        } = await execFileNoThrow('git', ['rev-list', '--count', `${worktreeSession.originalHeadCommit}..HEAD`]);
+        const count = parseInt(commitsStr.trim()) || 0;
+        setCommitCount(count);
+
+        // If no changes and no commits, clean up silently
+        if (changeLines.length === 0 && count === 0) {
+          setStatus('removing');
+          void cleanupWorktree().then(() => {
+            process.chdir(worktreeSession.originalCwd);
+            setCwd(worktreeSession.originalCwd);
+            recordWorktreeExit();
+            getPlansDirectory.cache.clear?.();
+            setResultMessage('Worktree removed (no changes)');
+          }).catch(error => {
+            logForDebugging(`Failed to clean up worktree: ${error}`, {
+              level: 'error'
+            });
+            setResultMessage('Worktree cleanup failed, exiting anyway');
+          }).then(() => {
+            setStatus('done');
+          });
+          return;
+        } else {
+          setStatus('asking');
+        }
+      }
+    }
+    void loadChanges();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
+  }, [worktreeSession]);
+  useEffect(() => {
+    if (status === 'done') {
+      onDone(resultMessage);
+    }
+  }, [status, onDone, resultMessage]);
+  if (!worktreeSession) {
+    onDone('No active worktree session found', {
+      display: 'system'
+    });
+    return null;
+  }
+  if (status === 'loading' || status === 'done') {
+    return null;
+  }
+  async function handleSelect(value: string) {
+    if (!worktreeSession) return;
+    const hasTmux = Boolean(worktreeSession.tmuxSessionName);
+    if (value === 'keep' || value === 'keep-with-tmux') {
+      setStatus('keeping');
+      logEvent('tengu_worktree_kept', {
+        commits: commitCount,
+        changed_files: changes.length
+      });
+      await keepWorktree();
+      process.chdir(worktreeSession.originalCwd);
+      setCwd(worktreeSession.originalCwd);
+      recordWorktreeExit();
+      getPlansDirectory.cache.clear?.();
+      if (hasTmux) {
+        setResultMessage(`Worktree kept. Your work is saved at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}. Reattach to tmux session with: tmux attach -t ${worktreeSession.tmuxSessionName}`);
+      } else {
+        setResultMessage(`Worktree kept. Your work is saved at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}`);
+      }
+      setStatus('done');
+    } else if (value === 'keep-kill-tmux') {
+      setStatus('keeping');
+      logEvent('tengu_worktree_kept', {
+        commits: commitCount,
+        changed_files: changes.length
+      });
+      if (worktreeSession.tmuxSessionName) {
+        await killTmuxSession(worktreeSession.tmuxSessionName);
+      }
+      await keepWorktree();
+      process.chdir(worktreeSession.originalCwd);
+      setCwd(worktreeSession.originalCwd);
+      recordWorktreeExit();
+      getPlansDirectory.cache.clear?.();
+      setResultMessage(`Worktree kept at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}. Tmux session terminated.`);
+      setStatus('done');
+    } else if (value === 'remove' || value === 'remove-with-tmux') {
+      setStatus('removing');
+      logEvent('tengu_worktree_removed', {
+        commits: commitCount,
+        changed_files: changes.length
+      });
+      if (worktreeSession.tmuxSessionName) {
+        await killTmuxSession(worktreeSession.tmuxSessionName);
+      }
+      try {
+        await cleanupWorktree();
+        process.chdir(worktreeSession.originalCwd);
+        setCwd(worktreeSession.originalCwd);
+        recordWorktreeExit();
+        getPlansDirectory.cache.clear?.();
+      } catch (error) {
+        logForDebugging(`Failed to clean up worktree: ${error}`, {
+          level: 'error'
+        });
+        setResultMessage('Worktree cleanup failed, exiting anyway');
+        setStatus('done');
+        return;
+      }
+      const tmuxNote = hasTmux ? ' Tmux session terminated.' : '';
+      if (commitCount > 0 && changes.length > 0) {
+        setResultMessage(`Worktree removed. ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} and uncommitted changes were discarded.${tmuxNote}`);
+      } else if (commitCount > 0) {
+        setResultMessage(`Worktree removed. ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${worktreeSession.worktreeBranch} ${commitCount === 1 ? 'was' : 'were'} discarded.${tmuxNote}`);
+      } else if (changes.length > 0) {
+        setResultMessage(`Worktree removed. Uncommitted changes were discarded.${tmuxNote}`);
+      } else {
+        setResultMessage(`Worktree removed.${tmuxNote}`);
+      }
+      setStatus('done');
+    }
+  }
+  if (status === 'keeping') {
+    return <Box flexDirection="row" marginY={1}>
+        <Spinner />
+        <Text>Keeping worktree…</Text>
+      </Box>;
+  }
+  if (status === 'removing') {
+    return <Box flexDirection="row" marginY={1}>
+        <Spinner />
+        <Text>Removing worktree…</Text>
+      </Box>;
+  }
+  const branchName = worktreeSession.worktreeBranch;
+  const hasUncommitted = changes.length > 0;
+  const hasCommits = commitCount > 0;
+  let subtitle = '';
+  if (hasUncommitted && hasCommits) {
+    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? 'file' : 'files'} and ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${branchName}. All will be lost if you remove.`;
+  } else if (hasUncommitted) {
+    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? 'file' : 'files'}. These will be lost if you remove the worktree.`;
+  } else if (hasCommits) {
+    subtitle = `You have ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${branchName}. The branch will be deleted if you remove the worktree.`;
+  } else {
+    subtitle = 'You are working in a worktree. Keep it to continue working there, or remove it to clean up.';
+  }
+  function handleCancel() {
+    if (onCancel) {
+      // Abort exit and return to the session
+      onCancel();
+      return;
+    }
+    // Fallback: treat Escape as "keep" if no onCancel provided
+    void handleSelect('keep');
+  }
+  const removeDescription = hasUncommitted || hasCommits ? 'All changes and commits will be lost.' : 'Clean up the worktree directory.';
+  const hasTmuxSession = Boolean(worktreeSession.tmuxSessionName);
+  const options = hasTmuxSession ? [{
+    label: 'Keep worktree and tmux session',
+    value: 'keep-with-tmux',
+    description: `Stays at ${worktreeSession.worktreePath}. Reattach with: tmux attach -t ${worktreeSession.tmuxSessionName}`
+  }, {
+    label: 'Keep worktree, kill tmux session',
+    value: 'keep-kill-tmux',
+    description: `Keeps worktree at ${worktreeSession.worktreePath}, terminates tmux session.`
+  }, {
+    label: 'Remove worktree and tmux session',
+    value: 'remove-with-tmux',
+    description: removeDescription
+  }] : [{
+    label: 'Keep worktree',
+    value: 'keep',
+    description: `Stays at ${worktreeSession.worktreePath}`
+  }, {
+    label: 'Remove worktree',
+    value: 'remove',
+    description: removeDescription
+  }];
+  const defaultValue = hasTmuxSession ? 'keep-with-tmux' : 'keep';
+  return <Dialog title="Exiting worktree session" subtitle={subtitle} onCancel={handleCancel}>
+      <Select defaultFocusValue={defaultValue} options={options} onChange={handleSelect} />
+    </Dialog>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","CommandResultDisplay","logEvent","logForDebugging","Box","Text","execFileNoThrow","getPlansDirectory","setCwd","cleanupWorktree","getCurrentWorktreeSession","keepWorktree","killTmuxSession","Select","Dialog","Spinner","recordWorktreeExit","require","saveWorktreeState","Props","onDone","result","options","display","onCancel","WorktreeExitDialog","ReactNode","status","setStatus","changes","setChanges","commitCount","setCommitCount","resultMessage","setResultMessage","worktreeSession","loadChanges","changeLines","gitStatus","stdout","split","filter","_","trim","commitsStr","originalHeadCommit","count","parseInt","length","then","process","chdir","originalCwd","cache","clear","catch","error","level","handleSelect","value","hasTmux","Boolean","tmuxSessionName","commits","changed_files","worktreePath","worktreeBranch","tmuxNote","branchName","hasUncommitted","hasCommits","subtitle","handleCancel","removeDescription","hasTmuxSession","label","description","defaultValue"],"sources":["WorktreeExitDialog.tsx"],"sourcesContent":["import React, { useEffect, useState } from 'react'\nimport type { CommandResultDisplay } from 'src/commands.js'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { logForDebugging } from 'src/utils/debug.js'\nimport { Box, Text } from '../ink.js'\nimport { execFileNoThrow } from '../utils/execFileNoThrow.js'\nimport { getPlansDirectory } from '../utils/plans.js'\nimport { setCwd } from '../utils/Shell.js'\nimport {\n  cleanupWorktree,\n  getCurrentWorktreeSession,\n  keepWorktree,\n  killTmuxSession,\n} from '../utils/worktree.js'\nimport { Select } from './CustomSelect/select.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { Spinner } from './Spinner.js'\n\n// Inline require breaks the cycle this file would otherwise close:\n// sessionStorage → commands → exit → ExitFlow → here. All call sites\n// are inside callbacks, so the lazy require never sees an undefined import.\nfunction recordWorktreeExit(): void {\n  /* eslint-disable @typescript-eslint/no-require-imports */\n  ;(\n    require('../utils/sessionStorage.js') as typeof import('../utils/sessionStorage.js')\n  ).saveWorktreeState(null)\n  /* eslint-enable @typescript-eslint/no-require-imports */\n}\n\ntype Props = {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n  onCancel?: () => void\n}\n\nexport function WorktreeExitDialog({\n  onDone,\n  onCancel,\n}: Props): React.ReactNode {\n  const [status, setStatus] = useState<\n    'loading' | 'asking' | 'keeping' | 'removing' | 'done'\n  >('loading')\n  const [changes, setChanges] = useState<string[]>([])\n  const [commitCount, setCommitCount] = useState<number>(0)\n  const [resultMessage, setResultMessage] = useState<string | undefined>()\n  const worktreeSession = getCurrentWorktreeSession()\n\n  useEffect(() => {\n    async function loadChanges() {\n      let changeLines: string[] = []\n      const gitStatus = await execFileNoThrow('git', ['status', '--porcelain'])\n      if (gitStatus.stdout) {\n        changeLines = gitStatus.stdout.split('\\n').filter(_ => _.trim() !== '')\n        setChanges(changeLines)\n      }\n\n      // Check for commits to eject\n      if (worktreeSession) {\n        // Get commits in worktree that are not in original branch\n        const { stdout: commitsStr } = await execFileNoThrow('git', [\n          'rev-list',\n          '--count',\n          `${worktreeSession.originalHeadCommit}..HEAD`,\n        ])\n        const count = parseInt(commitsStr.trim()) || 0\n        setCommitCount(count)\n\n        // If no changes and no commits, clean up silently\n        if (changeLines.length === 0 && count === 0) {\n          setStatus('removing')\n          void cleanupWorktree()\n            .then(() => {\n              process.chdir(worktreeSession.originalCwd)\n              setCwd(worktreeSession.originalCwd)\n              recordWorktreeExit()\n              getPlansDirectory.cache.clear?.()\n              setResultMessage('Worktree removed (no changes)')\n            })\n            .catch(error => {\n              logForDebugging(`Failed to clean up worktree: ${error}`, {\n                level: 'error',\n              })\n              setResultMessage('Worktree cleanup failed, exiting anyway')\n            })\n            .then(() => {\n              setStatus('done')\n            })\n          return\n        } else {\n          setStatus('asking')\n        }\n      }\n    }\n    void loadChanges()\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  }, [worktreeSession])\n\n  useEffect(() => {\n    if (status === 'done') {\n      onDone(resultMessage)\n    }\n  }, [status, onDone, resultMessage])\n\n  if (!worktreeSession) {\n    onDone('No active worktree session found', { display: 'system' })\n    return null\n  }\n\n  if (status === 'loading' || status === 'done') {\n    return null\n  }\n\n  async function handleSelect(value: string) {\n    if (!worktreeSession) return\n\n    const hasTmux = Boolean(worktreeSession.tmuxSessionName)\n\n    if (value === 'keep' || value === 'keep-with-tmux') {\n      setStatus('keeping')\n      logEvent('tengu_worktree_kept', {\n        commits: commitCount,\n        changed_files: changes.length,\n      })\n      await keepWorktree()\n      process.chdir(worktreeSession.originalCwd)\n      setCwd(worktreeSession.originalCwd)\n      recordWorktreeExit()\n      getPlansDirectory.cache.clear?.()\n      if (hasTmux) {\n        setResultMessage(\n          `Worktree kept. Your work is saved at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}. Reattach to tmux session with: tmux attach -t ${worktreeSession.tmuxSessionName}`,\n        )\n      } else {\n        setResultMessage(\n          `Worktree kept. Your work is saved at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}`,\n        )\n      }\n      setStatus('done')\n    } else if (value === 'keep-kill-tmux') {\n      setStatus('keeping')\n      logEvent('tengu_worktree_kept', {\n        commits: commitCount,\n        changed_files: changes.length,\n      })\n      if (worktreeSession.tmuxSessionName) {\n        await killTmuxSession(worktreeSession.tmuxSessionName)\n      }\n      await keepWorktree()\n      process.chdir(worktreeSession.originalCwd)\n      setCwd(worktreeSession.originalCwd)\n      recordWorktreeExit()\n      getPlansDirectory.cache.clear?.()\n      setResultMessage(\n        `Worktree kept at ${worktreeSession.worktreePath} on branch ${worktreeSession.worktreeBranch}. Tmux session terminated.`,\n      )\n      setStatus('done')\n    } else if (value === 'remove' || value === 'remove-with-tmux') {\n      setStatus('removing')\n      logEvent('tengu_worktree_removed', {\n        commits: commitCount,\n        changed_files: changes.length,\n      })\n      if (worktreeSession.tmuxSessionName) {\n        await killTmuxSession(worktreeSession.tmuxSessionName)\n      }\n      try {\n        await cleanupWorktree()\n        process.chdir(worktreeSession.originalCwd)\n        setCwd(worktreeSession.originalCwd)\n        recordWorktreeExit()\n        getPlansDirectory.cache.clear?.()\n      } catch (error) {\n        logForDebugging(`Failed to clean up worktree: ${error}`, {\n          level: 'error',\n        })\n        setResultMessage('Worktree cleanup failed, exiting anyway')\n        setStatus('done')\n        return\n      }\n      const tmuxNote = hasTmux ? ' Tmux session terminated.' : ''\n      if (commitCount > 0 && changes.length > 0) {\n        setResultMessage(\n          `Worktree removed. ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} and uncommitted changes were discarded.${tmuxNote}`,\n        )\n      } else if (commitCount > 0) {\n        setResultMessage(\n          `Worktree removed. ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${worktreeSession.worktreeBranch} ${commitCount === 1 ? 'was' : 'were'} discarded.${tmuxNote}`,\n        )\n      } else if (changes.length > 0) {\n        setResultMessage(\n          `Worktree removed. Uncommitted changes were discarded.${tmuxNote}`,\n        )\n      } else {\n        setResultMessage(`Worktree removed.${tmuxNote}`)\n      }\n      setStatus('done')\n    }\n  }\n\n  if (status === 'keeping') {\n    return (\n      <Box flexDirection=\"row\" marginY={1}>\n        <Spinner />\n        <Text>Keeping worktree…</Text>\n      </Box>\n    )\n  }\n\n  if (status === 'removing') {\n    return (\n      <Box flexDirection=\"row\" marginY={1}>\n        <Spinner />\n        <Text>Removing worktree…</Text>\n      </Box>\n    )\n  }\n\n  const branchName = worktreeSession.worktreeBranch\n  const hasUncommitted = changes.length > 0\n  const hasCommits = commitCount > 0\n\n  let subtitle = ''\n  if (hasUncommitted && hasCommits) {\n    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? 'file' : 'files'} and ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${branchName}. All will be lost if you remove.`\n  } else if (hasUncommitted) {\n    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? 'file' : 'files'}. These will be lost if you remove the worktree.`\n  } else if (hasCommits) {\n    subtitle = `You have ${commitCount} ${commitCount === 1 ? 'commit' : 'commits'} on ${branchName}. The branch will be deleted if you remove the worktree.`\n  } else {\n    subtitle =\n      'You are working in a worktree. Keep it to continue working there, or remove it to clean up.'\n  }\n\n  function handleCancel() {\n    if (onCancel) {\n      // Abort exit and return to the session\n      onCancel()\n      return\n    }\n    // Fallback: treat Escape as \"keep\" if no onCancel provided\n    void handleSelect('keep')\n  }\n\n  const removeDescription =\n    hasUncommitted || hasCommits\n      ? 'All changes and commits will be lost.'\n      : 'Clean up the worktree directory.'\n\n  const hasTmuxSession = Boolean(worktreeSession.tmuxSessionName)\n\n  const options = hasTmuxSession\n    ? [\n        {\n          label: 'Keep worktree and tmux session',\n          value: 'keep-with-tmux',\n          description: `Stays at ${worktreeSession.worktreePath}. Reattach with: tmux attach -t ${worktreeSession.tmuxSessionName}`,\n        },\n        {\n          label: 'Keep worktree, kill tmux session',\n          value: 'keep-kill-tmux',\n          description: `Keeps worktree at ${worktreeSession.worktreePath}, terminates tmux session.`,\n        },\n        {\n          label: 'Remove worktree and tmux session',\n          value: 'remove-with-tmux',\n          description: removeDescription,\n        },\n      ]\n    : [\n        {\n          label: 'Keep worktree',\n          value: 'keep',\n          description: `Stays at ${worktreeSession.worktreePath}`,\n        },\n        {\n          label: 'Remove worktree',\n          value: 'remove',\n          description: removeDescription,\n        },\n      ]\n\n  const defaultValue = hasTmuxSession ? 'keep-with-tmux' : 'keep'\n\n  return (\n    <Dialog\n      title=\"Exiting worktree session\"\n      subtitle={subtitle}\n      onCancel={handleCancel}\n    >\n      <Select\n        defaultFocusValue={defaultValue}\n        options={options}\n        onChange={handleSelect}\n      />\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}