@zyycn/claudex 1.0.3-fork.3767904

package/dist/chunk-enjbm16s.js

@@ -0,0 +1,212 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} from "./chunk-njmw3yt4.js";
+import {
+  Dialog,
+  init_Dialog
+} from "./chunk-k2qkkhf9.js";
+import {
+  Link,
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-8aww16wk.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_config1 as init_config,
+  saveCurrentProjectConfig
+} from "./chunk-z06751ss.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/ClaudeMdExternalIncludesDialog.tsx
+function ClaudeMdExternalIncludesDialog(t0) {
+  const $ = import_compiler_runtime.c(18);
+  const {
+    onDone,
+    isStandaloneDialog,
+    externalIncludes
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  import_react.default.useEffect(_temp, t1);
+  let t2;
+  if ($[1] !== onDone) {
+    t2 = (value) => {
+      if (value === "no") {
+        logEvent("tengu_claude_md_external_includes_dialog_declined", {});
+        saveCurrentProjectConfig(_temp2);
+      } else {
+        logEvent("tengu_claude_md_external_includes_dialog_accepted", {});
+        saveCurrentProjectConfig(_temp3);
+      }
+      onDone();
+    };
+    $[1] = onDone;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleSelection = t2;
+  let t3;
+  if ($[3] !== handleSelection) {
+    t3 = () => {
+      handleSelection("no");
+    };
+    $[3] = handleSelection;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  const handleEscape = t3;
+  const t4 = !isStandaloneDialog;
+  const t5 = !isStandaloneDialog;
+  let t6;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: "This project's CLAUDE.md imports files outside the current working directory. Never allow this for third-party repositories."
+    }, undefined, false, undefined, this);
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  let t7;
+  if ($[6] !== externalIncludes) {
+    t7 = externalIncludes && externalIncludes.length > 0 && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "External imports:"
+        }, undefined, false, undefined, this),
+        externalIncludes.map(_temp4)
+      ]
+    }, undefined, true, undefined, this);
+    $[6] = externalIncludes;
+    $[7] = t7;
+  } else {
+    t7 = $[7];
+  }
+  let t8;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        "Important: Only use Claude Code with files you trust. Accessing untrusted files may pose security risks",
+        " ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+          url: "https://code.claude.com/docs/en/security"
+        }, undefined, false, undefined, this),
+        " "
+      ]
+    }, undefined, true, undefined, this);
+    $[8] = t8;
+  } else {
+    t8 = $[8];
+  }
+  let t9;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = [{
+      label: "Yes, allow external imports",
+      value: "yes"
+    }, {
+      label: "No, disable external imports",
+      value: "no"
+    }];
+    $[9] = t9;
+  } else {
+    t9 = $[9];
+  }
+  let t10;
+  if ($[10] !== handleSelection) {
+    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+      options: t9,
+      onChange: (value_0) => handleSelection(value_0)
+    }, undefined, false, undefined, this);
+    $[10] = handleSelection;
+    $[11] = t10;
+  } else {
+    t10 = $[11];
+  }
+  let t11;
+  if ($[12] !== handleEscape || $[13] !== t10 || $[14] !== t4 || $[15] !== t5 || $[16] !== t7) {
+    t11 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Allow external CLAUDE.md file imports?",
+      color: "warning",
+      onCancel: handleEscape,
+      hideBorder: t4,
+      hideInputGuide: t5,
+      children: [
+        t6,
+        t7,
+        t8,
+        t10
+      ]
+    }, undefined, true, undefined, this);
+    $[12] = handleEscape;
+    $[13] = t10;
+    $[14] = t4;
+    $[15] = t5;
+    $[16] = t7;
+    $[17] = t11;
+  } else {
+    t11 = $[17];
+  }
+  return t11;
+}
+function _temp4(include, i) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+    dimColor: true,
+    children: [
+      "  ",
+      include.path
+    ]
+  }, i, true, undefined, this);
+}
+function _temp3(current_0) {
+  return {
+    ...current_0,
+    hasClaudeMdExternalIncludesApproved: true,
+    hasClaudeMdExternalIncludesWarningShown: true
+  };
+}
+function _temp2(current) {
+  return {
+    ...current,
+    hasClaudeMdExternalIncludesApproved: false,
+    hasClaudeMdExternalIncludesWarningShown: true
+  };
+}
+function _temp() {
+  logEvent("tengu_claude_md_includes_dialog_shown", {});
+}
+var import_compiler_runtime, import_react, jsx_dev_runtime;
+var init_ClaudeMdExternalIncludesDialog = __esm(() => {
+  init_analytics();
+  init_ink();
+  init_config();
+  init_CustomSelect();
+  init_Dialog();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { ClaudeMdExternalIncludesDialog, init_ClaudeMdExternalIncludesDialog };

package/dist/chunk-epf7hfx9.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-njmw3yt4.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-eebcvtbb.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sessionTitle.ts
+function extractConversationText(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.type !== "user" && msg.type !== "assistant")
+      continue;
+    if ("isMeta" in msg && msg.isMeta)
+      continue;
+    if ("origin" in msg && msg.origin && msg.origin.kind !== "human")
+      continue;
+    const content = msg.message.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+          parts.push(block.text);
+        }
+      }
+    }
+  }
+  const text = parts.join(`
+`);
+  return text.length > MAX_CONVERSATION_TEXT ? text.slice(-MAX_CONVERSATION_TEXT) : text;
+}
+async function generateSessionTitle(description, signal) {
+  const trimmed = description.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([SESSION_TITLE_PROMPT]),
+      userPrompt: trimmed,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" }
+          },
+          required: ["title"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "generate_session_title",
+        agents: [],
+        isNonInteractiveSession: getIsNonInteractiveSession(),
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const text = extractTextContent(result.message.content);
+    const parsed = titleSchema().safeParse(safeParseJSON(text));
+    const title = parsed.success ? parsed.data.title.trim() || null : null;
+    logEvent("tengu_session_title_generated", { success: title !== null });
+    return title;
+  } catch (error) {
+    logForDebugging(`generateSessionTitle failed: ${error}`, {
+      level: "error"
+    });
+    logEvent("tengu_session_title_generated", { success: false });
+    return null;
+  }
+}
+var MAX_CONVERSATION_TEXT = 1000, SESSION_TITLE_PROMPT = `Generate a concise, sentence-case title (3-7 words) that captures the main topic or goal of this coding session. The title should be clear enough that the user recognizes the session in a list. Use sentence case: capitalize only the first word and proper nouns.
+
+Return JSON with a single "title" field.
+
+Good examples:
+{"title": "Fix login button on mobile"}
+{"title": "Add OAuth authentication"}
+{"title": "Debug failing CI tests"}
+{"title": "Refactor API client error handling"}
+
+Bad (too vague): {"title": "Code changes"}
+Bad (too long): {"title": "Investigate and fix the issue where the login button does not respond on mobile devices"}
+Bad (wrong case): {"title": "Fix Login Button On Mobile"}`, titleSchema;
+var init_sessionTitle = __esm(() => {
+  init_v4();
+  init_state();
+  init_analytics();
+  init_claude();
+  init_debug();
+  init_json();
+  init_lazySchema();
+  init_messages();
+  init_systemPromptType();
+  titleSchema = lazySchema(() => exports_external.object({ title: exports_external.string() }));
+});
+
+export { extractConversationText, generateSessionTitle, init_sessionTitle };

