claude-code-best 1.0.3

package/dist/chunk-3gqdqmzb.js

@@ -0,0 +1,75 @@
+// @bun
+import {
+  dirIsInGitRepo,
+  findCanonicalGitRoot,
+  findGitRoot,
+  findRemoteBase,
+  getBranch,
+  getChangedFiles,
+  getDefaultBranch,
+  getFileStatus,
+  getGitDir,
+  getGitState,
+  getGithubRepo,
+  getHead,
+  getIsClean,
+  getIsGit,
+  getIsHeadOnRemote,
+  getRemoteUrl,
+  getRepoRemoteHash,
+  getWorktreeCount,
+  gitExe,
+  hasUnpushedCommits,
+  init_git,
+  isAtGitRoot,
+  isCurrentDirectoryBareGitRepo,
+  normalizeGitRemoteUrl,
+  preserveGitStateForIssue,
+  stashToCleanState
+} from "./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-qp2qdcda.js";
+init_git();
+
+export {
+  stashToCleanState,
+  preserveGitStateForIssue,
+  normalizeGitRemoteUrl,
+  isCurrentDirectoryBareGitRepo,
+  isAtGitRoot,
+  hasUnpushedCommits,
+  gitExe,
+  getWorktreeCount,
+  getRepoRemoteHash,
+  getRemoteUrl,
+  getIsHeadOnRemote,
+  getIsGit,
+  getIsClean,
+  getHead,
+  getGithubRepo,
+  getGitState,
+  getGitDir,
+  getFileStatus,
+  getDefaultBranch,
+  getChangedFiles,
+  getBranch,
+  findRemoteBase,
+  findGitRoot,
+  findCanonicalGitRoot,
+  dirIsInGitRepo
+};

package/dist/chunk-3h8a89gy.js

@@ -0,0 +1,46 @@
+// @bun
+import {
+  require_client
+} from "./chunk-b4wg70y1.js";
+import {
+  require_dist_cjs
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+credential-provider-env@3.972.24/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
+var import_client, import_property_provider, ENV_KEY = "AWS_ACCESS_KEY_ID", ENV_SECRET = "AWS_SECRET_ACCESS_KEY", ENV_SESSION = "AWS_SESSION_TOKEN", ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION", ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE", ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID", fromEnv = (init) => async () => {
+  init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
+  const accessKeyId = process.env[ENV_KEY];
+  const secretAccessKey = process.env[ENV_SECRET];
+  const sessionToken = process.env[ENV_SESSION];
+  const expiry = process.env[ENV_EXPIRATION];
+  const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
+  const accountId = process.env[ENV_ACCOUNT_ID];
+  if (accessKeyId && secretAccessKey) {
+    const credentials = {
+      accessKeyId,
+      secretAccessKey,
+      ...sessionToken && { sessionToken },
+      ...expiry && { expiration: new Date(expiry) },
+      ...credentialScope && { credentialScope },
+      ...accountId && { accountId }
+    };
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
+    return credentials;
+  }
+  throw new import_property_provider.CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
+};
+var init_fromEnv = __esm(() => {
+  import_client = __toESM(require_client(), 1);
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-env@3.972.24/node_modules/@aws-sdk/credential-provider-env/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_fromEnv();
+});
+
+export { ENV_KEY, ENV_SECRET, ENV_SESSION, ENV_EXPIRATION, ENV_CREDENTIAL_SCOPE, ENV_ACCOUNT_ID, fromEnv, init_dist_es };

package/dist/chunk-3nk79af8.js

@@ -0,0 +1,8 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/utils/sdkHeapDumpMonitor.ts
+var startSdkMemoryMonitor = () => {};
+export {
+  startSdkMemoryMonitor
+};

