@xortex/xcode 3.0.1 → 3.0.3

package/components/wizard/WizardNavigationFooter.tsx

@@ -0,0 +1,24 @@
+import React, { type ReactNode } from 'react';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { Box, Text } from '../../ink.js';
+import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
+import { Byline } from '../design-system/Byline.js';
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js';
+type Props = {
+  instructions?: ReactNode;
+};
+export function WizardNavigationFooter({
+  instructions = <Byline>
+      <KeyboardShortcutHint shortcut="↑↓" action="navigate" />
+      <KeyboardShortcutHint shortcut="Enter" action="select" />
+      <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+    </Byline>
+}: Props): ReactNode {
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  return <Box marginLeft={3} marginTop={1}>
+      <Text dimColor>
+        {exitState.pending ? `Press ${exitState.keyName} again to exit` : instructions}
+      </Text>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/components/wizard/WizardProvider.tsx

@@ -0,0 +1,213 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, type ReactNode, useCallback, useEffect, useMemo, useState } from 'react';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import type { WizardContextValue, WizardProviderProps } from './types.js';
+
+// Use any here for the context since it will be cast properly when used
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const WizardContext = createContext<WizardContextValue<any> | null>(null);
+export function WizardProvider(t0) {
+  const $ = _c(38);
+  const {
+    steps,
+    initialData: t1,
+    onComplete,
+    onCancel,
+    children,
+    title,
+    showStepCounter: t2
+  } = t0;
+  let t3;
+  if ($[0] !== t1) {
+    t3 = t1 === undefined ? {} as T : t1;
+    $[0] = t1;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const initialData = t3;
+  const showStepCounter = t2 === undefined ? true : t2;
+  const [currentStepIndex, setCurrentStepIndex] = useState(0);
+  const [wizardData, setWizardData] = useState(initialData);
+  const [isCompleted, setIsCompleted] = useState(false);
+  let t4;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = [];
+    $[2] = t4;
+  } else {
+    t4 = $[2];
+  }
+  const [navigationHistory, setNavigationHistory] = useState(t4);
+  useExitOnCtrlCDWithKeybindings();
+  let t5;
+  let t6;
+  if ($[3] !== isCompleted || $[4] !== onComplete || $[5] !== wizardData) {
+    t5 = () => {
+      if (isCompleted) {
+        setNavigationHistory([]);
+        onComplete(wizardData);
+      }
+    };
+    t6 = [isCompleted, wizardData, onComplete];
+    $[3] = isCompleted;
+    $[4] = onComplete;
+    $[5] = wizardData;
+    $[6] = t5;
+    $[7] = t6;
+  } else {
+    t5 = $[6];
+    t6 = $[7];
+  }
+  useEffect(t5, t6);
+  let t7;
+  if ($[8] !== currentStepIndex || $[9] !== navigationHistory || $[10] !== steps.length) {
+    t7 = () => {
+      if (currentStepIndex < steps.length - 1) {
+        if (navigationHistory.length > 0) {
+          setNavigationHistory(prev => [...prev, currentStepIndex]);
+        }
+        setCurrentStepIndex(_temp);
+      } else {
+        setIsCompleted(true);
+      }
+    };
+    $[8] = currentStepIndex;
+    $[9] = navigationHistory;
+    $[10] = steps.length;
+    $[11] = t7;
+  } else {
+    t7 = $[11];
+  }
+  const goNext = t7;
+  let t8;
+  if ($[12] !== currentStepIndex || $[13] !== navigationHistory || $[14] !== onCancel) {
+    t8 = () => {
+      if (navigationHistory.length > 0) {
+        const previousStep = navigationHistory[navigationHistory.length - 1];
+        if (previousStep !== undefined) {
+          setNavigationHistory(_temp2);
+          setCurrentStepIndex(previousStep);
+        }
+      } else {
+        if (currentStepIndex > 0) {
+          setCurrentStepIndex(_temp3);
+        } else {
+          if (onCancel) {
+            onCancel();
+          }
+        }
+      }
+    };
+    $[12] = currentStepIndex;
+    $[13] = navigationHistory;
+    $[14] = onCancel;
+    $[15] = t8;
+  } else {
+    t8 = $[15];
+  }
+  const goBack = t8;
+  let t9;
+  if ($[16] !== currentStepIndex || $[17] !== steps.length) {
+    t9 = index => {
+      if (index >= 0 && index < steps.length) {
+        setNavigationHistory(prev_3 => [...prev_3, currentStepIndex]);
+        setCurrentStepIndex(index);
+      }
+    };
+    $[16] = currentStepIndex;
+    $[17] = steps.length;
+    $[18] = t9;
+  } else {
+    t9 = $[18];
+  }
+  const goToStep = t9;
+  let t10;
+  if ($[19] !== onCancel) {
+    t10 = () => {
+      setNavigationHistory([]);
+      if (onCancel) {
+        onCancel();
+      }
+    };
+    $[19] = onCancel;
+    $[20] = t10;
+  } else {
+    t10 = $[20];
+  }
+  const cancel = t10;
+  let t11;
+  if ($[21] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = updates => {
+      setWizardData(prev_4 => ({
+        ...prev_4,
+        ...updates
+      }));
+    };
+    $[21] = t11;
+  } else {
+    t11 = $[21];
+  }
+  const updateWizardData = t11;
+  let t12;
+  if ($[22] !== cancel || $[23] !== currentStepIndex || $[24] !== goBack || $[25] !== goNext || $[26] !== goToStep || $[27] !== showStepCounter || $[28] !== steps.length || $[29] !== title || $[30] !== wizardData) {
+    t12 = {
+      currentStepIndex,
+      totalSteps: steps.length,
+      wizardData,
+      setWizardData,
+      updateWizardData,
+      goNext,
+      goBack,
+      goToStep,
+      cancel,
+      title,
+      showStepCounter
+    };
+    $[22] = cancel;
+    $[23] = currentStepIndex;
+    $[24] = goBack;
+    $[25] = goNext;
+    $[26] = goToStep;
+    $[27] = showStepCounter;
+    $[28] = steps.length;
+    $[29] = title;
+    $[30] = wizardData;
+    $[31] = t12;
+  } else {
+    t12 = $[31];
+  }
+  const contextValue = t12;
+  const CurrentStepComponent = steps[currentStepIndex];
+  if (!CurrentStepComponent || isCompleted) {
+    return null;
+  }
+  let t13;
+  if ($[32] !== CurrentStepComponent || $[33] !== children) {
+    t13 = children || <CurrentStepComponent />;
+    $[32] = CurrentStepComponent;
+    $[33] = children;
+    $[34] = t13;
+  } else {
+    t13 = $[34];
+  }
+  let t14;
+  if ($[35] !== contextValue || $[36] !== t13) {
+    t14 = <WizardContext.Provider value={contextValue}>{t13}</WizardContext.Provider>;
+    $[35] = contextValue;
+    $[36] = t13;
+    $[37] = t14;
+  } else {
+    t14 = $[37];
+  }
+  return t14;
+}
+function _temp3(prev_2) {
+  return prev_2 - 1;
+}
+function _temp2(prev_1) {
+  return prev_1.slice(0, -1);
+}
+function _temp(prev_0) {
+  return prev_0 + 1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","ReactNode","useCallback","useEffect","useMemo","useState","useExitOnCtrlCDWithKeybindings","WizardContextValue","WizardProviderProps","WizardContext","WizardProvider","t0","$","_c","steps","initialData","t1","onComplete","onCancel","children","title","showStepCounter","t2","t3","undefined","T","currentStepIndex","setCurrentStepIndex","wizardData","setWizardData","isCompleted","setIsCompleted","t4","Symbol","for","navigationHistory","setNavigationHistory","t5","t6","t7","length","prev","_temp","goNext","t8","previousStep","_temp2","_temp3","goBack","t9","index","prev_3","goToStep","t10","cancel","t11","updates","prev_4","updateWizardData","t12","totalSteps","contextValue","CurrentStepComponent","t13","t14","prev_2","prev_1","slice","prev_0"],"sources":["WizardProvider.tsx"],"sourcesContent":["import React, {\n  createContext,\n  type ReactNode,\n  useCallback,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport type { WizardContextValue, WizardProviderProps } from './types.js'\n\n// Use any here for the context since it will be cast properly when used\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const WizardContext = createContext<WizardContextValue<any> | null>(null)\n\nexport function WizardProvider<T extends Record<string, unknown>>({\n  steps,\n  initialData = {} as T,\n  onComplete,\n  onCancel,\n  children,\n  title,\n  showStepCounter = true,\n}: WizardProviderProps<T>): ReactNode {\n  const [currentStepIndex, setCurrentStepIndex] = useState(0)\n  const [wizardData, setWizardData] = useState<T>(initialData)\n  const [isCompleted, setIsCompleted] = useState(false)\n  const [navigationHistory, setNavigationHistory] = useState<number[]>([])\n\n  useExitOnCtrlCDWithKeybindings()\n\n  // Handle completion in useEffect to avoid updating parent during render\n  useEffect(() => {\n    if (isCompleted) {\n      setNavigationHistory([])\n      void onComplete(wizardData)\n    }\n  }, [isCompleted, wizardData, onComplete])\n\n  const goNext = useCallback(() => {\n    if (currentStepIndex < steps.length - 1) {\n      // If we have history (non-linear flow), add current step to it\n      if (navigationHistory.length > 0) {\n        setNavigationHistory(prev => [...prev, currentStepIndex])\n      }\n\n      setCurrentStepIndex(prev => prev + 1)\n    } else {\n      // Mark as completed, which will trigger useEffect\n      setIsCompleted(true)\n    }\n  }, [currentStepIndex, steps.length, navigationHistory])\n\n  const goBack = useCallback(() => {\n    // Check if we have navigation history to use\n    if (navigationHistory.length > 0) {\n      const previousStep = navigationHistory[navigationHistory.length - 1]\n      if (previousStep !== undefined) {\n        setNavigationHistory(prev => prev.slice(0, -1))\n        setCurrentStepIndex(previousStep)\n      }\n    } else if (currentStepIndex > 0) {\n      // Fallback to simple decrement if no history\n      setCurrentStepIndex(prev => prev - 1)\n    } else if (onCancel) {\n      onCancel()\n    }\n  }, [currentStepIndex, navigationHistory, onCancel])\n\n  const goToStep = useCallback(\n    (index: number) => {\n      if (index >= 0 && index < steps.length) {\n        // Push current step to history before jumping\n        setNavigationHistory(prev => [...prev, currentStepIndex])\n        setCurrentStepIndex(index)\n      }\n    },\n    [currentStepIndex, steps.length],\n  )\n\n  const cancel = useCallback(() => {\n    setNavigationHistory([])\n    if (onCancel) {\n      onCancel()\n    }\n  }, [onCancel])\n\n  const updateWizardData = useCallback((updates: Partial<T>) => {\n    setWizardData(prev => ({ ...prev, ...updates }))\n  }, [])\n\n  const contextValue = useMemo<WizardContextValue<T>>(\n    () => ({\n      currentStepIndex,\n      totalSteps: steps.length,\n      wizardData,\n      setWizardData,\n      updateWizardData,\n      goNext,\n      goBack,\n      goToStep,\n      cancel,\n      title,\n      showStepCounter,\n    }),\n    [\n      currentStepIndex,\n      steps.length,\n      wizardData,\n      updateWizardData,\n      goNext,\n      goBack,\n      goToStep,\n      cancel,\n      title,\n      showStepCounter,\n    ],\n  )\n\n  const CurrentStepComponent = steps[currentStepIndex]\n\n  if (!CurrentStepComponent || isCompleted) {\n    return null\n  }\n\n  return (\n    <WizardContext.Provider value={contextValue}>\n      {children || <CurrentStepComponent />}\n    </WizardContext.Provider>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/wizard/index.ts

@@ -0,0 +1,9 @@
+export type {
+  WizardContextValue,
+  WizardProviderProps,
+  WizardStepComponent,
+} from './types.js'
+export { useWizard } from './useWizard.js'
+export { WizardDialogLayout } from './WizardDialogLayout.js'
+export { WizardNavigationFooter } from './WizardNavigationFooter.js'
+export { WizardProvider } from './WizardProvider.js'

package/components/wizard/useWizard.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react'
+import type { WizardContextValue } from './types.js'
+import { WizardContext } from './WizardProvider.js'
+
+export function useWizard<
+  T extends Record<string, unknown> = Record<string, unknown>,
+>(): WizardContextValue<T> {
+  const context = useContext(WizardContext) as WizardContextValue<T> | null
+  if (!context) {
+    throw new Error('useWizard must be used within a WizardProvider')
+  }
+  return context
+}

package/context.ts

@@ -0,0 +1,189 @@
+import { feature } from 'bun:bundle'
+import memoize from 'lodash-es/memoize.js'
+import {
+  getAdditionalDirectoriesForClaudeMd,
+  setCachedClaudeMdContent,
+} from './bootstrap/state.js'
+import { getLocalISODate } from './constants/common.js'
+import {
+  filterInjectedMemoryFiles,
+  getClaudeMds,
+  getMemoryFiles,
+} from './utils/claudemd.js'
+import { logForDiagnosticsNoPII } from './utils/diagLogs.js'
+import { isBareMode, isEnvTruthy } from './utils/envUtils.js'
+import { execFileNoThrow } from './utils/execFileNoThrow.js'
+import { getBranch, getDefaultBranch, getIsGit, gitExe } from './utils/git.js'
+import { shouldIncludeGitInstructions } from './utils/gitSettings.js'
+import { logError } from './utils/log.js'
+
+const MAX_STATUS_CHARS = 2000
+
+// System prompt injection for cache breaking (ant-only, ephemeral debugging state)
+let systemPromptInjection: string | null = null
+
+export function getSystemPromptInjection(): string | null {
+  return systemPromptInjection
+}
+
+export function setSystemPromptInjection(value: string | null): void {
+  systemPromptInjection = value
+  // Clear context caches immediately when injection changes
+  getUserContext.cache.clear?.()
+  getSystemContext.cache.clear?.()
+}
+
+export const getGitStatus = memoize(async (): Promise<string | null> => {
+  if (process.env.NODE_ENV === 'test') {
+    // Avoid cycles in tests
+    return null
+  }
+
+  const startTime = Date.now()
+  logForDiagnosticsNoPII('info', 'git_status_started')
+
+  const isGitStart = Date.now()
+  const isGit = await getIsGit()
+  logForDiagnosticsNoPII('info', 'git_is_git_check_completed', {
+    duration_ms: Date.now() - isGitStart,
+    is_git: isGit,
+  })
+
+  if (!isGit) {
+    logForDiagnosticsNoPII('info', 'git_status_skipped_not_git', {
+      duration_ms: Date.now() - startTime,
+    })
+    return null
+  }
+
+  try {
+    const gitCmdsStart = Date.now()
+    const [branch, mainBranch, status, log, userName] = await Promise.all([
+      getBranch(),
+      getDefaultBranch(),
+      execFileNoThrow(gitExe(), ['--no-optional-locks', 'status', '--short'], {
+        preserveOutputOnError: false,
+      }).then(({ stdout }) => stdout.trim()),
+      execFileNoThrow(
+        gitExe(),
+        ['--no-optional-locks', 'log', '--oneline', '-n', '5'],
+        {
+          preserveOutputOnError: false,
+        },
+      ).then(({ stdout }) => stdout.trim()),
+      execFileNoThrow(gitExe(), ['config', 'user.name'], {
+        preserveOutputOnError: false,
+      }).then(({ stdout }) => stdout.trim()),
+    ])
+
+    logForDiagnosticsNoPII('info', 'git_commands_completed', {
+      duration_ms: Date.now() - gitCmdsStart,
+      status_length: status.length,
+    })
+
+    // Check if status exceeds character limit
+    const truncatedStatus =
+      status.length > MAX_STATUS_CHARS
+        ? status.substring(0, MAX_STATUS_CHARS) +
+          '\n... (truncated because it exceeds 2k characters. If you need more information, run "git status" using BashTool)'
+        : status
+
+    logForDiagnosticsNoPII('info', 'git_status_completed', {
+      duration_ms: Date.now() - startTime,
+      truncated: status.length > MAX_STATUS_CHARS,
+    })
+
+    return [
+      `This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.`,
+      `Current branch: ${branch}`,
+      `Main branch (you will usually use this for PRs): ${mainBranch}`,
+      ...(userName ? [`Git user: ${userName}`] : []),
+      `Status:\n${truncatedStatus || '(clean)'}`,
+      `Recent commits:\n${log}`,
+    ].join('\n\n')
+  } catch (error) {
+    logForDiagnosticsNoPII('error', 'git_status_failed', {
+      duration_ms: Date.now() - startTime,
+    })
+    logError(error)
+    return null
+  }
+})
+
+/**
+ * This context is prepended to each conversation, and cached for the duration of the conversation.
+ */
+export const getSystemContext = memoize(
+  async (): Promise<{
+    [k: string]: string
+  }> => {
+    const startTime = Date.now()
+    logForDiagnosticsNoPII('info', 'system_context_started')
+
+    // Skip git status in CCR (unnecessary overhead on resume) or when git instructions are disabled
+    const gitStatus =
+      isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) ||
+      !shouldIncludeGitInstructions()
+        ? null
+        : await getGitStatus()
+
+    // Include system prompt injection if set (for cache breaking, ant-only)
+    const injection = feature('BREAK_CACHE_COMMAND')
+      ? getSystemPromptInjection()
+      : null
+
+    logForDiagnosticsNoPII('info', 'system_context_completed', {
+      duration_ms: Date.now() - startTime,
+      has_git_status: gitStatus !== null,
+      has_injection: injection !== null,
+    })
+
+    return {
+      ...(gitStatus && { gitStatus }),
+      ...(feature('BREAK_CACHE_COMMAND') && injection
+        ? {
+            cacheBreaker: `[CACHE_BREAKER: ${injection}]`,
+          }
+        : {}),
+    }
+  },
+)
+
+/**
+ * This context is prepended to each conversation, and cached for the duration of the conversation.
+ */
+export const getUserContext = memoize(
+  async (): Promise<{
+    [k: string]: string
+  }> => {
+    const startTime = Date.now()
+    logForDiagnosticsNoPII('info', 'user_context_started')
+
+    // CLAUDE_CODE_DISABLE_CLAUDE_MDS: hard off, always.
+    // --bare: skip auto-discovery (cwd walk), BUT honor explicit --add-dir.
+    // --bare means "skip what I didn't ask for", not "ignore what I asked for".
+    const shouldDisableClaudeMd =
+      isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_CLAUDE_MDS) ||
+      (isBareMode() && getAdditionalDirectoriesForClaudeMd().length === 0)
+    // Await the async I/O (readFile/readdir directory walk) so the event
+    // loop yields naturally at the first fs.readFile.
+    const claudeMd = shouldDisableClaudeMd
+      ? null
+      : getClaudeMds(filterInjectedMemoryFiles(await getMemoryFiles()))
+    // Cache for the auto-mode classifier (yoloClassifier.ts reads this
+    // instead of importing claudemd.ts directly, which would create a
+    // cycle through permissions/filesystem → permissions → yoloClassifier).
+    setCachedClaudeMdContent(claudeMd || null)
+
+    logForDiagnosticsNoPII('info', 'user_context_completed', {
+      duration_ms: Date.now() - startTime,
+      claudemd_length: claudeMd?.length ?? 0,
+      claudemd_disabled: Boolean(shouldDisableClaudeMd),
+    })
+
+    return {
+      ...(claudeMd && { claudeMd }),
+      currentDate: `Today's date is ${getLocalISODate()}.`,
+    }
+  },
+)