oh-my-opencode 0.1.23 → 0.1.24

package/dist/index.js

@@ -1571,6 +1571,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"],
@@ -15025,7 +15028,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 +15055,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 +15094,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 +15135,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) {
@@ -15475,6 +15504,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"],
@@ -15532,16 +15564,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) {
@@ -15567,47 +15589,114 @@ async function runSg(options) {
       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 +15785,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 +15809,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 +15903,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 +15940,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 +15948,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) {
@@ -15980,8 +16087,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 +16189,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 +16212,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: [],

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/package.json

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