claude-code-best 1.0.3

package/dist/chunk-5r3ak65p.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  EXIT_PLAN_MODE_V2_TOOL_NAME,
+  createAssistantMessage,
+  getPlan,
+  init_constants2 as init_constants,
+  init_messages1 as init_messages,
+  init_plans
+} from "./chunk-g9q2cznf.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-x14dq3v1.js";
+import {
+  LOCAL_COMMAND_STDERR_TAG,
+  LOCAL_COMMAND_STDOUT_TAG,
+  init_xml
+} from "./chunk-p7g7pf3f.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/messages/mappers.ts
+import { randomUUID } from "crypto";
+function toInternalMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: message.message,
+            uuid: message.uuid,
+            requestId: undefined,
+            timestamp: new Date().toISOString()
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            uuid: message.uuid ?? randomUUID(),
+            timestamp: message.timestamp ?? new Date().toISOString(),
+            isMeta: message.isSynthetic
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary") {
+          const compactMsg = message;
+          return [
+            {
+              type: "system",
+              content: "Conversation compacted",
+              level: "info",
+              subtype: "compact_boundary",
+              compactMetadata: fromSDKCompactMetadata(compactMsg.compact_metadata),
+              uuid: message.uuid,
+              timestamp: new Date().toISOString()
+            }
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function toSDKCompactMetadata(meta) {
+  const seg = meta.preservedSegment;
+  return {
+    trigger: meta.trigger,
+    pre_tokens: meta.preTokens,
+    ...seg && {
+      preserved_segment: {
+        head_uuid: seg.headUuid,
+        anchor_uuid: seg.anchorUuid,
+        tail_uuid: seg.tailUuid
+      }
+    }
+  };
+}
+function fromSDKCompactMetadata(meta) {
+  const m = meta;
+  const seg = m.preserved_segment;
+  return {
+    trigger: m.trigger,
+    preTokens: m.pre_tokens,
+    ...seg && {
+      preservedSegment: {
+        headUuid: seg.head_uuid,
+        anchorUuid: seg.anchor_uuid,
+        tailUuid: seg.tail_uuid
+      }
+    }
+  };
+}
+function toSDKMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: normalizeAssistantMessageForSDK(message),
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            error: message.error
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            timestamp: message.timestamp,
+            isSynthetic: message.isMeta || message.isVisibleInTranscriptOnly,
+            ...message.toolUseResult !== undefined ? { tool_use_result: message.toolUseResult } : {}
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary" && message.compactMetadata) {
+          return [
+            {
+              type: "system",
+              subtype: "compact_boundary",
+              session_id: getSessionId(),
+              uuid: message.uuid,
+              compact_metadata: toSDKCompactMetadata(message.compactMetadata)
+            }
+          ];
+        }
+        if (message.subtype === "local_command" && (message.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`) || message.content.includes(`<${LOCAL_COMMAND_STDERR_TAG}>`))) {
+          return [
+            localCommandOutputToSDKAssistantMessage(message.content, message.uuid)
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function localCommandOutputToSDKAssistantMessage(rawContent, uuid) {
+  const cleanContent = stripAnsi(rawContent).replace(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/, "$1").replace(/<local-command-stderr>([\s\S]*?)<\/local-command-stderr>/, "$1").trim();
+  const synthetic = createAssistantMessage({ content: cleanContent });
+  return {
+    type: "assistant",
+    content: synthetic.message?.content,
+    message: synthetic.message,
+    parent_tool_use_id: null,
+    session_id: getSessionId(),
+    uuid
+  };
+}
+function toSDKRateLimitInfo(limits) {
+  if (!limits) {
+    return;
+  }
+  return {
+    type: "rate_limit",
+    status: limits.status,
+    ...limits.resetsAt !== undefined && { resetsAt: limits.resetsAt },
+    ...limits.rateLimitType !== undefined && {
+      rateLimitType: limits.rateLimitType
+    },
+    ...limits.utilization !== undefined && {
+      utilization: limits.utilization
+    },
+    ...limits.overageStatus !== undefined && {
+      overageStatus: limits.overageStatus
+    },
+    ...limits.overageResetsAt !== undefined && {
+      overageResetsAt: limits.overageResetsAt
+    },
+    ...limits.overageDisabledReason !== undefined && {
+      overageDisabledReason: limits.overageDisabledReason
+    },
+    ...limits.isUsingOverage !== undefined && {
+      isUsingOverage: limits.isUsingOverage
+    },
+    ...limits.surpassedThreshold !== undefined && {
+      surpassedThreshold: limits.surpassedThreshold
+    }
+  };
+}
+function normalizeAssistantMessageForSDK(message) {
+  const content = message.message.content;
+  if (!Array.isArray(content)) {
+    return message.message;
+  }
+  const normalizedContent = content.map((block) => {
+    if (block.type !== "tool_use") {
+      return block;
+    }
+    if (block.name === EXIT_PLAN_MODE_V2_TOOL_NAME) {
+      const plan = getPlan();
+      if (plan) {
+        return {
+          ...block,
+          input: { ...block.input, plan }
+        };
+      }
+    }
+    return block;
+  });
+  return {
+    ...message.message,
+    content: normalizedContent
+  };
+}
+var init_mappers = __esm(() => {
+  init_state();
+  init_xml();
+  init_constants();
+  init_strip_ansi();
+  init_messages();
+  init_plans();
+});
+
+export { toInternalMessages, toSDKCompactMetadata, fromSDKCompactMetadata, toSDKMessages, localCommandOutputToSDKAssistantMessage, toSDKRateLimitInfo, init_mappers };

package/dist/chunk-5t59fqg3.js

@@ -0,0 +1,127 @@
+// @bun
+import {
+  Ansi,
+  Box_default,
+  Button_default,
+  ClickEvent,
+  Event,
+  EventEmitter,
+  FocusManager,
+  InputEvent,
+  Link,
+  Newline,
+  NoSelect,
+  RawAnsi,
+  Spacer,
+  TerminalFocusEvent,
+  Text,
+  ThemeProvider,
+  ThemedBox_default,
+  ThemedText,
+  color,
+  createRoot,
+  init_ink,
+  measure_element_default,
+  render,
+  supportsTabStatus,
+  useAnimationFrame,
+  useAnimationTimer,
+  useInterval1 as useInterval,
+  usePreviewTheme,
+  useSelection,
+  useTabStatus,
+  useTerminalFocus,
+  useTerminalTitle,
+  useTerminalViewport,
+  useTheme,
+  useThemeSetting,
+  use_app_default,
+  use_input_default,
+  use_stdin_default,
+  wrapText
+} from "./chunk-8d5eyjse.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-7wm1rjfm.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-5hva0tsg.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_ink();
+
+export {
+  wrapText,
+  useThemeSetting,
+  useTheme,
+  useTerminalViewport,
+  useTerminalTitle,
+  useTerminalFocus,
+  useTabStatus,
+  use_stdin_default as useStdin,
+  useSelection,
+  usePreviewTheme,
+  useInterval,
+  use_input_default as useInput,
+  use_app_default as useApp,
+  useAnimationTimer,
+  useAnimationFrame,
+  supportsTabStatus,
+  render,
+  measure_element_default as measureElement,
+  createRoot,
+  color,
+  ThemeProvider,
+  ThemedText as Text,
+  TerminalFocusEvent,
+  Spacer,
+  RawAnsi,
+  NoSelect,
+  Newline,
+  Link,
+  InputEvent,
+  FocusManager,
+  EventEmitter,
+  Event,
+  ClickEvent,
+  Button_default as Button,
+  ThemedBox_default as Box,
+  Text as BaseText,
+  Box_default as BaseBox,
+  Ansi
+};

package/dist/chunk-5wnn3t3a.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  Login,
+  init_login
+} from "./chunk-2tkt52mz.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-m06q12hg.js";
+import {
+  getClaudeAIOAuthTokens,
+  getOauthProfileFromOauthToken,
+  init_auth,
+  init_getOauthProfile,
+  isClaudeAISubscriber
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/upgrade/upgrade.tsx
+async function call(onDone, context) {
+  try {
+    if (isClaudeAISubscriber()) {
+      const tokens = getClaudeAIOAuthTokens();
+      let isMax20x = false;
+      if (tokens?.subscriptionType && tokens?.rateLimitTier) {
+        isMax20x = tokens.subscriptionType === "max" && tokens.rateLimitTier === "default_claude_max_20x";
+      } else if (tokens?.accessToken) {
+        const profile = await getOauthProfileFromOauthToken(tokens.accessToken);
+        isMax20x = profile?.organization?.organization_type === "claude_max" && profile?.organization?.rate_limit_tier === "default_claude_max_20x";
+      }
+      if (isMax20x) {
+        setTimeout(onDone, 0, "You are already on the highest Max subscription plan. For additional usage, run /login to switch to an API usage-billed account.");
+        return null;
+      }
+    }
+    const url = "https://claude.ai/upgrade/max";
+    await openBrowser(url);
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Login, {
+      startingMessage: "Starting new login following /upgrade. Exit with Ctrl-C to use existing account.",
+      onDone: (success) => {
+        context.onChangeAPIKey();
+        onDone(success ? "Login successful" : "Login interrupted");
+      }
+    }, undefined, false, undefined, this);
+  } catch (error) {
+    logError(error);
+    setTimeout(onDone, 0, "Failed to open browser. Please visit https://claude.ai/upgrade/max to upgrade.");
+  }
+  return null;
+}
+var jsx_dev_runtime;
+var init_upgrade = __esm(() => {
+  init_getOauthProfile();
+  init_auth();
+  init_browser();
+  init_log();
+  init_login();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { call, init_upgrade };

package/dist/chunk-5wxspfct.js

@@ -0,0 +1,40 @@
+// @bun
+import {
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  init_auth,
+  init_growthbook
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_envUtils
+} from "./chunk-3r24h7t6.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/bridge/bridgeEnabled.ts
+function isBridgeEnabled() {
+  return false;
+}
+async function isBridgeEnabledBlocking() {
+  return false;
+}
+function isEnvLessBridgeEnabled() {
+  return false;
+}
+function isCseShimEnabled() {
+  return true;
+}
+function checkBridgeMinVersion() {
+  if (false) {}
+  return null;
+}
+var init_bridgeEnabled = __esm(() => {
+  init_growthbook();
+  init_auth();
+  init_envUtils();
+  init_semver();
+});
+
+export { isBridgeEnabled, isBridgeEnabledBlocking, isEnvLessBridgeEnabled, isCseShimEnabled, checkBridgeMinVersion, init_bridgeEnabled };