@jayjiang/open-cc 0.2.1

package/dist/chunk-5gzg4q1k.js

@@ -0,0 +1,99 @@
+// @bun
+import {
+  attributionRestoreStateFromLog,
+  buildSurfaceKey,
+  calculateCommitAttribution,
+  computeContentHash,
+  createEmptyAttributionState,
+  expandFilePath,
+  getAttributionRepoRoot,
+  getClientSurface,
+  getFileMtime,
+  getGitDiffSize,
+  getRepoClassCached,
+  getStagedFiles,
+  incrementPromptCount,
+  init_commitAttribution,
+  isFileDeleted,
+  isGitTransientState,
+  isInternalModelRepo,
+  isInternalModelRepoCached,
+  normalizeFilePath,
+  restoreAttributionStateFromSnapshots,
+  sanitizeModelName,
+  sanitizeSurfaceKey,
+  stateToSnapshotMessage,
+  trackBulkFileChanges,
+  trackFileCreation,
+  trackFileDeletion,
+  trackFileModification
+} from "./chunk-rc5bbzx4.js";
+import"./chunk-30chpfyc.js";
+import"./chunk-84k64e4a.js";
+import"./chunk-y3py9g5d.js";
+import"./chunk-7pemewz2.js";
+import"./chunk-s4w01jsb.js";
+import"./chunk-c8vn3ynx.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-mzdtkccs.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-5k2gdxnr.js";
+import"./chunk-2qhs9n36.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-mr9df5v8.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-r1v8d6da.js";
+import"./chunk-d3v2fbay.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-f2zhqnb6.js";
+import"./chunk-cvp5vayb.js";
+import"./chunk-b5b7h81y.js";
+import"./chunk-nm2cncrq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-0rkbrabt.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-rwagvxh5.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-0fkqze0v.js";
+import"./chunk-2zcaw1jd.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_commitAttribution();
+
+export {
+  trackFileModification,
+  trackFileDeletion,
+  trackFileCreation,
+  trackBulkFileChanges,
+  stateToSnapshotMessage,
+  sanitizeSurfaceKey,
+  sanitizeModelName,
+  restoreAttributionStateFromSnapshots,
+  normalizeFilePath,
+  isInternalModelRepoCached,
+  isInternalModelRepo,
+  isGitTransientState,
+  isFileDeleted,
+  incrementPromptCount,
+  getStagedFiles,
+  getRepoClassCached,
+  getGitDiffSize,
+  getFileMtime,
+  getClientSurface,
+  getAttributionRepoRoot,
+  expandFilePath,
+  createEmptyAttributionState,
+  computeContentHash,
+  calculateCommitAttribution,
+  buildSurfaceKey,
+  attributionRestoreStateFromLog
+};

package/dist/chunk-5k2gdxnr.js

