opencode-dux 1.0.0

package/src/tools/ast-grep/cli.ts

@@ -0,0 +1,257 @@
+import { existsSync } from 'node:fs';
+import { crossSpawn } from '../../utils/compat';
+import {
+  DEFAULT_MAX_MATCHES,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_TIMEOUT_MS,
+  findSgCliPathSync,
+  getSgCliPath,
+  setSgCliPath,
+} from './constants';
+import { ensureAstGrepBinary } from './downloader';
+import type { CliLanguage, CliMatch, SgResult } from './types';
+
+export interface RunOptions {
+  pattern: string;
+  lang: CliLanguage;
+  paths?: string[];
+  globs?: string[];
+  rewrite?: string;
+  context?: number;
+  updateAll?: boolean;
+}
+
+// Use a single init promise to avoid race conditions
+let initPromise: Promise<string | null> | null = null;
+
+export async function getAstGrepPath(): Promise<string | null> {
+  const currentPath = getSgCliPath();
+  if (currentPath !== 'sg' && existsSync(currentPath)) {
+    return currentPath;
+  }
+
+  if (initPromise) {
+    return initPromise;
+  }
+
+  initPromise = (async () => {
+    const syncPath = findSgCliPathSync();
+    if (syncPath && existsSync(syncPath)) {
+      setSgCliPath(syncPath);
+      return syncPath;
+    }
+
+    const downloadedPath = await ensureAstGrepBinary();
+    if (downloadedPath) {
+      setSgCliPath(downloadedPath);
+      return downloadedPath;
+    }
+
+    return null;
+  })();
+
+  return initPromise;
+}
+
+export function startBackgroundInit(): void {
+  if (!initPromise) {
+    initPromise = getAstGrepPath();
+    initPromise.catch((err) => {
+      console.warn(
+        '[ast-grep] Background initialization failed:',
+        err?.message ?? err,
+      );
+    });
+  }
+}
+
+export async function runSg(options: RunOptions): Promise<SgResult> {
+  const args = [
+    'run',
+    '-p',
+    options.pattern,
+    '--lang',
+    options.lang,
+    '--json=compact',
+  ];
+
+  if (options.rewrite) {
+    args.push('-r', options.rewrite);
+    if (options.updateAll) {
+      args.push('--update-all');
+    }
+  }
+
+  if (options.context && options.context > 0) {
+    args.push('-C', String(options.context));
+  }
+
+  if (options.globs) {
+    for (const glob of options.globs) {
+      args.push('--globs', glob);
+    }
+  }
+
+  const paths =
+    options.paths && options.paths.length > 0 ? options.paths : ['.'];
+  args.push(...paths);
+
+  let cliPath = getSgCliPath();
+
+  if (!existsSync(cliPath) && cliPath !== 'sg') {
+    const downloadedPath = await getAstGrepPath();
+    if (downloadedPath) {
+      cliPath = downloadedPath;
+    }
+  }
+
+  const timeout = DEFAULT_TIMEOUT_MS;
+
+  const proc = crossSpawn([cliPath, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    const id = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`Search timeout after ${timeout}ms`));
+    }, timeout);
+    proc.exited.then(() => clearTimeout(id));
+  });
+
+  let stdout: string;
+  let stderr: string;
+  let exitCode: number;
+
+  try {
+    stdout = await Promise.race([proc.stdout(), timeoutPromise]);
+    stderr = await proc.stderr();
+    exitCode = await proc.exited;
+  } catch (e) {
+    const error = e as Error;
+    if (error.message?.includes('timeout')) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: true,
+        truncatedReason: 'timeout',
+        error: error.message,
+      };
+    }
+
+    const nodeError = e as NodeJS.ErrnoException;
+    if (
+      nodeError.code === 'ENOENT' ||
+      nodeError.message?.includes('ENOENT') ||
+      nodeError.message?.includes('not found')
+    ) {
+      const downloadedPath = await ensureAstGrepBinary();
+      if (downloadedPath) {
+        setSgCliPath(downloadedPath);
+        return runSg(options);
+      } else {
+        return {
+          matches: [],
+          totalMatches: 0,
+          truncated: false,
+          error:
+            `ast-grep CLI binary not found.\n\n` +
+            `Auto-download failed. Manual install options:\n` +
+            `  bun add -D @ast-grep/cli\n` +
+            `  cargo install ast-grep --locked\n` +
+            `  brew install ast-grep`,
+        };
+      }
+    }
+
+    return {
+      matches: [],
+      totalMatches: 0,
+      truncated: false,
+      error: `Failed to spawn ast-grep: ${error.message}`,
+    };
+  }
+
+  if (exitCode !== 0 && stdout.trim() === '') {
+    if (stderr.includes('No files found')) {
+      return { matches: [], totalMatches: 0, truncated: false };
+    }
+    if (stderr.trim()) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        error: stderr.trim(),
+      };
+    }
+    return { matches: [], totalMatches: 0, truncated: false };
+  }
+
+  if (!stdout.trim()) {
+    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: CliMatch[] = [];
+  try {
+    matches = JSON.parse(outputToProcess) as CliMatch[];
+  } catch {
+    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) as CliMatch[];
+          }
+        }
+      } 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,
+  };
+}
+
+export function isCliAvailable(): boolean {
+  const path = findSgCliPathSync();
+  return path !== null && existsSync(path);
+}
+
+export async function ensureCliAvailable(): Promise<boolean> {
+  const path = await getAstGrepPath();
+  return path !== null && existsSync(path);
+}

