@costrict/csc 4.0.1

package/dist/chunk-4zh96y27.js

@@ -0,0 +1,202 @@
+// @bun
+import {
+  disableAllPluginsOp,
+  disablePluginOp,
+  enablePluginOp,
+  init_pluginOperations,
+  installPluginOp,
+  uninstallPluginOp,
+  updatePluginOp
+} from "./chunk-k04vbmv4.js";
+import {
+  buildPluginTelemetryFields,
+  classifyPluginCommandError,
+  getManagedPluginNames,
+  gracefulShutdown,
+  init_gracefulShutdown,
+  init_managedPlugins,
+  init_pluginIdentifier,
+  init_pluginTelemetry,
+  parsePluginIdentifier
+} from "./chunk-97kwfkef.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-qajrkk97.js";
+import {
+  init_process,
+  writeToStdout
+} from "./chunk-fbv4apne.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.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 };

package/dist/chunk-512kh02z.js

@@ -0,0 +1,117 @@
+// @bun
+import {
+  call,
+  init_thinkback,
+  playAnimation
+} from "./chunk-gzykgb04.js";
+import"./chunk-k04vbmv4.js";
+import"./chunk-bend4tmg.js";
+import"./chunk-97kwfkef.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-s2jznn2t.js";
+import"./chunk-zejm280k.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-enz148g9.js";
+import"./chunk-jmt3t5ka.js";
+import"./chunk-3x2jaxpw.js";
+import"./chunk-wm26jyc3.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-3vxgde8h.js";
+import"./chunk-9k8qsaph.js";
+import"./chunk-bnrctxq5.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import"./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-3sj7jkgr.js";
+import"./chunk-62xkxk9z.js";
+import"./chunk-ers3hn71.js";
+import"./chunk-5krq9sjq.js";
+import"./chunk-85em0j2s.js";
+import"./chunk-dmfnhfbm.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-ew2qn2ct.js";
+import"./chunk-3bes9fg8.js";
+import"./chunk-ygj29dpk.js";
+import"./chunk-6km733xr.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-z915v06p.js";
+import"./chunk-rw0b3wq4.js";
+import"./chunk-ms3y5kf0.js";
+import"./chunk-pfc94kdv.js";
+import"./chunk-kwdta9bw.js";
+import"./chunk-3dy7fxmg.js";
+import"./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-xzc7k2hh.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-yjkamwzv.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import"./chunk-qp2qdcda.js";
+init_thinkback();
+
+export {
+  playAnimation,
+  call
+};

package/dist/chunk-538ydk68.js

@@ -0,0 +1,85 @@
+// @bun
+import {
+  extractConversationText,
+  init_sessionTitle
+} from "./chunk-nk5x8t2h.js";
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-97kwfkef.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-3ns6ys7f.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.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-56ax2vae.js

@@ -0,0 +1,255 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-9n6x41fh.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-6x0hj15f.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-97kwfkef.js";
+import {
+  count,
+  init_array
+} from "./chunk-1cwdhk7a.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-13hhjhs8.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-z6e5jp2w.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 };