package/dist/chunk-3psth3ez.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  expandPastedTextRefs,
+  formatPastedTextRef,
+  generateTempFilePath,
+  getPastedTextRefNumLines,
+  init_history,
+  init_ide,
+  init_tempfile,
+  toIDEDisplayName
+} from "./chunk-g9q2cznf.js";
+import {
+  init_instances,
+  instances_default
+} from "./chunk-8d5eyjse.js";
+import {
+  init_which,
+  whichSync
+} from "./chunk-hjhc4cpt.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-vyc0rjyx.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  logForDebugging,
+  writeFileSync_DEPRECATED
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/editor.ts
+import {
+  spawn,
+  spawnSync
+} from "child_process";
+import { basename } from "path";
+function isCommandAvailable(command) {
+  return !!whichSync(command);
+}
+function classifyGuiEditor(editor) {
+  const base = basename(editor.split(" ")[0] ?? "");
+  return GUI_EDITORS.find((g) => base.includes(g));
+}
+function guiGotoArgv(guiFamily, filePath, line) {
+  if (!line)
+    return [filePath];
+  if (VSCODE_FAMILY.has(guiFamily))
+    return ["-g", `${filePath}:${line}`];
+  if (guiFamily === "subl")
+    return [`${filePath}:${line}`];
+  return [filePath];
+}
+function openFileInExternalEditor(filePath, line) {
+  const editor = getExternalEditor();
+  if (!editor)
+    return false;
+  const parts = editor.split(" ");
+  const base = parts[0] ?? editor;
+  const editorArgs = parts.slice(1);
+  const guiFamily = classifyGuiEditor(editor);
+  if (guiFamily) {
+    const gotoArgv = guiGotoArgv(guiFamily, filePath, line);
+    const detachedOpts = { detached: true, stdio: "ignore" };
+    let child;
+    if (process.platform === "win32") {
+      const gotoStr = gotoArgv.map((a) => `"${a}"`).join(" ");
+      child = spawn(`${editor} ${gotoStr}`, { ...detachedOpts, shell: true });
+    } else {
+      child = spawn(base, [...editorArgs, ...gotoArgv], detachedOpts);
+    }
+    child.on("error", (e) => logForDebugging(`editor spawn failed: ${e}`, { level: "error" }));
+    child.unref();
+    return true;
+  }
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance)
+    return false;
+  const useGotoLine = line && PLUS_N_EDITORS.test(basename(base));
+  inkInstance.enterAlternateScreen();
+  try {
+    const syncOpts = { stdio: "inherit" };
+    let result;
+    if (process.platform === "win32") {
+      const lineArg = useGotoLine ? `+${line} ` : "";
+      result = spawnSync(`${editor} ${lineArg}"${filePath}"`, {
+        ...syncOpts,
+        shell: true
+      });
+    } else {
+      const args = [
+        ...editorArgs,
+        ...useGotoLine ? [`+${line}`, filePath] : [filePath]
+      ];
+      result = spawnSync(base, args, syncOpts);
+    }
+    if (result.error) {
+      logForDebugging(`editor spawn failed: ${result.error}`, {
+        level: "error"
+      });
+      return false;
+    }
+    return true;
+  } finally {
+    inkInstance.exitAlternateScreen();
+  }
+}
+var GUI_EDITORS, PLUS_N_EDITORS, VSCODE_FAMILY, getExternalEditor;
+var init_editor = __esm(() => {
+  init_memoize();
+  init_instances();
+  init_debug();
+  init_which();
+  GUI_EDITORS = [
+    "code",
+    "cursor",
+    "windsurf",
+    "codium",
+    "subl",
+    "atom",
+    "gedit",
+    "notepad++",
+    "notepad"
+  ];
+  PLUS_N_EDITORS = /\b(vi|vim|nvim|nano|emacs|pico|micro|helix|hx)\b/;
+  VSCODE_FAMILY = new Set(["code", "cursor", "windsurf", "codium"]);
+  getExternalEditor = memoize_default(() => {
+    if (process.env.VISUAL?.trim()) {
+      return process.env.VISUAL.trim();
+    }
+    if (process.env.EDITOR?.trim()) {
+      return process.env.EDITOR.trim();
+    }
+    if (process.platform === "win32") {
+      return "start /wait notepad";
+    }
+    const editors = ["code", "vi", "nano"];
+    return editors.find((command) => isCommandAvailable(command));
+  });
+});
+
+// src/utils/promptEditor.ts
+function isGuiEditor(editor) {
+  return classifyGuiEditor(editor) !== undefined;
+}
+function editFileInEditor(filePath) {
+  const fs = getFsImplementation();
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance) {
+    throw new Error("Ink instance not found - cannot pause rendering");
+  }
+  const editor = getExternalEditor();
+  if (!editor) {
+    return { content: null };
+  }
+  try {
+    fs.statSync(filePath);
+  } catch {
+    return { content: null };
+  }
+  const useAlternateScreen = !isGuiEditor(editor);
+  if (useAlternateScreen) {
+    inkInstance.enterAlternateScreen();
+  } else {
+    inkInstance.pause();
+    inkInstance.suspendStdin();
+  }
+  try {
+    const editorCommand = EDITOR_OVERRIDES[editor] ?? editor;
+    execSync_DEPRECATED(`${editorCommand} "${filePath}"`, {
+      stdio: "inherit"
+    });
+    const editedContent = fs.readFileSync(filePath, { encoding: "utf-8" });
+    return { content: editedContent };
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "status" in err && typeof err.status === "number") {
+      const status = err.status;
+      if (status !== 0) {
+        const editorName = toIDEDisplayName(editor);
+        return {
+          content: null,
+          error: `${editorName} exited with code ${status}`
+        };
+      }
+    }
+    return { content: null };
+  } finally {
+    if (useAlternateScreen) {
+      inkInstance.exitAlternateScreen();
+    } else {
+      inkInstance.resumeStdin();
+      inkInstance.resume();
+    }
+  }
+}
+function recollapsePastedContent(editedPrompt, originalPrompt, pastedContents) {
+  let collapsed = editedPrompt;
+  for (const [id, content] of Object.entries(pastedContents)) {
+    if (content.type === "text") {
+      const pasteId = parseInt(id);
+      const contentStr = content.content;
+      const contentIndex = collapsed.indexOf(contentStr);
+      if (contentIndex !== -1) {
+        const numLines = getPastedTextRefNumLines(contentStr);
+        const ref = formatPastedTextRef(pasteId, numLines);
+        collapsed = collapsed.slice(0, contentIndex) + ref + collapsed.slice(contentIndex + contentStr.length);
+      }
+    }
+  }
+  return collapsed;
+}
+function editPromptInEditor(currentPrompt, pastedContents) {
+  const fs = getFsImplementation();
+  const tempFile = generateTempFilePath();
+  try {
+    const expandedPrompt = pastedContents ? expandPastedTextRefs(currentPrompt, pastedContents) : currentPrompt;
+    writeFileSync_DEPRECATED(tempFile, expandedPrompt, {
+      encoding: "utf-8",
+      flush: true
+    });
+    const result = editFileInEditor(tempFile);
+    if (result.content === null) {
+      return result;
+    }
+    let finalContent = result.content;
+    if (finalContent.endsWith(`
+`) && !finalContent.endsWith(`
+
+`)) {
+      finalContent = finalContent.slice(0, -1);
+    }
+    if (pastedContents) {
+      finalContent = recollapsePastedContent(finalContent, currentPrompt, pastedContents);
+    }
+    return { content: finalContent };
+  } finally {
+    try {
+      fs.unlinkSync(tempFile);
+    } catch {}
+  }
+}
+var EDITOR_OVERRIDES;
+var init_promptEditor = __esm(() => {
+  init_history();
+  init_instances();
+  init_editor();
+  init_execSyncWrapper();
+  init_fsOperations();
+  init_ide();
+  init_slowOperations();
+  init_tempfile();
+  EDITOR_OVERRIDES = {
+    code: "code -w",
+    subl: "subl --wait"
+  };
+});
+
+export { openFileInExternalEditor, getExternalEditor, init_editor, editFileInEditor, editPromptInEditor, init_promptEditor };

