@xortex/xcode 3.0.1 → 3.0.2

package/hooks/notifs/useRateLimitWarningNotification.tsx

@@ -0,0 +1,114 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { Text } from 'src/ink.js';
+import { getRateLimitWarning, getUsingOverageText } from 'src/services/claudeAiLimits.js';
+import { useClaudeAiLimits } from 'src/services/claudeAiLimitsHook.js';
+import { getSubscriptionType } from 'src/utils/auth.js';
+import { hasClaudeAiBillingAccess } from 'src/utils/billing.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+export function useRateLimitWarningNotification(model) {
+  const $ = _c(17);
+  const {
+    addNotification
+  } = useNotifications();
+  const claudeAiLimits = useClaudeAiLimits();
+  let t0;
+  if ($[0] !== claudeAiLimits || $[1] !== model) {
+    t0 = getRateLimitWarning(claudeAiLimits, model);
+    $[0] = claudeAiLimits;
+    $[1] = model;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const rateLimitWarning = t0;
+  let t1;
+  if ($[3] !== claudeAiLimits) {
+    t1 = getUsingOverageText(claudeAiLimits);
+    $[3] = claudeAiLimits;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const usingOverageText = t1;
+  const shownWarningRef = useRef(null);
+  let t2;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = getSubscriptionType();
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const subscriptionType = t2;
+  let t3;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = hasClaudeAiBillingAccess();
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const hasBillingAccess = t3;
+  const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise";
+  const [hasShownOverageNotification, setHasShownOverageNotification] = useState(false);
+  let t4;
+  let t5;
+  if ($[7] !== addNotification || $[8] !== claudeAiLimits.isUsingOverage || $[9] !== hasShownOverageNotification || $[10] !== usingOverageText) {
+    t4 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (claudeAiLimits.isUsingOverage && !hasShownOverageNotification && (!isTeamOrEnterprise || hasBillingAccess)) {
+        addNotification({
+          key: "limit-reached",
+          text: usingOverageText,
+          priority: "immediate"
+        });
+        setHasShownOverageNotification(true);
+      } else {
+        if (!claudeAiLimits.isUsingOverage && hasShownOverageNotification) {
+          setHasShownOverageNotification(false);
+        }
+      }
+    };
+    t5 = [claudeAiLimits.isUsingOverage, usingOverageText, hasShownOverageNotification, addNotification, hasBillingAccess, isTeamOrEnterprise];
+    $[7] = addNotification;
+    $[8] = claudeAiLimits.isUsingOverage;
+    $[9] = hasShownOverageNotification;
+    $[10] = usingOverageText;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t4 = $[11];
+    t5 = $[12];
+  }
+  useEffect(t4, t5);
+  let t6;
+  let t7;
+  if ($[13] !== addNotification || $[14] !== rateLimitWarning) {
+    t6 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (rateLimitWarning && rateLimitWarning !== shownWarningRef.current) {
+        shownWarningRef.current = rateLimitWarning;
+        addNotification({
+          key: "rate-limit-warning",
+          jsx: <Text><Text color="warning">{rateLimitWarning}</Text></Text>,
+          priority: "high"
+        });
+      }
+    };
+    t7 = [rateLimitWarning, addNotification];
+    $[13] = addNotification;
+    $[14] = rateLimitWarning;
+    $[15] = t6;
+    $[16] = t7;
+  } else {
+    t6 = $[15];
+    t7 = $[16];
+  }
+  useEffect(t6, t7);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useMemo","useRef","useState","useNotifications","Text","getRateLimitWarning","getUsingOverageText","useClaudeAiLimits","getSubscriptionType","hasClaudeAiBillingAccess","getIsRemoteMode","useRateLimitWarningNotification","model","$","_c","addNotification","claudeAiLimits","t0","rateLimitWarning","t1","usingOverageText","shownWarningRef","t2","Symbol","for","subscriptionType","t3","hasBillingAccess","isTeamOrEnterprise","hasShownOverageNotification","setHasShownOverageNotification","t4","t5","isUsingOverage","key","text","priority","t6","t7","current","jsx"],"sources":["useRateLimitWarningNotification.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { Text } from 'src/ink.js'\nimport {\n  getRateLimitWarning,\n  getUsingOverageText,\n} from 'src/services/claudeAiLimits.js'\nimport { useClaudeAiLimits } from 'src/services/claudeAiLimitsHook.js'\nimport { getSubscriptionType } from 'src/utils/auth.js'\nimport { hasClaudeAiBillingAccess } from 'src/utils/billing.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\n\nexport function useRateLimitWarningNotification(model: string): void {\n  const { addNotification } = useNotifications()\n  const claudeAiLimits = useClaudeAiLimits()\n  // claudeAiLimits reference is stable until statusListeners fire (API\n  // response), so these skip the Intl formatting work on most REPL renders.\n  const rateLimitWarning = useMemo(\n    () => getRateLimitWarning(claudeAiLimits, model),\n    [claudeAiLimits, model],\n  )\n  const usingOverageText = useMemo(\n    () => getUsingOverageText(claudeAiLimits),\n    [claudeAiLimits],\n  )\n  const shownWarningRef = useRef<string | null>(null)\n  const subscriptionType = getSubscriptionType()\n  const hasBillingAccess = hasClaudeAiBillingAccess()\n  const isTeamOrEnterprise =\n    subscriptionType === 'team' || subscriptionType === 'enterprise'\n\n  // Track overage mode transitions\n  const [hasShownOverageNotification, setHasShownOverageNotification] =\n    useState(false)\n\n  // Show immediate notification when entering overage mode\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (\n      claudeAiLimits.isUsingOverage &&\n      !hasShownOverageNotification &&\n      (!isTeamOrEnterprise || hasBillingAccess)\n    ) {\n      addNotification({\n        key: 'limit-reached',\n        text: usingOverageText,\n        priority: 'immediate',\n      })\n      setHasShownOverageNotification(true)\n    } else if (!claudeAiLimits.isUsingOverage && hasShownOverageNotification) {\n      // Reset when no longer in overage mode\n      setHasShownOverageNotification(false)\n    }\n  }, [\n    claudeAiLimits.isUsingOverage,\n    usingOverageText,\n    hasShownOverageNotification,\n    addNotification,\n    hasBillingAccess,\n    isTeamOrEnterprise,\n  ])\n\n  // Show warning notification for approaching limits\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (rateLimitWarning && rateLimitWarning !== shownWarningRef.current) {\n      shownWarningRef.current = rateLimitWarning\n      addNotification({\n        key: 'rate-limit-warning',\n        jsx: (\n          <Text>\n            <Text color=\"warning\">{rateLimitWarning}</Text>\n          </Text>\n        ),\n        priority: 'high',\n      })\n    }\n  }, [rateLimitWarning, addNotification])\n}\n"],"mappings":"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","ignoreList":[]}

