gong-code 0.1.0

package/dist/chunk-vxgdzx6p.js

@@ -0,0 +1,338 @@
+// @bun
+import {
+  init_which,
+  which,
+  whichSync
+} from "./chunk-w1jew5sn.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-rex82hys.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-4s93jyky.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-318g78ty.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-eta5aekm.js";
+import {
+  __INVALID__REF__
+} from "./chunk-ccyg9ap9.js";
+import {
+  fileSuffixForOauthConfig,
+  init_oauth
+} from "./chunk-rx6z23h0.js";
+
+// src/utils/bundledMode.ts
+function isRunningWithBun() {
+  return process.versions.bun !== undefined;
+}
+function isInBundledMode() {
+  return typeof Bun !== "undefined" && Array.isArray(Bun.embeddedFiles) && Bun.embeddedFiles.length > 0;
+}
+
+// src/utils/findExecutable.ts
+function findExecutable(exe, args) {
+  const resolved = whichSync(exe);
+  return { cmd: resolved ?? exe, args };
+}
+var init_findExecutable = __esm(() => {
+  init_which();
+});
+
+// src/utils/env.ts
+import { homedir } from "os";
+import { join } from "path";
+async function isCommandAvailable(command) {
+  try {
+    return !!await which(command);
+  } catch {
+    return false;
+  }
+}
+function isConductor() {
+  return process.env.__CFBundleIdentifier === "com.conductor.app";
+}
+function detectTerminal() {
+  if (process.env.CURSOR_TRACE_ID)
+    return "cursor";
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("cursor")) {
+    return "cursor";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("windsurf")) {
+    return "windsurf";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("antigravity")) {
+    return "antigravity";
+  }
+  const bundleId = process.env.__CFBundleIdentifier?.toLowerCase();
+  if (bundleId?.includes("vscodium"))
+    return "codium";
+  if (bundleId?.includes("windsurf"))
+    return "windsurf";
+  if (bundleId?.includes("com.google.android.studio"))
+    return "androidstudio";
+  if (bundleId) {
+    for (const ide of JETBRAINS_IDES) {
+      if (bundleId.includes(ide))
+        return ide;
+    }
+  }
+  if (process.env.VisualStudioVersion) {
+    return "visualstudio";
+  }
+  if (process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm") {
+    if (process.platform === "darwin")
+      return "pycharm";
+    return "pycharm";
+  }
+  if (process.env.TERM === "xterm-ghostty") {
+    return "ghostty";
+  }
+  if (process.env.TERM?.includes("kitty")) {
+    return "kitty";
+  }
+  if (process.env.TERM_PROGRAM) {
+    return process.env.TERM_PROGRAM;
+  }
+  if (process.env.TMUX)
+    return "tmux";
+  if (process.env.STY)
+    return "screen";
+  if (process.env.KONSOLE_VERSION)
+    return "konsole";
+  if (process.env.GNOME_TERMINAL_SERVICE)
+    return "gnome-terminal";
+  if (process.env.XTERM_VERSION)
+    return "xterm";
+  if (process.env.VTE_VERSION)
+    return "vte-based";
+  if (process.env.TERMINATOR_UUID)
+    return "terminator";
+  if (process.env.KITTY_WINDOW_ID) {
+    return "kitty";
+  }
+  if (process.env.ALACRITTY_LOG)
+    return "alacritty";
+  if (process.env.TILIX_ID)
+    return "tilix";
+  if (process.env.WT_SESSION)
+    return "windows-terminal";
+  if (process.env.SESSIONNAME && process.env.TERM === "cygwin")
+    return "cygwin";
+  if (process.env.MSYSTEM)
+    return process.env.MSYSTEM.toLowerCase();
+  if (process.env.ConEmuANSI || process.env.ConEmuPID || process.env.ConEmuTask) {
+    return "conemu";
+  }
+  if (process.env.WSL_DISTRO_NAME)
+    return `wsl-${process.env.WSL_DISTRO_NAME}`;
+  if (isSSHSession()) {
+    return "ssh-session";
+  }
+  if (process.env.TERM) {
+    const term = process.env.TERM;
+    if (term.includes("alacritty"))
+      return "alacritty";
+    if (term.includes("rxvt"))
+      return "rxvt";
+    if (term.includes("termite"))
+      return "termite";
+    return process.env.TERM;
+  }
+  if (!process.stdout.isTTY)
+    return "non-interactive";
+  return null;
+}
+function isSSHSession() {
+  return !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY);
+}
+function getHostPlatformForAnalytics() {
+  const override = process.env.CLAUDE_CODE_HOST_PLATFORM;
+  if (override === "win32" || override === "darwin" || override === "linux") {
+    return override;
+  }
+  return env.platform;
+}
+var getGlobalClaudeFile, hasInternetAccess, detectPackageManagers, detectRuntimes, isWslEnvironment, isNpmFromWindowsPath, JETBRAINS_IDES, detectDeploymentEnvironment, env;
+var init_env = __esm(() => {
+  init_memoize();
+  init_oauth();
+  init_envUtils();
+  init_findExecutable();
+  init_fsOperations();
+  init_which();
+  getGlobalClaudeFile = memoize_default(() => {
+    if (getFsImplementation().existsSync(join(getClaudeConfigHomeDir(), ".config.json"))) {
+      return join(getClaudeConfigHomeDir(), ".config.json");
+    }
+    const filename = `.claude${fileSuffixForOauthConfig()}.json`;
+    return join(process.env.CLAUDE_CONFIG_DIR || homedir(), filename);
+  });
+  hasInternetAccess = memoize_default(async () => {
+    try {
+      const { default: axiosClient } = await import("./chunk-q5b0kpr3.js");
+      await axiosClient.head("http://1.1.1.1", {
+        signal: AbortSignal.timeout(1000)
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  detectPackageManagers = memoize_default(async () => {
+    const packageManagers = [];
+    if (await isCommandAvailable("npm"))
+      packageManagers.push("npm");
+    if (await isCommandAvailable("yarn"))
+      packageManagers.push("yarn");
+    if (await isCommandAvailable("pnpm"))
+      packageManagers.push("pnpm");
+    return packageManagers;
+  });
+  detectRuntimes = memoize_default(async () => {
+    const runtimes = [];
+    if (await isCommandAvailable("bun"))
+      runtimes.push("bun");
+    if (await isCommandAvailable("deno"))
+      runtimes.push("deno");
+    if (await isCommandAvailable("node"))
+      runtimes.push("node");
+    return runtimes;
+  });
+  isWslEnvironment = memoize_default(() => {
+    try {
+      return getFsImplementation().existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+    } catch (_error) {
+      return false;
+    }
+  });
+  isNpmFromWindowsPath = memoize_default(() => {
+    try {
+      if (!isWslEnvironment()) {
+        return false;
+      }
+      const { cmd } = findExecutable("npm", []);
+      return cmd.startsWith("/mnt/c/");
+    } catch (_error) {
+      return false;
+    }
+  });
+  JETBRAINS_IDES = [
+    "pycharm",
+    "intellij",
+    "webstorm",
+    "phpstorm",
+    "rubymine",
+    "clion",
+    "goland",
+    "rider",
+    "datagrip",
+    "appcode",
+    "dataspell",
+    "aqua",
+    "gateway",
+    "fleet",
+    "jetbrains",
+    "androidstudio"
+  ];
+  detectDeploymentEnvironment = memoize_default(() => {
+    if (isEnvTruthy(process.env.CODESPACES))
+      return "codespaces";
+    if (process.env.GITPOD_WORKSPACE_ID)
+      return "gitpod";
+    if (process.env.REPL_ID || process.env.REPL_SLUG)
+      return "replit";
+    if (process.env.PROJECT_DOMAIN)
+      return "glitch";
+    if (isEnvTruthy(process.env.VERCEL))
+      return "vercel";
+    if (process.env.RAILWAY_ENVIRONMENT_NAME || process.env.RAILWAY_SERVICE_NAME) {
+      return "railway";
+    }
+    if (isEnvTruthy(process.env.RENDER))
+      return "render";
+    if (isEnvTruthy(process.env.NETLIFY))
+      return "netlify";
+    if (process.env.DYNO)
+      return "heroku";
+    if (process.env.FLY_APP_NAME || process.env.FLY_MACHINE_ID)
+      return "fly.io";
+    if (isEnvTruthy(process.env.CF_PAGES))
+      return "cloudflare-pages";
+    if (process.env.DENO_DEPLOYMENT_ID)
+      return "deno-deploy";
+    if (process.env.AWS_LAMBDA_FUNCTION_NAME)
+      return "aws-lambda";
+    if (process.env.AWS_EXECUTION_ENV === "AWS_ECS_FARGATE")
+      return "aws-fargate";
+    if (process.env.AWS_EXECUTION_ENV === "AWS_ECS_EC2")
+      return "aws-ecs";
+    try {
+      const uuid = getFsImplementation().readFileSync("/sys/hypervisor/uuid", { encoding: "utf8" }).trim().toLowerCase();
+      if (uuid.startsWith("ec2"))
+        return "aws-ec2";
+    } catch {}
+    if (process.env.K_SERVICE)
+      return "gcp-cloud-run";
+    if (process.env.GOOGLE_CLOUD_PROJECT)
+      return "gcp";
+    if (process.env.WEBSITE_SITE_NAME || process.env.WEBSITE_SKU)
+      return "azure-app-service";
+    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
+      return "azure-functions";
+    if (process.env.APP_URL?.includes("ondigitalocean.app")) {
+      return "digitalocean-app-platform";
+    }
+    if (process.env.SPACE_CREATOR_USER_ID)
+      return "huggingface-spaces";
+    if (isEnvTruthy(process.env.GITHUB_ACTIONS))
+      return "github-actions";
+    if (isEnvTruthy(process.env.GITLAB_CI))
+      return "gitlab-ci";
+    if (process.env.CIRCLECI)
+      return "circleci";
+    if (process.env.BUILDKITE)
+      return "buildkite";
+    if (isEnvTruthy(process.env.CI))
+      return "ci";
+    if (process.env.KUBERNETES_SERVICE_HOST)
+      return "kubernetes";
+    try {
+      if (getFsImplementation().existsSync("/.dockerenv"))
+        return "docker";
+    } catch {}
+    if (env.platform === "darwin")
+      return "unknown-darwin";
+    if (env.platform === "linux")
+      return "unknown-linux";
+    if (env.platform === "win32")
+      return "unknown-win32";
+    return "unknown";
+  });
+  env = {
+    hasInternetAccess,
+    isCI: isEnvTruthy(process.env.CI),
+    platform: ["win32", "darwin"].includes(process.platform) ? process.platform : "linux",
+    arch: process.arch,
+    nodeVersion: process.version,
+    terminal: detectTerminal(),
+    isSSH: isSSHSession,
+    getPackageManagers: detectPackageManagers,
+    getRuntimes: detectRuntimes,
+    isRunningWithBun: memoize_default(isRunningWithBun),
+    isWslEnvironment,
+    isNpmFromWindowsPath,
+    isConductor,
+    detectDeploymentEnvironment
+  };
+});
+
+export { isRunningWithBun, isInBundledMode, findExecutable, init_findExecutable, getGlobalClaudeFile, JETBRAINS_IDES, env, getHostPlatformForAnalytics, init_env };

package/dist/chunk-vxqhjyfz.js

@@ -0,0 +1,15 @@
+// @bun
+import"./chunk-eta5aekm.js";
+import {
+  __INVALID__REF__
+} from "./chunk-ccyg9ap9.js";
+
+// src/utils/worktreeModeEnabled.ts
+function isWorktreeModeEnabled() {
+  return true;
+}
+export {
+  isWorktreeModeEnabled
+};
+
+export { isWorktreeModeEnabled };

package/dist/chunk-vzsstfmb.js

@@ -0,0 +1,80 @@
+// @bun
+import"./chunk-78n9kfp8.js";
+import"./chunk-j8mxc6k6.js";
+import"./chunk-z0exw850.js";
+import"./chunk-3jf3k40v.js";
+import"./chunk-yvmhx96e.js";
+import"./chunk-qezv7msv.js";
+import"./chunk-sscms68s.js";
+import"./chunk-7e1qjk3s.js";
+import"./chunk-1gjysfnf.js";
+import"./chunk-vxgdzx6p.js";
+import"./chunk-kv147680.js";
+import"./chunk-2p0hvt8k.js";
+import"./chunk-ycr0hp6v.js";
+import"./chunk-9029sbq1.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-ezpa510h.js";
+import"./chunk-kp6nepx4.js";
+import"./chunk-1jjzp2pa.js";
+import"./chunk-w1jew5sn.js";
+import"./chunk-g98m2qe6.js";
+import"./chunk-sez03qd9.js";
+import"./chunk-vsfj449x.js";
+import"./chunk-r4cxb6t7.js";
+import"./chunk-bp0ynk17.js";
+import"./chunk-7yexhdjs.js";
+import"./chunk-rex82hys.js";
+import"./chunk-4s93jyky.js";
+import"./chunk-318g78ty.js";
+import"./chunk-c0bdmy7w.js";
+import"./chunk-syxy4pf2.js";
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-y66bqywr.js";
+import"./chunk-nwk16bbd.js";
+import"./chunk-rx6z23h0.js";
+import"./chunk-df5c1x8m.js";
+import"./chunk-65z8hg8j.js";
+import"./chunk-5cp2q9sh.js";
+import"./chunk-rjjakkw2.js";
+import"./chunk-0sbddf6m.js";
+import"./chunk-q5b0kpr3.js";
+
+// src/commands/vim/vim.ts
+var call = async () => {
+  const config = getGlobalConfig();
+  let currentMode = config.editorMode || "normal";
+  if (currentMode === "emacs") {
+    currentMode = "normal";
+  }
+  const newMode = currentMode === "normal" ? "vim" : "normal";
+  saveGlobalConfig((current) => ({
+    ...current,
+    editorMode: newMode
+  }));
+  logEvent("tengu_editor_mode_changed", {
+    mode: newMode,
+    source: "command"
+  });
+  return {
+    type: "text",
+    value: `Editor mode set to ${newMode}. ${newMode === "vim" ? "Use Escape key to toggle between INSERT and NORMAL modes." : "Using standard (readline) keyboard bindings."}`
+  };
+};
+var init_vim = __esm(() => {
+  init_analytics();
+  init_config();
+});
+init_vim();
+
+export {
+  call
+};

package/dist/chunk-w1jew5sn.js

@@ -0,0 +1,69 @@
+// @bun
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-g98m2qe6.js";
+import {
+  execa,
+  init_execa
+} from "./chunk-sez03qd9.js";
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+
+// src/utils/which.ts
+async function whichNodeAsync(command) {
+  if (process.platform === "win32") {
+    const result2 = await execa(`where.exe ${command}`, {
+      shell: true,
+      stderr: "ignore",
+      reject: false
+    });
+    if (result2.exitCode !== 0 || !result2.stdout) {
+      return null;
+    }
+    return result2.stdout.trim().split(/\r?\n/)[0] || null;
+  }
+  const result = await execa(`which ${command}`, {
+    shell: true,
+    stderr: "ignore",
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+function whichNodeSync(command) {
+  if (process.platform === "win32") {
+    try {
+      const result = execSync_DEPRECATED(`where.exe ${command}`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const output = result.toString().trim();
+      return output.split(/\r?\n/)[0] || null;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`which ${command}`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return result.toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+var bunWhich, which, whichSync;
+var init_which = __esm(() => {
+  init_execa();
+  init_execSyncWrapper();
+  bunWhich = typeof Bun !== "undefined" && typeof Bun.which === "function" ? Bun.which : null;
+  which = bunWhich ? async (command) => bunWhich(command) : whichNodeAsync;
+  whichSync = bunWhich ?? whichNodeSync;
+});
+
+export { which, whichSync, init_which };