@jdi-code/claude-code 1.0.3

package/dist/chunk-tjaqa99q.js

@@ -0,0 +1,125 @@
+// @bun
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/platform.ts
+import { readdir, readFile } from "fs/promises";
+import { release as osRelease } from "os";
+async function detectVcs(dir) {
+  const detected = new Set;
+  if (process.env.P4PORT) {
+    detected.add("perforce");
+  }
+  try {
+    const targetDir = dir ?? getFsImplementation().cwd();
+    const entries = new Set(await readdir(targetDir));
+    for (const [marker, vcs] of VCS_MARKERS) {
+      if (entries.has(marker)) {
+        detected.add(vcs);
+      }
+    }
+  } catch {}
+  return [...detected];
+}
+var SUPPORTED_PLATFORMS, getPlatform, getWslVersion, getLinuxDistroInfo, VCS_MARKERS;
+var init_platform = __esm(() => {
+  init_memoize();
+  init_fsOperations();
+  init_log();
+  SUPPORTED_PLATFORMS = ["macos", "wsl"];
+  getPlatform = memoize_default(() => {
+    try {
+      if (process.platform === "darwin") {
+        return "macos";
+      }
+      if (process.platform === "win32") {
+        return "windows";
+      }
+      if (process.platform === "linux") {
+        try {
+          const procVersion = getFsImplementation().readFileSync("/proc/version", { encoding: "utf8" });
+          if (procVersion.toLowerCase().includes("microsoft") || procVersion.toLowerCase().includes("wsl")) {
+            return "wsl";
+          }
+        } catch (error) {
+          logError(error);
+        }
+        return "linux";
+      }
+      return "unknown";
+    } catch (error) {
+      logError(error);
+      return "unknown";
+    }
+  });
+  getWslVersion = memoize_default(() => {
+    if (process.platform !== "linux") {
+      return;
+    }
+    try {
+      const procVersion = getFsImplementation().readFileSync("/proc/version", {
+        encoding: "utf8"
+      });
+      const wslVersionMatch = procVersion.match(/WSL(\d+)/i);
+      if (wslVersionMatch && wslVersionMatch[1]) {
+        return wslVersionMatch[1];
+      }
+      if (procVersion.toLowerCase().includes("microsoft")) {
+        return "1";
+      }
+      return;
+    } catch (error) {
+      logError(error);
+      return;
+    }
+  });
+  getLinuxDistroInfo = memoize_default(async () => {
+    if (process.platform !== "linux") {
+      return;
+    }
+    const result = {
+      linuxKernel: osRelease()
+    };
+    try {
+      const content = await readFile("/etc/os-release", "utf8");
+      for (const line of content.split(`
+`)) {
+        const match = line.match(/^(ID|VERSION_ID)=(.*)$/);
+        if (match && match[1] && match[2]) {
+          const value = match[2].replace(/^"|"$/g, "");
+          if (match[1] === "ID") {
+            result.linuxDistroId = value;
+          } else {
+            result.linuxDistroVersion = value;
+          }
+        }
+      }
+    } catch {}
+    return result;
+  });
+  VCS_MARKERS = [
+    [".git", "git"],
+    [".hg", "mercurial"],
+    [".svn", "svn"],
+    [".p4config", "perforce"],
+    ["$tf", "tfs"],
+    [".tfvc", "tfs"],
+    [".jj", "jujutsu"],
+    [".sl", "sapling"]
+  ];
+});
+
+export { SUPPORTED_PLATFORMS, getPlatform, getWslVersion, getLinuxDistroInfo, detectVcs, init_platform };

package/dist/chunk-tmcxeatp.js

