supipowers 1.5.3 → 2.0.1

package/src/tool-catalog/active-tool-planner.ts

@@ -0,0 +1,212 @@
+import { computeActiveServers } from "../mcp/activation.js";
+import type { ServerConfig } from "../mcp/types.js";
+import type { ContextModeLazyToolsConfig } from "../types.js";
+import {
+  BALANCED_KEYWORD_TOOLS,
+  CONTEXT_MODE_TOOL_NAMES,
+  MCPC_MANAGER_TOOL_NAME,
+  isSupiOwnedTool,
+  orderOwnedTools,
+} from "./tool-groups.js";
+
+export interface ActiveToolPlannerDiagnostics {
+  unknownConfiguredTools: string[];
+  unavailableTools: string[];
+  unmatchedTags: string[];
+  missingMcpGatewayTools: string[];
+}
+
+export interface PlanActiveToolsInput {
+  prompt: string;
+  currentActive: string[];
+  allTools: string[];
+  lazyTools: ContextModeLazyToolsConfig;
+  mcpServers?: Record<string, ServerConfig>;
+  pendingTags?: string[];
+  cacheHandlesEnabled?: boolean;
+}
+
+export interface ActiveToolPlan {
+  activeTools: string[];
+  activated: string[];
+  deactivated: string[];
+  diagnostics: ActiveToolPlannerDiagnostics;
+}
+
+const RARE_CONTEXT_TOOLS = new Set(["ctx_stats", "ctx_purge"]);
+
+export function planActiveTools(input: PlanActiveToolsInput): ActiveToolPlan {
+  const registeredOwnedTools = new Set(input.allTools.filter(isSupiOwnedTool));
+  const selectedOwnedTools = new Set<string>();
+  const diagnostics: ActiveToolPlannerDiagnostics = {
+    unknownConfiguredTools: [],
+    unavailableTools: [],
+    unmatchedTags: [],
+    missingMcpGatewayTools: [],
+  };
+
+  const addRegisteredTool = (toolName: string, source: "config" | "policy"): void => {
+    if (!isSupiOwnedTool(toolName)) {
+      if (source === "config") diagnostics.unknownConfiguredTools.push(toolName);
+      return;
+    }
+    if (!registeredOwnedTools.has(toolName)) {
+      if (source === "config") diagnostics.unavailableTools.push(toolName);
+      return;
+    }
+    selectedOwnedTools.add(toolName);
+  };
+
+  for (const toolName of input.lazyTools.alwaysKeep) {
+    addRegisteredTool(toolName, "config");
+  }
+
+  if (input.cacheHandlesEnabled) {
+    addRegisteredTool("ctx_open_cached", "policy");
+  }
+
+  if (input.lazyTools.mode === "conservative") {
+    for (const toolName of CONTEXT_MODE_TOOL_NAMES) {
+      if (!RARE_CONTEXT_TOOLS.has(toolName)) addRegisteredTool(toolName, "policy");
+    }
+    addRegisteredTool(MCPC_MANAGER_TOOL_NAME, "policy");
+  }
+
+  for (const toolName of getTriggeredTools(input.prompt, BALANCED_KEYWORD_TOOLS)) {
+    addRegisteredTool(toolName, "policy");
+  }
+
+  for (const toolName of getTriggeredTools(input.prompt, input.lazyTools.keywordTools)) {
+    addRegisteredTool(toolName, "config");
+  }
+
+
+  const mcpServers = input.mcpServers ?? {};
+  const pendingTags = input.pendingTags ?? [];
+  const knownServerNames = new Set(Object.keys(mcpServers));
+  for (const tag of pendingTags) {
+    if (!knownServerNames.has(tag)) diagnostics.unmatchedTags.push(tag);
+  }
+  for (const serverName of computeActiveServers(mcpServers, input.prompt, pendingTags)) {
+    const gatewayToolName = `mcpc_${serverName}`;
+    if (registeredOwnedTools.has(gatewayToolName)) {
+      selectedOwnedTools.add(gatewayToolName);
+    } else {
+      diagnostics.missingMcpGatewayTools.push(gatewayToolName);
+    }
+  }
+  for (const toolName of getCommandAllowlistTools(input.prompt, input.lazyTools.commandAllowlist)) {
+    addRegisteredTool(toolName, "config");
+  }
+
+  const activeTools = orderPlannedTools({
+    currentActive: input.currentActive,
+    selectedOwnedTools,
+  });
+
+  return {
+    activeTools,
+    activated: activeTools.filter((toolName) => !input.currentActive.includes(toolName)),
+    deactivated: input.currentActive.filter((toolName) => !activeTools.includes(toolName)),
+    diagnostics: dedupeDiagnostics(diagnostics),
+  };
+}
+
+function orderPlannedTools(input: {
+  currentActive: string[];
+  selectedOwnedTools: Set<string>;
+}): string[] {
+  const activeTools: string[] = [];
+  const push = (toolName: string): void => {
+    if (!activeTools.includes(toolName)) activeTools.push(toolName);
+  };
+
+  for (const toolName of input.currentActive) {
+    if (!isSupiOwnedTool(toolName)) push(toolName);
+  }
+
+  for (const toolName of input.currentActive) {
+    if (input.selectedOwnedTools.has(toolName)) push(toolName);
+  }
+
+  const newlySelectedOwnedTools = [...input.selectedOwnedTools].filter(
+    (toolName) => !input.currentActive.includes(toolName),
+  );
+  for (const toolName of orderOwnedTools(newlySelectedOwnedTools)) {
+    push(toolName);
+  }
+
+  return activeTools;
+}
+
+function getTriggeredTools(prompt: string, keywordTools: Record<string, string[]>): string[] {
+  const normalizedPrompt = normalizePrompt(prompt);
+  const triggeredTools: string[] = [];
+
+  if (/https?:\/\/\S+/i.test(prompt)) {
+    triggeredTools.push("ctx_fetch_and_index");
+  }
+  if (/cache:\/\/[a-f0-9]{8,}/i.test(prompt)) {
+    triggeredTools.push("ctx_open_cached");
+  }
+
+  for (const [term, tools] of Object.entries(keywordTools)) {
+    if (literalTermMatches(normalizedPrompt, term)) {
+      triggeredTools.push(...tools);
+    }
+  }
+
+  return triggeredTools;
+}
+
+function getCommandAllowlistTools(
+  prompt: string,
+  commandAllowlist: Record<string, string[]>,
+): string[] {
+  const commandName = parseLeadingCommandName(prompt);
+  if (!commandName) return [];
+  return commandAllowlist[commandName] ?? [];
+}
+
+function parseLeadingCommandName(prompt: string): string | null {
+  const trimmed = prompt.trimStart();
+  if (!trimmed.startsWith("/")) return null;
+  const command = trimmed.slice(1).split(/\s+/, 1)[0]?.toLowerCase();
+  return command || null;
+}
+
+function literalTermMatches(normalizedPrompt: string, rawTerm: string): boolean {
+  const normalizedTerm = normalizePrompt(rawTerm);
+  if (!normalizedTerm) return false;
+  if (/\s/.test(normalizedTerm)) return normalizedPrompt.includes(normalizedTerm);
+  return containsSingleTokenLiteral(normalizedPrompt, normalizedTerm);
+}
+
+function containsSingleTokenLiteral(normalizedPrompt: string, normalizedTerm: string): boolean {
+  let start = normalizedPrompt.indexOf(normalizedTerm);
+  while (start !== -1) {
+    const before = start === 0 ? "" : normalizedPrompt[start - 1];
+    const afterIndex = start + normalizedTerm.length;
+    const after = afterIndex >= normalizedPrompt.length ? "" : normalizedPrompt[afterIndex];
+    if (!isAsciiWordChar(before) && !isAsciiWordChar(after)) return true;
+    start = normalizedPrompt.indexOf(normalizedTerm, start + 1);
+  }
+  return false;
+}
+
+function isAsciiWordChar(char: string): boolean {
+  return /^[A-Za-z0-9_]$/.test(char);
+}
+
+function normalizePrompt(value: string): string {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+function dedupeDiagnostics(diagnostics: ActiveToolPlannerDiagnostics): ActiveToolPlannerDiagnostics {
+  return {
+    unknownConfiguredTools: [...new Set(diagnostics.unknownConfiguredTools)],
+    unavailableTools: [...new Set(diagnostics.unavailableTools)],
+    unmatchedTags: [...new Set(diagnostics.unmatchedTags)],
+    missingMcpGatewayTools: [...new Set(diagnostics.missingMcpGatewayTools)],
+  };
+}

package/src/tool-catalog/tool-groups.ts

@@ -0,0 +1,102 @@
+export const CONTEXT_MODE_TOOL_NAMES = [
+  "ctx_execute",
+  "ctx_execute_file",
+  "ctx_batch_execute",
+  "ctx_index",
+  "ctx_search",
+  "ctx_open_cached",
+  "ctx_fetch_and_index",
+  "ctx_stats",
+  "ctx_purge",
+  "ctx_repomap",
+  "ctx_symbol",
+] as const;
+
+export type ContextModeToolName = (typeof CONTEXT_MODE_TOOL_NAMES)[number];
+
+export const MCPC_MANAGER_TOOL_NAME = "mcpc_manager";
+export const MCPC_TOOL_PREFIX = "mcpc_";
+
+export const OWNED_TOOL_PRIORITY = [
+  "ctx_execute",
+  "ctx_search",
+  "ctx_open_cached",
+  "ctx_batch_execute",
+  "ctx_execute_file",
+  "ctx_fetch_and_index",
+  "ctx_index",
+  "ctx_stats",
+  "ctx_purge",
+  "ctx_repomap",
+  "ctx_symbol",
+  MCPC_MANAGER_TOOL_NAME,
+] as const;
+
+const CONTEXT_MODE_TOOL_SET = new Set<string>(CONTEXT_MODE_TOOL_NAMES);
+const OWNED_PRIORITY_INDEX = new Map<string, number>(
+  OWNED_TOOL_PRIORITY.map((name, index) => [name, index]),
+);
+
+export const BALANCED_KEYWORD_TOOLS: Record<string, string[]> = {
+  search: ["ctx_batch_execute"],
+  grep: ["ctx_batch_execute"],
+  find: ["ctx_batch_execute"],
+  scan: ["ctx_batch_execute"],
+  inspect: ["ctx_batch_execute"],
+  explore: ["ctx_batch_execute"],
+  "analyze repo": ["ctx_batch_execute"],
+  "project-wide": ["ctx_batch_execute"],
+  todo: ["ctx_batch_execute"],
+  references: ["ctx_batch_execute"],
+  "large file": ["ctx_execute_file"],
+  "summarize file": ["ctx_execute_file"],
+  "extract from file": ["ctx_execute_file"],
+  "process file without reading": ["ctx_execute_file"],
+  http: ["ctx_fetch_and_index"],
+  https: ["ctx_fetch_and_index"],
+  curl: ["ctx_fetch_and_index"],
+  wget: ["ctx_fetch_and_index"],
+  "fetch docs": ["ctx_fetch_and_index"],
+  "web page": ["ctx_fetch_and_index"],
+  "index this": ["ctx_index"],
+  "store in knowledge": ["ctx_index"],
+  "make searchable": ["ctx_index"],
+  "context stats": ["ctx_stats"],
+  "token usage": ["ctx_stats"],
+  savings: ["ctx_stats"],
+  "ctx stats": ["ctx_stats"],
+  "ctx purge": ["ctx_purge"],
+  "purge knowledge": ["ctx_purge"],
+  "reset knowledge index": ["ctx_purge"],
+  "open cached": ["ctx_open_cached"],
+  "cached handle": ["ctx_open_cached"],
+  ctx_open_cached: ["ctx_open_cached"],
+  repomap: ["ctx_repomap"],
+  "repo map": ["ctx_repomap"],
+  symbol: ["ctx_symbol"],
+  symbols: ["ctx_symbol"],
+};
+
+export function isContextModeTool(name: string): boolean {
+  return CONTEXT_MODE_TOOL_SET.has(name);
+}
+
+export function isMcpcGatewayTool(name: string): boolean {
+  return name.startsWith(MCPC_TOOL_PREFIX) && /^mcpc_[^_].+/.test(name);
+}
+
+export function isSupiOwnedTool(name: string): boolean {
+  return isContextModeTool(name) || name === MCPC_MANAGER_TOOL_NAME || isMcpcGatewayTool(name);
+}
+
+export function orderOwnedTools(names: Iterable<string>): string[] {
+  return [...new Set([...names].filter(isSupiOwnedTool))].sort((a, b) => {
+    const aPriority = OWNED_PRIORITY_INDEX.get(a);
+    const bPriority = OWNED_PRIORITY_INDEX.get(b);
+
+    if (aPriority !== undefined && bPriority !== undefined) return aPriority - bPriority;
+    if (aPriority !== undefined) return -1;
+    if (bPriority !== undefined) return 1;
+    return a.localeCompare(b);
+  });
+}