@redscope-ai/redscope 1.0.0

package/dist/chunk-z2dp53wn.js

@@ -0,0 +1,17 @@
+// @bun
+// src/cli/exit.ts
+function cliError(msg) {
+  if (msg)
+    console.error(msg);
+  process.exit(1);
+  return;
+}
+function cliOk(msg) {
+  if (msg)
+    process.stdout.write(msg + `
+`);
+  process.exit(0);
+  return;
+}
+
+export { cliError, cliOk };

package/dist/chunk-z79355gz.js

@@ -0,0 +1,308 @@
+// @bun
+import {
+  Cursor,
+  getLastKill,
+  init_Cursor,
+  init_useTerminalSize,
+  pushToKillRing,
+  recordYank,
+  resetKillAccumulation,
+  resetYankState,
+  updateYankLength,
+  yankPop
+} from "./chunk-gmdy2w3z.js";
+import {
+  KeyboardEvent,
+  init_src,
+  useTerminalSize,
+  use_input_default
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/hooks/useSearchInput.ts
+function isKillKey(e) {
+  if (e.ctrl && (e.key === "k" || e.key === "u" || e.key === "w")) {
+    return true;
+  }
+  if (e.meta && e.key === "backspace") {
+    return true;
+  }
+  return false;
+}
+function isYankKey(e) {
+  return (e.ctrl || e.meta) && e.key === "y";
+}
+function useSearchInput({
+  isActive,
+  onExit,
+  onCancel,
+  onExitUp,
+  columns,
+  passthroughCtrlKeys = [],
+  initialQuery = "",
+  backspaceExitsOnEmpty = true
+}) {
+  const { columns: terminalColumns } = useTerminalSize();
+  const effectiveColumns = columns ?? terminalColumns;
+  const [query, setQueryState] = import_react.useState(initialQuery);
+  const [cursorOffset, setCursorOffset] = import_react.useState(initialQuery.length);
+  const setQuery = import_react.useCallback((q) => {
+    setQueryState(q);
+    setCursorOffset(q.length);
+  }, []);
+  const handleKeyDown = (e) => {
+    if (!isActive)
+      return;
+    const cursor = Cursor.fromText(query, effectiveColumns, cursorOffset);
+    if (e.ctrl && passthroughCtrlKeys.includes(e.key.toLowerCase())) {
+      return;
+    }
+    if (!isKillKey(e)) {
+      resetKillAccumulation();
+    }
+    if (!isYankKey(e)) {
+      resetYankState();
+    }
+    if (e.key === "return" || e.key === "down") {
+      e.preventDefault();
+      onExit();
+      return;
+    }
+    if (e.key === "up") {
+      e.preventDefault();
+      if (onExitUp) {
+        onExitUp();
+      }
+      return;
+    }
+    if (e.key === "escape") {
+      e.preventDefault();
+      if (onCancel) {
+        onCancel();
+      } else if (query.length > 0) {
+        setQueryState("");
+        setCursorOffset(0);
+      } else {
+        onExit();
+      }
+      return;
+    }
+    if (e.key === "backspace") {
+      e.preventDefault();
+      if (e.meta) {
+        const { cursor: newCursor2, killed } = cursor.deleteWordBefore();
+        pushToKillRing(killed, "prepend");
+        setQueryState(newCursor2.text);
+        setCursorOffset(newCursor2.offset);
+        return;
+      }
+      if (query.length === 0) {
+        if (backspaceExitsOnEmpty)
+          (onCancel ?? onExit)();
+        return;
+      }
+      const newCursor = cursor.backspace();
+      setQueryState(newCursor.text);
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "delete") {
+      e.preventDefault();
+      const newCursor = cursor.del();
+      setQueryState(newCursor.text);
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "left" && (e.ctrl || e.meta || e.fn)) {
+      e.preventDefault();
+      const newCursor = cursor.prevWord();
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "right" && (e.ctrl || e.meta || e.fn)) {
+      e.preventDefault();
+      const newCursor = cursor.nextWord();
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "left") {
+      e.preventDefault();
+      const newCursor = cursor.left();
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "right") {
+      e.preventDefault();
+      const newCursor = cursor.right();
+      setCursorOffset(newCursor.offset);
+      return;
+    }
+    if (e.key === "home") {
+      e.preventDefault();
+      setCursorOffset(0);
+      return;
+    }
+    if (e.key === "end") {
+      e.preventDefault();
+      setCursorOffset(query.length);
+      return;
+    }
+    if (e.ctrl) {
+      e.preventDefault();
+      switch (e.key.toLowerCase()) {
+        case "a":
+          setCursorOffset(0);
+          return;
+        case "e":
+          setCursorOffset(query.length);
+          return;
+        case "b":
+          setCursorOffset(cursor.left().offset);
+          return;
+        case "f":
+          setCursorOffset(cursor.right().offset);
+          return;
+        case "d": {
+          if (query.length === 0) {
+            (onCancel ?? onExit)();
+            return;
+          }
+          const newCursor = cursor.del();
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "h": {
+          if (query.length === 0) {
+            if (backspaceExitsOnEmpty)
+              (onCancel ?? onExit)();
+            return;
+          }
+          const newCursor = cursor.backspace();
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "k": {
+          const { cursor: newCursor, killed } = cursor.deleteToLineEnd();
+          pushToKillRing(killed, "append");
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "u": {
+          const { cursor: newCursor, killed } = cursor.deleteToLineStart();
+          pushToKillRing(killed, "prepend");
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "w": {
+          const { cursor: newCursor, killed } = cursor.deleteWordBefore();
+          pushToKillRing(killed, "prepend");
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "y": {
+          const text = getLastKill();
+          if (text.length > 0) {
+            const startOffset = cursor.offset;
+            const newCursor = cursor.insert(text);
+            recordYank(startOffset, text.length);
+            setQueryState(newCursor.text);
+            setCursorOffset(newCursor.offset);
+          }
+          return;
+        }
+        case "g":
+        case "c":
+          if (onCancel) {
+            onCancel();
+            return;
+          }
+      }
+      return;
+    }
+    if (e.meta) {
+      e.preventDefault();
+      switch (e.key.toLowerCase()) {
+        case "b":
+          setCursorOffset(cursor.prevWord().offset);
+          return;
+        case "f":
+          setCursorOffset(cursor.nextWord().offset);
+          return;
+        case "d": {
+          const newCursor = cursor.deleteWordAfter();
+          setQueryState(newCursor.text);
+          setCursorOffset(newCursor.offset);
+          return;
+        }
+        case "y": {
+          const popResult = yankPop();
+          if (popResult) {
+            const { text, start, length } = popResult;
+            const before = query.slice(0, start);
+            const after = query.slice(start + length);
+            const newText = before + text + after;
+            const newOffset = start + text.length;
+            updateYankLength(text.length);
+            setQueryState(newText);
+            setCursorOffset(newOffset);
+          }
+          return;
+        }
+      }
+      return;
+    }
+    if (e.key === "tab") {
+      return;
+    }
+    if (e.key.length >= 1 && !UNHANDLED_SPECIAL_KEYS.has(e.key)) {
+      e.preventDefault();
+      const newCursor = cursor.insert(e.key);
+      setQueryState(newCursor.text);
+      setCursorOffset(newCursor.offset);
+    }
+  };
+  use_input_default((_input, _key, event) => {
+    handleKeyDown(new KeyboardEvent(event.keypress));
+  }, { isActive });
+  return { query, setQuery, cursorOffset, handleKeyDown };
+}
+var import_react, UNHANDLED_SPECIAL_KEYS;
+var init_useSearchInput = __esm(() => {
+  init_src();
+  init_Cursor();
+  init_useTerminalSize();
+  import_react = __toESM(require_react(), 1);
+  UNHANDLED_SPECIAL_KEYS = new Set([
+    "pageup",
+    "pagedown",
+    "insert",
+    "wheelup",
+    "wheeldown",
+    "mouse",
+    "f1",
+    "f2",
+    "f3",
+    "f4",
+    "f5",
+    "f6",
+    "f7",
+    "f8",
+    "f9",
+    "f10",
+    "f11",
+    "f12"
+  ]);
+});
+
+export { useSearchInput, init_useSearchInput };

package/dist/chunk-z7e94hxz.js

@@ -0,0 +1,251 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-eax32zk4.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-fpd1gpt8.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-gmdy2w3z.js";
+import {
+  count,
+  init_array
+} from "./chunk-k7hexw3v.js";
+import {
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-10k5jfc5.js";
+import {
+  init_debug,
+  init_errors,
+  init_log,
+  logError,
+  logForDebugging,
+  toError
+} from "./chunk-s3hafnk3.js";
+import {
+  __toESM
+} from "./chunk-hhsxm2yr.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 };