@@ -0,0 +1,116 @@
+// @bun
+import {
+  Settings,
+  init_Settings
+} from "./chunk-1n1xqxv5.js";
+import"./chunk-fdy0651p.js";
+import"./chunk-74v9z7z4.js";
+import"./chunk-et4jnyb5.js";
+import"./chunk-q0yg73za.js";
+import"./chunk-v496te8v.js";
+import"./chunk-f1rrxxcf.js";
+import"./chunk-yp5kc8hq.js";
+import"./chunk-b0eez8w0.js";
+import"./chunk-x5j50p5x.js";
+import"./chunk-src9fqj8.js";
+import"./chunk-5frcqxsv.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-gb2q3nvc.js";
+import"./chunk-neh2frnn.js";
+import"./chunk-q6b51yc5.js";
+import"./chunk-gfkppe34.js";
+import"./chunk-kqd0e3xj.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-xe6z85xc.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-pxrffn0w.js";
+import"./chunk-0nt9md2b.js";
+import"./chunk-rn4kqfvd.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-n8sjmqba.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-g653q217.js";
+import"./chunk-z72st5c8.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-35x3tjnr.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-40b8p5em.js";
+import"./chunk-s0xfxkys.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.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-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.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"./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 {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/usage/usage.tsx
+var jsx_dev_runtime, call = async (onDone, context) => {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Settings, {
+    onClose: onDone,
+    context,
+    defaultTab: "Usage"
+  }, undefined, false, undefined, this);
+};
+var init_usage = __esm(() => {
+  init_Settings();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_usage();
+
+export {
+  call
+};

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-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
+};

package/dist/chunk-twsxz9ph.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  CONFIG_WRITE_DISPLAY_THRESHOLD,
+  DEFAULT_GLOBAL_CONFIG,
+  EDITOR_MODES,
+  GLOBAL_CONFIG_KEYS,
+  NOTIFICATION_CHANNELS,
+  PROJECT_CONFIG_KEYS,
+  _getConfigForTesting,
+  _setGlobalConfigCacheForTesting,
+  _wouldLoseAuthStateForTesting,
+  checkHasTrustDialogAccepted,
+  enableConfigs,
+  formatAutoUpdaterDisabledReason,
+  getAutoUpdaterDisabledReason,
+  getCurrentProjectConfig,
+  getCustomApiKeyStatus,
+  getGlobalConfig,
+  getGlobalConfigWriteCount,
+  getManagedClaudeRulesDir,
+  getMemoryPath,
+  getOrCreateUserID,
+  getProjectPathForConfig,
+  getRemoteControlAtStartup,
+  getUserClaudeRulesDir,
+  init_config1 as init_config,
+  isAutoUpdaterDisabled,
+  isGlobalConfigKey,
+  isPathTrusted,
+  isProjectConfigKey,
+  recordFirstStartTime,
+  resetTrustDialogAcceptedCacheForTesting,
+  saveCurrentProjectConfig,
+  saveGlobalConfig,
+  shouldSkipPluginAutoupdate
+} from "./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.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-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.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_config();
+
+export {
+  shouldSkipPluginAutoupdate,
+  saveGlobalConfig,
+  saveCurrentProjectConfig,
+  resetTrustDialogAcceptedCacheForTesting,
+  recordFirstStartTime,
+  isProjectConfigKey,
+  isPathTrusted,
+  isGlobalConfigKey,
+  isAutoUpdaterDisabled,
+  getUserClaudeRulesDir,
+  getRemoteControlAtStartup,
+  getProjectPathForConfig,
+  getOrCreateUserID,
+  getMemoryPath,
+  getManagedClaudeRulesDir,
+  getGlobalConfigWriteCount,
+  getGlobalConfig,
+  getCustomApiKeyStatus,
+  getCurrentProjectConfig,
+  getAutoUpdaterDisabledReason,
+  formatAutoUpdaterDisabledReason,
+  enableConfigs,
+  checkHasTrustDialogAccepted,
+  _wouldLoseAuthStateForTesting,
+  _setGlobalConfigCacheForTesting,
+  _getConfigForTesting,
+  PROJECT_CONFIG_KEYS,
+  NOTIFICATION_CHANNELS,
+  GLOBAL_CONFIG_KEYS,
+  EDITOR_MODES,
+  DEFAULT_GLOBAL_CONFIG,
+  CONFIG_WRITE_DISPLAY_THRESHOLD
+};