@xortex/xcode 3.0.1 → 3.0.3

package/components/LogoV2/Opus1mMergeNotice.tsx

@@ -0,0 +1,55 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { UP_ARROW } from '../../constants/figures.js';
+import { Box, Text } from '../../ink.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { isOpus1mMergeEnabled } from '../../utils/model/model.js';
+import { AnimatedAsterisk } from './AnimatedAsterisk.js';
+const MAX_SHOW_COUNT = 6;
+export function shouldShowOpus1mMergeNotice(): boolean {
+  return isOpus1mMergeEnabled() && (getGlobalConfig().opus1mMergeNoticeSeenCount ?? 0) < MAX_SHOW_COUNT;
+}
+export function Opus1mMergeNotice() {
+  const $ = _c(4);
+  const [show] = useState(shouldShowOpus1mMergeNotice);
+  let t0;
+  let t1;
+  if ($[0] !== show) {
+    t0 = () => {
+      if (!show) {
+        return;
+      }
+      const newCount = (getGlobalConfig().opus1mMergeNoticeSeenCount ?? 0) + 1;
+      saveGlobalConfig(prev => {
+        if ((prev.opus1mMergeNoticeSeenCount ?? 0) >= newCount) {
+          return prev;
+        }
+        return {
+          ...prev,
+          opus1mMergeNoticeSeenCount: newCount
+        };
+      });
+    };
+    t1 = [show];
+    $[0] = show;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  if (!show) {
+    return null;
+  }
+  let t2;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box paddingLeft={2}><AnimatedAsterisk char={UP_ARROW} /><Text dimColor={true}>{" "}Opus now defaults to 1M context · 5x more room, same pricing</Text></Box>;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/components/LogoV2/OverageCreditUpsell.tsx

@@ -0,0 +1,166 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useState } from 'react';
+import { Text } from '../../ink.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { formatGrantAmount, getCachedOverageCreditGrant, refreshOverageCreditGrantCache } from '../../services/api/overageCreditGrant.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { truncate } from '../../utils/format.js';
+import type { FeedConfig } from './Feed.js';
+const MAX_IMPRESSIONS = 3;
+
+/**
+ * Whether to show the overage credit upsell on any surface.
+ *
+ * Eligibility comes entirely from the backend GET /overage_credit_grant
+ * response — the CLI doesn't replicate tier/threshold/role checks. The
+ * backend returns available: false for Team members who aren't admins,
+ * so they don't see an upsell they can't act on.
+ *
+ * isEligibleForOverageCreditGrant — just the backend eligibility. Use for
+ *   persistent reference surfaces (/usage) where the info should show
+ *   whenever eligible, no impression cap.
+ * shouldShowOverageCreditUpsell — adds the 3-impression cap and
+ *   hasVisitedExtraUsage dismiss. Use for promotional surfaces
+ *   (welcome feed, tips).
+ */
+export function isEligibleForOverageCreditGrant(): boolean {
+  const info = getCachedOverageCreditGrant();
+  if (!info || !info.available || info.granted) return false;
+  return formatGrantAmount(info) !== null;
+}
+export function shouldShowOverageCreditUpsell(): boolean {
+  if (!isEligibleForOverageCreditGrant()) return false;
+  const config = getGlobalConfig();
+  if (config.hasVisitedExtraUsage) return false;
+  if ((config.overageCreditUpsellSeenCount ?? 0) >= MAX_IMPRESSIONS) return false;
+  return true;
+}
+
+/**
+ * Kick off a background fetch if the cache is empty. Safe to call
+ * unconditionally on mount — it no-ops if cache is fresh.
+ */
+export function maybeRefreshOverageCreditCache(): void {
+  if (getCachedOverageCreditGrant() !== null) return;
+  void refreshOverageCreditGrantCache();
+}
+export function useShowOverageCreditUpsell() {
+  const [show] = useState(_temp);
+  return show;
+}
+function _temp() {
+  maybeRefreshOverageCreditCache();
+  return shouldShowOverageCreditUpsell();
+}
+export function incrementOverageCreditUpsellSeenCount(): void {
+  let newCount = 0;
+  saveGlobalConfig(prev => {
+    newCount = (prev.overageCreditUpsellSeenCount ?? 0) + 1;
+    return {
+      ...prev,
+      overageCreditUpsellSeenCount: newCount
+    };
+  });
+  logEvent('tengu_overage_credit_upsell_shown', {
+    seen_count: newCount
+  });
+}
+
+// Copy from "OC & Bulk Overages copy" doc (#6 — CLI /usage)
+function getUsageText(amount: string): string {
+  return `${amount} in extra usage for third-party apps · /extra-usage`;
+}
+
+// Copy from "OC & Bulk Overages copy" doc (#4 — CLI Welcome screen).
+// Char budgets: title ≤19, subtitle ≤48.
+const FEED_SUBTITLE = 'On us. Works on third-party apps · /extra-usage';
+function getFeedTitle(amount: string): string {
+  return `${amount} in extra usage`;
+}
+type Props = {
+  maxWidth?: number;
+  twoLine?: boolean;
+};
+export function OverageCreditUpsell(t0) {
+  const $ = _c(8);
+  const {
+    maxWidth,
+    twoLine
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== maxWidth || $[1] !== twoLine) {
+    t2 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const info = getCachedOverageCreditGrant();
+      if (!info) {
+        t2 = null;
+        break bb0;
+      }
+      const amount = formatGrantAmount(info);
+      if (!amount) {
+        t2 = null;
+        break bb0;
+      }
+      if (twoLine) {
+        const title = getFeedTitle(amount);
+        let t3;
+        if ($[4] !== maxWidth) {
+          t3 = maxWidth ? truncate(FEED_SUBTITLE, maxWidth) : FEED_SUBTITLE;
+          $[4] = maxWidth;
+          $[5] = t3;
+        } else {
+          t3 = $[5];
+        }
+        let t4;
+        if ($[6] !== t3) {
+          t4 = <Text dimColor={true}>{t3}</Text>;
+          $[6] = t3;
+          $[7] = t4;
+        } else {
+          t4 = $[7];
+        }
+        t2 = <><Text color="claude">{maxWidth ? truncate(title, maxWidth) : title}</Text>{t4}</>;
+        break bb0;
+      }
+      const text = getUsageText(amount);
+      const display = maxWidth ? truncate(text, maxWidth) : text;
+      const highlightLen = Math.min(getFeedTitle(amount).length, display.length);
+      t1 = <Text dimColor={true}><Text color="claude">{display.slice(0, highlightLen)}</Text>{display.slice(highlightLen)}</Text>;
+    }
+    $[0] = maxWidth;
+    $[1] = twoLine;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  if (t2 !== Symbol.for("react.early_return_sentinel")) {
+    return t2;
+  }
+  return t1;
+}
+
+/**
+ * Feed config for the homescreen rotating feed. Mirrors
+ * createGuestPassesFeed in feedConfigs.tsx.
+ *
+ * Copy from "OC & Bulk Overages copy" doc (#4 — CLI Welcome screen).
+ * Char budgets: title ≤19, subtitle ≤48.
+ */
+export function createOverageCreditFeed(): FeedConfig {
+  const info = getCachedOverageCreditGrant();
+  const amount = info ? formatGrantAmount(info) : null;
+  const title = amount ? getFeedTitle(amount) : 'extra usage credit';
+  return {
+    title,
+    lines: [],
+    customContent: {
+      content: <Text dimColor>{FEED_SUBTITLE}</Text>,
+      width: Math.max(title.length, FEED_SUBTITLE.length)
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","Text","logEvent","formatGrantAmount","getCachedOverageCreditGrant","refreshOverageCreditGrantCache","getGlobalConfig","saveGlobalConfig","truncate","FeedConfig","MAX_IMPRESSIONS","isEligibleForOverageCreditGrant","info","available","granted","shouldShowOverageCreditUpsell","config","hasVisitedExtraUsage","overageCreditUpsellSeenCount","maybeRefreshOverageCreditCache","useShowOverageCreditUpsell","show","_temp","incrementOverageCreditUpsellSeenCount","newCount","prev","seen_count","getUsageText","amount","FEED_SUBTITLE","getFeedTitle","Props","maxWidth","twoLine","OverageCreditUpsell","t0","$","_c","t1","t2","Symbol","for","bb0","title","t3","t4","text","display","highlightLen","Math","min","length","slice","createOverageCreditFeed","lines","customContent","content","width","max"],"sources":["OverageCreditUpsell.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useState } from 'react'\nimport { Text } from '../../ink.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport {\n  formatGrantAmount,\n  getCachedOverageCreditGrant,\n  refreshOverageCreditGrantCache,\n} from '../../services/api/overageCreditGrant.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport { truncate } from '../../utils/format.js'\nimport type { FeedConfig } from './Feed.js'\n\nconst MAX_IMPRESSIONS = 3\n\n/**\n * Whether to show the overage credit upsell on any surface.\n *\n * Eligibility comes entirely from the backend GET /overage_credit_grant\n * response — the CLI doesn't replicate tier/threshold/role checks. The\n * backend returns available: false for Team members who aren't admins,\n * so they don't see an upsell they can't act on.\n *\n * isEligibleForOverageCreditGrant — just the backend eligibility. Use for\n *   persistent reference surfaces (/usage) where the info should show\n *   whenever eligible, no impression cap.\n * shouldShowOverageCreditUpsell — adds the 3-impression cap and\n *   hasVisitedExtraUsage dismiss. Use for promotional surfaces\n *   (welcome feed, tips).\n */\nexport function isEligibleForOverageCreditGrant(): boolean {\n  const info = getCachedOverageCreditGrant()\n  if (!info || !info.available || info.granted) return false\n  return formatGrantAmount(info) !== null\n}\n\nexport function shouldShowOverageCreditUpsell(): boolean {\n  if (!isEligibleForOverageCreditGrant()) return false\n\n  const config = getGlobalConfig()\n  if (config.hasVisitedExtraUsage) return false\n  if ((config.overageCreditUpsellSeenCount ?? 0) >= MAX_IMPRESSIONS)\n    return false\n\n  return true\n}\n\n/**\n * Kick off a background fetch if the cache is empty. Safe to call\n * unconditionally on mount — it no-ops if cache is fresh.\n */\nexport function maybeRefreshOverageCreditCache(): void {\n  if (getCachedOverageCreditGrant() !== null) return\n  void refreshOverageCreditGrantCache()\n}\n\nexport function useShowOverageCreditUpsell(): boolean {\n  const [show] = useState(() => {\n    maybeRefreshOverageCreditCache()\n    return shouldShowOverageCreditUpsell()\n  })\n  return show\n}\n\nexport function incrementOverageCreditUpsellSeenCount(): void {\n  let newCount = 0\n  saveGlobalConfig(prev => {\n    newCount = (prev.overageCreditUpsellSeenCount ?? 0) + 1\n    return {\n      ...prev,\n      overageCreditUpsellSeenCount: newCount,\n    }\n  })\n  logEvent('tengu_overage_credit_upsell_shown', { seen_count: newCount })\n}\n\n// Copy from \"OC & Bulk Overages copy\" doc (#6 — CLI /usage)\nfunction getUsageText(amount: string): string {\n  return `${amount} in extra usage for third-party apps · /extra-usage`\n}\n\n// Copy from \"OC & Bulk Overages copy\" doc (#4 — CLI Welcome screen).\n// Char budgets: title ≤19, subtitle ≤48.\nconst FEED_SUBTITLE = 'On us. Works on third-party apps · /extra-usage'\n\nfunction getFeedTitle(amount: string): string {\n  return `${amount} in extra usage`\n}\n\ntype Props = { maxWidth?: number; twoLine?: boolean }\n\nexport function OverageCreditUpsell({\n  maxWidth,\n  twoLine,\n}: Props): React.ReactNode {\n  const info = getCachedOverageCreditGrant()\n  if (!info) return null\n  const amount = formatGrantAmount(info)\n  if (!amount) return null\n\n  if (twoLine) {\n    const title = getFeedTitle(amount)\n    return (\n      <>\n        <Text color=\"claude\">\n          {maxWidth ? truncate(title, maxWidth) : title}\n        </Text>\n        <Text dimColor>\n          {maxWidth ? truncate(FEED_SUBTITLE, maxWidth) : FEED_SUBTITLE}\n        </Text>\n      </>\n    )\n  }\n\n  const text = getUsageText(amount)\n  const display = maxWidth ? truncate(text, maxWidth) : text\n  const highlightLen = Math.min(getFeedTitle(amount).length, display.length)\n\n  return (\n    <Text dimColor>\n      <Text color=\"claude\">{display.slice(0, highlightLen)}</Text>\n      {display.slice(highlightLen)}\n    </Text>\n  )\n}\n\n/**\n * Feed config for the homescreen rotating feed. Mirrors\n * createGuestPassesFeed in feedConfigs.tsx.\n *\n * Copy from \"OC & Bulk Overages copy\" doc (#4 — CLI Welcome screen).\n * Char budgets: title ≤19, subtitle ≤48.\n */\nexport function createOverageCreditFeed(): FeedConfig {\n  const info = getCachedOverageCreditGrant()\n  const amount = info ? formatGrantAmount(info) : null\n  const title = amount ? getFeedTitle(amount) : 'extra usage credit'\n  return {\n    title,\n    lines: [],\n    customContent: {\n      content: <Text dimColor>{FEED_SUBTITLE}</Text>,\n      width: Math.max(title.length, FEED_SUBTITLE.length),\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/components/LogoV2/VoiceModeNotice.tsx

@@ -0,0 +1,68 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { Box, Text } from '../../ink.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { getInitialSettings } from '../../utils/settings/settings.js';
+import { isVoiceModeEnabled } from '../../voice/voiceModeEnabled.js';
+import { AnimatedAsterisk } from './AnimatedAsterisk.js';
+import { shouldShowOpus1mMergeNotice } from './Opus1mMergeNotice.js';
+const MAX_SHOW_COUNT = 3;
+export function VoiceModeNotice() {
+  const $ = _c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = feature("VOICE_MODE") ? <VoiceModeNoticeInner /> : null;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+function VoiceModeNoticeInner() {
+  const $ = _c(4);
+  const [show] = useState(_temp);
+  let t0;
+  let t1;
+  if ($[0] !== show) {
+    t0 = () => {
+      if (!show) {
+        return;
+      }
+      const newCount = (getGlobalConfig().voiceNoticeSeenCount ?? 0) + 1;
+      saveGlobalConfig(prev => {
+        if ((prev.voiceNoticeSeenCount ?? 0) >= newCount) {
+          return prev;
+        }
+        return {
+          ...prev,
+          voiceNoticeSeenCount: newCount
+        };
+      });
+    };
+    t1 = [show];
+    $[0] = show;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  if (!show) {
+    return null;
+  }
+  let t2;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box paddingLeft={2}><AnimatedAsterisk /><Text dimColor={true}> Voice mode is now available · /voice to enable</Text></Box>;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
+}
+function _temp() {
+  return isVoiceModeEnabled() && getInitialSettings().voiceEnabled !== true && (getGlobalConfig().voiceNoticeSeenCount ?? 0) < MAX_SHOW_COUNT && !shouldShowOpus1mMergeNotice();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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