oh-my-opencode 0.1.17 → 0.1.19

package/dist/index.js

@@ -803,7 +803,7 @@ function detectErrorType(error) {
   if (message.includes("tool_use") && message.includes("tool_result")) {
     return "tool_result_missing";
   }
-  if (message.includes("thinking") && message.includes("first block")) {
+  if (message.includes("thinking") && (message.includes("first block") || message.includes("must start with") || message.includes("preceeding"))) {
     return "thinking_block_order";
   }
   if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
@@ -15258,9 +15258,120 @@ 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 } 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 { homedir as homedir3 } from "os";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname2, join as join4 } from "path";
-import { existsSync as existsSync6 } from "fs";
+var REPO2 = "ast-grep/ast-grep";
+var DEFAULT_VERSION = "0.40.0";
+function getAstGrepVersion() {
+  try {
+    const require2 = createRequire3(import.meta.url);
+    const pkg = require2("@ast-grep/cli/package.json");
+    return pkg.version;
+  } catch {
+    return DEFAULT_VERSION;
+  }
+}
+var PLATFORM_MAP2 = {
+  "darwin-arm64": { arch: "aarch64", os: "apple-darwin" },
+  "darwin-x64": { arch: "x86_64", os: "apple-darwin" },
+  "linux-arm64": { arch: "aarch64", os: "unknown-linux-gnu" },
+  "linux-x64": { arch: "x86_64", os: "unknown-linux-gnu" },
+  "win32-x64": { arch: "x86_64", os: "pc-windows-msvc" },
+  "win32-arm64": { arch: "aarch64", os: "pc-windows-msvc" },
+  "win32-ia32": { arch: "i686", os: "pc-windows-msvc" }
+};
+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 xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join4(homedir3(), ".cache");
+  return join4(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;
+}
+async function extractZip2(archivePath, destDir) {
+  const proc = process.platform === "win32" ? spawn4([
+    "powershell",
+    "-command",
+    `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`
+  ], { stdout: "pipe", stderr: "pipe" }) : spawn4(["unzip", "-o", archivePath, "-d", destDir], { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    const toolHint = process.platform === "win32" ? "Ensure PowerShell is available on your system." : "Please install 'unzip' (e.g., apt install unzip, brew install unzip).";
+    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}
+
+${toolHint}`);
+  }
+}
+async function downloadAstGrep(version2 = DEFAULT_VERSION) {
+  const platformKey = `${process.platform}-${process.arch}`;
+  const platformInfo = PLATFORM_MAP2[platformKey];
+  if (!platformInfo) {
+    console.error(`[oh-my-opencode] Unsupported platform for ast-grep: ${platformKey}`);
+    return null;
+  }
+  const cacheDir = getCacheDir2();
+  const binaryName = getBinaryName3();
+  const binaryPath = join4(cacheDir, binaryName);
+  if (existsSync6(binaryPath)) {
+    return binaryPath;
+  }
+  const { arch, os } = platformInfo;
+  const assetName = `app-${arch}-${os}.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 });
+    }
+    const response = await fetch(downloadUrl, { redirect: "follow" });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const archivePath = join4(cacheDir, assetName);
+    const arrayBuffer = await response.arrayBuffer();
+    await Bun.write(archivePath, arrayBuffer);
+    await extractZip2(archivePath, cacheDir);
+    if (existsSync6(archivePath)) {
+      unlinkSync2(archivePath);
+    }
+    if (process.platform !== "win32" && existsSync6(binaryPath)) {
+      chmodSync2(binaryPath, 493);
+    }
+    console.log(`[oh-my-opencode] ast-grep binary ready.`);
+    return binaryPath;
+  } catch (err) {
+    console.error(`[oh-my-opencode] Failed to download ast-grep: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+async function ensureAstGrepBinary() {
+  const cachedPath = getCachedBinaryPath2();
+  if (cachedPath) {
+    return cachedPath;
+  }
+  const version2 = getAstGrepVersion();
+  return downloadAstGrep(version2);
+}
+
+// src/tools/ast-grep/constants.ts
 function getPlatformPackageName2() {
   const platform = process.platform;
   const arch = process.arch;
@@ -15275,32 +15386,60 @@ function getPlatformPackageName2() {
   };
   return platformMap[`${platform}-${arch}`] ?? null;
 }
-function findSgCliPath() {
+function findSgCliPathSync() {
+  const binaryName = process.platform === "win32" ? "sg.exe" : "sg";
   try {
-    const require2 = createRequire3(import.meta.url);
+    const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname2(cliPkgPath);
-    const sgPath = join4(cliDir, process.platform === "win32" ? "sg.exe" : "sg");
-    if (existsSync6(sgPath)) {
+    const sgPath = join5(cliDir, binaryName);
+    if (existsSync7(sgPath)) {
       return sgPath;
     }
   } catch {}
   const platformPkg = getPlatformPackageName2();
   if (platformPkg) {
     try {
-      const require2 = createRequire3(import.meta.url);
+      const require2 = createRequire4(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname2(pkgPath);
-      const binaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join4(pkgDir, binaryName);
-      if (existsSync6(binaryPath)) {
+      const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
+      const binaryPath = join5(pkgDir, astGrepName);
+      if (existsSync7(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)) {
+        return path;
+      }
+    }
+  }
+  const cachedPath = getCachedBinaryPath2();
+  if (cachedPath) {
+    return cachedPath;
+  }
+  return null;
+}
+var resolvedCliPath2 = null;
+function getSgCliPath() {
+  if (resolvedCliPath2 !== null) {
+    return resolvedCliPath2;
+  }
+  const syncPath = findSgCliPathSync();
+  if (syncPath) {
+    resolvedCliPath2 = syncPath;
+    return syncPath;
+  }
   return "sg";
 }
-var SG_CLI_PATH = findSgCliPath();
+function setSgCliPath(path) {
+  resolvedCliPath2 = path;
+}
+var SG_CLI_PATH = getSgCliPath();
 var CLI_LANGUAGES = [
   "bash",
   "c",
@@ -15358,7 +15497,44 @@ var LANG_EXTENSIONS = {
 };
 
 // src/tools/ast-grep/cli.ts
-var {spawn: spawn4 } = globalThis.Bun;
+var {spawn: spawn5 } = globalThis.Bun;
+import { existsSync as existsSync8 } from "fs";
+var resolvedCliPath3 = null;
+var initPromise2 = null;
+async function getAstGrepPath() {
+  if (resolvedCliPath3 !== null && existsSync8(resolvedCliPath3)) {
+    return resolvedCliPath3;
+  }
+  if (initPromise2) {
+    return initPromise2;
+  }
+  initPromise2 = (async () => {
+    const syncPath = findSgCliPathSync();
+    if (syncPath && existsSync8(syncPath)) {
+      resolvedCliPath3 = syncPath;
+      setSgCliPath(syncPath);
+      return syncPath;
+    }
+    const downloadedPath = await ensureAstGrepBinary();
+    if (downloadedPath) {
+      resolvedCliPath3 = downloadedPath;
+      setSgCliPath(downloadedPath);
+      return downloadedPath;
+    }
+    return null;
+  })();
+  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) {
@@ -15377,13 +15553,37 @@ async function runSg(options) {
   }
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn4([SG_CLI_PATH, ...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;
+  let cliPath = getSgCliPath();
+  if (!existsSync8(cliPath) && cliPath !== "sg") {
+    const downloadedPath = await getAstGrepPath();
+    if (downloadedPath) {
+      cliPath = downloadedPath;
+    }
+  }
+  let result;
+  try {
+    result = await spawnSg(cliPath, args);
+  } catch (e) {
+    const error45 = e;
+    if (error45.code === "ENOENT" || error45.message?.includes("ENOENT") || error45.message?.includes("not found")) {
+      const downloadedPath = await ensureAstGrepBinary();
+      if (downloadedPath) {
+        resolvedCliPath3 = downloadedPath;
+        setSgCliPath(downloadedPath);
+        result = await spawnSg(downloadedPath, args);
+      } else {
+        throw new 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`);
+      }
+    } else {
+      throw new 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 [];
@@ -15413,7 +15613,15 @@ var LANG_MAP = {
   typescript: Lang.TypeScript
 };
 function parseCode(code, lang) {
-  return parse5(LANG_MAP[lang], code);
+  const parseLang = LANG_MAP[lang];
+  if (!parseLang) {
+    const supportedLangs = NAPI_LANGUAGES.join(", ");
+    throw new Error(`Unsupported language for NAPI: "${lang}"
+` + `Supported languages: ${supportedLangs}
+
+` + `Use ast_grep_search for other languages (25 supported via CLI).`);
+  }
+  return parse5(parseLang, code);
 }
 function findPattern(root, pattern) {
   return root.root().findAll(pattern);
@@ -15551,25 +15759,22 @@ function showOutputToUser(context, output) {
   const ctx = context;
   ctx.metadata?.({ metadata: { output } });
 }
-var JS_TS_LANGUAGES = ["javascript", "typescript", "tsx"];
-function validatePatternForCli(pattern, lang) {
-  if (!JS_TS_LANGUAGES.includes(lang)) {
-    return;
-  }
+function getEmptyResultHint(pattern, lang) {
   const src = pattern.trim();
-  const incompleteFunctionDecl = /^(export\s+)?(default\s+)?(async\s+)?function\s+\$[A-Z_][A-Z0-9_]*\s*$/i.test(src);
-  if (incompleteFunctionDecl) {
-    throw new Error(`Incomplete AST pattern for ${lang}: "${pattern}"
-
-` + `ast-grep requires complete AST nodes. Function declarations must include parameters and body.
-
-` + `Examples of correct patterns:
-` + `  - "export async function $NAME($$$) { $$$ }" (matches export async functions)
-` + `  - "function $NAME($$$) { $$$ }" (matches all function declarations)
-` + `  - "async function $NAME($$$) { $$$ }" (matches async functions)
-
-` + `Your pattern "${pattern}" is missing the parameter list and body.`);
+  if (lang === "python") {
+    if (src.startsWith("class ") && src.endsWith(":")) {
+      return `\uD83D\uDCA1 Hint: Python class patterns need body. Try "class $NAME" or include body with $$$BODY`;
+    }
+    if ((src.startsWith("def ") || src.startsWith("async def ")) && src.endsWith(":")) {
+      return `\uD83D\uDCA1 Hint: Python function patterns need body. Try "def $FUNC($$$):\\n    $$$BODY"`;
+    }
   }
+  if (["javascript", "typescript", "tsx"].includes(lang)) {
+    if (/^(export\s+)?(async\s+)?function\s+\$[A-Z_]+\s*$/i.test(src)) {
+      return `\uD83D\uDCA1 Hint: Function patterns need params and body. Try "function $NAME($$$) { $$$ }"`;
+    }
+  }
+  return null;
 }
 var ast_grep_search = tool({
   description: "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. " + "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " + "IMPORTANT: Patterns must be complete AST nodes (valid code). " + "For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. " + "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
@@ -15582,7 +15787,6 @@ var ast_grep_search = tool({
   },
   execute: async (args, context) => {
     try {
-      validatePatternForCli(args.pattern, args.lang);
       const matches = await runSg({
         pattern: args.pattern,
         lang: args.lang,
@@ -15590,7 +15794,15 @@ var ast_grep_search = tool({
         globs: args.globs,
         context: args.context
       });
-      const output = formatSearchResult(matches);
+      let output = formatSearchResult(matches);
+      if (matches.length === 0) {
+        const hint = getEmptyResultHint(args.pattern, args.lang);
+        if (hint) {
+          output += `
+
+${hint}`;
+        }
+      }
       showOutputToUser(context, output);
       return output;
     } catch (e) {
@@ -15696,13 +15908,12 @@ var ast_grep_transform = tool({
     }
   }
 });
-
 // src/tools/safe-grep/cli.ts
-var {spawn: spawn5 } = globalThis.Bun;
+var {spawn: spawn6 } = globalThis.Bun;
 
 // src/tools/safe-grep/constants.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -15723,13 +15934,13 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join5(execDir, rgName),
-    join5(execDir, "bin", rgName),
-    join5(execDir, "..", "bin", rgName),
-    join5(execDir, "..", "libexec", rgName)
+    join6(execDir, rgName),
+    join6(execDir, "bin", rgName),
+    join6(execDir, "..", "bin", rgName),
+    join6(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync7(candidate)) {
+    if (existsSync9(candidate)) {
       return candidate;
     }
   }
@@ -15870,7 +16081,7 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn5([cli.path, ...args], {
+  const proc = spawn6([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -16168,7 +16379,14 @@ var OhMyOpenCodePlugin = async (ctx) => {
             sessionID,
             error: error45
           };
-          await sessionRecovery.handleSessionRecovery(messageInfo);
+          const recovered = await sessionRecovery.handleSessionRecovery(messageInfo);
+          if (recovered && sessionID && sessionID === mainSessionID) {
+            await ctx.client.session.prompt({
+              path: { id: sessionID },
+              body: { parts: [{ type: "text", text: "continue" }] },
+              query: { directory: ctx.directory }
+            }).catch(() => {});
+          }
         }
         if (sessionID && sessionID === mainSessionID) {
           updateTerminalTitle({

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

@@ -8,4 +8,8 @@ export interface RunOptions {
     context?: number;
     updateAll?: boolean;
 }
+export declare function getAstGrepPath(): Promise<string | null>;
+export declare function startBackgroundInit(): void;
 export declare function runSg(options: RunOptions): Promise<CliMatch[]>;
+export declare function isCliAvailable(): boolean;
+export declare function ensureCliAvailable(): Promise<boolean>;

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

@@ -1,4 +1,27 @@
+export declare function findSgCliPathSync(): string | null;
+export declare function getSgCliPath(): string;
+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 LANG_EXTENSIONS: Record<string, string[]>;
+export interface EnvironmentCheckResult {
+    cli: {
+        available: boolean;
+        path: string;
+        error?: string;
+    };
+    napi: {
+        available: boolean;
+        error?: string;
+    };
+}
+/**
+ * Check if ast-grep CLI and NAPI are available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export declare function checkEnvironment(): EnvironmentCheckResult;
+/**
+ * Format environment check result as user-friendly message.
+ */
+export declare function formatEnvironmentCheck(result: EnvironmentCheckResult): string;

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

@@ -0,0 +1,5 @@
+export declare function getCacheDir(): string;
+export declare function getBinaryName(): string;
+export declare function getCachedBinaryPath(): string | null;
+export declare function downloadAstGrep(version?: string): Promise<string | null>;
+export declare function ensureAstGrepBinary(): Promise<string | null>;

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

@@ -89,4 +89,8 @@ export declare const builtinTools: {
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
 };
-export { ast_grep_search, ast_grep_replace, };
+export { ast_grep_search, ast_grep_replace };
+export { ensureAstGrepBinary, getCachedBinaryPath, getCacheDir } from "./downloader";
+export { getAstGrepPath, isCliAvailable, ensureCliAvailable, startBackgroundInit } from "./cli";
+export { checkEnvironment, formatEnvironmentCheck } from "./constants";
+export type { EnvironmentCheckResult } from "./constants";

package/package.json

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