@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-r0v9bxma.js

@@ -0,0 +1,83 @@
+// @bun
+import {
+  extractConversationText,
+  init_sessionTitle
+} from "./chunk-wz2ekprb.js";
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-1m68rrvt.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-eebcvtbb.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rename/generateSessionName.ts
+async function generateSessionName(messages, signal) {
+  const conversationText = extractConversationText(messages);
+  if (!conversationText) {
+    return null;
+  }
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([
+        'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.'
+      ]),
+      userPrompt: conversationText,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            name: { type: "string" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "rename_generate_name",
+        agents: [],
+        isNonInteractiveSession: false,
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const content = Array.isArray(result.message.content) ? extractTextContent(result.message.content) : result.message.content;
+    const response = safeParseJSON(content);
+    if (response && typeof response === "object" && "name" in response && typeof response.name === "string") {
+      return response.name;
+    }
+    return null;
+  } catch (error) {
+    logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, {
+      level: "error"
+    });
+    return null;
+  }
+}
+var init_generateSessionName = __esm(() => {
+  init_claude();
+  init_debug();
+  init_errors();
+  init_json();
+  init_messages();
+  init_sessionTitle();
+  init_systemPromptType();
+});
+
+export { generateSessionName, init_generateSessionName };

package/dist/chunk-r6b58y3x.js

@@ -0,0 +1,17 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/output-style/output-style.tsx
+async function call(onDone) {
+  onDone("/output-style has been deprecated. Use /config to change your output style, or set it in your settings file. Changes take effect on the next session.", {
+    display: "system"
+  });
+}
+var init_output_style = () => {};
+init_output_style();
+
+export {
+  call
+};

package/dist/chunk-r9madq2h.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  init_datadog,
+  trackDatadogEvent
+} from "./chunk-qjg7a3vk.js";
+import {
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  init_firstPartyEventLogger,
+  init_growthbook,
+  init_sinkKillswitch,
+  isSinkKilled,
+  logEventTo1P,
+  shouldSampleEvent
+} from "./chunk-3zzszjst.js";
+import {
+  attachAnalyticsSink,
+  init_analytics,
+  stripProtoFields
+} from "./chunk-h0rbjg6x.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/analytics/sink.ts
+function shouldTrackDatadog() {
+  if (isSinkKilled("datadog")) {
+    return false;
+  }
+  if (isDatadogGateEnabled !== undefined) {
+    return isDatadogGateEnabled;
+  }
+  try {
+    return checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME);
+  } catch {
+    return false;
+  }
+}
+function logEventImpl(eventName, metadata) {
+  const sampleResult = shouldSampleEvent(eventName);
+  if (sampleResult === 0) {
+    return;
+  }
+  const metadataWithSampleRate = sampleResult !== null ? { ...metadata, sample_rate: sampleResult } : metadata;
+  if (shouldTrackDatadog()) {
+    trackDatadogEvent(eventName, stripProtoFields(metadataWithSampleRate));
+  }
+  logEventTo1P(eventName, metadataWithSampleRate);
+}
+function logEventAsyncImpl(eventName, metadata) {
+  logEventImpl(eventName, metadata);
+  return Promise.resolve();
+}
+function initializeAnalyticsGates() {
+  isDatadogGateEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME);
+}
+function initializeAnalyticsSink() {
+  attachAnalyticsSink({
+    logEvent: logEventImpl,
+    logEventAsync: logEventAsyncImpl
+  });
+}
+var DATADOG_GATE_NAME = "tengu_log_datadog_events", isDatadogGateEnabled = undefined;
+var init_sink = __esm(() => {
+  init_datadog();
+  init_firstPartyEventLogger();
+  init_growthbook();
+  init_analytics();
+  init_sinkKillswitch();
+});
+
+export { initializeAnalyticsGates, initializeAnalyticsSink, init_sink };

package/dist/chunk-raqgs410.js

