oh-my-opencode 0.1.23 → 0.1.25

package/README.ko.md

@@ -136,6 +136,11 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
 - **Context Window Monitor**: [컨텍스트 윈도우 불안 관리](https://agentic-patterns.com/patterns/context-window-anxiety-management/) 패턴을 구현합니다.
   - 사용량이 70%를 넘으면 에이전트에게 아직 토큰이 충분하다고 상기시켜, 급하게 불완전한 작업을 하는 것을 완화합니다.
 - **Session Notification**: 에이전트가 작업을 마치면 OS 네이티브 알림을 보냅니다 (macOS, Linux, Windows).
+- **Session Recovery**: API 에러로부터 자동으로 복구하여 세션 안정성을 보장합니다. 네 가지 시나리오를 처리합니다:
+  - **Tool Result Missing**: `tool_use` 블록이 있지만 `tool_result`가 없을 때 (ESC 인터럽트) → "cancelled" tool result 주입
+  - **Thinking Block Order**: thinking 블록이 첫 번째여야 하는데 아닐 때 → 빈 thinking 블록 추가
+  - **Thinking Disabled Violation**: thinking 이 비활성화인데 thinking 블록이 있을 때 → thinking 블록 제거
+  - **Empty Content Message**: 메시지가 thinking/meta 블록만 있고 실제 내용이 없을 때 → 파일시스템을 통해 "(interrupted)" 텍스트 주입
 - **Comment Checker**: 코드 수정 후 불필요한 주석을 감지하여 보고합니다. BDD 패턴, 지시어, 독스트링 등 유효한 주석은 똑똑하게 제외하고, AI가 남긴 흔적을 제거하여 코드를 깨끗하게 유지합니다.
 
 ### Agents

package/README.md

@@ -132,7 +132,11 @@ I believe in the right tool for the job. For your wallet's sake, use CLIProxyAPI
 - **Todo Continuation Enforcer**: Forces the agent to complete all tasks before exiting. Eliminates the common LLM issue of "giving up halfway".
 - **Context Window Monitor**: Implements [Context Window Anxiety Management](https://agentic-patterns.com/patterns/context-window-anxiety-management/). When context usage exceeds 70%, it reminds the agent that resources are sufficient, preventing rushed or low-quality output.
 - **Session Notification**: Sends a native OS notification when the job is done (macOS, Linux, Windows).
-- **Session Recovery**: Automatically recovers from API errors by injecting missing tool results and correcting thinking block violations, ensuring session stability.
+- **Session Recovery**: Automatically recovers from API errors, ensuring session stability. Handles four scenarios:
+  - **Tool Result Missing**: When `tool_use` block exists without `tool_result` (ESC interrupt) → injects "cancelled" tool results
+  - **Thinking Block Order**: When thinking block must be first but isn't → prepends empty thinking block
+  - **Thinking Disabled Violation**: When thinking blocks exist but thinking is disabled → strips thinking blocks
+  - **Empty Content Message**: When message has only thinking/meta blocks without actual content → injects "(interrupted)" text via filesystem
 - **Comment Checker**: Detects and reports unnecessary comments after code modifications. Smartly ignores valid patterns (BDD, directives, docstrings, shebangs) to keep the codebase clean from AI-generated artifacts.
 
 ### Agents

package/dist/hooks/session-recovery.d.ts

@@ -12,7 +12,7 @@
  *    - Recovery: strip thinking/redacted_thinking blocks
  *
  * 4. Empty content message (non-empty content required)
- *    - Recovery: delete the empty message via revert
+ *    - Recovery: inject text part directly via filesystem
  */
 import type { PluginInput } from "@opencode-ai/plugin";
 interface MessageInfo {

package/dist/index.js

@@ -790,6 +790,32 @@ ${CONTEXT_REMINDER}
   };
 }
 // src/hooks/session-recovery.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// node_modules/xdg-basedir/index.js
+import os from "os";
+import path from "path";
+var homeDirectory = os.homedir();
+var { env } = process;
+var xdgData = env.XDG_DATA_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "share") : undefined);
+var xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path.join(homeDirectory, ".config") : undefined);
+var xdgState = env.XDG_STATE_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "state") : undefined);
+var xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? path.join(homeDirectory, ".cache") : undefined);
+var xdgRuntime = env.XDG_RUNTIME_DIR || undefined;
+var xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
+if (xdgData) {
+  xdgDataDirectories.unshift(xdgData);
+}
+var xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) {
+  xdgConfigDirectories.unshift(xdgConfig);
+}
+
+// src/hooks/session-recovery.ts
+var OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+var MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message");
+var PART_STORAGE = join(OPENCODE_STORAGE, "part");
 function getErrorMessage(error) {
   if (!error)
     return "";
@@ -894,80 +920,121 @@ async function recoverThinkingDisabledViolation(client, sessionID, failedAssista
   return false;
 }
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
-function hasNonEmptyOutput(msg) {
-  const parts = msg.parts;
-  if (!parts || parts.length === 0)
-    return false;
-  return parts.some((p) => {
-    if (THINKING_TYPES.has(p.type))
-      return false;
-    if (p.type === "step-start" || p.type === "step-finish")
+var META_TYPES = new Set(["step-start", "step-finish"]);
+function generatePartId() {
+  const timestamp = Date.now().toString(16);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `prt_${timestamp}${random}`;
+}
+function getMessageDir(sessionID) {
+  const projectHash = readdirSync(MESSAGE_STORAGE).find((dir) => {
+    const sessionDir = join(MESSAGE_STORAGE, dir);
+    try {
+      return readdirSync(sessionDir).some((f) => f.includes(sessionID.replace("ses_", "")));
+    } catch {
       return false;
-    if (p.type === "text" && p.text && p.text.trim())
-      return true;
-    if (p.type === "tool_use" && p.id)
-      return true;
-    if (p.type === "tool_result")
-      return true;
-    return false;
+    }
   });
+  if (projectHash) {
+    return join(MESSAGE_STORAGE, projectHash, sessionID);
+  }
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync(sessionPath)) {
+      return sessionPath;
+    }
+  }
+  return "";
 }
-function findEmptyContentMessage(msgs) {
-  for (let i = 0;i < msgs.length; i++) {
-    const msg = msgs[i];
-    const isLastMessage = i === msgs.length - 1;
-    const isAssistant = msg.info?.role === "assistant";
-    if (isLastMessage && isAssistant)
+function readMessagesFromStorage(sessionID) {
+  const messageDir = getMessageDir(sessionID);
+  if (!messageDir || !existsSync(messageDir))
+    return [];
+  const messages = [];
+  for (const file of readdirSync(messageDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync(join(messageDir, file), "utf-8");
+      messages.push(JSON.parse(content));
+    } catch {
       continue;
-    if (!hasNonEmptyOutput(msg)) {
-      return msg;
     }
   }
-  return null;
+  return messages.sort((a, b) => a.id.localeCompare(b.id));
 }
-async function recoverEmptyContentMessage(client, sessionID, failedAssistantMsg, directory) {
-  try {
-    const messagesResp = await client.session.messages({
-      path: { id: sessionID },
-      query: { directory }
-    });
-    const msgs = messagesResp.data;
-    if (!msgs || msgs.length === 0)
-      return false;
-    const emptyMsg = findEmptyContentMessage(msgs) || failedAssistantMsg;
-    const messageID = emptyMsg.info?.id;
-    if (!messageID)
-      return false;
-    const existingParts = emptyMsg.parts || [];
-    const hasOnlyThinkingOrMeta = existingParts.length > 0 && existingParts.every((p) => THINKING_TYPES.has(p.type) || p.type === "step-start" || p.type === "step-finish");
-    if (hasOnlyThinkingOrMeta) {
-      const strippedParts = [{ type: "text", text: "(interrupted)" }];
-      try {
-        await client.message?.update?.({
-          path: { id: messageID },
-          body: { parts: strippedParts }
-        });
-        return true;
-      } catch {}
-      try {
-        await client.session.patch?.({
-          path: { id: sessionID },
-          body: { messageID, parts: strippedParts }
-        });
-        return true;
-      } catch {}
+function readPartsFromStorage(messageID) {
+  const partDir = join(PART_STORAGE, messageID);
+  if (!existsSync(partDir))
+    return [];
+  const parts = [];
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const content = readFileSync(join(partDir, file), "utf-8");
+      parts.push(JSON.parse(content));
+    } catch {
+      continue;
     }
-    const revertTargetID = emptyMsg.info?.parentID || messageID;
-    await client.session.revert({
-      path: { id: sessionID },
-      body: { messageID: revertTargetID },
-      query: { directory }
-    });
+  }
+  return parts;
+}
+function injectTextPartToStorage(sessionID, messageID, text) {
+  const partDir = join(PART_STORAGE, messageID);
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true });
+  }
+  const partId = generatePartId();
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "text",
+    text
+  };
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
     return true;
   } catch {
     return false;
   }
 }
+function findEmptyContentMessageFromStorage(sessionID) {
+  const messages = readMessagesFromStorage(sessionID);
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant")
+      continue;
+    const isLastMessage = i === messages.length - 1;
+    if (isLastMessage)
+      continue;
+    const parts = readPartsFromStorage(msg.id);
+    const hasContent = parts.some((p) => {
+      if (THINKING_TYPES.has(p.type))
+        return false;
+      if (META_TYPES.has(p.type))
+        return false;
+      if (p.type === "text" && p.text?.trim())
+        return true;
+      if (p.type === "tool_use")
+        return true;
+      if (p.type === "tool_result")
+        return true;
+      return false;
+    });
+    if (!hasContent && parts.length > 0) {
+      return msg.id;
+    }
+  }
+  return null;
+}
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
+  const emptyMessageID = findEmptyContentMessageFromStorage(sessionID) || failedAssistantMsg.info?.id;
+  if (!emptyMessageID)
+    return false;
+  return injectTextPartToStorage(sessionID, emptyMessageID, "(interrupted)");
+}
 async function fallbackRevertStrategy(client, sessionID, failedAssistantMsg, directory) {
   const parentMsgID = failedAssistantMsg.info?.parentID;
   const messagesResp = await client.session.messages({
@@ -1093,14 +1160,14 @@ function createSessionRecoveryHook(ctx) {
 // src/hooks/comment-checker/cli.ts
 var {spawn: spawn2 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
-import { dirname, join as join2 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 import * as fs from "fs";
 
 // src/hooks/comment-checker/downloader.ts
 var {spawn } = globalThis.Bun;
-import { existsSync, mkdirSync, chmodSync, unlinkSync, appendFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync, unlinkSync, appendFileSync } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 import { createRequire } from "module";
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
@@ -1121,16 +1188,16 @@ var PLATFORM_MAP = {
   "win32-x64": { os: "windows", arch: "amd64", ext: "zip" }
 };
 function getCacheDir() {
-  const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join(homedir(), ".cache");
-  return join(base, "oh-my-opencode", "bin");
+  const xdgCache2 = process.env.XDG_CACHE_HOME;
+  const base = xdgCache2 || join2(homedir(), ".cache");
+  return join2(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join(getCacheDir(), getBinaryName());
-  return existsSync(binaryPath) ? binaryPath : null;
+  const binaryPath = join2(getCacheDir(), getBinaryName());
+  return existsSync2(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -1177,26 +1244,26 @@ async function downloadCommentChecker() {
   }
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join(cacheDir, binaryName);
-  if (existsSync(binaryPath)) {
+  const binaryPath = join2(cacheDir, binaryName);
+  if (existsSync2(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
   const version = getPackageVersion();
-  const { os, arch, ext } = platformInfo;
-  const assetName = `comment-checker_v${version}_${os}_${arch}.${ext}`;
+  const { os: os2, arch, ext } = platformInfo;
+  const assetName = `comment-checker_v${version}_${os2}_${arch}.${ext}`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/v${version}/${assetName}`;
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
+    if (!existsSync2(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join(cacheDir, assetName);
+    const archivePath = join2(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     debugLog(`Downloaded archive to: ${archivePath}`);
@@ -1205,10 +1272,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync(archivePath)) {
+    if (existsSync2(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync(binaryPath)) {
+    if (process.platform !== "win32" && existsSync2(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -1261,8 +1328,8 @@ function findCommentCheckerPathSync() {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
-    const binaryPath = join2(cliDir, "bin", binaryName);
-    if (existsSync2(binaryPath)) {
+    const binaryPath = join3(cliDir, "bin", binaryName);
+    if (existsSync3(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -1275,8 +1342,8 @@ function findCommentCheckerPathSync() {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname(pkgPath);
-      const binaryPath = join2(pkgDir, "bin", binaryName);
-      if (existsSync2(binaryPath)) {
+      const binaryPath = join3(pkgDir, "bin", binaryName);
+      if (existsSync3(binaryPath)) {
         debugLog2("found binary in platform package:", binaryPath);
         return binaryPath;
       }
@@ -1289,10 +1356,10 @@ function findCommentCheckerPathSync() {
       "/opt/homebrew/bin/comment-checker",
       "/usr/local/bin/comment-checker"
     ];
-    for (const path of homebrewPaths) {
-      if (existsSync2(path)) {
-        debugLog2("found binary via homebrew:", path);
-        return path;
+    for (const path2 of homebrewPaths) {
+      if (existsSync3(path2)) {
+        debugLog2("found binary via homebrew:", path2);
+        return path2;
       }
     }
   }
@@ -1315,7 +1382,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync2(syncPath)) {
+    if (syncPath && existsSync3(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -1335,8 +1402,8 @@ async function getCommentCheckerPath() {
 function startBackgroundInit() {
   if (!initPromise) {
     initPromise = getCommentCheckerPath();
-    initPromise.then((path) => {
-      debugLog2("background init complete:", path || "no binary");
+    initPromise.then((path2) => {
+      debugLog2("background init complete:", path2 || "no binary");
     }).catch((err) => {
       debugLog2("background init error:", err);
     });
@@ -1349,7 +1416,7 @@ async function runCommentChecker(input, cliPath) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync2(binaryPath)) {
+  if (!existsSync3(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -1383,7 +1450,7 @@ async function runCommentChecker(input, cliPath) {
 
 // src/hooks/comment-checker/index.ts
 import * as fs2 from "fs";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
 var DEBUG_FILE3 = "/tmp/comment-checker-debug.log";
 function debugLog3(...args) {
@@ -1409,8 +1476,8 @@ function createCommentCheckerHooks() {
   debugLog3("createCommentCheckerHooks called");
   startBackgroundInit();
   cliPathPromise = getCommentCheckerPath();
-  cliPathPromise.then((path) => {
-    debugLog3("CLI path resolved:", path || "disabled (no binary)");
+  cliPathPromise.then((path2) => {
+    debugLog3("CLI path resolved:", path2 || "disabled (no binary)");
   }).catch((err) => {
     debugLog3("CLI path resolution error:", err);
   });
@@ -1461,7 +1528,7 @@ function createCommentCheckerHooks() {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync3(cliPath)) {
+        if (!cliPath || !existsSync4(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -1571,6 +1638,9 @@ var SEVERITY_MAP = {
   3: "information",
   4: "hint"
 };
+var DEFAULT_MAX_REFERENCES = 200;
+var DEFAULT_MAX_SYMBOLS = 200;
+var DEFAULT_MAX_DIAGNOSTICS = 200;
 var BUILTIN_SERVERS = {
   typescript: {
     command: ["typescript-language-server", "--stdio"],
@@ -1707,14 +1777,14 @@ var EXT_TO_LANG = {
   ".yml": "yaml"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync4, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
-function loadJsonFile(path) {
-  if (!existsSync4(path))
+function loadJsonFile(path2) {
+  if (!existsSync5(path2))
     return null;
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    return JSON.parse(readFileSync2(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -1722,9 +1792,9 @@ function loadJsonFile(path) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join3(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join3(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join3(homedir2(), ".config", "opencode", "opencode.json")
+    project: join4(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join4(homedir2(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join4(homedir2(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -1817,7 +1887,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync4(join3(p, cmd))) {
+    if (existsSync5(join4(p, cmd))) {
       return true;
     }
   }
@@ -1867,7 +1937,7 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn3 } = globalThis.Bun;
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { extname, resolve } from "path";
 class LSPServerManager {
   static instance;
@@ -2254,7 +2324,7 @@ ${msg}`);
     const absPath = resolve(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync2(absPath, "utf-8");
+    const text = readFileSync3(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -2361,16 +2431,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve2 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve2(filePath);
-  if (!existsSync5(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync6(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync5(__require("path").join(dir, marker))) {
+      if (existsSync6(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -2484,12 +2554,22 @@ function formatPrepareRenameResult(result) {
   if ("defaultBehavior" in result) {
     return result.defaultBehavior ? "Rename supported (using default behavior)" : "Cannot rename at this position";
   }
-  const startLine = result.range.start.line + 1;
-  const startChar = result.range.start.character;
-  const endLine = result.range.end.line + 1;
-  const endChar = result.range.end.character;
-  const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
-  return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+  if ("range" in result && result.range) {
+    const startLine = result.range.start.line + 1;
+    const startChar = result.range.start.character;
+    const endLine = result.range.end.line + 1;
+    const endChar = result.range.end.character;
+    const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
+    return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+  }
+  if ("start" in result && "end" in result) {
+    const startLine = result.start.line + 1;
+    const startChar = result.start.character;
+    const endLine = result.end.line + 1;
+    const endChar = result.end.character;
+    return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}`;
+  }
+  return "Cannot rename at this position";
 }
 function formatCodeAction(action) {
   let result = `[${action.kind || "action"}] ${action.title}`;
@@ -2518,7 +2598,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync3(filePath, "utf-8");
+    let content = readFileSync4(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -2543,7 +2623,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync(filePath, lines.join(`
+    writeFileSync2(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -2574,7 +2654,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync(filePath, "", "utf-8");
+            writeFileSync2(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -2584,8 +2664,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync3(oldPath, "utf-8");
-            writeFileSync(newPath, content, "utf-8");
+            const content = readFileSync4(oldPath, "utf-8");
+            writeFileSync2(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -3365,10 +3445,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3727,11 +3807,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -3899,7 +3979,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path = []) => {
+  const processError = (error2, path2 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -3909,7 +3989,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3941,8 +4021,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15025,7 +15105,14 @@ var lsp_find_references = tool({
         const output2 = "No references found";
         return output2;
       }
-      const output = result.map(formatLocation).join(`
+      const total = result.length;
+      const truncated = total > DEFAULT_MAX_REFERENCES;
+      const limited = truncated ? result.slice(0, DEFAULT_MAX_REFERENCES) : result;
+      const lines = limited.map(formatLocation);
+      if (truncated) {
+        lines.unshift(`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`);
+      }
+      const output = lines.join(`
 `);
       return output;
     } catch (e) {
@@ -15045,18 +15132,23 @@ var lsp_document_symbols = tool({
         return await client.documentSymbols(args.filePath);
       });
       if (!result || result.length === 0) {
-        const output2 = "No symbols found";
-        return output2;
+        const output = "No symbols found";
+        return output;
       }
-      let output;
-      if ("range" in result[0]) {
-        output = result.map((s) => formatDocumentSymbol(s)).join(`
-`);
+      const total = result.length;
+      const truncated = total > DEFAULT_MAX_SYMBOLS;
+      const limited = truncated ? result.slice(0, DEFAULT_MAX_SYMBOLS) : result;
+      const lines = [];
+      if (truncated) {
+        lines.push(`Found ${total} symbols (showing first ${DEFAULT_MAX_SYMBOLS}):`);
+      }
+      if ("range" in limited[0]) {
+        lines.push(...limited.map((s) => formatDocumentSymbol(s)));
       } else {
-        output = result.map(formatSymbolInfo).join(`
-`);
+        lines.push(...limited.map(formatSymbolInfo));
       }
-      return output;
+      return lines.join(`
+`);
     } catch (e) {
       const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
       return output;
@@ -15079,8 +15171,15 @@ var lsp_workspace_symbols = tool({
         const output2 = "No symbols found";
         return output2;
       }
-      const limited = args.limit ? result.slice(0, args.limit) : result;
-      const output = limited.map(formatSymbolInfo).join(`
+      const total = result.length;
+      const limit = Math.min(args.limit ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS);
+      const truncated = total > limit;
+      const limited = result.slice(0, limit);
+      const lines = limited.map(formatSymbolInfo);
+      if (truncated) {
+        lines.unshift(`Found ${total} symbols (showing first ${limit}):`);
+      }
+      const output = lines.join(`
 `);
       return output;
     } catch (e) {
@@ -15113,7 +15212,14 @@ var lsp_diagnostics = tool({
         const output2 = "No diagnostics found";
         return output2;
       }
-      const output = diagnostics.map(formatDiagnostic).join(`
+      const total = diagnostics.length;
+      const truncated = total > DEFAULT_MAX_DIAGNOSTICS;
+      const limited = truncated ? diagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS) : diagnostics;
+      const lines = limited.map(formatDiagnostic);
+      if (truncated) {
+        lines.unshift(`Found ${total} diagnostics (showing first ${DEFAULT_MAX_DIAGNOSTICS}):`);
+      }
+      const output = lines.join(`
 `);
       return output;
     } catch (e) {
@@ -15259,13 +15365,13 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname2, join as join5 } from "path";
-import { existsSync as existsSync7, statSync } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { existsSync as existsSync8, statSync } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, chmodSync as chmodSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, chmodSync as chmodSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -15291,19 +15397,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join4(homedir3(), "AppData", "Local");
-    return join4(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join5(homedir3(), "AppData", "Local");
+    return join5(base2, "oh-my-opencode", "bin");
   }
-  const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join4(homedir3(), ".cache");
-  return join4(base, "oh-my-opencode", "bin");
+  const xdgCache2 = process.env.XDG_CACHE_HOME;
+  const base = xdgCache2 || join5(homedir3(), ".cache");
+  return join5(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join4(getCacheDir2(), getBinaryName3());
-  return existsSync6(binaryPath) ? binaryPath : null;
+  const binaryPath = join5(getCacheDir2(), getBinaryName3());
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn4([
@@ -15329,30 +15435,30 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join4(cacheDir, binaryName);
-  if (existsSync6(binaryPath)) {
+  const binaryPath = join5(cacheDir, binaryName);
+  if (existsSync7(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os } = platformInfo;
-  const assetName = `app-${arch}-${os}.zip`;
+  const { arch, os: os2 } = platformInfo;
+  const assetName = `app-${arch}-${os2}.zip`;
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync6(cacheDir)) {
-      mkdirSync2(cacheDir, { recursive: true });
+    if (!existsSync7(cacheDir)) {
+      mkdirSync3(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join4(cacheDir, assetName);
+    const archivePath = join5(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync6(binaryPath)) {
+    if (process.platform !== "win32" && existsSync7(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -15403,8 +15509,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname2(cliPkgPath);
-    const sgPath = join5(cliDir, binaryName);
-    if (existsSync7(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join6(cliDir, binaryName);
+    if (existsSync8(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -15415,17 +15521,17 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname2(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join5(pkgDir, astGrepName);
-      if (existsSync7(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join6(pkgDir, astGrepName);
+      if (existsSync8(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path of homebrewPaths) {
-      if (existsSync7(path) && isValidBinary(path)) {
-        return path;
+    for (const path2 of homebrewPaths) {
+      if (existsSync8(path2) && isValidBinary(path2)) {
+        return path2;
       }
     }
   }
@@ -15443,8 +15549,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path) {
-  resolvedCliPath2 = path;
+function setSgCliPath(path2) {
+  resolvedCliPath2 = path2;
 }
 var SG_CLI_PATH = getSgCliPath();
 var CLI_LANGUAGES = [
@@ -15475,6 +15581,9 @@ var CLI_LANGUAGES = [
   "yaml"
 ];
 var NAPI_LANGUAGES = ["html", "javascript", "tsx", "css", "typescript"];
+var DEFAULT_TIMEOUT_MS = 300000;
+var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
+var DEFAULT_MAX_MATCHES = 500;
 var LANG_EXTENSIONS = {
   bash: [".bash", ".sh", ".zsh", ".bats"],
   c: [".c", ".h"],
@@ -15505,11 +15614,11 @@ var LANG_EXTENSIONS = {
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync8(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync9(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -15517,7 +15626,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync8(syncPath)) {
+    if (syncPath && existsSync9(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -15532,16 +15641,6 @@ async function getAstGrepPath() {
   })();
   return initPromise2;
 }
-async function spawnSg(cliPath, args) {
-  const proc = spawn5([cliPath, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-  return { stdout, stderr, exitCode };
-}
 async function runSg(options) {
   const args = ["run", "-p", options.pattern, "--lang", options.lang, "--json=compact"];
   if (options.rewrite) {
@@ -15561,53 +15660,120 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync8(cliPath) && cliPath !== "sg") {
+  if (!existsSync9(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
-  let result;
+  const timeout = DEFAULT_TIMEOUT_MS;
+  const proc = spawn5([cliPath, ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const timeoutPromise = new Promise((_, reject) => {
+    const id = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`Search timeout after ${timeout}ms`));
+    }, timeout);
+    proc.exited.then(() => clearTimeout(id));
+  });
+  let stdout;
+  let stderr;
+  let exitCode;
   try {
-    result = await spawnSg(cliPath, args);
+    stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
+    stderr = await new Response(proc.stderr).text();
+    exitCode = await proc.exited;
   } catch (e) {
     const error45 = e;
-    if (error45.code === "ENOENT" || error45.message?.includes("ENOENT") || error45.message?.includes("not found")) {
+    if (error45.message?.includes("timeout")) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: true,
+        truncatedReason: "timeout",
+        error: error45.message
+      };
+    }
+    const nodeError = e;
+    if (nodeError.code === "ENOENT" || nodeError.message?.includes("ENOENT") || nodeError.message?.includes("not found")) {
       const downloadedPath = await ensureAstGrepBinary();
       if (downloadedPath) {
         resolvedCliPath3 = downloadedPath;
         setSgCliPath(downloadedPath);
-        result = await spawnSg(downloadedPath, args);
+        return runSg(options);
       } else {
-        throw new Error(`ast-grep CLI binary not found.
+        return {
+          matches: [],
+          totalMatches: 0,
+          truncated: false,
+          error: `ast-grep CLI binary not found.
 
 ` + `Auto-download failed. Manual install options:
 ` + `  bun add -D @ast-grep/cli
 ` + `  cargo install ast-grep --locked
-` + `  brew install ast-grep`);
+` + `  brew install ast-grep`
+        };
       }
-    } else {
-      throw new Error(`Failed to spawn ast-grep: ${error45.message}`);
     }
+    return {
+      matches: [],
+      totalMatches: 0,
+      truncated: false,
+      error: `Failed to spawn ast-grep: ${error45.message}`
+    };
   }
-  const { stdout, stderr, exitCode } = result;
   if (exitCode !== 0 && stdout.trim() === "") {
     if (stderr.includes("No files found")) {
-      return [];
+      return { matches: [], totalMatches: 0, truncated: false };
     }
     if (stderr.trim()) {
-      throw new Error(stderr.trim());
+      return { matches: [], totalMatches: 0, truncated: false, error: stderr.trim() };
     }
-    return [];
+    return { matches: [], totalMatches: 0, truncated: false };
   }
   if (!stdout.trim()) {
-    return [];
+    return { matches: [], totalMatches: 0, truncated: false };
   }
+  const outputTruncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES;
+  const outputToProcess = outputTruncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES) : stdout;
+  let matches = [];
   try {
-    return JSON.parse(stdout);
+    matches = JSON.parse(outputToProcess);
   } catch {
-    return [];
+    if (outputTruncated) {
+      try {
+        const lastValidIndex = outputToProcess.lastIndexOf("}");
+        if (lastValidIndex > 0) {
+          const bracketIndex = outputToProcess.lastIndexOf("},", lastValidIndex);
+          if (bracketIndex > 0) {
+            const truncatedJson = outputToProcess.substring(0, bracketIndex + 1) + "]";
+            matches = JSON.parse(truncatedJson);
+          }
+        }
+      } catch {
+        return {
+          matches: [],
+          totalMatches: 0,
+          truncated: true,
+          truncatedReason: "max_output_bytes",
+          error: "Output too large and could not be parsed"
+        };
+      }
+    } else {
+      return { matches: [], totalMatches: 0, truncated: false };
+    }
   }
+  const totalMatches = matches.length;
+  const matchesTruncated = totalMatches > DEFAULT_MAX_MATCHES;
+  const finalMatches = matchesTruncated ? matches.slice(0, DEFAULT_MAX_MATCHES) : matches;
+  return {
+    matches: finalMatches,
+    totalMatches,
+    truncated: outputTruncated || matchesTruncated,
+    truncatedReason: outputTruncated ? "max_output_bytes" : matchesTruncated ? "max_matches" : undefined
+  };
 }
 
 // src/tools/ast-grep/napi.ts
@@ -15696,13 +15862,22 @@ function getRootInfo(code, lang) {
 }
 
 // src/tools/ast-grep/utils.ts
-function formatSearchResult(matches) {
-  if (matches.length === 0) {
+function formatSearchResult(result) {
+  if (result.error) {
+    return `Error: ${result.error}`;
+  }
+  if (result.matches.length === 0) {
     return "No matches found";
   }
-  const lines = [`Found ${matches.length} match(es):
-`];
-  for (const match of matches) {
+  const lines = [];
+  if (result.truncated) {
+    const reason = result.truncatedReason === "max_matches" ? `showing first ${result.matches.length} of ${result.totalMatches}` : result.truncatedReason === "max_output_bytes" ? "output exceeded 1MB limit" : "search timed out";
+    lines.push(`\u26A0\uFE0F Results truncated (${reason})
+`);
+  }
+  lines.push(`Found ${result.matches.length} match(es)${result.truncated ? ` (truncated from ${result.totalMatches})` : ""}:
+`);
+  for (const match of result.matches) {
     const loc = `${match.file}:${match.range.start.line + 1}:${match.range.start.column + 1}`;
     lines.push(`${loc}`);
     lines.push(`  ${match.lines.trim()}`);
@@ -15711,14 +15886,23 @@ function formatSearchResult(matches) {
   return lines.join(`
 `);
 }
-function formatReplaceResult(matches, isDryRun) {
-  if (matches.length === 0) {
+function formatReplaceResult(result, isDryRun) {
+  if (result.error) {
+    return `Error: ${result.error}`;
+  }
+  if (result.matches.length === 0) {
     return "No matches found to replace";
   }
   const prefix = isDryRun ? "[DRY RUN] " : "";
-  const lines = [`${prefix}${matches.length} replacement(s):
-`];
-  for (const match of matches) {
+  const lines = [];
+  if (result.truncated) {
+    const reason = result.truncatedReason === "max_matches" ? `showing first ${result.matches.length} of ${result.totalMatches}` : result.truncatedReason === "max_output_bytes" ? "output exceeded 1MB limit" : "search timed out";
+    lines.push(`\u26A0\uFE0F Results truncated (${reason})
+`);
+  }
+  lines.push(`${prefix}${result.matches.length} replacement(s):
+`);
+  for (const match of result.matches) {
     const loc = `${match.file}:${match.range.start.line + 1}:${match.range.start.column + 1}`;
     lines.push(`${loc}`);
     lines.push(`  ${match.text}`);
@@ -15796,15 +15980,15 @@ var ast_grep_search = tool({
   },
   execute: async (args, context) => {
     try {
-      const matches = await runSg({
+      const result = await runSg({
         pattern: args.pattern,
         lang: args.lang,
         paths: args.paths,
         globs: args.globs,
         context: args.context
       });
-      let output = formatSearchResult(matches);
-      if (matches.length === 0) {
+      let output = formatSearchResult(result);
+      if (result.matches.length === 0 && !result.error) {
         const hint = getEmptyResultHint(args.pattern, args.lang);
         if (hint) {
           output += `
@@ -15833,7 +16017,7 @@ var ast_grep_replace = tool({
   },
   execute: async (args, context) => {
     try {
-      const matches = await runSg({
+      const result = await runSg({
         pattern: args.pattern,
         rewrite: args.rewrite,
         lang: args.lang,
@@ -15841,7 +16025,7 @@ var ast_grep_replace = tool({
         globs: args.globs,
         updateAll: args.dryRun === false
       });
-      const output = formatReplaceResult(matches, args.dryRun !== false);
+      const output = formatReplaceResult(result, args.dryRun !== false);
       showOutputToUser(context, output);
       return output;
     } catch (e) {
@@ -15921,8 +16105,8 @@ var ast_grep_transform = tool({
 var {spawn: spawn6 } = globalThis.Bun;
 
 // src/tools/safe-grep/constants.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -15943,13 +16127,13 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join6(execDir, rgName),
-    join6(execDir, "bin", rgName),
-    join6(execDir, "..", "bin", rgName),
-    join6(execDir, "..", "libexec", rgName)
+    join7(execDir, rgName),
+    join7(execDir, "bin", rgName),
+    join7(execDir, "..", "bin", rgName),
+    join7(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
@@ -15980,8 +16164,8 @@ var DEFAULT_MAX_DEPTH = 20;
 var DEFAULT_MAX_FILESIZE = "10M";
 var DEFAULT_MAX_COUNT = 500;
 var DEFAULT_MAX_COLUMNS = 1000;
-var DEFAULT_TIMEOUT_MS = 300000;
-var DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS2 = 300000;
+var DEFAULT_MAX_OUTPUT_BYTES2 = 10 * 1024 * 1024;
 var RG_SAFETY_FLAGS = [
   "--no-follow",
   "--color=never",
@@ -16082,7 +16266,7 @@ function parseOutput(output) {
 async function runRg(options) {
   const cli = resolveGrepCli();
   const args = buildArgs(options, cli.backend);
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS);
+  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS2, DEFAULT_TIMEOUT_MS2);
   if (cli.backend === "rg") {
     args.push("--", options.pattern);
   } else {
@@ -16105,8 +16289,8 @@ async function runRg(options) {
     const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
     const stderr = await new Response(proc.stderr).text();
     const exitCode = await proc.exited;
-    const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES;
-    const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES) : stdout;
+    const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES2;
+    const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES2) : stdout;
     if (exitCode > 1 && stderr.trim()) {
       return {
         matches: [],
@@ -16282,11 +16466,11 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 });
 // src/index.ts
 import * as fs3 from "fs";
-import * as path from "path";
+import * as path2 from "path";
 function loadPluginConfig(directory) {
   const configPaths = [
-    path.join(directory, "oh-my-opencode.json"),
-    path.join(directory, ".oh-my-opencode.json")
+    path2.join(directory, "oh-my-opencode.json"),
+    path2.join(directory, ".oh-my-opencode.json")
   ];
   for (const configPath of configPaths) {
     try {

package/dist/tools/ast-grep/cli.d.ts

@@ -1,4 +1,4 @@
-import type { CliMatch, CliLanguage } from "./types";
+import type { CliLanguage, SgResult } from "./types";
 export interface RunOptions {
     pattern: string;
     lang: CliLanguage;
@@ -10,6 +10,6 @@ export interface RunOptions {
 }
 export declare function getAstGrepPath(): Promise<string | null>;
 export declare function startBackgroundInit(): void;
-export declare function runSg(options: RunOptions): Promise<CliMatch[]>;
+export declare function runSg(options: RunOptions): Promise<SgResult>;
 export declare function isCliAvailable(): boolean;
 export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/tools/ast-grep/constants.d.ts

@@ -4,6 +4,9 @@ export declare function setSgCliPath(path: string): void;
 export declare const SG_CLI_PATH: string;
 export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
 export declare const NAPI_LANGUAGES: readonly ["html", "javascript", "tsx", "css", "typescript"];
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_MATCHES = 500;
 export declare const LANG_EXTENSIONS: Record<string, string[]>;
 export interface EnvironmentCheckResult {
     cli: {

package/dist/tools/ast-grep/types.d.ts

@@ -49,3 +49,10 @@ export interface TransformResult {
     transformed: string;
     editCount: number;
 }
+export interface SgResult {
+    matches: CliMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    truncatedReason?: "max_matches" | "max_output_bytes" | "timeout";
+    error?: string;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -1,5 +1,5 @@
-import type { CliMatch, AnalyzeResult } from "./types";
-export declare function formatSearchResult(matches: CliMatch[]): string;
-export declare function formatReplaceResult(matches: CliMatch[], isDryRun: boolean): string;
+import type { AnalyzeResult, SgResult } from "./types";
+export declare function formatSearchResult(result: SgResult): string;
+export declare function formatReplaceResult(result: SgResult, isDryRun: boolean): string;
 export declare function formatAnalyzeResult(results: AnalyzeResult[], extractedMetaVars: boolean): string;
 export declare function formatTransformResult(original: string, transformed: string, editCount: number): string;

package/dist/tools/lsp/constants.d.ts

@@ -1,5 +1,8 @@
 import type { LSPServerConfig } from "./types";
 export declare const SYMBOL_KIND_MAP: Record<number, string>;
 export declare const SEVERITY_MAP: Record<number, string>;
+export declare const DEFAULT_MAX_REFERENCES = 200;
+export declare const DEFAULT_MAX_SYMBOLS = 200;
+export declare const DEFAULT_MAX_DIAGNOSTICS = 200;
 export declare const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, "id">>;
 export declare const EXT_TO_LANG: Record<string, string>;

package/dist/tools/lsp/utils.d.ts

@@ -1,5 +1,5 @@
 import { LSPClient } from "./client";
-import type { HoverResult, DocumentSymbol, SymbolInfo, Location, LocationLink, Diagnostic, PrepareRenameResult, PrepareRenameDefaultBehavior, WorkspaceEdit, TextEdit, CodeAction, Command } from "./types";
+import type { HoverResult, DocumentSymbol, SymbolInfo, Location, LocationLink, Diagnostic, PrepareRenameResult, PrepareRenameDefaultBehavior, Range, WorkspaceEdit, TextEdit, CodeAction, Command } from "./types";
 export declare function findWorkspaceRoot(filePath: string): string;
 export declare function withLspClient<T>(filePath: string, fn: (client: LSPClient) => Promise<T>): Promise<T>;
 export declare function formatHoverResult(result: HoverResult | null): string;
@@ -10,7 +10,7 @@ export declare function formatDocumentSymbol(symbol: DocumentSymbol, indent?: nu
 export declare function formatSymbolInfo(symbol: SymbolInfo): string;
 export declare function formatDiagnostic(diag: Diagnostic): string;
 export declare function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: "error" | "warning" | "information" | "hint" | "all"): Diagnostic[];
-export declare function formatPrepareRenameResult(result: PrepareRenameResult | PrepareRenameDefaultBehavior | null): string;
+export declare function formatPrepareRenameResult(result: PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null): string;
 export declare function formatTextEdit(edit: TextEdit): string;
 export declare function formatWorkspaceEdit(edit: WorkspaceEdit | null): string;
 export declare function formatCodeAction(action: CodeAction): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,6 +46,7 @@
     "@ast-grep/napi": "^0.40.0",
     "@code-yeongyu/comment-checker": "^0.4.1",
     "@opencode-ai/plugin": "^1.0.7",
+    "xdg-basedir": "^5.1.0",
     "zod": "^4.1.8"
   },
   "devDependencies": {