package/dist/chunk-eqp1rfft.js

@@ -0,0 +1,17 @@
+// @bun
+import {
+  FSWatcher,
+  WatchHelper,
+  chokidar_default,
+  init_chokidar,
+  watch
+} from "./chunk-ehtwnxpg.js";
+import"./chunk-qp2qdcda.js";
+init_chokidar();
+
+export {
+  watch,
+  chokidar_default as default,
+  WatchHelper,
+  FSWatcher
+};

package/dist/chunk-er596fa7.js

@@ -0,0 +1,246 @@
+// @bun
+import {
+  MODEL_COSTS,
+  getAPIProvider,
+  getCanonicalName,
+  getEventMetadata,
+  getOrCreateUserID,
+  init_config,
+  init_config1 as init_config2,
+  init_metadata,
+  init_model,
+  init_modelCost,
+  init_providers,
+  isAnalyticsDisabled
+} from "./chunk-z06751ss.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/analytics/datadog.ts
+import { createHash } from "crypto";
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+async function flushLogs() {
+  if (logBatch.length === 0)
+    return;
+  const logsToSend = logBatch;
+  logBatch = [];
+  try {
+    await axios_default.post(DATADOG_LOGS_ENDPOINT, logsToSend, {
+      headers: {
+        "Content-Type": "application/json",
+        "DD-API-KEY": DATADOG_CLIENT_TOKEN
+      },
+      timeout: NETWORK_TIMEOUT_MS
+    });
+  } catch (error) {
+    logError(error);
+  }
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flushLogs();
+  }, getFlushIntervalMs()).unref();
+}
+async function shutdownDatadog() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  await flushLogs();
+}
+async function trackDatadogEvent(eventName, properties) {
+  if (true) {
+    return;
+  }
+  if (getAPIProvider() !== "firstParty") {
+    return;
+  }
+  let initialized = datadogInitialized;
+  if (initialized === null) {
+    initialized = await initializeDatadog();
+  }
+  if (!initialized || !DATADOG_ALLOWED_EVENTS.has(eventName)) {
+    return;
+  }
+  try {
+    const metadata = await getEventMetadata({
+      model: properties.model,
+      betas: properties.betas
+    });
+    const { envContext, ...restMetadata } = metadata;
+    const allData = {
+      ...restMetadata,
+      ...envContext,
+      ...properties,
+      userBucket: getUserBucket()
+    };
+    if (typeof allData.toolName === "string" && allData.toolName.startsWith("mcp__")) {
+      allData.toolName = "mcp";
+    }
+    if (process.env.USER_TYPE !== "ant" && typeof allData.model === "string") {
+      const shortName = getCanonicalName(allData.model.replace(/\[1m]$/i, ""));
+      allData.model = shortName in MODEL_COSTS ? shortName : "other";
+    }
+    if (typeof allData.version === "string") {
+      allData.version = allData.version.replace(/^(\d+\.\d+\.\d+-dev\.\d{8})\.t\d+\.sha[a-f0-9]+$/, "$1");
+    }
+    if (allData.status !== undefined && allData.status !== null) {
+      const statusCode = String(allData.status);
+      allData.http_status = statusCode;
+      const firstDigit = statusCode.charAt(0);
+      if (firstDigit >= "1" && firstDigit <= "5") {
+        allData.http_status_range = `${firstDigit}xx`;
+      }
+      delete allData.status;
+    }
+    const allDataRecord = allData;
+    const tags = [
+      `event:${eventName}`,
+      ...TAG_FIELDS.filter((field) => allDataRecord[field] !== undefined && allDataRecord[field] !== null).map((field) => `${camelToSnakeCase(field)}:${allDataRecord[field]}`)
+    ];
+    const log = {
+      ddsource: "nodejs",
+      ddtags: tags.join(","),
+      message: eventName,
+      service: "claude-code",
+      hostname: "claude-code",
+      env: process.env.USER_TYPE
+    };
+    for (const [key, value] of Object.entries(allData)) {
+      if (value !== undefined && value !== null) {
+        log[camelToSnakeCase(key)] = value;
+      }
+    }
+    logBatch.push(log);
+    if (logBatch.length >= MAX_BATCH_SIZE) {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      flushLogs();
+    } else {
+      scheduleFlush();
+    }
+  } catch (error) {
+    logError(error);
+  }
+}
+function getFlushIntervalMs() {
+  return parseInt(process.env.CLAUDE_CODE_DATADOG_FLUSH_INTERVAL_MS || "", 10) || DEFAULT_FLUSH_INTERVAL_MS;
+}
+var DATADOG_LOGS_ENDPOINT = "https://http-intake.logs.us5.datadoghq.com/api/v2/logs", DATADOG_CLIENT_TOKEN = "pubbbf48e6d78dae54bceaa4acf463299bf", DEFAULT_FLUSH_INTERVAL_MS = 15000, MAX_BATCH_SIZE = 100, NETWORK_TIMEOUT_MS = 5000, DATADOG_ALLOWED_EVENTS, TAG_FIELDS, logBatch, flushTimer = null, datadogInitialized = null, initializeDatadog, NUM_USER_BUCKETS = 30, getUserBucket;
+var init_datadog = __esm(() => {
+  init_axios();
+  init_memoize();
+  init_config2();
+  init_log();
+  init_model();
+  init_providers();
+  init_modelCost();
+  init_config();
+  init_metadata();
+  DATADOG_ALLOWED_EVENTS = new Set([
+    "chrome_bridge_connection_succeeded",
+    "chrome_bridge_connection_failed",
+    "chrome_bridge_disconnected",
+    "chrome_bridge_tool_call_completed",
+    "chrome_bridge_tool_call_error",
+    "chrome_bridge_tool_call_started",
+    "chrome_bridge_tool_call_timeout",
+    "tengu_api_error",
+    "tengu_api_success",
+    "tengu_brief_mode_enabled",
+    "tengu_brief_mode_toggled",
+    "tengu_brief_send",
+    "tengu_cancel",
+    "tengu_compact_failed",
+    "tengu_exit",
+    "tengu_flicker",
+    "tengu_init",
+    "tengu_model_fallback_triggered",
+    "tengu_oauth_error",
+    "tengu_oauth_success",
+    "tengu_oauth_token_refresh_failure",
+    "tengu_oauth_token_refresh_success",
+    "tengu_oauth_token_refresh_lock_acquiring",
+    "tengu_oauth_token_refresh_lock_acquired",
+    "tengu_oauth_token_refresh_starting",
+    "tengu_oauth_token_refresh_completed",
+    "tengu_oauth_token_refresh_lock_releasing",
+    "tengu_oauth_token_refresh_lock_released",
+    "tengu_query_error",
+    "tengu_session_file_read",
+    "tengu_started",
+    "tengu_tool_use_error",
+    "tengu_tool_use_granted_in_prompt_permanent",
+    "tengu_tool_use_granted_in_prompt_temporary",
+    "tengu_tool_use_rejected_in_prompt",
+    "tengu_tool_use_success",
+    "tengu_uncaught_exception",
+    "tengu_unhandled_rejection",
+    "tengu_voice_recording_started",
+    "tengu_voice_toggled",
+    "tengu_team_mem_sync_pull",
+    "tengu_team_mem_sync_push",
+    "tengu_team_mem_sync_started",
+    "tengu_team_mem_entries_capped"
+  ]);
+  TAG_FIELDS = [
+    "arch",
+    "clientType",
+    "errorType",
+    "http_status_range",
+    "http_status",
+    "kairosActive",
+    "model",
+    "platform",
+    "provider",
+    "skillMode",
+    "subscriptionType",
+    "toolName",
+    "userBucket",
+    "userType",
+    "version",
+    "versionBase"
+  ];
+  logBatch = [];
+  initializeDatadog = memoize_default(async () => {
+    if (isAnalyticsDisabled()) {
+      datadogInitialized = false;
+      return false;
+    }
+    try {
+      datadogInitialized = true;
+      return true;
+    } catch (error) {
+      logError(error);
+      datadogInitialized = false;
+      return false;
+    }
+  });
+  getUserBucket = memoize_default(() => {
+    const userId = getOrCreateUserID();
+    const hash = createHash("sha256").update(userId).digest("hex");
+    return parseInt(hash.slice(0, 8), 16) % NUM_USER_BUCKETS;
+  });
+});
+
+export { shutdownDatadog, trackDatadogEvent, init_datadog };

