@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-qqfvrtr3.js

@@ -0,0 +1,99 @@
+// @bun
+import {
+  checkEnabledPlugins,
+  findMissingPlugins,
+  getInstalledPlugins,
+  getPluginEditableScopes,
+  init_pluginStartupCheck,
+  installSelectedPlugins,
+  isPersistableScope,
+  settingSourceToScope
+} from "./chunk-0htr6ryz.js";
+import"./chunk-1m68rrvt.js";
+import"./chunk-sdxgmmma.js";
+import"./chunk-qjg7a3vk.js";
+import"./chunk-nypgx8vs.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-41m5za5y.js";
+import"./chunk-gz457zg6.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-x7vg43fv.js";
+import"./chunk-vn1e1j7w.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-s5dg9njs.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-dnqqes3z.js";
+import"./chunk-ph936yc1.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-wt69n71b.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-z7ns4g0p.js";
+import"./chunk-adg4351g.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-0hw5q246.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-8smr33wf.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-wq8v0d1k.js";
+import"./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-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.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"./chunk-qp2qdcda.js";
+init_pluginStartupCheck();
+
+export {
+  settingSourceToScope,
+  isPersistableScope,
+  installSelectedPlugins,
+  getPluginEditableScopes,
+  getInstalledPlugins,
+  findMissingPlugins,
+  checkEnabledPlugins
+};

package/dist/chunk-qrqenkjd.js

