@comfanion/usethis_search 4.1.0-dev.1 → 4.1.0-dev.2

package/hooks/tool-substitution.ts

@@ -0,0 +1,261 @@
+/**
+ * Tool Output Substitution Hook
+ *
+ * Intercepts read() tool outputs and replaces them with compact messages
+ * when the file is in the workspace cache.
+ *
+ * Rationale:
+ *   - search() attaches files to workspace cache
+ *   - message.before hook injects full file content into context
+ *   - Tool outputs are redundant — files already visible to AI
+ *   - Substitution saves tokens by replacing big outputs with 1-line summaries
+ *
+ * Behavior:
+ *   - read(file): If file in workspace → "[File is in workspace context]"
+ *   - grep(pattern): NOT substituted (AI needs line numbers and match context)
+ *   - glob(pattern): NOT substituted (discovery tool, paths are metadata)
+ *   - Config flag: substituteToolOutputs (default: true)
+ *   - Sub-agents: Skip substitution (title gen, summarizer)
+ *   - Empty workspace: Skip substitution
+ */
+
+import type { SessionState } from "./types.ts"
+import { workspaceCache, WorkspaceCache } from "../cache/manager.ts"
+
+/**
+ * Create the tool output substitution handler.
+ *
+ * Hook: tool.execute.after
+ * Replaces tool outputs when all matched files are in workspace.
+ *
+ * @param state Session state (tracks sub-agent detection)
+ * @param cache Optional workspace cache (for testing; defaults to singleton)
+ */
+export function createToolSubstitutionHandler(state: SessionState, cache?: WorkspaceCache) {
+  const wsCache = cache || workspaceCache
+
+  return async (
+    input: {
+      tool: string
+      sessionID: string
+      callID: string
+    },
+    output: {
+      title: string
+      output: string
+      metadata: any
+    }
+  ): Promise<void> => {
+    // Skip for sub-agents (title generation, summarization, etc.)
+    if (state.isSubAgent) return
+
+    // ── Track dirty files (edit/write tools modify files on disk) ────────
+    // Mark files as dirty so read() substitution is bypassed until freshen()
+    if (input.tool === "edit" || input.tool === "write" || input.tool === "Edit" || input.tool === "Write") {
+      const filePath = output.metadata?.filePath || output.metadata?.path || extractFilePathFromTitle(output.title)
+      if (filePath && wsCache.has(filePath)) {
+        wsCache.markDirty(filePath)
+      }
+      return // edit/write don't need output substitution
+    }
+
+    // Skip if workspace is empty
+    if (wsCache.size === 0) return
+
+    // Check config flag
+    const wsConfig = wsCache.getConfig()
+    if (wsConfig.substituteToolOutputs === false) return
+
+    // Route to appropriate substitution handler
+    // NOTE: grep/glob NOT substituted — their structured output (file:line:content)
+    // is valuable for AI navigation. Only read() is substituted.
+    switch (input.tool) {
+      case "read":
+        substituteReadOutput(output, wsCache)
+        break
+      // case "grep":  // Disabled — AI needs line numbers and match context
+      // case "glob":  // Disabled — discovery tool, paths are metadata not content
+    }
+  }
+}
+
+/**
+ * Substitute read() output if file is in workspace.
+ *
+ * Input: { filePath: "src/auth.ts", offset?: 0, limit?: 100 }
+ * Output: "export function login(...)\n..."
+ *
+ * If file in workspace AND no offset/limit (full read):
+ *   Replace with: "[File "src/auth.ts" is in workspace context — see <workspace_context> for full content.]"
+ *
+ * If offset/limit present (partial read):
+ *   Keep original (partial reads are not in workspace injection)
+ */
+function substituteReadOutput(output: { title: string; output: string; metadata: any }, cache: WorkspaceCache): void {
+  try {
+    // Extract filePath from metadata or title
+    const filePath = output.metadata?.filePath || extractFilePathFromTitle(output.title)
+    if (!filePath) return
+
+    // Check if this is a partial read (offset/limit present)
+    const isPartialRead = output.metadata?.offset !== undefined || output.metadata?.limit !== undefined
+    if (isPartialRead) return
+
+    // Check if file is in workspace
+    if (!cache.has(filePath)) return
+
+    // Don't substitute if file was modified (dirty) — workspace has stale content
+    if (cache.isDirty(filePath)) return
+
+    // Replace output with compact message
+    output.output = `[File "${filePath}" is in workspace context — see <workspace_context> for full content.]`
+  } catch {
+    // Silently fail — don't break tool execution
+  }
+}
+
+/**
+ * Substitute grep() output if ALL matched files are in workspace.
+ *
+ * Input: { pattern: "auth", include?: "*.ts" }
+ * Output: "src/auth.ts:10:export function login(...)\nsrc/types.ts:5:interface User {...}"
+ *
+ * Parse output to extract file paths, check if ALL are in workspace.
+ * If yes: Replace with "[Pattern "auth" matched N files, all in workspace context:\n- file1\n- file2\n...]"
+ * If partial: Keep original
+ */
+function substituteGrepOutput(output: { title: string; output: string; metadata: any }, cache: WorkspaceCache): void {
+  try {
+    const pattern = output.metadata?.pattern || extractPatternFromTitle(output.title)
+    if (!pattern) return
+
+    // Parse grep output to extract file paths
+    // Format: "path:line:content" or just "path"
+    const filePaths = parseGrepOutput(output.output)
+    if (filePaths.length === 0) return
+
+    // Check if ALL files are in workspace
+    const allInWorkspace = filePaths.every(fp => cache.has(fp))
+    if (!allInWorkspace) return
+
+    // Replace with compact message
+    const fileList = filePaths.map(fp => `- ${fp}`).join("\n")
+    output.output = `[Pattern "${pattern}" matched ${filePaths.length} files, all in workspace context:\n${fileList}]`
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Substitute glob() output if ALL matched files are in workspace.
+ *
+ * Input: { pattern: "src/[glob-pattern].ts" }
+ * Output: "src/auth.ts\nsrc/types.ts\nsrc/utils.ts"
+ *
+ * Parse output (newline-separated paths), check if ALL are in workspace.
+ * If yes: Replace with "[Pattern matched N files, all in workspace context:\n- file1\n- file2\n...]"
+ * If partial: Keep original
+ */
+function substituteGlobOutput(output: { title: string; output: string; metadata: any }, cache: WorkspaceCache): void {
+  try {
+    const pattern = output.metadata?.pattern || extractPatternFromTitle(output.title)
+    if (!pattern) return
+
+    // Parse glob output (newline-separated file paths)
+    const filePaths = parseGlobOutput(output.output)
+    if (filePaths.length === 0) return
+
+    // Check if ALL files are in workspace
+    const allInWorkspace = filePaths.every(fp => cache.has(fp))
+    if (!allInWorkspace) return
+
+    // Replace with compact message
+    const fileList = filePaths.map(fp => `- ${fp}`).join("\n")
+    output.output = `[Pattern "${pattern}" matched ${filePaths.length} files, all in workspace context:\n${fileList}]`
+  } catch {
+    // Silently fail
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Extract file path from read() title.
+ * Title format: "Read file: src/auth.ts" or similar
+ */
+function extractFilePathFromTitle(title: string): string | null {
+  // Try common patterns
+  const patterns = [
+    /Read file:\s*(.+?)(?:\s*\(|$)/,
+    /read\s+(.+?)(?:\s*\(|$)/i,
+    /file:\s*(.+?)(?:\s*\(|$)/i,
+  ]
+
+  for (const pattern of patterns) {
+    const match = title.match(pattern)
+    if (match) {
+      return match[1].trim()
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extract pattern from grep() or glob() title.
+ * Title format: "Search for: auth" or "Find files: src/[pattern].ts" or similar
+ */
+function extractPatternFromTitle(title: string): string | null {
+  // Try common patterns
+  const patterns = [
+    /(?:search|find|pattern|glob).*?:\s*(.+?)(?:\s*\(|$)/i,
+    /(?:search|find|pattern|glob)\s+(.+?)(?:\s*\(|$)/i,
+  ]
+
+  for (const pattern of patterns) {
+    const match = title.match(pattern)
+    if (match) {
+      return match[1].trim()
+    }
+  }
+
+  return null
+}
+
+/**
+ * Parse grep output to extract file paths.
+ *
+ * Format variations:
+ *   - "path:line:content" (standard grep)
+ *   - "path:line" (grep -n without content)
+ *   - "path" (grep -l, list files only)
+ *
+ * Returns unique file paths.
+ */
+function parseGrepOutput(output: string): string[] {
+  const lines = output.split("\n").filter(l => l.trim())
+  const paths = new Set<string>()
+
+  for (const line of lines) {
+    // Extract path (everything before first colon, or entire line if no colon)
+    const colonIndex = line.indexOf(":")
+    const path = colonIndex >= 0 ? line.substring(0, colonIndex) : line
+
+    if (path.trim()) {
+      paths.add(path.trim())
+    }
+  }
+
+  return Array.from(paths)
+}
+
+/**
+ * Parse glob output to extract file paths.
+ *
+ * Format: newline-separated file paths
+ * Returns unique file paths.
+ */
+function parseGlobOutput(output: string): string[] {
+  const lines = output.split("\n").filter(l => l.trim())
+  return Array.from(new Set(lines.map(l => l.trim())))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/usethis_search",
-  "version": "4.1.0-dev.1",
+  "version": "4.1.0-dev.2",
   "description": "OpenCode plugin: semantic search with workspace injection + tool output substitution (v4.1-dev: read() substitution, dirty file tracking)",
   "type": "module",
   "main": "./index.ts",
@@ -27,6 +27,7 @@
     "tools/workspace.ts",
     "cache/manager.ts",
     "hooks/message-before.ts",
+    "hooks/tool-substitution.ts",
     "hooks/types.ts",
     "vectorizer/index.ts",
     "vectorizer/content-cleaner.ts",