package/src/tools/ast-grep/constants.ts

@@ -0,0 +1,214 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { getCachedBinaryPath } from './downloader';
+import { CLI_LANGUAGES } from './types';
+
+type Platform = 'darwin' | 'linux' | 'win32' | 'unsupported';
+
+// Minimum expected size for a valid sg binary (filters out stub files)
+const MIN_BINARY_SIZE = 10_000;
+
+function isValidBinary(filePath: string): boolean {
+  try {
+    return statSync(filePath).size > MIN_BINARY_SIZE;
+  } catch {
+    return false;
+  }
+}
+
+function getPlatformPackageName(): string | null {
+  const platform = process.platform as Platform;
+  const arch = process.arch;
+
+  const platformMap: Record<string, string> = {
+    'darwin-arm64': '@ast-grep/cli-darwin-arm64',
+    'darwin-x64': '@ast-grep/cli-darwin-x64',
+    'linux-arm64': '@ast-grep/cli-linux-arm64-gnu',
+    'linux-x64': '@ast-grep/cli-linux-x64-gnu',
+    'win32-x64': '@ast-grep/cli-win32-x64-msvc',
+    'win32-arm64': '@ast-grep/cli-win32-arm64-msvc',
+    'win32-ia32': '@ast-grep/cli-win32-ia32-msvc',
+  };
+
+  return platformMap[`${platform}-${arch}`] ?? null;
+}
+
+// Single source of truth for resolved CLI path
+let resolvedCliPath: string | null = null;
+
+export function findSgCliPathSync(): string | null {
+  const binaryName = process.platform === 'win32' ? 'sg.exe' : 'sg';
+
+  const cachedPath = getCachedBinaryPath();
+  if (cachedPath && isValidBinary(cachedPath)) {
+    return cachedPath;
+  }
+
+  try {
+    const require = createRequire(import.meta.url);
+    const cliPkgPath = require.resolve('@ast-grep/cli/package.json');
+    const cliDir = dirname(cliPkgPath);
+    const sgPath = join(cliDir, binaryName);
+
+    if (existsSync(sgPath) && isValidBinary(sgPath)) {
+      return sgPath;
+    }
+  } catch {
+    // @ast-grep/cli not installed
+  }
+
+  const platformPkg = getPlatformPackageName();
+  if (platformPkg) {
+    try {
+      const require = createRequire(import.meta.url);
+      const pkgPath = require.resolve(`${platformPkg}/package.json`);
+      const pkgDir = dirname(pkgPath);
+      const astGrepName =
+        process.platform === 'win32' ? 'ast-grep.exe' : 'ast-grep';
+      const binaryPath = join(pkgDir, astGrepName);
+
+      if (existsSync(binaryPath) && isValidBinary(binaryPath)) {
+        return binaryPath;
+      }
+    } catch {
+      // Platform-specific package not installed
+    }
+  }
+
+  if (process.platform === 'darwin') {
+    const homebrewPaths = ['/opt/homebrew/bin/sg', '/usr/local/bin/sg'];
+    for (const path of homebrewPaths) {
+      if (existsSync(path) && isValidBinary(path)) {
+        return path;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function getSgCliPath(): string {
+  if (resolvedCliPath !== null) {
+    return resolvedCliPath;
+  }
+
+  const syncPath = findSgCliPathSync();
+  if (syncPath) {
+    resolvedCliPath = syncPath;
+    return syncPath;
+  }
+
+  return 'sg';
+}
+
+export function setSgCliPath(path: string): void {
+  resolvedCliPath = path;
+}
+
+// Re-export language constants
+export { CLI_LANGUAGES };
+
+// Defaults
+export const DEFAULT_TIMEOUT_MS = 300_000;
+export const DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
+export const DEFAULT_MAX_MATCHES = 500;
+
+export const LANG_EXTENSIONS: Record<string, string[]> = {
+  bash: ['.bash', '.sh', '.zsh', '.bats'],
+  c: ['.c', '.h'],
+  cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.h'],
+  csharp: ['.cs'],
+  css: ['.css'],
+  elixir: ['.ex', '.exs'],
+  go: ['.go'],
+  haskell: ['.hs', '.lhs'],
+  html: ['.html', '.htm'],
+  java: ['.java'],
+  javascript: ['.js', '.jsx', '.mjs', '.cjs'],
+  json: ['.json'],
+  kotlin: ['.kt', '.kts'],
+  lua: ['.lua'],
+  nix: ['.nix'],
+  php: ['.php'],
+  python: ['.py', '.pyi'],
+  ruby: ['.rb', '.rake'],
+  rust: ['.rs'],
+  scala: ['.scala', '.sc'],
+  solidity: ['.sol'],
+  swift: ['.swift'],
+  typescript: ['.ts', '.cts', '.mts'],
+  tsx: ['.tsx'],
+  yaml: ['.yml', '.yaml'],
+};
+
+export interface EnvironmentCheckResult {
+  cli: {
+    available: boolean;
+    path: string;
+    error?: string;
+  };
+}
+
+/**
+ * Check if ast-grep CLI is available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export function checkEnvironment(): EnvironmentCheckResult {
+  const cliPath = getSgCliPath();
+  const result: EnvironmentCheckResult = {
+    cli: {
+      available: false,
+      path: cliPath,
+    },
+  };
+
+  if (existsSync(cliPath)) {
+    result.cli.available = true;
+  } else if (cliPath === 'sg') {
+    try {
+      const whichResult = spawnSync(
+        process.platform === 'win32' ? 'where' : 'which',
+        ['sg'],
+        {
+          encoding: 'utf-8',
+          timeout: 5000,
+        },
+      );
+      result.cli.available =
+        whichResult.status === 0 && !!whichResult.stdout?.trim();
+      if (!result.cli.available) {
+        result.cli.error = 'sg binary not found in PATH';
+      }
+    } catch {
+      result.cli.error = 'Failed to check sg availability';
+    }
+  } else {
+    result.cli.error = `Binary not found: ${cliPath}`;
+  }
+
+  return result;
+}
+
+/**
+ * Format environment check result as user-friendly message.
+ */
+export function formatEnvironmentCheck(result: EnvironmentCheckResult): string {
+  const lines: string[] = ['ast-grep Environment Status:', ''];
+
+  if (result.cli.available) {
+    lines.push(`✓ CLI: Available (${result.cli.path})`);
+  } else {
+    lines.push(`✗ CLI: Not available`);
+    if (result.cli.error) {
+      lines.push(`  Error: ${result.cli.error}`);
+    }
+    lines.push(`  Install: bun add -D @ast-grep/cli`);
+  }
+
+  lines.push('');
+  lines.push(`CLI supports ${CLI_LANGUAGES.length} languages`);
+
+  return lines.join('\n');
+}

package/src/tools/ast-grep/downloader.ts

@@ -0,0 +1,131 @@
+import { chmodSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { extractZip } from '../../utils';
+import { crossWrite } from '../../utils/compat';
+
+const REPO = 'ast-grep/ast-grep';
+
+// IMPORTANT: Update this when bumping @ast-grep/cli in package.json
+// This is only used as fallback when @ast-grep/cli package.json cannot be read
+const DEFAULT_VERSION = '0.40.0';
+
+function getAstGrepVersion(): string {
+  try {
+    const require = createRequire(import.meta.url);
+    const pkg = require('@ast-grep/cli/package.json');
+    return pkg.version;
+  } catch {
+    return DEFAULT_VERSION;
+  }
+}
+
+interface PlatformInfo {
+  arch: string;
+  os: string;
+}
+
+const PLATFORM_MAP: Record<string, PlatformInfo> = {
+  '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' },
+};
+
+export function getCacheDir(): string {
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base = localAppData || join(homedir(), 'AppData', 'Local');
+    return join(base, 'opencode-dux', 'bin');
+  }
+
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join(homedir(), '.cache');
+  return join(base, 'opencode-dux', 'bin');
+}
+
+export function getBinaryName(): string {
+  return process.platform === 'win32' ? 'sg.exe' : 'sg';
+}
+
+export function getCachedBinaryPath(): string | null {
+  const binaryPath = join(getCacheDir(), getBinaryName());
+  return existsSync(binaryPath) ? binaryPath : null;
+}
+
+export async function downloadAstGrep(
+  version: string = DEFAULT_VERSION,
+): Promise<string | null> {
+  const platformKey = `${process.platform}-${process.arch}`;
+  const platformInfo = PLATFORM_MAP[platformKey];
+
+  if (!platformInfo) {
+    console.error(
+      `[opencode-dux] Unsupported platform for ast-grep: ${platformKey}`,
+    );
+    return null;
+  }
+
+  const cacheDir = getCacheDir();
+  const binaryName = getBinaryName();
+  const binaryPath = join(cacheDir, binaryName);
+
+  if (existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  const { arch, os } = platformInfo;
+  const assetName = `app-${arch}-${os}.zip`;
+  const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
+
+  console.log(`[opencode-dux] Downloading ast-grep binary...`);
+
+  try {
+    if (!existsSync(cacheDir)) {
+      mkdirSync(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 arrayBuffer = await response.arrayBuffer();
+    await crossWrite(archivePath, arrayBuffer);
+
+    await extractZip(archivePath, cacheDir);
+
+    if (existsSync(archivePath)) {
+      unlinkSync(archivePath);
+    }
+
+    if (process.platform !== 'win32' && existsSync(binaryPath)) {
+      chmodSync(binaryPath, 0o755);
+    }
+
+    console.log(`[opencode-dux] ast-grep binary ready.`);
+
+    return binaryPath;
+  } catch (err) {
+    console.error(
+      `[opencode-dux] Failed to download ast-grep: ${err instanceof Error ? err.message : err}`,
+    );
+    return null;
+  }
+}
+
+export async function ensureAstGrepBinary(): Promise<string | null> {
+  const cachedPath = getCachedBinaryPath();
+  if (cachedPath) {
+    return cachedPath;
+  }
+
+  const version = getAstGrepVersion();
+  return downloadAstGrep(version);
+}

package/src/tools/ast-grep/index.ts

@@ -0,0 +1,24 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import { ast_grep_replace, ast_grep_search } from './tools';
+
+export const builtinTools: Record<string, ToolDefinition> = {
+  ast_grep_search,
+  ast_grep_replace,
+};
+
+export {
+  ensureCliAvailable,
+  getAstGrepPath,
+  isCliAvailable,
+  startBackgroundInit,
+} from './cli';
+export type { EnvironmentCheckResult } from './constants';
+export { checkEnvironment, formatEnvironmentCheck } from './constants';
+export {
+  ensureAstGrepBinary,
+  getCacheDir,
+  getCachedBinaryPath,
+} from './downloader';
+export type { CliLanguage, CliMatch, SgResult } from './types';
+export { CLI_LANGUAGES } from './types';
+export { ast_grep_replace, ast_grep_search };