supipowers 0.6.1 → 0.7.1

package/bin/install.mjs

@@ -83,6 +83,11 @@ function isInstalled(binary) {
   return result.status === 0;
 }
 
+// ── CLI Flags ────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const skipLsp = args.includes("--skip-lsp");
+
 // ── Main ─────────────────────────────────────────────────────
 
 async function main() {
@@ -191,41 +196,45 @@ async function main() {
     }
   }
 
-  // ── Step 3: LSP setup (optional) ──────────────────────────
-
-  const lspSpinner = spinner();
-  lspSpinner.start("Checking installed LSP servers...");
-  const lspOptions = LSP_SERVERS.map((srv) => {
-    const installed = isInstalled(srv.server);
-    return {
-      value: srv,
-      label: srv.language,
-      hint: installed ? `${srv.server} (installed)` : srv.server,
-    };
-  });
-  const installedCount = lspOptions.filter((o) => o.hint.includes("(installed)")).length;
-  lspSpinner.stop(`Found ${installedCount}/${LSP_SERVERS.length} LSP servers installed`);
+  // ── Step 3: LSP setup (optional, skipped with --skip-lsp) ──
 
-  const selected = await multiselect({
-    message: "Install LSP servers for better code intelligence?",
-    options: lspOptions,
-    required: false,
-  });
+  if (skipLsp) {
+    note("LSP setup skipped (--skip-lsp)", "LSP");
+  } else {
+    const lspSpinner = spinner();
+    lspSpinner.start("Checking installed LSP servers...");
+    const lspOptions = LSP_SERVERS.map((srv) => {
+      const installed = isInstalled(srv.server);
+      return {
+        value: srv,
+        label: srv.language,
+        hint: installed ? `${srv.server} (installed)` : srv.server,
+      };
+    });
+    const installedCount = lspOptions.filter((o) => o.hint.includes("(installed)")).length;
+    lspSpinner.stop(`Found ${installedCount}/${LSP_SERVERS.length} LSP servers installed`);
 
-  if (!isCancel(selected) && selected.length > 0) {
-    for (const srv of selected) {
-      if (isInstalled(srv.server)) {
-        note(`${srv.server} is already installed, skipping.`, srv.language);
-        continue;
-      }
-      const ls = spinner();
-      ls.start(`Installing ${srv.server}...`);
-      const [cmd, ...args] = srv.installCmd.split(" ");
-      const r = run(cmd, args);
-      if (r.status !== 0) {
-        ls.stop(`Failed to install ${srv.server} — you can install manually: ${srv.installCmd}`);
-      } else {
-        ls.stop(`${srv.server} installed`);
+    const selected = await multiselect({
+      message: "Install LSP servers for better code intelligence?",
+      options: lspOptions,
+      required: false,
+    });
+
+    if (!isCancel(selected) && selected.length > 0) {
+      for (const srv of selected) {
+        if (isInstalled(srv.server)) {
+          note(`${srv.server} is already installed, skipping.`, srv.language);
+          continue;
+        }
+        const ls = spinner();
+        ls.start(`Installing ${srv.server}...`);
+        const [cmd, ...installArgs] = srv.installCmd.split(" ");
+        const r = run(cmd, installArgs);
+        if (r.status !== 0) {
+          ls.stop(`Failed to install ${srv.server} — you can install manually: ${srv.installCmd}`);
+        } else {
+          ls.stop(`${srv.server} installed`);
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "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/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,16 @@ 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;
+    // Always re-detect: MCP tools may load after extension init
+    const status = detectContextMode(pi.getActiveTools());
+    cachedStatus = status;
 
-    // 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, status, {
+      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,138 @@
+// 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.",
+    };
+  }
+
+  // Find/Glob → block, redirect to ctx_execute or ctx_batch_execute
+  if (options.enforceRouting && toolName === "find") {
+    if (!status.tools.ctxExecute) return undefined;
+    return {
+      block: true,
+      reason:
+        'Use ctx_execute(language: "shell", code: "find ...") or ctx_batch_execute instead of Find/Glob. ' +
+        "Results are indexed and compressed to save context window.",
+    };
+  }
+
+  // Fetch/WebFetch → block, redirect to ctx_fetch_and_index
+  if (toolName === "fetch" || toolName === "web_fetch") {
+    if (!status.tools.ctxFetchAndIndex) return undefined;
+    return {
+      block: true,
+      reason:
+        "Use ctx_fetch_and_index instead of Fetch/WebFetch. " +
+        "It fetches the URL, indexes the content, and returns a compressed summary.",
+    };
+  }
+
+  // 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 */