package/hooks/notifs/useSettingsErrors.tsx

@@ -0,0 +1,69 @@
+import { c as _c } from "react/compiler-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { getSettingsWithAllErrors } from '../../utils/settings/allErrors.js';
+import type { ValidationError } from '../../utils/settings/validation.js';
+import { useSettingsChange } from '../useSettingsChange.js';
+const SETTINGS_ERRORS_NOTIFICATION_KEY = 'settings-errors';
+export function useSettingsErrors() {
+  const $ = _c(6);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  const [errors_0, setErrors] = useState(_temp);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = () => {
+      const {
+        errors: errors_1
+      } = getSettingsWithAllErrors();
+      setErrors(errors_1);
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const handleSettingsChange = t0;
+  useSettingsChange(handleSettingsChange);
+  let t1;
+  let t2;
+  if ($[1] !== addNotification || $[2] !== errors_0 || $[3] !== removeNotification) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (errors_0.length > 0) {
+        const message = `Found ${errors_0.length} settings ${errors_0.length === 1 ? "issue" : "issues"} · /doctor for details`;
+        addNotification({
+          key: SETTINGS_ERRORS_NOTIFICATION_KEY,
+          text: message,
+          color: "warning",
+          priority: "high",
+          timeoutMs: 60000
+        });
+      } else {
+        removeNotification(SETTINGS_ERRORS_NOTIFICATION_KEY);
+      }
+    };
+    t2 = [errors_0, addNotification, removeNotification];
+    $[1] = addNotification;
+    $[2] = errors_0;
+    $[3] = removeNotification;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  useEffect(t1, t2);
+  return errors_0;
+}
+function _temp() {
+  const {
+    errors
+  } = getSettingsWithAllErrors();
+  return errors;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/hooks/notifs/useStartupNotification.ts

@@ -0,0 +1,41 @@
+import { useEffect, useRef } from 'react'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import {
+  type Notification,
+  useNotifications,
+} from '../../context/notifications.js'
+import { logError } from '../../utils/log.js'
+
+type Result = Notification | Notification[] | null
+
+/**
+ * Fires notification(s) once on mount. Encapsulates the remote-mode gate and
+ * once-per-session ref guard that was hand-rolled across 10+ notifs/ hooks.
+ *
+ * The compute fn runs exactly once on first effect. Return null to skip,
+ * a Notification to fire one, or an array to fire several. Sync or async.
+ * Rejections are routed to logError.
+ */
+export function useStartupNotification(
+  compute: () => Result | Promise<Result>,
+): void {
+  const { addNotification } = useNotifications()
+  const hasRunRef = useRef(false)
+  const computeRef = useRef(compute)
+  computeRef.current = compute
+
+  useEffect(() => {
+    if (getIsRemoteMode() || hasRunRef.current) return
+    hasRunRef.current = true
+
+    void Promise.resolve()
+      .then(() => computeRef.current())
+      .then(result => {
+        if (!result) return
+        for (const n of Array.isArray(result) ? result : [result]) {
+          addNotification(n)
+        }
+      })
+      .catch(logError)
+  }, [addNotification])
+}

package/hooks/notifs/useTeammateShutdownNotification.ts

@@ -0,0 +1,78 @@
+import { useEffect, useRef } from 'react'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import {
+  type Notification,
+  useNotifications,
+} from '../../context/notifications.js'
+import { useAppState } from '../../state/AppState.js'
+import { isInProcessTeammateTask } from '../../tasks/InProcessTeammateTask/types.js'
+
+function parseCount(notif: Notification): number {
+  if (!('text' in notif)) {
+    return 1
+  }
+  const match = notif.text.match(/^(\d+)/)
+  return match?.[1] ? parseInt(match[1], 10) : 1
+}
+
+function foldSpawn(acc: Notification, _incoming: Notification): Notification {
+  return makeSpawnNotif(parseCount(acc) + 1)
+}
+
+function makeSpawnNotif(count: number): Notification {
+  return {
+    key: 'teammate-spawn',
+    text: count === 1 ? '1 agent spawned' : `${count} agents spawned`,
+    priority: 'low',
+    timeoutMs: 5000,
+    fold: foldSpawn,
+  }
+}
+
+function foldShutdown(
+  acc: Notification,
+  _incoming: Notification,
+): Notification {
+  return makeShutdownNotif(parseCount(acc) + 1)
+}
+
+function makeShutdownNotif(count: number): Notification {
+  return {
+    key: 'teammate-shutdown',
+    text: count === 1 ? '1 agent shut down' : `${count} agents shut down`,
+    priority: 'low',
+    timeoutMs: 5000,
+    fold: foldShutdown,
+  }
+}
+
+/**
+ * Fires batched notifications when in-process teammates spawn or shut down.
+ * Uses fold() to combine repeated events into a single notification
+ * like "3 agents spawned" or "2 agents shut down".
+ */
+export function useTeammateLifecycleNotification(): void {
+  const tasks = useAppState(s => s.tasks)
+  const { addNotification } = useNotifications()
+  const seenRunningRef = useRef<Set<string>>(new Set())
+  const seenCompletedRef = useRef<Set<string>>(new Set())
+
+  useEffect(() => {
+    if (getIsRemoteMode()) return
+    for (const [id, task] of Object.entries(tasks)) {
+      if (!isInProcessTeammateTask(task)) {
+        continue
+      }
+
+      if (task.status === 'running' && !seenRunningRef.current.has(id)) {
+        seenRunningRef.current.add(id)
+        addNotification(makeSpawnNotif(1))
+      }
+
+      if (task.status === 'completed' && !seenCompletedRef.current.has(id)) {
+        seenCompletedRef.current.add(id)
+        addNotification(makeShutdownNotif(1))
+      }
+    }
+  }, [tasks, addNotification])
+}

package/hooks/renderPlaceholder.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk'
+
+type PlaceholderRendererProps = {
+  placeholder?: string
+  value: string
+  showCursor?: boolean
+  focus?: boolean
+  terminalFocus: boolean
+  invert?: (text: string) => string
+  hidePlaceholderText?: boolean
+}
+
+export function renderPlaceholder({
+  placeholder,
+  value,
+  showCursor,
+  focus,
+  terminalFocus = true,
+  invert = chalk.inverse,
+  hidePlaceholderText = false,
+}: PlaceholderRendererProps): {
+  renderedPlaceholder: string | undefined
+  showPlaceholder: boolean
+} {
+  let renderedPlaceholder: string | undefined = undefined
+
+  if (placeholder) {
+    if (hidePlaceholderText) {
+      // Voice recording: show only the cursor, no placeholder text
+      renderedPlaceholder =
+        showCursor && focus && terminalFocus ? invert(' ') : ''
+    } else {
+      renderedPlaceholder = chalk.dim(placeholder)
+
+      // Show inverse cursor only when both input and terminal are focused
+      if (showCursor && focus && terminalFocus) {
+        renderedPlaceholder =
+          placeholder.length > 0
+            ? invert(placeholder[0]!) + chalk.dim(placeholder.slice(1))
+            : invert(' ')
+      }
+    }
+  }
+
+  const showPlaceholder = value.length === 0 && Boolean(placeholder)
+
+  return {
+    renderedPlaceholder,
+    showPlaceholder,
+  }
+}