@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-6r9v2rce.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  EXIT_PLAN_MODE_V2_TOOL_NAME,
+  createAssistantMessage,
+  getPlan,
+  init_constants2 as init_constants,
+  init_messages1 as init_messages,
+  init_plans
+} from "./chunk-1m68rrvt.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-wgcssf6v.js";
+import {
+  LOCAL_COMMAND_STDERR_TAG,
+  LOCAL_COMMAND_STDOUT_TAG,
+  init_xml
+} from "./chunk-yysj6sxt.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/messages/mappers.ts
+import { randomUUID } from "crypto";
+function toInternalMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: message.message,
+            uuid: message.uuid,
+            requestId: undefined,
+            timestamp: new Date().toISOString()
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            uuid: message.uuid ?? randomUUID(),
+            timestamp: message.timestamp ?? new Date().toISOString(),
+            isMeta: message.isSynthetic
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary") {
+          const compactMsg = message;
+          return [
+            {
+              type: "system",
+              content: "Conversation compacted",
+              level: "info",
+              subtype: "compact_boundary",
+              compactMetadata: fromSDKCompactMetadata(compactMsg.compact_metadata),
+              uuid: message.uuid,
+              timestamp: new Date().toISOString()
+            }
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function toSDKCompactMetadata(meta) {
+  const seg = meta.preservedSegment;
+  return {
+    trigger: meta.trigger,
+    pre_tokens: meta.preTokens,
+    ...seg && {
+      preserved_segment: {
+        head_uuid: seg.headUuid,
+        anchor_uuid: seg.anchorUuid,
+        tail_uuid: seg.tailUuid
+      }
+    }
+  };
+}
+function fromSDKCompactMetadata(meta) {
+  const m = meta;
+  const seg = m.preserved_segment;
+  return {
+    trigger: m.trigger,
+    preTokens: m.pre_tokens,
+    ...seg && {
+      preservedSegment: {
+        headUuid: seg.head_uuid,
+        anchorUuid: seg.anchor_uuid,
+        tailUuid: seg.tail_uuid
+      }
+    }
+  };
+}
+function toSDKMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.type) {
+      case "assistant":
+        return [
+          {
+            type: "assistant",
+            message: normalizeAssistantMessageForSDK(message),
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            error: message.error
+          }
+        ];
+      case "user":
+        return [
+          {
+            type: "user",
+            message: message.message,
+            session_id: getSessionId(),
+            parent_tool_use_id: null,
+            uuid: message.uuid,
+            timestamp: message.timestamp,
+            isSynthetic: message.isMeta || message.isVisibleInTranscriptOnly,
+            ...message.toolUseResult !== undefined ? { tool_use_result: message.toolUseResult } : {}
+          }
+        ];
+      case "system":
+        if (message.subtype === "compact_boundary" && message.compactMetadata) {
+          return [
+            {
+              type: "system",
+              subtype: "compact_boundary",
+              session_id: getSessionId(),
+              uuid: message.uuid,
+              compact_metadata: toSDKCompactMetadata(message.compactMetadata)
+            }
+          ];
+        }
+        if (message.subtype === "local_command" && (message.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`) || message.content.includes(`<${LOCAL_COMMAND_STDERR_TAG}>`))) {
+          return [
+            localCommandOutputToSDKAssistantMessage(message.content, message.uuid)
+          ];
+        }
+        return [];
+      default:
+        return [];
+    }
+  });
+}
+function localCommandOutputToSDKAssistantMessage(rawContent, uuid) {
+  const cleanContent = stripAnsi(rawContent).replace(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/, "$1").replace(/<local-command-stderr>([\s\S]*?)<\/local-command-stderr>/, "$1").trim();
+  const synthetic = createAssistantMessage({ content: cleanContent });
+  return {
+    type: "assistant",
+    content: synthetic.message?.content,
+    message: synthetic.message,
+    parent_tool_use_id: null,
+    session_id: getSessionId(),
+    uuid
+  };
+}
+function toSDKRateLimitInfo(limits) {
+  if (!limits) {
+    return;
+  }
+  return {
+    type: "rate_limit",
+    status: limits.status,
+    ...limits.resetsAt !== undefined && { resetsAt: limits.resetsAt },
+    ...limits.rateLimitType !== undefined && {
+      rateLimitType: limits.rateLimitType
+    },
+    ...limits.utilization !== undefined && {
+      utilization: limits.utilization
+    },
+    ...limits.overageStatus !== undefined && {
+      overageStatus: limits.overageStatus
+    },
+    ...limits.overageResetsAt !== undefined && {
+      overageResetsAt: limits.overageResetsAt
+    },
+    ...limits.overageDisabledReason !== undefined && {
+      overageDisabledReason: limits.overageDisabledReason
+    },
+    ...limits.isUsingOverage !== undefined && {
+      isUsingOverage: limits.isUsingOverage
+    },
+    ...limits.surpassedThreshold !== undefined && {
+      surpassedThreshold: limits.surpassedThreshold
+    }
+  };
+}
+function normalizeAssistantMessageForSDK(message) {
+  const content = message.message.content;
+  if (!Array.isArray(content)) {
+    return message.message;
+  }
+  const normalizedContent = content.map((block) => {
+    if (block.type !== "tool_use") {
+      return block;
+    }
+    if (block.name === EXIT_PLAN_MODE_V2_TOOL_NAME) {
+      const plan = getPlan();
+      if (plan) {
+        return {
+          ...block,
+          input: { ...block.input, plan }
+        };
+      }
+    }
+    return block;
+  });
+  return {
+    ...message.message,
+    content: normalizedContent
+  };
+}
+var init_mappers = __esm(() => {
+  init_state();
+  init_xml();
+  init_constants();
+  init_strip_ansi();
+  init_messages();
+  init_plans();
+});
+
+export { toInternalMessages, toSDKCompactMetadata, fromSDKCompactMetadata, toSDKMessages, localCommandOutputToSDKAssistantMessage, toSDKRateLimitInfo, init_mappers };

package/dist/chunk-6tq2v3rk.js

@@ -0,0 +1,186 @@
+// @bun
+import {
+  require_index_node_http,
+  require_src as require_src4,
+  require_src1 as require_src5
+} from "./chunk-90wp6wez.js";
+import {
+  require_src as require_src3
+} from "./chunk-a8ejc632.js";
+import {
+  require_src1 as require_src2
+} from "./chunk-f5ma3nh5.js";
+import {
+  require_src
+} from "./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/OTLPMetricExporterOptions.js
+var require_OTLPMetricExporterOptions = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AggregationTemporalityPreference = undefined;
+  var AggregationTemporalityPreference;
+  (function(AggregationTemporalityPreference2) {
+    AggregationTemporalityPreference2[AggregationTemporalityPreference2["DELTA"] = 0] = "DELTA";
+    AggregationTemporalityPreference2[AggregationTemporalityPreference2["CUMULATIVE"] = 1] = "CUMULATIVE";
+    AggregationTemporalityPreference2[AggregationTemporalityPreference2["LOWMEMORY"] = 2] = "LOWMEMORY";
+  })(AggregationTemporalityPreference = exports.AggregationTemporalityPreference || (exports.AggregationTemporalityPreference = {}));
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/OTLPMetricExporterBase.js
+var require_OTLPMetricExporterBase = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporterBase = exports.LowMemoryTemporalitySelector = exports.DeltaTemporalitySelector = exports.CumulativeTemporalitySelector = undefined;
+  var core_1 = require_src2();
+  var sdk_metrics_1 = require_src3();
+  var OTLPMetricExporterOptions_1 = require_OTLPMetricExporterOptions();
+  var otlp_exporter_base_1 = require_src4();
+  var api_1 = require_src();
+  var CumulativeTemporalitySelector = () => sdk_metrics_1.AggregationTemporality.CUMULATIVE;
+  exports.CumulativeTemporalitySelector = CumulativeTemporalitySelector;
+  var DeltaTemporalitySelector = (instrumentType) => {
+    switch (instrumentType) {
+      case sdk_metrics_1.InstrumentType.COUNTER:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_COUNTER:
+      case sdk_metrics_1.InstrumentType.GAUGE:
+      case sdk_metrics_1.InstrumentType.HISTOGRAM:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_GAUGE:
+        return sdk_metrics_1.AggregationTemporality.DELTA;
+      case sdk_metrics_1.InstrumentType.UP_DOWN_COUNTER:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:
+        return sdk_metrics_1.AggregationTemporality.CUMULATIVE;
+    }
+  };
+  exports.DeltaTemporalitySelector = DeltaTemporalitySelector;
+  var LowMemoryTemporalitySelector = (instrumentType) => {
+    switch (instrumentType) {
+      case sdk_metrics_1.InstrumentType.COUNTER:
+      case sdk_metrics_1.InstrumentType.HISTOGRAM:
+        return sdk_metrics_1.AggregationTemporality.DELTA;
+      case sdk_metrics_1.InstrumentType.GAUGE:
+      case sdk_metrics_1.InstrumentType.UP_DOWN_COUNTER:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_COUNTER:
+      case sdk_metrics_1.InstrumentType.OBSERVABLE_GAUGE:
+        return sdk_metrics_1.AggregationTemporality.CUMULATIVE;
+    }
+  };
+  exports.LowMemoryTemporalitySelector = LowMemoryTemporalitySelector;
+  function chooseTemporalitySelectorFromEnvironment() {
+    const configuredTemporality = ((0, core_1.getStringFromEnv)("OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE") ?? "cumulative").toLowerCase();
+    if (configuredTemporality === "cumulative") {
+      return exports.CumulativeTemporalitySelector;
+    }
+    if (configuredTemporality === "delta") {
+      return exports.DeltaTemporalitySelector;
+    }
+    if (configuredTemporality === "lowmemory") {
+      return exports.LowMemoryTemporalitySelector;
+    }
+    api_1.diag.warn(`OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE is set to '${configuredTemporality}', but only 'cumulative' and 'delta' are allowed. Using default ('cumulative') instead.`);
+    return exports.CumulativeTemporalitySelector;
+  }
+  function chooseTemporalitySelector(temporalityPreference) {
+    if (temporalityPreference != null) {
+      if (temporalityPreference === OTLPMetricExporterOptions_1.AggregationTemporalityPreference.DELTA) {
+        return exports.DeltaTemporalitySelector;
+      } else if (temporalityPreference === OTLPMetricExporterOptions_1.AggregationTemporalityPreference.LOWMEMORY) {
+        return exports.LowMemoryTemporalitySelector;
+      }
+      return exports.CumulativeTemporalitySelector;
+    }
+    return chooseTemporalitySelectorFromEnvironment();
+  }
+  var DEFAULT_AGGREGATION = Object.freeze({
+    type: sdk_metrics_1.AggregationType.DEFAULT
+  });
+  function chooseAggregationSelector(config) {
+    return config?.aggregationPreference ?? (() => DEFAULT_AGGREGATION);
+  }
+
+  class OTLPMetricExporterBase extends otlp_exporter_base_1.OTLPExporterBase {
+    _aggregationTemporalitySelector;
+    _aggregationSelector;
+    constructor(delegate, config) {
+      super(delegate);
+      this._aggregationSelector = chooseAggregationSelector(config);
+      this._aggregationTemporalitySelector = chooseTemporalitySelector(config?.temporalityPreference);
+    }
+    selectAggregation(instrumentType) {
+      return this._aggregationSelector(instrumentType);
+    }
+    selectAggregationTemporality(instrumentType) {
+      return this._aggregationTemporalitySelector(instrumentType);
+    }
+  }
+  exports.OTLPMetricExporterBase = OTLPMetricExporterBase;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/platform/node/OTLPMetricExporter.js
+var require_OTLPMetricExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporterBase_1 = require_OTLPMetricExporterBase();
+  var otlp_transformer_1 = require_src5();
+  var node_http_1 = require_index_node_http();
+
+  class OTLPMetricExporter extends OTLPMetricExporterBase_1.OTLPMetricExporterBase {
+    constructor(config) {
+      super((0, node_http_1.createOtlpHttpExportDelegate)((0, node_http_1.convertLegacyHttpOptions)(config ?? {}, "METRICS", "v1/metrics", {
+        "Content-Type": "application/json"
+      }), otlp_transformer_1.JsonMetricsSerializer), config);
+    }
+  }
+  exports.OTLPMetricExporter = OTLPMetricExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/platform/node/index.js
+var require_node = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporter_1 = require_OTLPMetricExporter();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return OTLPMetricExporter_1.OTLPMetricExporter;
+  } });
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/platform/index.js
+var require_platform = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var node_1 = require_node();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return node_1.OTLPMetricExporter;
+  } });
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-http/build/src/index.js
+var require_src6 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporterBase = exports.LowMemoryTemporalitySelector = exports.DeltaTemporalitySelector = exports.CumulativeTemporalitySelector = exports.AggregationTemporalityPreference = exports.OTLPMetricExporter = undefined;
+  var platform_1 = require_platform();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return platform_1.OTLPMetricExporter;
+  } });
+  var OTLPMetricExporterOptions_1 = require_OTLPMetricExporterOptions();
+  Object.defineProperty(exports, "AggregationTemporalityPreference", { enumerable: true, get: function() {
+    return OTLPMetricExporterOptions_1.AggregationTemporalityPreference;
+  } });
+  var OTLPMetricExporterBase_1 = require_OTLPMetricExporterBase();
+  Object.defineProperty(exports, "CumulativeTemporalitySelector", { enumerable: true, get: function() {
+    return OTLPMetricExporterBase_1.CumulativeTemporalitySelector;
+  } });
+  Object.defineProperty(exports, "DeltaTemporalitySelector", { enumerable: true, get: function() {
+    return OTLPMetricExporterBase_1.DeltaTemporalitySelector;
+  } });
+  Object.defineProperty(exports, "LowMemoryTemporalitySelector", { enumerable: true, get: function() {
+    return OTLPMetricExporterBase_1.LowMemoryTemporalitySelector;
+  } });
+  Object.defineProperty(exports, "OTLPMetricExporterBase", { enumerable: true, get: function() {
+    return OTLPMetricExporterBase_1.OTLPMetricExporterBase;
+  } });
+});
+
+export { require_src6 as require_src };

package/dist/chunk-70spdapk.js

@@ -0,0 +1,79 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-3zzszjst.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.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 {
+  __esm
+} from "./chunk-qp2qdcda.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
+};