@@ -0,0 +1,116 @@
+// @bun
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/protectedNamespace.ts
+var exports_protectedNamespace = {};
+__export(exports_protectedNamespace, {
+  checkProtectedNamespace: () => checkProtectedNamespace
+});
+var checkProtectedNamespace = () => false;
+var init_protectedNamespace = () => {};
+
+// src/utils/envUtils.ts
+import { homedir } from "os";
+import { join } from "path";
+function getLegacyClaudeConfigHomeDir() {
+  return join(homedir(), ".claude").normalize("NFC");
+}
+function getTeamsDir() {
+  return join(getClaudeConfigHomeDir(), "teams");
+}
+function hasNodeOption(flag) {
+  const nodeOptions = process.env.NODE_OPTIONS;
+  if (!nodeOptions) {
+    return false;
+  }
+  return nodeOptions.split(/\s+/).includes(flag);
+}
+function isEnvTruthy(envVar) {
+  if (!envVar)
+    return false;
+  if (typeof envVar === "boolean")
+    return envVar;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
+function isEnvDefinedFalsy(envVar) {
+  if (envVar === undefined)
+    return false;
+  if (typeof envVar === "boolean")
+    return !envVar;
+  if (!envVar)
+    return false;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["0", "false", "no", "off"].includes(normalizedValue);
+}
+function isBareMode() {
+  return isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) || process.argv.includes("--bare");
+}
+function parseEnvVars(rawEnvArgs) {
+  const parsedEnv = {};
+  if (rawEnvArgs) {
+    for (const envStr of rawEnvArgs) {
+      const [key, ...valueParts] = envStr.split("=");
+      if (!key || valueParts.length === 0) {
+        throw new Error(`Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`);
+      }
+      parsedEnv[key] = valueParts.join("=");
+    }
+  }
+  return parsedEnv;
+}
+function getAWSRegion() {
+  return process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+}
+function getDefaultVertexRegion() {
+  return process.env.CLOUD_ML_REGION || "us-east5";
+}
+function shouldMaintainProjectWorkingDir() {
+  return isEnvTruthy(process.env.CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR);
+}
+function isRunningOnHomespace() {
+  return process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.COO_RUNNING_ON_HOMESPACE);
+}
+function isInProtectedNamespace() {
+  if (process.env.USER_TYPE === "ant") {
+    return (init_protectedNamespace(), __toCommonJS(exports_protectedNamespace)).checkProtectedNamespace();
+  }
+  return false;
+}
+function getVertexRegionForModel(model) {
+  if (model) {
+    const match = VERTEX_REGION_OVERRIDES.find(([prefix]) => model.startsWith(prefix));
+    if (match) {
+      return process.env[match[1]] || getDefaultVertexRegion();
+    }
+  }
+  return getDefaultVertexRegion();
+}
+var getClaudeConfigHomeDir, VERTEX_REGION_OVERRIDES;
+var init_envUtils = __esm(() => {
+  init_memoize();
+  getClaudeConfigHomeDir = memoize_default(() => {
+    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claudex")).normalize("NFC");
+  }, () => process.env.CLAUDE_CONFIG_DIR);
+  VERTEX_REGION_OVERRIDES = [
+    ["claude-haiku-4-5", "VERTEX_REGION_CLAUDE_HAIKU_4_5"],
+    ["claude-3-5-haiku", "VERTEX_REGION_CLAUDE_3_5_HAIKU"],
+    ["claude-3-5-sonnet", "VERTEX_REGION_CLAUDE_3_5_SONNET"],
+    ["claude-3-7-sonnet", "VERTEX_REGION_CLAUDE_3_7_SONNET"],
+    ["claude-opus-4-1", "VERTEX_REGION_CLAUDE_4_1_OPUS"],
+    ["claude-opus-4", "VERTEX_REGION_CLAUDE_4_0_OPUS"],
+    ["claude-sonnet-4-6", "VERTEX_REGION_CLAUDE_4_6_SONNET"],
+    ["claude-sonnet-4-5", "VERTEX_REGION_CLAUDE_4_5_SONNET"],
+    ["claude-sonnet-4", "VERTEX_REGION_CLAUDE_4_0_SONNET"]
+  ];
+});
+
+export { getClaudeConfigHomeDir, getLegacyClaudeConfigHomeDir, getTeamsDir, hasNodeOption, isEnvTruthy, isEnvDefinedFalsy, isBareMode, parseEnvVars, getAWSRegion, getDefaultVertexRegion, shouldMaintainProjectWorkingDir, isRunningOnHomespace, isInProtectedNamespace, getVertexRegionForModel, init_envUtils };

package/dist/chunk-rc28tav4.js

@@ -0,0 +1,202 @@
+// @bun
+import {
+  disableAllPluginsOp,
+  disablePluginOp,
+  enablePluginOp,
+  init_pluginOperations,
+  installPluginOp,
+  uninstallPluginOp,
+  updatePluginOp
+} from "./chunk-2sndq2nq.js";
+import {
+  buildPluginTelemetryFields,
+  classifyPluginCommandError,
+  getManagedPluginNames,
+  gracefulShutdown,
+  init_gracefulShutdown,
+  init_managedPlugins,
+  init_pluginIdentifier,
+  init_pluginTelemetry,
+  parsePluginIdentifier
+} from "./chunk-1m68rrvt.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-sbbj6ta3.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 };