package/dist/chunk-3r24h7t6.js

@@ -0,0 +1,113 @@
+// @bun
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/protectedNamespace.ts
+var exports_protectedNamespace = {};
+__export(exports_protectedNamespace, {
+  checkProtectedNamespace: () => checkProtectedNamespace
+});
+var checkProtectedNamespace = () => false;
+var init_protectedNamespace = () => {};
+
+// src/utils/envUtils.ts
+import { homedir } from "os";
+import { join } from "path";
+function getTeamsDir() {
+  return join(getClaudeConfigHomeDir(), "teams");
+}
+function hasNodeOption(flag) {
+  const nodeOptions = process.env.NODE_OPTIONS;
+  if (!nodeOptions) {
+    return false;
+  }
+  return nodeOptions.split(/\s+/).includes(flag);
+}
+function isEnvTruthy(envVar) {
+  if (!envVar)
+    return false;
+  if (typeof envVar === "boolean")
+    return envVar;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
+function isEnvDefinedFalsy(envVar) {
+  if (envVar === undefined)
+    return false;
+  if (typeof envVar === "boolean")
+    return !envVar;
+  if (!envVar)
+    return false;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["0", "false", "no", "off"].includes(normalizedValue);
+}
+function isBareMode() {
+  return isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) || process.argv.includes("--bare");
+}
+function parseEnvVars(rawEnvArgs) {
+  const parsedEnv = {};
+  if (rawEnvArgs) {
+    for (const envStr of rawEnvArgs) {
+      const [key, ...valueParts] = envStr.split("=");
+      if (!key || valueParts.length === 0) {
+        throw new Error(`Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`);
+      }
+      parsedEnv[key] = valueParts.join("=");
+    }
+  }
+  return parsedEnv;
+}
+function getAWSRegion() {
+  return process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+}
+function getDefaultVertexRegion() {
+  return process.env.CLOUD_ML_REGION || "us-east5";
+}
+function shouldMaintainProjectWorkingDir() {
+  return isEnvTruthy(process.env.CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR);
+}
+function isRunningOnHomespace() {
+  return process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.COO_RUNNING_ON_HOMESPACE);
+}
+function isInProtectedNamespace() {
+  if (process.env.USER_TYPE === "ant") {
+    return (init_protectedNamespace(), __toCommonJS(exports_protectedNamespace)).checkProtectedNamespace();
+  }
+  return false;
+}
+function getVertexRegionForModel(model) {
+  if (model) {
+    const match = VERTEX_REGION_OVERRIDES.find(([prefix]) => model.startsWith(prefix));
+    if (match) {
+      return process.env[match[1]] || getDefaultVertexRegion();
+    }
+  }
+  return getDefaultVertexRegion();
+}
+var getClaudeConfigHomeDir, VERTEX_REGION_OVERRIDES;
+var init_envUtils = __esm(() => {
+  init_memoize();
+  getClaudeConfigHomeDir = memoize_default(() => {
+    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC");
+  }, () => process.env.CLAUDE_CONFIG_DIR);
+  VERTEX_REGION_OVERRIDES = [
+    ["claude-haiku-4-5", "VERTEX_REGION_CLAUDE_HAIKU_4_5"],
+    ["claude-3-5-haiku", "VERTEX_REGION_CLAUDE_3_5_HAIKU"],
+    ["claude-3-5-sonnet", "VERTEX_REGION_CLAUDE_3_5_SONNET"],
+    ["claude-3-7-sonnet", "VERTEX_REGION_CLAUDE_3_7_SONNET"],
+    ["claude-opus-4-1", "VERTEX_REGION_CLAUDE_4_1_OPUS"],
+    ["claude-opus-4", "VERTEX_REGION_CLAUDE_4_0_OPUS"],
+    ["claude-sonnet-4-6", "VERTEX_REGION_CLAUDE_4_6_SONNET"],
+    ["claude-sonnet-4-5", "VERTEX_REGION_CLAUDE_4_5_SONNET"],
+    ["claude-sonnet-4", "VERTEX_REGION_CLAUDE_4_0_SONNET"]
+  ];
+});
+
+export { getClaudeConfigHomeDir, getTeamsDir, hasNodeOption, isEnvTruthy, isEnvDefinedFalsy, isBareMode, parseEnvVars, getAWSRegion, getDefaultVertexRegion, shouldMaintainProjectWorkingDir, isRunningOnHomespace, isInProtectedNamespace, getVertexRegionForModel, init_envUtils };