@@ -0,0 +1,336 @@
+// @bun
+import {
+  fileSuffixForOauthConfig,
+  init_oauth
+} from "./chunk-2qhs9n36.js";
+import {
+  init_which,
+  which,
+  whichSync
+} from "./chunk-f2zhqnb6.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-rwagvxh5.js";
+import {
+  getConfigHomeDir,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-0fkqze0v.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.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;
+}
+var init_bundledMode = () => {};
+
+// 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_bundledMode();
+  init_envUtils();
+  init_findExecutable();
+  init_fsOperations();
+  init_which();
+  getGlobalClaudeFile = memoize_default(() => {
+    if (getFsImplementation().existsSync(join(getConfigHomeDir(), ".config.json"))) {
+      return join(getConfigHomeDir(), ".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-8hq5kk3y.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, init_bundledMode, findExecutable, init_findExecutable, getGlobalClaudeFile, JETBRAINS_IDES, env, getHostPlatformForAnalytics, init_env };

package/dist/chunk-5kp252z6.js

@@ -0,0 +1,202 @@
+// @bun
+import {
+  disableAllPluginsOp,
+  disablePluginOp,
+  enablePluginOp,
+  init_pluginOperations,
+  installPluginOp,
+  uninstallPluginOp,
+  updatePluginOp
+} from "./chunk-qjcxkbv6.js";
+import {
+  buildPluginTelemetryFields,
+  classifyPluginCommandError,
+  getManagedPluginNames,
+  gracefulShutdown,
+  init_gracefulShutdown,
+  init_managedPlugins,
+  init_pluginIdentifier,
+  init_pluginTelemetry,
+  parsePluginIdentifier
+} from "./chunk-2y54j9ew.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-b5b7h81y.js";
+import {
+  init_log,
+  logError
+} from "./chunk-nm2cncrq.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-rwagvxh5.js";
+import {
+  init_process,
+  writeToStdout
+} from "./chunk-fbv4apne.js";
+
+// src/services/plugins/pluginCliCommands.ts
+init_figures();
+init_errors();
+init_gracefulShutdown();
+init_log();
+init_managedPlugins();
+init_pluginIdentifier();
+init_process();
+init_pluginTelemetry();
+init_analytics();
+init_pluginOperations();
+function handlePluginCommandError(error, command, plugin) {
+  logError(error);
+  const operation = plugin ? `${command} plugin "${plugin}"` : command === "disable-all" ? "disable all plugins" : `${command} plugins`;
+  console.error(`${figures_default.cross} Failed to ${operation}: ${errorMessage(error)}`);
+  const telemetryFields = plugin ? (() => {
+    const { name, marketplace } = parsePluginIdentifier(plugin);
+    return {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    };
+  })() : {};
+  logEvent("tengu_plugin_command_failed", {
+    command,
+    error_category: classifyPluginCommandError(error),
+    ...telemetryFields
+  });
+  process.exit(1);
+}
+async function installPlugin(plugin, scope = "user") {
+  try {
+    console.log(`Installing plugin "${plugin}"...`);
+    const result = await installPluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_installed_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope || scope,
+      install_source: "cli-explicit",
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "install", plugin);
+  }
+}
+async function uninstallPlugin(plugin, scope = "user", keepData = false) {
+  try {
+    const result = await uninstallPluginOp(plugin, scope, !keepData);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_uninstalled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope || scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "uninstall", plugin);
+  }
+}
+async function enablePlugin(plugin, scope) {
+  try {
+    const result = await enablePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_enabled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "enable", plugin);
+  }
+}
+async function disablePlugin(plugin, scope) {
+  try {
+    const result = await disablePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+    logEvent("tengu_plugin_disabled_cli", {
+      _PROTO_plugin_name: name,
+      ...marketplace && {
+        _PROTO_marketplace_name: marketplace
+      },
+      scope: result.scope,
+      ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+    });
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "disable", plugin);
+  }
+}
+async function disableAllPlugins() {
+  try {
+    const result = await disableAllPluginsOp();
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    console.log(`${figures_default.tick} ${result.message}`);
+    logEvent("tengu_plugin_disabled_all_cli", {});
+    process.exit(0);
+  } catch (error) {
+    handlePluginCommandError(error, "disable-all");
+  }
+}
+async function updatePluginCli(plugin, scope) {
+  try {
+    writeToStdout(`Checking for updates for plugin "${plugin}" at ${scope} scope\u2026
+`);
+    const result = await updatePluginOp(plugin, scope);
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    writeToStdout(`${figures_default.tick} ${result.message}
+`);
+    if (!result.alreadyUpToDate) {
+      const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+      logEvent("tengu_plugin_updated_cli", {
+        _PROTO_plugin_name: name,
+        ...marketplace && {
+          _PROTO_marketplace_name: marketplace
+        },
+        old_version: result.oldVersion || "unknown",
+        new_version: result.newVersion || "unknown",
+        ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames())
+      });
+    }
+    await gracefulShutdown(0);
+  } catch (error) {
+    handlePluginCommandError(error, "update", plugin);
+  }
+}
+
+export { installPlugin, uninstallPlugin, enablePlugin, disablePlugin, disableAllPlugins, updatePluginCli };