package/dist/chunk-ewadzrm8.js

@@ -0,0 +1,103 @@
+// @bun
+import {
+  AsyncDecompress,
+  AsyncDeflate,
+  AsyncGunzip,
+  AsyncGzip,
+  AsyncInflate,
+  AsyncUnzipInflate,
+  AsyncUnzlib,
+  AsyncZipDeflate,
+  AsyncZlib,
+  DecodeUTF8,
+  Decompress,
+  Deflate,
+  EncodeUTF8,
+  FlateErrorCode,
+  Gunzip,
+  Gzip,
+  Inflate,
+  Unzip,
+  UnzipInflate,
+  UnzipPassThrough,
+  Unzlib,
+  Zip,
+  ZipDeflate,
+  ZipPassThrough,
+  Zlib,
+  decompress,
+  decompressSync,
+  deflate,
+  deflateSync,
+  gunzip,
+  gunzipSync,
+  gzip,
+  gzipSync,
+  inflate,
+  inflateSync,
+  init_esm,
+  strFromU8,
+  strToU8,
+  unzip,
+  unzipSync,
+  unzlib,
+  unzlibSync,
+  zip,
+  zipSync,
+  zlib,
+  zlibSync
+} from "./chunk-vyjeh50y.js";
+import"./chunk-qp2qdcda.js";
+init_esm();
+
+export {
+  zlibSync,
+  zlib,
+  zipSync,
+  zip,
+  unzlibSync,
+  unzlib,
+  unzipSync,
+  unzip,
+  strToU8,
+  strFromU8,
+  inflateSync,
+  inflate,
+  gzipSync,
+  gzip,
+  gunzipSync,
+  gunzip,
+  deflateSync,
+  deflate,
+  decompressSync,
+  decompress,
+  gzipSync as compressSync,
+  gzip as compress,
+  Zlib,
+  ZipPassThrough,
+  ZipDeflate,
+  Zip,
+  Unzlib,
+  UnzipPassThrough,
+  UnzipInflate,
+  Unzip,
+  Inflate,
+  Gzip,
+  Gunzip,
+  FlateErrorCode,
+  EncodeUTF8,
+  Deflate,
+  Decompress,
+  DecodeUTF8,
+  Gzip as Compress,
+  AsyncZlib,
+  AsyncZipDeflate,
+  AsyncUnzlib,
+  AsyncUnzipInflate,
+  AsyncInflate,
+  AsyncGzip,
+  AsyncGunzip,
+  AsyncDeflate,
+  AsyncDecompress,
+  AsyncGzip as AsyncCompress
+};