@jdi-code/claude-code 1.0.3

package/dist/chunk-7va8tw32.js

@@ -0,0 +1,128 @@
+// @bun
+import {
+  clearFileSuggestionCaches,
+  init_fileSuggestions
+} from "./chunk-b6av9ny9.js";
+import {
+  clearTrackedMagicDocs,
+  init_magicDocs
+} from "./chunk-9xmsmn93.js";
+import {
+  clearAllDumpState,
+  clearAllPendingCallbacks,
+  clearAllSessions,
+  clearCommandPrefixCaches,
+  clearCommandsCache,
+  clearDynamicSkills,
+  clearSessionEnvVars,
+  clearStoredImagePaths,
+  getGitStatus,
+  getSessionStartDate,
+  getSystemContext,
+  getUserContext,
+  init_LSPDiagnosticRegistry,
+  init_attachments,
+  init_claudemd,
+  init_commands,
+  init_commands1 as init_commands2,
+  init_common,
+  init_context,
+  init_dumpPrompts,
+  init_imageStore,
+  init_loadSkillsDir,
+  init_postCompactCleanup,
+  init_promptCacheBreakDetection,
+  init_sessionEnvVars,
+  init_sessionIngress,
+  init_useSwarmPermissionPoller,
+  resetAllLSPDiagnosticState,
+  resetGetMemoryFilesCache,
+  resetPromptCacheBreakDetection,
+  resetSentSkillNames,
+  runPostCompactCleanup,
+  setSystemPromptInjection
+} from "./chunk-5frcqxsv.js";
+import {
+  clearRepositoryCaches,
+  init_detectRepository
+} from "./chunk-7z8j9qfn.js";
+import {
+  clearResolveGitDirCache,
+  init_gitFilesystem
+} from "./chunk-hrzerbfw.js";
+import {
+  clearInvokedSkills,
+  init_state,
+  setLastEmittedDate
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/clear/caches.ts
+function clearSessionCaches(preservedAgentIds = new Set) {
+  const hasPreserved = preservedAgentIds.size > 0;
+  getUserContext.cache.clear?.();
+  getSystemContext.cache.clear?.();
+  getGitStatus.cache.clear?.();
+  getSessionStartDate.cache.clear?.();
+  clearFileSuggestionCaches();
+  clearCommandsCache();
+  if (!hasPreserved)
+    resetPromptCacheBreakDetection();
+  setSystemPromptInjection(null);
+  setLastEmittedDate(null);
+  runPostCompactCleanup();
+  resetSentSkillNames();
+  resetGetMemoryFilesCache("session_start");
+  clearStoredImagePaths();
+  clearAllSessions();
+  if (!hasPreserved)
+    clearAllPendingCallbacks();
+  if (process.env.USER_TYPE === "ant") {
+    import("./chunk-jx817w05.js").then(({ clearSessionsWithTungstenUsage, resetInitializationState }) => {
+      clearSessionsWithTungstenUsage();
+      resetInitializationState();
+    });
+  }
+  if (false) {}
+  clearRepositoryCaches();
+  clearCommandPrefixCaches();
+  if (!hasPreserved)
+    clearAllDumpState();
+  clearInvokedSkills(preservedAgentIds);
+  clearResolveGitDirCache();
+  clearDynamicSkills();
+  resetAllLSPDiagnosticState();
+  clearTrackedMagicDocs();
+  clearSessionEnvVars();
+  import("./chunk-2y659zbj.js").then(({ clearWebFetchCache }) => clearWebFetchCache());
+  import("./chunk-dqqde43e.js").then(({ clearToolSearchDescriptionCache }) => clearToolSearchDescriptionCache());
+  import("./chunk-4br37gsw.js").then(({ clearAgentDefinitionsCache }) => clearAgentDefinitionsCache());
+  import("./chunk-8fg1egbv.js").then(({ clearPromptCache }) => clearPromptCache());
+}
+var init_caches = __esm(() => {
+  init_state();
+  init_commands2();
+  init_common();
+  init_context();
+  init_fileSuggestions();
+  init_useSwarmPermissionPoller();
+  init_dumpPrompts();
+  init_promptCacheBreakDetection();
+  init_sessionIngress();
+  init_postCompactCleanup();
+  init_LSPDiagnosticRegistry();
+  init_magicDocs();
+  init_loadSkillsDir();
+  init_attachments();
+  init_commands();
+  init_claudemd();
+  init_detectRepository();
+  init_gitFilesystem();
+  init_imageStore();
+  init_sessionEnvVars();
+});
+
+export { clearSessionCaches, init_caches };

package/dist/chunk-7wm5s02e.js

@@ -0,0 +1,216 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm(() => {
+  signals = [];
+  signals.push("SIGHUP", "SIGINT", "SIGTERM");
+  if (process.platform !== "win32") {
+    signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+  }
+});
+
+// node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function", kExitEmitter, global, ObjectDefineProperty, signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+}, SignalExitFallback, SignalExit, process2, onExit, load, unload;
+var init_mjs = __esm(() => {
+  init_signals();
+  kExitEmitter = Symbol.for("signal-exit emitter");
+  global = globalThis;
+  ObjectDefineProperty = Object.defineProperty.bind(Object);
+  SignalExitFallback = class SignalExitFallback extends SignalExitBase {
+    onExit() {
+      return () => {};
+    }
+    load() {}
+    unload() {}
+  };
+  SignalExit = class SignalExit extends SignalExitBase {
+    #hupSig = process2.platform === "win32" ? "SIGINT" : "SIGHUP";
+    #emitter = new Emitter;
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process2) {
+      super();
+      this.#process = process2;
+      this.#sigListeners = {};
+      for (const sig of signals) {
+        this.#sigListeners[sig] = () => {
+          const listeners = this.#process.listeners(sig);
+          let { count } = this.#emitter;
+          const p = process2;
+          if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+            count += p.__signal_exit_emitter__.count;
+          }
+          if (listeners.length === count) {
+            this.unload();
+            const ret = this.#emitter.emit("exit", null, sig);
+            const s = sig === "SIGHUP" ? this.#hupSig : sig;
+            if (!ret)
+              process2.kill(process2.pid, s);
+          }
+        };
+      }
+      this.#originalProcessReallyExit = process2.reallyExit;
+      this.#originalProcessEmit = process2.emit;
+    }
+    onExit(cb, opts) {
+      if (!processOk(this.#process)) {
+        return () => {};
+      }
+      if (this.#loaded === false) {
+        this.load();
+      }
+      const ev = opts?.alwaysLast ? "afterExit" : "exit";
+      this.#emitter.on(ev, cb);
+      return () => {
+        this.#emitter.removeListener(ev, cb);
+        if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+          this.unload();
+        }
+      };
+    }
+    load() {
+      if (this.#loaded) {
+        return;
+      }
+      this.#loaded = true;
+      this.#emitter.count += 1;
+      for (const sig of signals) {
+        try {
+          const fn = this.#sigListeners[sig];
+          if (fn)
+            this.#process.on(sig, fn);
+        } catch (_) {}
+      }
+      this.#process.emit = (ev, ...a) => {
+        return this.#processEmit(ev, ...a);
+      };
+      this.#process.reallyExit = (code) => {
+        return this.#processReallyExit(code);
+      };
+    }
+    unload() {
+      if (!this.#loaded) {
+        return;
+      }
+      this.#loaded = false;
+      signals.forEach((sig) => {
+        const listener = this.#sigListeners[sig];
+        if (!listener) {
+          throw new Error("Listener not defined for signal: " + sig);
+        }
+        try {
+          this.#process.removeListener(sig, listener);
+        } catch (_) {}
+      });
+      this.#process.emit = this.#originalProcessEmit;
+      this.#process.reallyExit = this.#originalProcessReallyExit;
+      this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+      if (!processOk(this.#process)) {
+        return 0;
+      }
+      this.#process.exitCode = code || 0;
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+      const og = this.#originalProcessEmit;
+      if (ev === "exit" && processOk(this.#process)) {
+        if (typeof args[0] === "number") {
+          this.#process.exitCode = args[0];
+        }
+        const ret = og.call(this.#process, ev, ...args);
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return ret;
+      } else {
+        return og.call(this.#process, ev, ...args);
+      }
+    }
+  };
+  process2 = globalThis.process;
+  ({
+    onExit,
+    load,
+    unload
+  } = signalExitWrap(processOk(process2) ? new SignalExit(process2) : new SignalExitFallback));
+});
+
+export { onExit, init_mjs };

package/dist/chunk-7ymfj7m3.js

@@ -0,0 +1,151 @@
+// @bun
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/constants/oauth.ts
+function getOauthConfigType() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.USE_LOCAL_OAUTH)) {
+      return "local";
+    }
+    if (isEnvTruthy(process.env.USE_STAGING_OAUTH)) {
+      return "staging";
+    }
+  }
+  return "prod";
+}
+function fileSuffixForOauthConfig() {
+  if (process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL) {
+    return "-custom-oauth";
+  }
+  switch (getOauthConfigType()) {
+    case "local":
+      return "-local-oauth";
+    case "staging":
+      return "-staging-oauth";
+    case "prod":
+      return "";
+  }
+}
+function getLocalOauthConfig() {
+  const api = process.env.CLAUDE_LOCAL_OAUTH_API_BASE?.replace(/\/$/, "") ?? "http://localhost:8000";
+  const apps = process.env.CLAUDE_LOCAL_OAUTH_APPS_BASE?.replace(/\/$/, "") ?? "http://localhost:4000";
+  const consoleBase = process.env.CLAUDE_LOCAL_OAUTH_CONSOLE_BASE?.replace(/\/$/, "") ?? "http://localhost:3000";
+  return {
+    BASE_API_URL: api,
+    CONSOLE_AUTHORIZE_URL: `${consoleBase}/oauth/authorize`,
+    CLAUDE_AI_AUTHORIZE_URL: `${apps}/oauth/authorize`,
+    CLAUDE_AI_ORIGIN: apps,
+    TOKEN_URL: `${api}/v1/oauth/token`,
+    API_KEY_URL: `${api}/api/oauth/claude_cli/create_api_key`,
+    ROLES_URL: `${api}/api/oauth/claude_cli/roles`,
+    CONSOLE_SUCCESS_URL: `${consoleBase}/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code`,
+    CLAUDEAI_SUCCESS_URL: `${consoleBase}/oauth/code/success?app=claude-code`,
+    MANUAL_REDIRECT_URL: `${consoleBase}/oauth/code/callback`,
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-local-oauth",
+    MCP_PROXY_URL: "http://localhost:8205",
+    MCP_PROXY_PATH: "/v1/toolbox/shttp/mcp/{server_id}"
+  };
+}
+function getOauthConfig() {
+  let config = (() => {
+    switch (getOauthConfigType()) {
+      case "local":
+        return getLocalOauthConfig();
+      case "staging":
+        return STAGING_OAUTH_CONFIG ?? PROD_OAUTH_CONFIG;
+      case "prod":
+        return PROD_OAUTH_CONFIG;
+    }
+  })();
+  const oauthBaseUrl = process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL;
+  if (oauthBaseUrl) {
+    const base = oauthBaseUrl.replace(/\/$/, "");
+    if (!ALLOWED_OAUTH_BASE_URLS.includes(base)) {
+      throw new Error("CLAUDE_CODE_CUSTOM_OAUTH_URL is not an approved endpoint.");
+    }
+    config = {
+      ...config,
+      BASE_API_URL: base,
+      CONSOLE_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_ORIGIN: base,
+      TOKEN_URL: `${base}/v1/oauth/token`,
+      API_KEY_URL: `${base}/api/oauth/claude_cli/create_api_key`,
+      ROLES_URL: `${base}/api/oauth/claude_cli/roles`,
+      CONSOLE_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      CLAUDEAI_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      MANUAL_REDIRECT_URL: `${base}/oauth/code/callback`,
+      OAUTH_FILE_SUFFIX: "-custom-oauth"
+    };
+  }
+  const clientIdOverride = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID;
+  if (clientIdOverride) {
+    config = {
+      ...config,
+      CLIENT_ID: clientIdOverride
+    };
+  }
+  return config;
+}
+var CLAUDE_AI_INFERENCE_SCOPE = "user:inference", CLAUDE_AI_PROFILE_SCOPE = "user:profile", CONSOLE_SCOPE = "org:create_api_key", OAUTH_BETA_HEADER = "oauth-2025-04-20", CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, PROD_OAUTH_CONFIG, MCP_CLIENT_METADATA_URL = "https://claude.ai/oauth/claude-code-client-metadata", STAGING_OAUTH_CONFIG, ALLOWED_OAUTH_BASE_URLS;
+var init_oauth = __esm(() => {
+  init_envUtils();
+  CONSOLE_OAUTH_SCOPES = [
+    CONSOLE_SCOPE,
+    CLAUDE_AI_PROFILE_SCOPE
+  ];
+  CLAUDE_AI_OAUTH_SCOPES = [
+    CLAUDE_AI_PROFILE_SCOPE,
+    CLAUDE_AI_INFERENCE_SCOPE,
+    "user:sessions:claude_code",
+    "user:mcp_servers",
+    "user:file_upload"
+  ];
+  ALL_OAUTH_SCOPES = Array.from(new Set([...CONSOLE_OAUTH_SCOPES, ...CLAUDE_AI_OAUTH_SCOPES]));
+  PROD_OAUTH_CONFIG = {
+    BASE_API_URL: "https://api.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.claude.com/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude.com/cai/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude.ai",
+    TOKEN_URL: "https://platform.claude.com/v1/oauth/token",
+    API_KEY_URL: "https://api.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.claude.com/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.claude.com/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.claude.com/oauth/code/callback",
+    CLIENT_ID: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+    OAUTH_FILE_SUFFIX: "",
+    MCP_PROXY_URL: "https://mcp-proxy.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  };
+  STAGING_OAUTH_CONFIG = process.env.USER_TYPE === "ant" ? {
+    BASE_API_URL: "https://api-staging.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude-ai.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude-ai.staging.ant.dev",
+    TOKEN_URL: "https://platform.staging.ant.dev/v1/oauth/token",
+    API_KEY_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.staging.ant.dev/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.staging.ant.dev/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.staging.ant.dev/oauth/code/callback",
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-staging-oauth",
+    MCP_PROXY_URL: "https://mcp-proxy-staging.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  } : undefined;
+  ALLOWED_OAUTH_BASE_URLS = [
+    "https://beacon.claude-ai.staging.ant.dev",
+    "https://claude.fedstart.com",
+    "https://claude-staging.fedstart.com"
+  ];
+});
+
+export { fileSuffixForOauthConfig, CLAUDE_AI_INFERENCE_SCOPE, CLAUDE_AI_PROFILE_SCOPE, OAUTH_BETA_HEADER, CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, MCP_CLIENT_METADATA_URL, getOauthConfig, init_oauth };

package/dist/chunk-7z3tkgec.js

@@ -0,0 +1,66 @@
+// @bun
+import {
+  checkBridgeMinVersion,
+  getBridgeDisabledReason,
+  getCcrAutoConnectDefault,
+  init_bridgeEnabled,
+  isBridgeEnabled,
+  isBridgeEnabledBlocking,
+  isCcrMirrorEnabled,
+  isCseShimEnabled,
+  isEnvLessBridgeEnabled
+} from "./chunk-74v9z7z4.js";
+import"./chunk-ps49ymvj.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-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_bridgeEnabled();
+
+export {
+  isEnvLessBridgeEnabled,
+  isCseShimEnabled,
+  isCcrMirrorEnabled,
+  isBridgeEnabledBlocking,
+  isBridgeEnabled,
+  getCcrAutoConnectDefault,
+  getBridgeDisabledReason,
+  checkBridgeMinVersion
+};

package/dist/chunk-7z8j9qfn.js

@@ -0,0 +1,121 @@
+// @bun
+import {
+  getRemoteUrl,
+  init_git
+} from "./chunk-hrzerbfw.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/detectRepository.ts
+function clearRepositoryCaches() {
+  repositoryWithHostCache.clear();
+}
+async function detectCurrentRepository() {
+  const result = await detectCurrentRepositoryWithHost();
+  if (!result)
+    return null;
+  if (result.host !== "github.com")
+    return null;
+  return `${result.owner}/${result.name}`;
+}
+async function detectCurrentRepositoryWithHost() {
+  const cwd = getCwd();
+  if (repositoryWithHostCache.has(cwd)) {
+    return repositoryWithHostCache.get(cwd) ?? null;
+  }
+  try {
+    const remoteUrl = await getRemoteUrl();
+    logForDebugging(`Git remote URL: ${remoteUrl}`);
+    if (!remoteUrl) {
+      logForDebugging("No git remote URL found");
+      repositoryWithHostCache.set(cwd, null);
+      return null;
+    }
+    const parsed = parseGitRemote(remoteUrl);
+    logForDebugging(`Parsed repository: ${parsed ? `${parsed.host}/${parsed.owner}/${parsed.name}` : null} from URL: ${remoteUrl}`);
+    repositoryWithHostCache.set(cwd, parsed);
+    return parsed;
+  } catch (error) {
+    logForDebugging(`Error detecting repository: ${error}`);
+    repositoryWithHostCache.set(cwd, null);
+    return null;
+  }
+}
+function getCachedRepository() {
+  const parsed = repositoryWithHostCache.get(getCwd());
+  if (!parsed || parsed.host !== "github.com")
+    return null;
+  return `${parsed.owner}/${parsed.name}`;
+}
+function parseGitRemote(input) {
+  const trimmed = input.trim();
+  const sshMatch = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch?.[1] && sshMatch[2] && sshMatch[3]) {
+    if (!looksLikeRealHostname(sshMatch[1]))
+      return null;
+    return {
+      host: sshMatch[1],
+      owner: sshMatch[2],
+      name: sshMatch[3]
+    };
+  }
+  const urlMatch = trimmed.match(/^(https?|ssh|git):\/\/(?:[^@]+@)?([^/:]+(?::\d+)?)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (urlMatch?.[1] && urlMatch[2] && urlMatch[3] && urlMatch[4]) {
+    const protocol = urlMatch[1];
+    const hostWithPort = urlMatch[2];
+    const hostWithoutPort = hostWithPort.split(":")[0] ?? "";
+    if (!looksLikeRealHostname(hostWithoutPort))
+      return null;
+    const host = protocol === "https" || protocol === "http" ? hostWithPort : hostWithoutPort;
+    return {
+      host,
+      owner: urlMatch[3],
+      name: urlMatch[4]
+    };
+  }
+  return null;
+}
+function parseGitHubRepository(input) {
+  const trimmed = input.trim();
+  const parsed = parseGitRemote(trimmed);
+  if (parsed) {
+    if (parsed.host !== "github.com")
+      return null;
+    return `${parsed.owner}/${parsed.name}`;
+  }
+  if (!trimmed.includes("://") && !trimmed.includes("@") && trimmed.includes("/")) {
+    const parts = trimmed.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const repo = parts[1].replace(/\.git$/, "");
+      return `${parts[0]}/${repo}`;
+    }
+  }
+  logForDebugging(`Could not parse repository from: ${trimmed}`);
+  return null;
+}
+function looksLikeRealHostname(host) {
+  if (!host.includes("."))
+    return false;
+  const lastSegment = host.split(".").pop();
+  if (!lastSegment)
+    return false;
+  return /^[a-zA-Z]+$/.test(lastSegment);
+}
+var repositoryWithHostCache;
+var init_detectRepository = __esm(() => {
+  init_cwd();
+  init_debug();
+  init_git();
+  repositoryWithHostCache = new Map;
+});
+
+export { clearRepositoryCaches, detectCurrentRepository, detectCurrentRepositoryWithHost, getCachedRepository, parseGitRemote, parseGitHubRepository, init_detectRepository };

package/dist/chunk-83hfzbx3.js

@@ -0,0 +1,10 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/components/agents/SnapshotUpdateDialog.ts
+var SnapshotUpdateDialog = () => null;
+var buildMergePrompt = () => "";
+export {
+  buildMergePrompt,
+  SnapshotUpdateDialog
+};