oh-my-opencode 2.4.1 → 2.4.3

package/dist/hooks/directory-agents-injector/index.d.ts

@@ -9,6 +9,9 @@ interface ToolExecuteOutput {
     output: string;
     metadata: unknown;
 }
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
 interface EventInput {
     event: {
         type: string;
@@ -16,6 +19,7 @@ interface EventInput {
     };
 }
 export declare function createDirectoryAgentsInjectorHook(ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
     "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
     event: ({ event }: EventInput) => Promise<void>;
 };

package/dist/hooks/directory-readme-injector/index.d.ts

@@ -9,6 +9,9 @@ interface ToolExecuteOutput {
     output: string;
     metadata: unknown;
 }
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
 interface EventInput {
     event: {
         type: string;
@@ -16,6 +19,7 @@ interface EventInput {
     };
 }
 export declare function createDirectoryReadmeInjectorHook(ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
     "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
     event: ({ event }: EventInput) => Promise<void>;
 };

package/dist/hooks/rules-injector/index.d.ts

@@ -9,6 +9,9 @@ interface ToolExecuteOutput {
     output: string;
     metadata: unknown;
 }
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
 interface EventInput {
     event: {
         type: string;
@@ -16,6 +19,7 @@ interface EventInput {
     };
 }
 export declare function createRulesInjectorHook(ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
     "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
     event: ({ event }: EventInput) => Promise<void>;
 };

package/dist/index.js

@@ -3271,8 +3271,7 @@ function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory
       config = { ...config, prompt: config.prompt + envContext };
     }
     if (override) {
-      const { model: _, ...restOverride } = override;
-      config = mergeAgentConfig(config, restOverride);
+      config = mergeAgentConfig(config, override);
     }
     result[name] = config;
   }
@@ -4921,18 +4920,19 @@ function clearInjectedPaths(sessionID) {
 // src/hooks/directory-agents-injector/index.ts
 function createDirectoryAgentsInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchReads = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve2(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve2(ctx.directory, path4);
   }
   function findAgentsMdUp(startDir) {
     const found = [];
@@ -4953,35 +4953,59 @@ function createDirectoryAgentsInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (input.tool.toLowerCase() !== "read")
-      return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const dir = dirname2(filePath);
-    const cache = getSessionCache(input.sessionID);
+    const dir = dirname2(resolved);
+    const cache = getSessionCache(sessionID);
     const agentsPaths = findAgentsMdUp(dir);
-    const toInject = [];
     for (const agentsPath of agentsPaths) {
       const agentsDir = dirname2(agentsPath);
       if (cache.has(agentsDir))
         continue;
       try {
         const content = readFileSync5(agentsPath, "utf-8");
-        toInject.push({ path: agentsPath, content });
+        output.output += `
+
+[Directory Context: ${agentsPath}]
+${content}`;
         cache.add(agentsDir);
       } catch {}
     }
-    if (toInject.length === 0)
+    saveInjectedPaths(sessionID, cache);
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
       return;
-    for (const { path: path4, content } of toInject) {
-      output.output += `
-
-[Directory Context: ${path4}]
-${content}`;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const readFilePaths = [];
+    for (const call of args.tool_calls) {
+      if (call.tool.toLowerCase() === "read" && call.parameters?.filePath) {
+        readFilePaths.push(call.parameters.filePath);
+      }
+    }
+    if (readFilePaths.length > 0) {
+      pendingBatchReads.set(input.callID, readFilePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (toolName === "read") {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchReads.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchReads.delete(input.callID);
+      }
     }
-    saveInjectedPaths(input.sessionID, cache);
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -5001,6 +5025,7 @@ ${content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
@@ -5062,18 +5087,19 @@ function clearInjectedPaths2(sessionID) {
 // src/hooks/directory-readme-injector/index.ts
 function createDirectoryReadmeInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchReads = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve3(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve3(ctx.directory, path4);
   }
   function findReadmeMdUp(startDir) {
     const found = [];
@@ -5094,35 +5120,59 @@ function createDirectoryReadmeInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (input.tool.toLowerCase() !== "read")
-      return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const dir = dirname3(filePath);
-    const cache = getSessionCache(input.sessionID);
+    const dir = dirname3(resolved);
+    const cache = getSessionCache(sessionID);
     const readmePaths = findReadmeMdUp(dir);
-    const toInject = [];
     for (const readmePath of readmePaths) {
       const readmeDir = dirname3(readmePath);
       if (cache.has(readmeDir))
         continue;
       try {
         const content = readFileSync7(readmePath, "utf-8");
-        toInject.push({ path: readmePath, content });
+        output.output += `
+
+[Project README: ${readmePath}]
+${content}`;
         cache.add(readmeDir);
       } catch {}
     }
-    if (toInject.length === 0)
+    saveInjectedPaths2(sessionID, cache);
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
       return;
-    for (const { path: path4, content } of toInject) {
-      output.output += `
-
-[Project README: ${path4}]
-${content}`;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const readFilePaths = [];
+    for (const call of args.tool_calls) {
+      if (call.tool.toLowerCase() === "read" && call.parameters?.filePath) {
+        readFilePaths.push(call.parameters.filePath);
+      }
+    }
+    if (readFilePaths.length > 0) {
+      pendingBatchReads.set(input.callID, readFilePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (toolName === "read") {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchReads.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchReads.delete(input.callID);
+      }
     }
-    saveInjectedPaths2(input.sessionID, cache);
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -5142,6 +5192,7 @@ ${content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
@@ -6100,11 +6151,22 @@ function createPreemptiveCompactionHook(ctx, options) {
       await ctx.client.tui.showToast({
         body: {
           title: "Compaction Complete",
-          message: "Session compacted successfully",
+          message: "Session compacted successfully. Resuming...",
           variant: "success",
           duration: 2000
         }
       }).catch(() => {});
+      state2.compactionInProgress.delete(sessionID);
+      setTimeout(async () => {
+        try {
+          await ctx.client.session.promptAsync({
+            path: { id: sessionID },
+            body: { parts: [{ type: "text", text: "Continue" }] },
+            query: { directory: ctx.directory }
+          });
+        } catch {}
+      }, 500);
+      return;
     } catch (err) {
       log("[preemptive-compaction] compaction failed", { sessionID, error: err });
     } finally {
@@ -7740,29 +7802,28 @@ function clearInjectedRules(sessionID) {
 var TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
 function createRulesInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchFiles = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedRules(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve4(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve4(ctx.directory, path4);
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (!TRACKED_TOOLS.includes(input.tool.toLowerCase()))
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
-      return;
-    const projectRoot = findProjectRoot(filePath);
-    const cache2 = getSessionCache(input.sessionID);
+    const projectRoot = findProjectRoot(resolved);
+    const cache2 = getSessionCache(sessionID);
     const home = homedir10();
-    const ruleFileCandidates = findRuleFiles(projectRoot, home, filePath);
+    const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved);
     const toInject = [];
     for (const candidate of ruleFileCandidates) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
@@ -7770,7 +7831,7 @@ function createRulesInjectorHook(ctx) {
       try {
         const rawContent = readFileSync10(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
-        const matchResult = shouldApplyRule(metadata, filePath, projectRoot);
+        const matchResult = shouldApplyRule(metadata, resolved, projectRoot);
         if (!matchResult.applies)
           continue;
         const contentHash = createContentHash(body);
@@ -7797,7 +7858,46 @@ function createRulesInjectorHook(ctx) {
 [Match: ${rule.matchReason}]
 ${rule.content}`;
     }
-    saveInjectedRules(input.sessionID, cache2);
+    saveInjectedRules(sessionID, cache2);
+  }
+  function extractFilePathFromToolCall(call) {
+    const params = call.parameters;
+    return params?.filePath ?? params?.file_path ?? params?.path;
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
+      return;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const filePaths = [];
+    for (const call of args.tool_calls) {
+      if (TRACKED_TOOLS.includes(call.tool.toLowerCase())) {
+        const filePath = extractFilePathFromToolCall(call);
+        if (filePath) {
+          filePaths.push(filePath);
+        }
+      }
+    }
+    if (filePaths.length > 0) {
+      pendingBatchFiles.set(input.callID, filePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (TRACKED_TOOLS.includes(toolName)) {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchFiles.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchFiles.delete(input.callID);
+      }
+    }
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -7817,6 +7917,7 @@ ${rule.content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
@@ -27826,6 +27927,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await claudeCodeHooks["tool.execute.before"](input, output);
       await nonInteractiveEnv?.["tool.execute.before"](input, output);
       await commentChecker?.["tool.execute.before"](input, output);
+      await directoryAgentsInjector?.["tool.execute.before"]?.(input, output);
+      await directoryReadmeInjector?.["tool.execute.before"]?.(input, output);
+      await rulesInjector?.["tool.execute.before"]?.(input, output);
       if (input.tool === "task") {
         const args = output.args;
         const subagentType = args.subagent_type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",