supipowers 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {

package/src/config/defaults.ts

@@ -33,6 +33,7 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
     compaction: true,
     llmSummarization: false,
     llmThreshold: 16384,
+    enforceRouting: true,
   },
 };
 

package/src/context-mode/detector.ts

@@ -13,14 +13,25 @@ export interface ContextModeStatus {
   };
 }
 
-const TOOL_MAP: Record<string, keyof ContextModeStatus["tools"]> = {
-  ctx_execute: "ctxExecute",
-  ctx_batch_execute: "ctxBatchExecute",
-  ctx_execute_file: "ctxExecuteFile",
-  ctx_index: "ctxIndex",
-  ctx_search: "ctxSearch",
-  ctx_fetch_and_index: "ctxFetchAndIndex",
-};
+/** Suffixes to match against full MCP-namespaced tool names */
+const TOOL_SUFFIXES: Array<[string, keyof ContextModeStatus["tools"]]> = [
+  ["ctx_execute", "ctxExecute"],
+  ["ctx_batch_execute", "ctxBatchExecute"],
+  ["ctx_execute_file", "ctxExecuteFile"],
+  ["ctx_index", "ctxIndex"],
+  ["ctx_search", "ctxSearch"],
+  ["ctx_fetch_and_index", "ctxFetchAndIndex"],
+];
+
+/**
+ * Extract the short tool name from a potentially MCP-namespaced tool name.
+ * MCP tools use the format: mcp__<server>__<tool_name>
+ * Native tools use bare names like: lsp, bash, etc.
+ */
+function getShortName(tool: string): string {
+  const lastSep = tool.lastIndexOf("__");
+  return lastSep >= 0 ? tool.slice(lastSep + 2) : tool;
+}
 
 /** Detect context-mode MCP tool availability from the active tools list */
 export function detectContextMode(activeTools: string[]): ContextModeStatus {
@@ -34,8 +45,13 @@ export function detectContextMode(activeTools: string[]): ContextModeStatus {
   };
 
   for (const tool of activeTools) {
-    const key = TOOL_MAP[tool];
-    if (key) tools[key] = true;
+    const shortName = getShortName(tool);
+    for (const [suffix, key] of TOOL_SUFFIXES) {
+      if (shortName === suffix) {
+        tools[key] = true;
+        break;
+      }
+    }
   }
 
   const available = Object.values(tools).some(Boolean);

package/src/context-mode/hooks.ts

@@ -6,6 +6,7 @@ import { detectContextMode, type ContextModeStatus } from "./detector.js";
 import { EventStore } from "./event-store.js";
 import { extractEvents, extractPromptEvents } from "./event-extractor.js";
 import { buildResumeSnapshot } from "./snapshot-builder.js";
+import { routeToolCall } from "./routing.js";
 import { readFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,19 +14,6 @@ import { fileURLToPath } from "node:url";
 // Cached detection result
 let cachedStatus: ContextModeStatus | null = null;
 
-/** HTTP command patterns for blocking */
-const HTTP_PATTERNS = [
-  /^\s*curl\s/,
-  /^\s*wget\s/,
-  /\bcurl\s+(-[a-zA-Z]*\s+)*https?:\/\//,
-  /\bwget\s+(-[a-zA-Z]*\s+)*https?:\/\//,
-];
-
-function isHttpCommand(command: unknown): boolean {
-  if (typeof command !== "string") return false;
-  return HTTP_PATTERNS.some((p) => p.test(command));
-}
-
 function loadRoutingSkill(): string | null {
   try {
     const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -77,24 +65,14 @@ export function registerContextModeHooks(pi: ExtensionAPI, config: SupipowersCon
     return compressed;
   });
 
-  // Phase 1: Command blocking
+  // Phase 1: Tool routing — block native tools and redirect to ctx_* equivalents
   pi.on("tool_call", (event) => {
-    if (!config.contextMode.blockHttpCommands) return;
-    if (event.toolName !== "bash") return;
-
-    const command = event.input?.command;
-    if (!isHttpCommand(command)) return;
-
-    // Only block if context-mode has a replacement tool
     if (!cachedStatus) cachedStatus = detectContextMode(pi.getActiveTools());
-    if (!cachedStatus.tools.ctxFetchAndIndex) return;
-
-    return {
-      block: true,
-      reason:
-        "Use ctx_fetch_and_index instead of curl/wget. " +
-        "It fetches the URL, indexes the content, and returns a compressed summary.",
-    };
+
+    return routeToolCall(event.toolName, event.input as any, cachedStatus, {
+      enforceRouting: config.contextMode.enforceRouting,
+      blockHttpCommands: config.contextMode.blockHttpCommands,
+    });
   });
 
   // Phase 1: Routing instructions + Phase 2: Prompt event extraction

package/src/context-mode/routing.ts

@@ -0,0 +1,116 @@
+// src/context-mode/routing.ts — Tool routing classification helpers
+import type { ContextModeStatus } from "./detector.js";
+
+/** HTTP command patterns for blocking */
+const HTTP_PATTERNS = [
+  /^\s*curl\s/,
+  /^\s*wget\s/,
+  /\bcurl\s+(-[a-zA-Z]*\s+)*https?:\/\//,
+  /\bwget\s+(-[a-zA-Z]*\s+)*https?:\/\//,
+];
+
+/** Bash commands that are search/find operations */
+const BASH_SEARCH_PATTERNS = [
+  /^\s*find\s+/,
+  /^\s*grep\s+/,
+  /^\s*rg\s+/,
+  /^\s*ag\s+/,
+  /^\s*fd\s+/,
+  /^\s*ack\s+/,
+];
+
+/** Bash commands that are always allowed through (even with piped grep) */
+const BASH_ALLOWED_PREFIXES = [
+  /^\s*git\s/, /^\s*ls\b/, /^\s*mkdir\s/, /^\s*rm\s/, /^\s*mv\s/,
+  /^\s*cp\s/, /^\s*cd\s/, /^\s*echo\s/, /^\s*cat\s/, /^\s*npm\s/,
+  /^\s*yarn\s/, /^\s*pnpm\s/, /^\s*node\s/, /^\s*python/, /^\s*pip\s/,
+  /^\s*touch\s/, /^\s*chmod\s/, /^\s*chown\s/, /^\s*docker\s/,
+  /^\s*brew\s/, /^\s*npx\s/, /^\s*vitest\s/, /^\s*jest\s/, /^\s*tsc\b/,
+];
+
+/** Check if a bash command is an HTTP request (curl/wget) */
+export function isHttpCommand(command: unknown): boolean {
+  if (typeof command !== "string") return false;
+  return HTTP_PATTERNS.some((p) => p.test(command));
+}
+
+/** Check if a bash command is a search/find operation that should be routed to ctx_execute */
+export function isBashSearchCommand(command: unknown): boolean {
+  if (typeof command !== "string") return false;
+  if (BASH_ALLOWED_PREFIXES.some((p) => p.test(command))) return false;
+  return BASH_SEARCH_PATTERNS.some((p) => p.test(command));
+}
+
+/** Check if a Read call is a full-file read (no limit/offset = likely analysis, not edit prep) */
+export function isFullFileRead(input: Record<string, unknown> | undefined): boolean {
+  if (!input) return true;
+  return input.limit == null && input.offset == null;
+}
+
+/** Block result returned by routing functions */
+export interface BlockResult {
+  block: true;
+  reason: string;
+}
+
+/** Route a tool call — returns a block result if the tool should be redirected, undefined otherwise */
+export function routeToolCall(
+  toolName: string,
+  input: Record<string, unknown> | undefined,
+  status: ContextModeStatus,
+  options: { enforceRouting: boolean; blockHttpCommands: boolean },
+): BlockResult | undefined {
+  if (!status.available) return undefined;
+
+  // Grep → block, redirect to ctx_search
+  if (options.enforceRouting && toolName === "grep") {
+    if (!status.tools.ctxSearch) return undefined;
+    return {
+      block: true,
+      reason:
+        'Use ctx_search(queries: ["<pattern>"]) or ctx_batch_execute instead of Grep. ' +
+        "Results are indexed and compressed to save context window.",
+    };
+  }
+
+  // Read (full-file, no limit/offset) → block, redirect to ctx_execute_file
+  if (options.enforceRouting && toolName === "read") {
+    if (!status.tools.ctxExecuteFile) return undefined;
+    if (!isFullFileRead(input)) return undefined;
+    return {
+      block: true,
+      reason:
+        "Use ctx_execute_file(path, language, code) for file analysis instead of Read. " +
+        "If you need to Read before editing, re-call with a limit parameter.",
+    };
+  }
+
+  // Bash routing
+  if (toolName === "bash") {
+    const command = input?.command;
+
+    // Bash search commands → block, redirect to ctx_execute
+    if (options.enforceRouting && isBashSearchCommand(command)) {
+      if (!status.tools.ctxExecute) return undefined;
+      return {
+        block: true,
+        reason:
+          'Use ctx_execute(language: "shell", code: "<command>") instead of Bash for search commands. ' +
+          "For multiple commands, use ctx_batch_execute. Results stay in sandbox and are auto-indexed.",
+      };
+    }
+
+    // Bash HTTP commands → block, redirect to ctx_fetch_and_index
+    if (options.blockHttpCommands && isHttpCommand(command)) {
+      if (!status.tools.ctxFetchAndIndex) return undefined;
+      return {
+        block: true,
+        reason:
+          "Use ctx_fetch_and_index instead of curl/wget. " +
+          "It fetches the URL, indexes the content, and returns a compressed summary.",
+      };
+    }
+  }
+
+  return undefined;
+}

package/src/types.ts

@@ -117,6 +117,8 @@ export interface ContextModeConfig {
   llmSummarization: boolean;
   /** Byte threshold above which LLM summarization is used instead of structural compression (default: 16384) */
   llmThreshold: number;
+  /** Hard-block native search/read tools when ctx_* equivalents are available (default: true) */
+  enforceRouting: boolean;
 }
 
 /** Config shape */