@@ -0,0 +1,140 @@
+// @bun
+import {
+  clearAllCaches,
+  clearPluginCacheExclusions,
+  getAgentDefinitionsWithOverrides,
+  getPluginCommands,
+  init_cacheUtils,
+  init_loadAgentsDir,
+  init_loadPluginCommands,
+  init_loadPluginHooks,
+  init_lspPluginIntegration,
+  init_manager,
+  init_mcpPluginIntegration,
+  init_orphanedPluginFilter,
+  init_pluginLoader,
+  loadAllPlugins,
+  loadPluginHooks,
+  loadPluginLspServers,
+  loadPluginMcpServers,
+  reinitializeLspServerManager
+} from "./chunk-1m68rrvt.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  getOriginalCwd,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/refresh.ts
+async function refreshActivePlugins(setAppState) {
+  logForDebugging("refreshActivePlugins: clearing all plugin caches");
+  clearAllCaches();
+  clearPluginCacheExclusions();
+  const pluginResult = await loadAllPlugins();
+  const [pluginCommands, agentDefinitions] = await Promise.all([
+    getPluginCommands(),
+    getAgentDefinitionsWithOverrides(getOriginalCwd())
+  ]);
+  const { enabled, disabled, errors } = pluginResult;
+  const [mcpCounts, lspCounts] = await Promise.all([
+    Promise.all(enabled.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;
+    })),
+    Promise.all(enabled.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 mcp_count = mcpCounts.reduce((sum, n) => sum + n, 0);
+  const lsp_count = lspCounts.reduce((sum, n) => sum + n, 0);
+  setAppState((prev) => ({
+    ...prev,
+    plugins: {
+      ...prev.plugins,
+      enabled,
+      disabled,
+      commands: pluginCommands,
+      errors: mergePluginErrors(prev.plugins.errors, errors),
+      needsRefresh: false
+    },
+    agentDefinitions,
+    mcp: {
+      ...prev.mcp,
+      pluginReconnectKey: prev.mcp.pluginReconnectKey + 1
+    }
+  }));
+  reinitializeLspServerManager();
+  let hook_load_failed = false;
+  try {
+    await loadPluginHooks();
+  } catch (e) {
+    hook_load_failed = true;
+    logError(e);
+    logForDebugging(`refreshActivePlugins: loadPluginHooks failed: ${errorMessage(e)}`);
+  }
+  const hook_count = enabled.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);
+  logForDebugging(`refreshActivePlugins: ${enabled.length} enabled, ${pluginCommands.length} commands, ${agentDefinitions.allAgents.length} agents, ${hook_count} hooks, ${mcp_count} MCP, ${lsp_count} LSP`);
+  return {
+    enabled_count: enabled.length,
+    disabled_count: disabled.length,
+    command_count: pluginCommands.length,
+    agent_count: agentDefinitions.allAgents.length,
+    hook_count,
+    mcp_count,
+    lsp_count,
+    error_count: errors.length + (hook_load_failed ? 1 : 0),
+    agentDefinitions,
+    pluginCommands
+  };
+}
+function mergePluginErrors(existing, fresh) {
+  const preserved = existing.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+  const freshKeys = new Set(fresh.map(errorKey));
+  const deduped = preserved.filter((e) => !freshKeys.has(errorKey(e)));
+  return [...deduped, ...fresh];
+}
+function errorKey(e) {
+  return e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`;
+}
+var init_refresh = __esm(() => {
+  init_state();
+  init_manager();
+  init_loadAgentsDir();
+  init_debug();
+  init_errors();
+  init_log();
+  init_cacheUtils();
+  init_loadPluginCommands();
+  init_loadPluginHooks();
+  init_lspPluginIntegration();
+  init_mcpPluginIntegration();
+  init_orphanedPluginFilter();
+  init_pluginLoader();
+});
+
+export { refreshActivePlugins, init_refresh };

package/dist/chunk-qrv8taxy.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  getStoredChangelogFromMemory,
+  init_releaseNotes,
+  parseChangelog
+} from "./chunk-wae2sy8c.js";
+import {
+  init_sessionStorage,
+  loadMessageLogs
+} from "./chunk-1m68rrvt.js";
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getDisplayPath,
+  getInitialSettings,
+  getSubscriptionName,
+  init_auth,
+  init_file,
+  init_settings1 as init_settings,
+  isClaudeAISubscriber
+} from "./chunk-3zzszjst.js";
+import {
+  init_format,
+  init_stringWidth,
+  stringWidth,
+  truncate,
+  truncateToWidth,
+  truncateToWidthNoEllipsis
+} from "./chunk-wgcssf6v.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getDirectConnectServerUrl,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/logoV2Utils.ts
+function getLayoutMode(columns) {
+  if (columns >= 70)
+    return "horizontal";
+  return "compact";
+}
+function calculateLayoutDimensions(columns, layoutMode, optimalLeftWidth) {
+  if (layoutMode === "horizontal") {
+    const leftWidth = optimalLeftWidth;
+    const usedSpace = BORDER_PADDING + CONTENT_PADDING + DIVIDER_WIDTH + leftWidth;
+    const availableForRight = columns - usedSpace;
+    let rightWidth = Math.max(30, availableForRight);
+    const totalWidth2 = Math.min(leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING, columns - BORDER_PADDING);
+    if (totalWidth2 < leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING) {
+      rightWidth = totalWidth2 - leftWidth - DIVIDER_WIDTH - CONTENT_PADDING;
+    }
+    return { leftWidth, rightWidth, totalWidth: totalWidth2 };
+  }
+  const totalWidth = Math.min(columns - BORDER_PADDING, MAX_LEFT_WIDTH + 20);
+  return {
+    leftWidth: totalWidth,
+    rightWidth: totalWidth,
+    totalWidth
+  };
+}
+function calculateOptimalLeftWidth(welcomeMessage, truncatedCwd, modelLine) {
+  const contentWidth = Math.max(stringWidth(welcomeMessage), stringWidth(truncatedCwd), stringWidth(modelLine), 20);
+  return Math.min(contentWidth + 4, MAX_LEFT_WIDTH);
+}
+function formatWelcomeMessage(username) {
+  if (!username || username.length > MAX_USERNAME_LENGTH) {
+    return "Welcome back!";
+  }
+  return `Welcome back ${username}!`;
+}
+function truncatePath(path, maxLength) {
+  if (stringWidth(path) <= maxLength)
+    return path;
+  const separator = "/";
+  const ellipsis = "\u2026";
+  const ellipsisWidth = 1;
+  const separatorWidth = 1;
+  const parts = path.split(separator);
+  const first = parts[0] || "";
+  const last = parts[parts.length - 1] || "";
+  const firstWidth = stringWidth(first);
+  const lastWidth = stringWidth(last);
+  if (parts.length === 1) {
+    return truncateToWidth(path, maxLength);
+  }
+  if (first === "" && ellipsisWidth + separatorWidth + lastWidth >= maxLength) {
+    return `${separator}${truncateToWidth(last, Math.max(1, maxLength - separatorWidth))}`;
+  }
+  if (first !== "" && ellipsisWidth * 2 + separatorWidth + lastWidth >= maxLength) {
+    return `${ellipsis}${separator}${truncateToWidth(last, Math.max(1, maxLength - ellipsisWidth - separatorWidth))}`;
+  }
+  if (parts.length === 2) {
+    const availableForFirst = maxLength - ellipsisWidth - separatorWidth - lastWidth;
+    return `${truncateToWidthNoEllipsis(first, availableForFirst)}${ellipsis}${separator}${last}`;
+  }
+  let available = maxLength - firstWidth - lastWidth - ellipsisWidth - 2 * separatorWidth;
+  if (available <= 0) {
+    const availableForFirst = Math.max(0, maxLength - lastWidth - ellipsisWidth - 2 * separatorWidth);
+    const truncatedFirst = truncateToWidthNoEllipsis(first, availableForFirst);
+    return `${truncatedFirst}${separator}${ellipsis}${separator}${last}`;
+  }
+  const middleParts = [];
+  for (let i = parts.length - 2;i > 0; i--) {
+    const part = parts[i];
+    if (part && stringWidth(part) + separatorWidth <= available) {
+      middleParts.unshift(part);
+      available -= stringWidth(part) + separatorWidth;
+    } else {
+      break;
+    }
+  }
+  if (middleParts.length === 0) {
+    return `${first}${separator}${ellipsis}${separator}${last}`;
+  }
+  return `${first}${separator}${ellipsis}${separator}${middleParts.join(separator)}${separator}${last}`;
+}
+async function getRecentActivity() {
+  if (cachePromise) {
+    return cachePromise;
+  }
+  const currentSessionId = getSessionId();
+  cachePromise = loadMessageLogs(10).then((logs) => {
+    cachedActivity = logs.filter((log) => {
+      if (log.isSidechain)
+        return false;
+      if (log.sessionId === currentSessionId)
+        return false;
+      if (log.summary?.includes("I apologize"))
+        return false;
+      const hasSummary = log.summary && log.summary !== "No prompt";
+      const hasFirstPrompt = log.firstPrompt && log.firstPrompt !== "No prompt";
+      return hasSummary || hasFirstPrompt;
+    }).slice(0, 3);
+    return cachedActivity;
+  }).catch(() => {
+    cachedActivity = [];
+    return cachedActivity;
+  });
+  return cachePromise;
+}
+function getRecentActivitySync() {
+  return cachedActivity;
+}
+function getLogoDisplayData() {
+  const version = process.env.DEMO_VERSION ?? "1.0.3-fork.2a74621";
+  const serverUrl = getDirectConnectServerUrl();
+  const displayPath = process.env.DEMO_VERSION ? "/code/claude" : getDisplayPath(getCwd());
+  const cwd = serverUrl ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, "")}` : displayPath;
+  const billingType = isClaudeAISubscriber() ? getSubscriptionName() : "API Usage Billing";
+  const agentName = getInitialSettings().agent;
+  return {
+    version,
+    cwd,
+    billingType,
+    agentName
+  };
+}
+function formatModelAndBilling(modelName, billingType, availableWidth) {
+  const separator = " \xB7 ";
+  const combinedWidth = stringWidth(modelName) + separator.length + stringWidth(billingType);
+  const shouldSplit = combinedWidth > availableWidth;
+  if (shouldSplit) {
+    return {
+      shouldSplit: true,
+      truncatedModel: truncate(modelName, availableWidth),
+      truncatedBilling: truncate(billingType, availableWidth)
+    };
+  }
+  return {
+    shouldSplit: false,
+    truncatedModel: truncate(modelName, Math.max(availableWidth - stringWidth(billingType) - separator.length, 10)),
+    truncatedBilling: billingType
+  };
+}
+function getRecentReleaseNotesSync(maxItems) {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog2 = "";
+    if (changelog2) {
+      const commits = changelog2.trim().split(`
+`).filter(Boolean);
+      return commits.slice(0, maxItems);
+    }
+    return [];
+  }
+  const changelog = getStoredChangelogFromMemory();
+  if (!changelog) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = parseChangelog(changelog);
+  } catch {
+    return [];
+  }
+  const allNotes = [];
+  const versions = Object.keys(parsed).sort((a, b) => gt(a, b) ? -1 : 1).slice(0, 3);
+  for (const version of versions) {
+    const notes = parsed[version];
+    if (notes) {
+      allNotes.push(...notes);
+    }
+  }
+  return allNotes.slice(0, maxItems);
+}
+var MAX_LEFT_WIDTH = 50, MAX_USERNAME_LENGTH = 20, BORDER_PADDING = 4, DIVIDER_WIDTH = 1, CONTENT_PADDING = 2, cachedActivity, cachePromise = null;
+var init_logoV2Utils = __esm(() => {
+  init_state();
+  init_stringWidth();
+  init_auth();
+  init_cwd();
+  init_file();
+  init_format();
+  init_releaseNotes();
+  init_semver();
+  init_sessionStorage();
+  init_settings();
+  cachedActivity = [];
+});
+
+export { getLayoutMode, calculateLayoutDimensions, calculateOptimalLeftWidth, formatWelcomeMessage, truncatePath, getRecentActivity, getRecentActivitySync, getLogoDisplayData, formatModelAndBilling, getRecentReleaseNotesSync, init_logoV2Utils };

