claude-code-best 1.0.3

package/dist/chunk-ts2p6bv1.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  Anthropic,
+  AnthropicError,
+  BaseAnthropic,
+  Beta,
+  Messages,
+  init_client,
+  init_error,
+  init_resources
+} from "./chunk-7739pg2c.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/core/error.mjs
+var init_error2 = __esm(() => {
+  init_error();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/values.mjs
+var isArray = (val) => (isArray = Array.isArray, isArray(val)), isReadonlyArray;
+var init_values = __esm(() => {
+  init_error2();
+  isReadonlyArray = isArray;
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/headers.mjs
+function* iterateHeaders(headers) {
+  if (!headers)
+    return;
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+  let shouldClear = false;
+  let iter;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isReadonlyArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    if (typeof name !== "string")
+      throw new TypeError("expected header name to be a string");
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined)
+        continue;
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+var brand_privateNullableHeaders, buildHeaders = (newHeaders) => {
+  const targetHeaders = new Headers;
+  const nullHeaders = new Set;
+  for (const headers of newHeaders) {
+    const seenHeaders = new Set;
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+var init_headers = __esm(() => {
+  init_values();
+  brand_privateNullableHeaders = Symbol.for("brand.privateNullableHeaders");
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/bytes.mjs
+var init_bytes = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/base64.mjs
+var init_base64 = __esm(() => {
+  init_error2();
+  init_bytes();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/env.mjs
+var readEnv = (env) => {
+  if (typeof globalThis.process !== "undefined") {
+    return globalThis.process.env?.[env]?.trim() ?? undefined;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    return globalThis.Deno.env?.get?.(env)?.trim();
+  }
+  return;
+};
+var init_env = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/log.mjs
+var init_log = __esm(() => {
+  init_values();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/uuid.mjs
+var init_uuid = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/sleep.mjs
+var init_sleep = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils.mjs
+var init_utils = __esm(() => {
+  init_values();
+  init_base64();
+  init_env();
+  init_log();
+  init_uuid();
+  init_sleep();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/client.mjs
+function makeMessagesResource(client) {
+  const resource = new Messages(client);
+  delete resource.batches;
+  return resource;
+}
+function makeBetaResource(client) {
+  const resource = new Beta(client);
+  delete resource.messages.batches;
+  return resource;
+}
+var AnthropicFoundry;
+var init_client2 = __esm(() => {
+  init_headers();
+  init_error2();
+  init_utils();
+  init_client();
+  init_client();
+  init_resources();
+  AnthropicFoundry = class AnthropicFoundry extends Anthropic {
+    constructor({ baseURL = readEnv("ANTHROPIC_FOUNDRY_BASE_URL"), apiKey = readEnv("ANTHROPIC_FOUNDRY_API_KEY"), resource = readEnv("ANTHROPIC_FOUNDRY_RESOURCE"), azureADTokenProvider, dangerouslyAllowBrowser, ...opts } = {}) {
+      if (typeof azureADTokenProvider === "function") {
+        dangerouslyAllowBrowser = true;
+      }
+      if (!azureADTokenProvider && !apiKey) {
+        throw new AnthropicError("Missing credentials. Please pass one of `apiKey` and `azureTokenProvider`, or set the `ANTHROPIC_FOUNDRY_API_KEY` environment variable.");
+      }
+      if (azureADTokenProvider && apiKey) {
+        throw new AnthropicError("The `apiKey` and `azureADTokenProvider` arguments are mutually exclusive; only one can be passed at a time.");
+      }
+      if (!baseURL) {
+        if (!resource) {
+          throw new AnthropicError("Must provide one of the `baseURL` or `resource` arguments, or the `ANTHROPIC_FOUNDRY_RESOURCE` environment variable");
+        }
+        baseURL = `https://${resource}.services.ai.azure.com/anthropic/`;
+      } else {
+        if (resource) {
+          throw new AnthropicError("baseURL and resource are mutually exclusive");
+        }
+      }
+      super({
+        apiKey: azureADTokenProvider ?? apiKey,
+        baseURL,
+        ...opts,
+        ...dangerouslyAllowBrowser !== undefined ? { dangerouslyAllowBrowser } : {}
+      });
+      this.resource = null;
+      this.messages = makeMessagesResource(this);
+      this.beta = makeBetaResource(this);
+      this.models = undefined;
+    }
+    async authHeaders() {
+      if (typeof this._options.apiKey === "function") {
+        let token;
+        try {
+          token = await this._options.apiKey();
+        } catch (err) {
+          if (err instanceof AnthropicError)
+            throw err;
+          throw new AnthropicError(`Failed to get token from azureADTokenProvider: ${err.message}`, { cause: err });
+        }
+        if (typeof token !== "string" || !token) {
+          throw new AnthropicError(`Expected azureADTokenProvider function argument to return a string but it returned ${token}`);
+        }
+        return buildHeaders([{ Authorization: `Bearer ${token}` }]);
+      }
+      if (typeof this._options.apiKey === "string") {
+        return buildHeaders([{ "x-api-key": this.apiKey }]);
+      }
+      return;
+    }
+    validateHeaders() {
+      return;
+    }
+  };
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/index.mjs
+var init_foundry_sdk = __esm(() => {
+  init_client2();
+  init_client2();
+});
+init_foundry_sdk();
+
+export {
+  AnthropicFoundry as default,
+  BaseAnthropic,
+  AnthropicFoundry
+};

package/dist/chunk-tse7q7k1.js

@@ -0,0 +1,255 @@
+// @bun
+import {
+  init_registry,
+  registerITermBackend
+} from "./chunk-g9q2cznf.js";
+import"./chunk-q1e6pzwh.js";
+import"./chunk-201dvaa3.js";
+import"./chunk-248szg6m.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-def1dc97.js";
+import"./chunk-9egdc8n4.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-b0105v1f.js";
+import"./chunk-hgtf13es.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-rcdpvnxh.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-madfgr3n.js";
+import"./chunk-pmzbyaat.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-ha0xq3e9.js";
+import"./chunk-hfzj1m07.js";
+import"./chunk-pvvew193.js";
+import"./chunk-8d5eyjse.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-2v1br2x0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-zkmxtgc3.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-grdvmq7q.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 {
+  IT2_COMMAND,
+  init_detection,
+  isInITerm2,
+  isIt2CliAvailable
+} from "./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-cvge4pvp.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.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-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./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 {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/swarm/backends/ITermBackend.ts
+function acquirePaneCreationLock() {
+  let release;
+  const newLock = new Promise((resolve) => {
+    release = resolve;
+  });
+  const previousLock = paneCreationLock;
+  paneCreationLock = newLock;
+  return previousLock.then(() => release);
+}
+function runIt2(args) {
+  return execFileNoThrow(IT2_COMMAND, args);
+}
+function parseSplitOutput(output) {
+  const match = output.match(/Created new pane:\s*(.+)/);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return "";
+}
+function getLeaderSessionId() {
+  const itermSessionId = process.env.ITERM_SESSION_ID;
+  if (!itermSessionId) {
+    return null;
+  }
+  const colonIndex = itermSessionId.indexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return itermSessionId.slice(colonIndex + 1);
+}
+
+class ITermBackend {
+  type = "iterm2";
+  displayName = "iTerm2";
+  supportsHideShow = false;
+  async isAvailable() {
+    const inITerm2 = isInITerm2();
+    logForDebugging(`[ITermBackend] isAvailable check: inITerm2=${inITerm2}`);
+    if (!inITerm2) {
+      logForDebugging("[ITermBackend] isAvailable: false (not in iTerm2)");
+      return false;
+    }
+    const it2Available = await isIt2CliAvailable();
+    logForDebugging(`[ITermBackend] isAvailable: ${it2Available} (it2 CLI ${it2Available ? "found" : "not found"})`);
+    return it2Available;
+  }
+  async isRunningInside() {
+    const result = isInITerm2();
+    logForDebugging(`[ITermBackend] isRunningInside: ${result}`);
+    return result;
+  }
+  async createTeammatePaneInSwarmView(name, color) {
+    logForDebugging(`[ITermBackend] createTeammatePaneInSwarmView called for ${name} with color ${color}`);
+    const releaseLock = await acquirePaneCreationLock();
+    try {
+      while (true) {
+        const isFirstTeammate = !firstPaneUsed;
+        logForDebugging(`[ITermBackend] Creating pane: isFirstTeammate=${isFirstTeammate}, existingPanes=${teammateSessionIds.length}`);
+        let splitArgs;
+        let targetedTeammateId;
+        if (isFirstTeammate) {
+          const leaderSessionId = getLeaderSessionId();
+          if (leaderSessionId) {
+            splitArgs = ["session", "split", "-v", "-s", leaderSessionId];
+            logForDebugging(`[ITermBackend] First split from leader session: ${leaderSessionId}`);
+          } else {
+            splitArgs = ["session", "split", "-v"];
+            logForDebugging("[ITermBackend] First split from active session (no leader ID)");
+          }
+        } else {
+          targetedTeammateId = teammateSessionIds[teammateSessionIds.length - 1];
+          if (targetedTeammateId) {
+            splitArgs = ["session", "split", "-s", targetedTeammateId];
+            logForDebugging(`[ITermBackend] Subsequent split from teammate session: ${targetedTeammateId}`);
+          } else {
+            splitArgs = ["session", "split"];
+            logForDebugging("[ITermBackend] Subsequent split from active session (no teammate ID)");
+          }
+        }
+        const splitResult = await runIt2(splitArgs);
+        if (splitResult.code !== 0) {
+          if (targetedTeammateId) {
+            const listResult = await runIt2(["session", "list"]);
+            if (listResult.code === 0 && !listResult.stdout.includes(targetedTeammateId)) {
+              logForDebugging(`[ITermBackend] Split failed targeting dead session ${targetedTeammateId}, pruning and retrying: ${splitResult.stderr}`);
+              const idx = teammateSessionIds.indexOf(targetedTeammateId);
+              if (idx !== -1) {
+                teammateSessionIds.splice(idx, 1);
+              }
+              if (teammateSessionIds.length === 0) {
+                firstPaneUsed = false;
+              }
+              continue;
+            }
+          }
+          throw new Error(`Failed to create iTerm2 split pane: ${splitResult.stderr}`);
+        }
+        if (isFirstTeammate) {
+          firstPaneUsed = true;
+        }
+        const paneId = parseSplitOutput(splitResult.stdout);
+        if (!paneId) {
+          throw new Error(`Failed to parse session ID from split output: ${splitResult.stdout}`);
+        }
+        logForDebugging(`[ITermBackend] Created teammate pane for ${name}: ${paneId}`);
+        teammateSessionIds.push(paneId);
+        return { paneId, isFirstTeammate };
+      }
+    } finally {
+      releaseLock();
+    }
+  }
+  async sendCommandToPane(paneId, command, _useExternalSession) {
+    const args = paneId ? ["session", "run", "-s", paneId, command] : ["session", "run", command];
+    const result = await runIt2(args);
+    if (result.code !== 0) {
+      throw new Error(`Failed to send command to iTerm2 pane ${paneId}: ${result.stderr}`);
+    }
+  }
+  async setPaneBorderColor(_paneId, _color, _useExternalSession) {}
+  async setPaneTitle(_paneId, _name, _color, _useExternalSession) {}
+  async enablePaneBorderStatus(_windowTarget, _useExternalSession) {}
+  async rebalancePanes(_windowTarget, _hasLeader) {
+    logForDebugging("[ITermBackend] Pane rebalancing not implemented for iTerm2");
+  }
+  async killPane(paneId, _useExternalSession) {
+    const result = await runIt2(["session", "close", "-f", "-s", paneId]);
+    const idx = teammateSessionIds.indexOf(paneId);
+    if (idx !== -1) {
+      teammateSessionIds.splice(idx, 1);
+    }
+    if (teammateSessionIds.length === 0) {
+      firstPaneUsed = false;
+    }
+    return result.code === 0;
+  }
+  async hidePane(_paneId, _useExternalSession) {
+    logForDebugging("[ITermBackend] hidePane not supported in iTerm2");
+    return false;
+  }
+  async showPane(_paneId, _targetWindowOrPane, _useExternalSession) {
+    logForDebugging("[ITermBackend] showPane not supported in iTerm2");
+    return false;
+  }
+}
+var teammateSessionIds, firstPaneUsed = false, paneCreationLock;
+var init_ITermBackend = __esm(() => {
+  init_debug();
+  init_execFileNoThrow();
+  init_detection();
+  init_registry();
+  teammateSessionIds = [];
+  paneCreationLock = Promise.resolve();
+  registerITermBackend(ITermBackend);
+});
+init_ITermBackend();
+
+export {
+  ITermBackend
+};

package/dist/chunk-ttk5dzz8.js

@@ -0,0 +1,25 @@
+// @bun
+import {
+  ENV_ACCOUNT_ID,
+  ENV_CREDENTIAL_SCOPE,
+  ENV_EXPIRATION,
+  ENV_KEY,
+  ENV_SECRET,
+  ENV_SESSION,
+  fromEnv,
+  init_dist_es
+} from "./chunk-3h8a89gy.js";
+import"./chunk-b4wg70y1.js";
+import"./chunk-hk9xz7gk.js";
+import"./chunk-qp2qdcda.js";
+init_dist_es();
+
+export {
+  fromEnv,
+  ENV_SESSION,
+  ENV_SECRET,
+  ENV_KEY,
+  ENV_EXPIRATION,
+  ENV_CREDENTIAL_SCOPE,
+  ENV_ACCOUNT_ID
+};