@jdi-code/claude-code 1.0.3

package/dist/chunk-9f7xza5r.js

@@ -0,0 +1,253 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-3vzs2gbq.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-czkshaff.js";
+import {
+  getPluginCommands,
+  init_AppState,
+  init_loadPluginAgents,
+  init_loadPluginCommands,
+  init_loadPluginHooks,
+  init_lspPluginIntegration,
+  init_manager,
+  init_mcpPluginIntegration,
+  init_notifications,
+  init_pluginLoader,
+  loadAllPlugins,
+  loadPluginAgents,
+  loadPluginHooks,
+  loadPluginLspServers,
+  loadPluginMcpServers,
+  reinitializeLspServerManager,
+  useAppState,
+  useNotifications,
+  useSetAppState
+} from "./chunk-5frcqxsv.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  count,
+  init_array
+} from "./chunk-0e1xsncc.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-hrzerbfw.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  init_debug,
+  init_errors,
+  logForDebugging,
+  toError
+} from "./chunk-nxsh6de2.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/useManagePlugins.ts
+init_notifications();
+init_analytics();
+init_manager();
+init_AppState();
+init_array();
+init_debug();
+init_diagLogs();
+init_errors();
+init_log();
+init_loadPluginAgents();
+init_loadPluginCommands();
+init_loadPluginHooks();
+init_lspPluginIntegration();
+init_mcpPluginIntegration();
+var import_react = __toESM(require_react(), 1);
+init_pluginFlagging();
+init_pluginLoader();
+function useManagePlugins({
+  enabled = true
+} = {}) {
+  const setAppState = useSetAppState();
+  const needsRefresh = useAppState((s) => s.plugins.needsRefresh);
+  const { addNotification } = useNotifications();
+  const initialPluginLoad = import_react.useCallback(async () => {
+    try {
+      const { enabled: enabled2, disabled, errors } = await loadAllPlugins();
+      await detectAndUninstallDelistedPlugins();
+      const flagged = getFlaggedPlugins();
+      if (Object.keys(flagged).length > 0) {
+        addNotification({
+          key: "plugin-delisted-flagged",
+          text: "Plugins flagged. Check /plugins",
+          color: "warning",
+          priority: "high"
+        });
+      }
+      let commands = [];
+      let agents = [];
+      try {
+        commands = await getPluginCommands();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-commands",
+          error: `Failed to load plugin commands: ${errorMessage}`
+        });
+      }
+      try {
+        agents = await loadPluginAgents();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-agents",
+          error: `Failed to load plugin agents: ${errorMessage}`
+        });
+      }
+      try {
+        await loadPluginHooks();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-hooks",
+          error: `Failed to load plugin hooks: ${errorMessage}`
+        });
+      }
+      const mcpServerCounts = await Promise.all(enabled2.map(async (p) => {
+        if (p.mcpServers)
+          return Object.keys(p.mcpServers).length;
+        const servers = await loadPluginMcpServers(p, errors);
+        if (servers)
+          p.mcpServers = servers;
+        return servers ? Object.keys(servers).length : 0;
+      }));
+      const mcp_count = mcpServerCounts.reduce((sum, n) => sum + n, 0);
+      const lspServerCounts = await Promise.all(enabled2.map(async (p) => {
+        if (p.lspServers)
+          return Object.keys(p.lspServers).length;
+        const servers = await loadPluginLspServers(p, errors);
+        if (servers)
+          p.lspServers = servers;
+        return servers ? Object.keys(servers).length : 0;
+      }));
+      const lsp_count = lspServerCounts.reduce((sum, n) => sum + n, 0);
+      reinitializeLspServerManager();
+      setAppState((prevState) => {
+        const existingLspErrors = prevState.plugins.errors.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+        const newErrorKeys = new Set(errors.map((e) => e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`));
+        const filteredExisting = existingLspErrors.filter((e) => {
+          const key = e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`;
+          return !newErrorKeys.has(key);
+        });
+        const mergedErrors = [...filteredExisting, ...errors];
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled: enabled2,
+            disabled,
+            commands,
+            errors: mergedErrors
+          }
+        };
+      });
+      logForDebugging(`Loaded plugins - Enabled: ${enabled2.length}, Disabled: ${disabled.length}, Commands: ${commands.length}, Agents: ${agents.length}, Errors: ${errors.length}`);
+      const hook_count = enabled2.reduce((sum, p) => {
+        if (!p.hooksConfig)
+          return sum;
+        return sum + Object.values(p.hooksConfig).reduce((s, matchers) => s + (matchers?.reduce((h, m) => h + m.hooks.length, 0) ?? 0), 0);
+      }, 0);
+      return {
+        enabled_count: enabled2.length,
+        disabled_count: disabled.length,
+        inline_count: count(enabled2, (p) => p.source.endsWith("@inline")),
+        marketplace_count: count(enabled2, (p) => !p.source.endsWith("@inline")),
+        error_count: errors.length,
+        skill_count: commands.length,
+        agent_count: agents.length,
+        hook_count,
+        mcp_count,
+        lsp_count,
+        ant_enabled_names: process.env.USER_TYPE === "ant" && enabled2.length > 0 ? enabled2.map((p) => p.name).sort().join(",") : undefined
+      };
+    } catch (error) {
+      const errorObj = toError(error);
+      logError(errorObj);
+      logForDebugging(`Error loading plugins: ${error}`);
+      setAppState((prevState) => {
+        const existingLspErrors = prevState.plugins.errors.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+        const newError = {
+          type: "generic-error",
+          source: "plugin-system",
+          error: errorObj.message
+        };
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled: [],
+            disabled: [],
+            commands: [],
+            errors: [...existingLspErrors, newError]
+          }
+        };
+      });
+      return {
+        enabled_count: 0,
+        disabled_count: 0,
+        inline_count: 0,
+        marketplace_count: 0,
+        error_count: 1,
+        skill_count: 0,
+        agent_count: 0,
+        hook_count: 0,
+        mcp_count: 0,
+        lsp_count: 0,
+        load_failed: true,
+        ant_enabled_names: undefined
+      };
+    }
+  }, [setAppState, addNotification]);
+  import_react.useEffect(() => {
+    if (!enabled)
+      return;
+    initialPluginLoad().then((metrics) => {
+      const { ant_enabled_names, ...baseMetrics } = metrics;
+      const allMetrics = {
+        ...baseMetrics,
+        has_custom_plugin_cache_dir: !!process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR
+      };
+      logEvent("tengu_plugins_loaded", {
+        ...allMetrics,
+        ...ant_enabled_names !== undefined && {
+          enabled_names: ant_enabled_names
+        }
+      });
+      logForDiagnosticsNoPII("info", "tengu_plugins_loaded", allMetrics);
+    });
+  }, [initialPluginLoad, enabled]);
+  import_react.useEffect(() => {
+    if (!enabled || !needsRefresh)
+      return;
+    addNotification({
+      key: "plugin-reload-pending",
+      text: "Plugins changed. Run /reload-plugins to activate.",
+      color: "suggestion",
+      priority: "low"
+    });
+  }, [enabled, needsRefresh, addNotification]);
+}
+
+export { useManagePlugins };

