oh-my-opencode 0.1.10 → 0.1.11

package/dist/hooks/comment-checker/detector.d.ts

@@ -1,3 +1,4 @@
 import type { CommentInfo } from "./types";
+export declare function warmupCommonLanguages(): void;
 export declare function isSupportedFile(filePath: string): boolean;
 export declare function detectComments(filePath: string, content: string, includeDocstrings?: boolean): Promise<CommentInfo[]>;

package/dist/index.js

@@ -4122,6 +4122,149 @@ function getLanguageByExtension(filePath) {
 }
 
 // src/hooks/comment-checker/detector.ts
+import * as fs2 from "fs";
+var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE = "/tmp/comment-checker-debug.log";
+function debugLog(...args2) {
+  if (DEBUG) {
+    const msg = `[${new Date().toISOString()}] [comment-checker:detector] ${args2.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
+`;
+    fs2.appendFileSync(DEBUG_FILE, msg);
+  }
+}
+var parserClass = null;
+var parserInitPromise = null;
+var languageCache = new Map;
+var LANGUAGE_NAME_MAP = {
+  golang: "go",
+  csharp: "c_sharp",
+  cpp: "cpp"
+};
+var COMMON_LANGUAGES = [
+  "python",
+  "typescript",
+  "javascript",
+  "tsx",
+  "go",
+  "rust",
+  "java"
+];
+async function initParserClass() {
+  if (parserClass)
+    return;
+  if (parserInitPromise) {
+    await parserInitPromise;
+    return;
+  }
+  parserInitPromise = (async () => {
+    debugLog("importing web-tree-sitter...");
+    parserClass = (await Promise.resolve().then(() => __toESM(require_tree_sitter(), 1))).default;
+    const treeSitterWasmPath = __require.resolve("/home/runner/work/oh-my-opencode/oh-my-opencode/node_modules/web-tree-sitter/tree-sitter.wasm");
+    debugLog("wasm path:", treeSitterWasmPath);
+    await parserClass.init({
+      locateFile: () => treeSitterWasmPath
+    });
+    debugLog("Parser class initialized");
+  })();
+  await parserInitPromise;
+}
+async function getParser() {
+  await initParserClass();
+  return new parserClass;
+}
+async function loadLanguageWasm(langName) {
+  const mappedLang = LANGUAGE_NAME_MAP[langName] || langName;
+  try {
+    const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${langName}.wasm`);
+    return wasmModule.default;
+  } catch {
+    if (mappedLang !== langName) {
+      try {
+        const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${mappedLang}.wasm`);
+        return wasmModule.default;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+async function getLanguage(langName) {
+  const cached = languageCache.get(langName);
+  if (cached) {
+    if (cached.initPromise) {
+      await cached.initPromise;
+    }
+    cached.lastUsedAt = Date.now();
+    debugLog("using cached language:", langName);
+    return cached.language;
+  }
+  debugLog("loading language wasm:", langName);
+  const initPromise2 = (async () => {
+    await initParserClass();
+    const wasmPath = await loadLanguageWasm(langName);
+    if (!wasmPath) {
+      debugLog("failed to load language wasm:", langName);
+      return null;
+    }
+    return await parserClass.Language.load(wasmPath);
+  })();
+  languageCache.set(langName, {
+    language: null,
+    initPromise: initPromise2,
+    isInitializing: true,
+    lastUsedAt: Date.now()
+  });
+  const language = await initPromise2;
+  const managed = languageCache.get(langName);
+  if (managed) {
+    managed.language = language;
+    managed.initPromise = undefined;
+    managed.isInitializing = false;
+  }
+  debugLog("language loaded and cached:", langName);
+  return language;
+}
+function warmupLanguage(langName) {
+  if (languageCache.has(langName))
+    return;
+  debugLog("warming up language (background):", langName);
+  const initPromise2 = (async () => {
+    await initParserClass();
+    const wasmPath = await loadLanguageWasm(langName);
+    if (!wasmPath)
+      return null;
+    return await parserClass.Language.load(wasmPath);
+  })();
+  languageCache.set(langName, {
+    language: null,
+    initPromise: initPromise2,
+    isInitializing: true,
+    lastUsedAt: Date.now()
+  });
+  initPromise2.then((language) => {
+    const managed = languageCache.get(langName);
+    if (managed) {
+      managed.language = language;
+      managed.initPromise = undefined;
+      managed.isInitializing = false;
+      debugLog("warmup complete:", langName);
+    }
+  }).catch((err2) => {
+    debugLog("warmup failed:", langName, err2);
+    languageCache.delete(langName);
+  });
+}
+function warmupCommonLanguages() {
+  debugLog("starting background warmup for common languages...");
+  initParserClass().then(() => {
+    for (const lang of COMMON_LANGUAGES) {
+      warmupLanguage(lang);
+    }
+  }).catch((err2) => {
+    debugLog("warmup initialization failed:", err2);
+  });
+}
 function isSupportedFile(filePath) {
   return getLanguageByExtension(filePath) !== null;
 }
@@ -4145,40 +4288,24 @@ function determineCommentType(text, nodeType) {
   return "line";
 }
 async function detectComments(filePath, content, includeDocstrings = true) {
+  debugLog("detectComments called:", { filePath, contentLength: content.length });
   const langName = getLanguageByExtension(filePath);
   if (!langName) {
+    debugLog("unsupported language for:", filePath);
     return [];
   }
   const queryPattern = QUERY_TEMPLATES[langName];
   if (!queryPattern) {
+    debugLog("no query pattern for:", langName);
     return [];
   }
   try {
-    const Parser2 = (await Promise.resolve().then(() => __toESM(require_tree_sitter(), 1))).default;
-    const treeSitterWasmPath = __require.resolve("/home/runner/work/oh-my-opencode/oh-my-opencode/node_modules/web-tree-sitter/tree-sitter.wasm");
-    await Parser2.init({
-      locateFile: () => treeSitterWasmPath
-    });
-    const parser = new Parser2;
-    let wasmPath;
-    try {
-      const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${langName}.wasm`);
-      wasmPath = wasmModule.default;
-    } catch {
-      const languageMap = {
-        golang: "go",
-        csharp: "c_sharp",
-        cpp: "cpp"
-      };
-      const mappedLang = languageMap[langName] || langName;
-      try {
-        const wasmModule = await import(`tree-sitter-wasms/out/tree-sitter-${mappedLang}.wasm`);
-        wasmPath = wasmModule.default;
-      } catch {
-        return [];
-      }
+    const parser = await getParser();
+    const language = await getLanguage(langName);
+    if (!language) {
+      debugLog("language not available:", langName);
+      return [];
     }
-    const language = await Parser2.Language.load(wasmPath);
     parser.setLanguage(language);
     const tree = parser.parse(content);
     const comments = [];
@@ -4230,8 +4357,10 @@ async function detectComments(filePath, content, includeDocstrings = true) {
       }
     }
     comments.sort((a, b) => a.lineNumber - b.lineNumber);
+    debugLog("detected comments:", comments.length);
     return comments;
-  } catch {
+  } catch (err2) {
+    debugLog("detectComments failed:", err2);
     return [];
   }
 }
@@ -4343,6 +4472,16 @@ function formatHookMessage(fileCommentsList) {
 `;
 }
 // src/hooks/comment-checker/index.ts
+import * as fs3 from "fs";
+var DEBUG2 = process.env.COMMENT_CHECKER_DEBUG === "1";
+var DEBUG_FILE2 = "/tmp/comment-checker-debug.log";
+function debugLog2(...args2) {
+  if (DEBUG2) {
+    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args2.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
+`;
+    fs3.appendFileSync(DEBUG_FILE2, msg);
+  }
+}
 var pendingCalls = new Map;
 var PENDING_CALL_TTL = 60000;
 function cleanupOldPendingCalls() {
@@ -4355,20 +4494,28 @@ function cleanupOldPendingCalls() {
 }
 setInterval(cleanupOldPendingCalls, 1e4);
 function createCommentCheckerHooks() {
+  debugLog2("createCommentCheckerHooks called");
+  warmupCommonLanguages();
   return {
     "tool.execute.before": async (input, output) => {
+      debugLog2("tool.execute.before:", { tool: input.tool, callID: input.callID, args: output.args });
       const toolLower = input.tool.toLowerCase();
       if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
+        debugLog2("skipping non-write/edit tool:", toolLower);
         return;
       }
       const filePath = output.args.filePath ?? output.args.file_path ?? output.args.path;
       const content = output.args.content;
+      debugLog2("extracted filePath:", filePath);
       if (!filePath) {
+        debugLog2("no filePath found");
         return;
       }
       if (!isSupportedFile(filePath)) {
+        debugLog2("unsupported file:", filePath);
         return;
       }
+      debugLog2("registering pendingCall:", { callID: input.callID, filePath, tool: toolLower });
       pendingCalls.set(input.callID, {
         filePath,
         content,
@@ -4378,25 +4525,38 @@ function createCommentCheckerHooks() {
       });
     },
     "tool.execute.after": async (input, output) => {
+      debugLog2("tool.execute.after:", { tool: input.tool, callID: input.callID });
       const pendingCall = pendingCalls.get(input.callID);
       if (!pendingCall) {
+        debugLog2("no pendingCall found for:", input.callID);
         return;
       }
       pendingCalls.delete(input.callID);
-      if (output.output.toLowerCase().includes("error")) {
+      debugLog2("processing pendingCall:", pendingCall);
+      const outputLower = output.output.toLowerCase();
+      const isToolFailure = outputLower.includes("error:") || outputLower.includes("failed to") || outputLower.includes("could not") || outputLower.startsWith("error");
+      if (isToolFailure) {
+        debugLog2("skipping due to tool failure in output");
         return;
       }
       try {
         let content;
         if (pendingCall.content) {
           content = pendingCall.content;
+          debugLog2("using content from args");
         } else {
+          debugLog2("reading file:", pendingCall.filePath);
           const file = Bun.file(pendingCall.filePath);
           content = await file.text();
+          debugLog2("file content length:", content.length);
         }
+        debugLog2("calling detectComments...");
         const rawComments = await detectComments(pendingCall.filePath, content);
+        debugLog2("raw comments:", rawComments.length);
         const filteredComments = applyFilters(rawComments);
+        debugLog2("filtered comments:", filteredComments.length);
         if (filteredComments.length === 0) {
+          debugLog2("no comments after filtering");
           return;
         }
         const fileComments = [
@@ -4406,10 +4566,13 @@ function createCommentCheckerHooks() {
           }
         ];
         const message = formatHookMessage(fileComments);
+        debugLog2("appending message to output");
         output.output += `
 
 ${message}`;
-      } catch {}
+      } catch (err2) {
+        debugLog2("tool.execute.after failed:", err2);
+      }
     }
   };
 }
@@ -18954,7 +19117,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   agents: AgentOverridesSchema.optional()
 });
 // src/index.ts
-import * as fs2 from "fs";
+import * as fs4 from "fs";
 import * as path from "path";
 function loadPluginConfig(directory) {
   const configPaths = [
@@ -18963,8 +19126,8 @@ function loadPluginConfig(directory) {
   ];
   for (const configPath of configPaths) {
     try {
-      if (fs2.existsSync(configPath)) {
-        const content = fs2.readFileSync(configPath, "utf-8");
+      if (fs4.existsSync(configPath)) {
+        const content = fs4.readFileSync(configPath, "utf-8");
         const rawConfig = JSON.parse(content);
         const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
         if (!result.success) {

package/package.json

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