package/dist/chunk-qypqtrgp.js

@@ -0,0 +1,176 @@
+// @bun
+import {
+  init_sink,
+  initializeAnalyticsSink
+} from "./chunk-r9madq2h.js";
+import {
+  CACHE_PATHS,
+  attachErrorLogSink,
+  dateToFilename,
+  init_cachePaths,
+  init_log
+} from "./chunk-yysj6sxt.js";
+import {
+  createBufferedWriter,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-sbbj6ta3.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+
+// src/utils/sinks.ts
+init_sink();
+
+// src/utils/errorLogSink.ts
+init_axios();
+init_state();
+init_bufferedWriter();
+init_cachePaths();
+init_cleanupRegistry();
+init_debug();
+init_fsOperations();
+init_log();
+init_slowOperations();
+import { dirname, join } from "path";
+var DATE = dateToFilename(new Date);
+function getErrorsPath() {
+  return join(CACHE_PATHS.errors(), DATE + ".jsonl");
+}
+function getMCPLogsPath(serverName) {
+  return join(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
+}
+function createJsonlWriter(options) {
+  const writer = createBufferedWriter(options);
+  return {
+    write(obj) {
+      writer.write(jsonStringify(obj) + `
+`);
+    },
+    flush: writer.flush,
+    dispose: writer.dispose
+  };
+}
+var logWriters = new Map;
+function getLogWriter(path) {
+  let writer = logWriters.get(path);
+  if (!writer) {
+    const dir = dirname(path);
+    writer = createJsonlWriter({
+      writeFn: (content) => {
+        try {
+          getFsImplementation().appendFileSync(path, content);
+        } catch {
+          getFsImplementation().mkdirSync(dir);
+          getFsImplementation().appendFileSync(path, content);
+        }
+      },
+      flushIntervalMs: 1000,
+      maxBufferSize: 50
+    });
+    logWriters.set(path, writer);
+    registerCleanup(async () => writer?.dispose());
+  }
+  return writer;
+}
+function appendToLog(path, message) {
+  if (process.env.USER_TYPE !== "ant") {
+    return;
+  }
+  const messageWithTimestamp = {
+    timestamp: new Date().toISOString(),
+    ...message,
+    cwd: getFsImplementation().cwd(),
+    userType: process.env.USER_TYPE,
+    sessionId: getSessionId(),
+    version: "1.0.3-fork.2a74621"
+  };
+  getLogWriter(path).write(messageWithTimestamp);
+}
+function extractServerMessage(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data && typeof data === "object") {
+    const obj = data;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "object" && obj.error && "message" in obj.error && typeof obj.error.message === "string") {
+      return obj.error.message;
+    }
+  }
+  return;
+}
+function logErrorImpl(error) {
+  const errorStr = error.stack || error.message;
+  let context = "";
+  if (axios_default.isAxiosError(error) && error.config?.url) {
+    const parts = [`url=${error.config.url}`];
+    if (error.response?.status !== undefined) {
+      parts.push(`status=${error.response.status}`);
+    }
+    const serverMessage = extractServerMessage(error.response?.data);
+    if (serverMessage) {
+      parts.push(`body=${serverMessage}`);
+    }
+    context = `[${parts.join(",")}] `;
+  }
+  logForDebugging(`${error.name}: ${context}${errorStr}`, { level: "error" });
+  appendToLog(getErrorsPath(), {
+    error: `${context}${errorStr}`
+  });
+}
+function logMCPErrorImpl(serverName, error) {
+  logForDebugging(`MCP server "${serverName}" ${error}`, { level: "error" });
+  const logFile = getMCPLogsPath(serverName);
+  const errorStr = error instanceof Error ? error.stack || error.message : String(error);
+  const errorInfo = {
+    error: errorStr,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(errorInfo);
+}
+function logMCPDebugImpl(serverName, message) {
+  logForDebugging(`MCP server "${serverName}": ${message}`);
+  const logFile = getMCPLogsPath(serverName);
+  const debugInfo = {
+    debug: message,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(debugInfo);
+}
+function initializeErrorLogSink() {
+  attachErrorLogSink({
+    logError: logErrorImpl,
+    logMCPError: logMCPErrorImpl,
+    logMCPDebug: logMCPDebugImpl,
+    getErrorsPath,
+    getMCPLogsPath
+  });
+  logForDebugging("Error log sink initialized");
+}
+
+// src/utils/sinks.ts
+function initSinks() {
+  initializeErrorLogSink();
+  initializeAnalyticsSink();
+}
+
+export { initSinks };