package/dist/chunk-9gbamk79.js

@@ -0,0 +1,93 @@
+// @bun
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/fileStateCache.ts
+import { normalize } from "path";
+
+class FileStateCache {
+  cache;
+  constructor(maxEntries, maxSizeBytes) {
+    this.cache = new L({
+      max: maxEntries,
+      maxSize: maxSizeBytes,
+      sizeCalculation: (value) => Math.max(1, Buffer.byteLength(value.content))
+    });
+  }
+  get(key) {
+    return this.cache.get(normalize(key));
+  }
+  set(key, value) {
+    this.cache.set(normalize(key), value);
+    return this;
+  }
+  has(key) {
+    return this.cache.has(normalize(key));
+  }
+  delete(key) {
+    return this.cache.delete(normalize(key));
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  get max() {
+    return this.cache.max;
+  }
+  get maxSize() {
+    return this.cache.maxSize;
+  }
+  get calculatedSize() {
+    return this.cache.calculatedSize;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  dump() {
+    return this.cache.dump();
+  }
+  load(entries) {
+    this.cache.load(entries);
+  }
+}
+function createFileStateCacheWithSizeLimit(maxEntries, maxSizeBytes = DEFAULT_MAX_CACHE_SIZE_BYTES) {
+  return new FileStateCache(maxEntries, maxSizeBytes);
+}
+function cacheToObject(cache) {
+  return Object.fromEntries(cache.entries());
+}
+function cacheKeys(cache) {
+  return Array.from(cache.keys());
+}
+function cloneFileStateCache(cache) {
+  const cloned = createFileStateCacheWithSizeLimit(cache.max, cache.maxSize);
+  cloned.load(cache.dump());
+  return cloned;
+}
+function mergeFileStateCaches(first, second) {
+  const merged = cloneFileStateCache(first);
+  for (const [filePath, fileState] of second.entries()) {
+    const existing = merged.get(filePath);
+    if (!existing || fileState.timestamp > existing.timestamp) {
+      merged.set(filePath, fileState);
+    }
+  }
+  return merged;
+}
+var READ_FILE_STATE_CACHE_SIZE = 100, DEFAULT_MAX_CACHE_SIZE_BYTES;
+var init_fileStateCache = __esm(() => {
+  init_index_min();
+  DEFAULT_MAX_CACHE_SIZE_BYTES = 25 * 1024 * 1024;
+});
+
+export { READ_FILE_STATE_CACHE_SIZE, createFileStateCacheWithSizeLimit, cacheToObject, cacheKeys, cloneFileStateCache, mergeFileStateCaches, init_fileStateCache };

package/dist/chunk-9gttd1xq.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-5frcqxsv.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-1rvz0433.js";
+import {
+  LOCAL_COMMAND_STDERR_TAG,
+  LOCAL_COMMAND_STDOUT_TAG,
+  init_xml
+} from "./chunk-p7g7pf3f.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 };