@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

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

@@ -1,119 +0,0 @@
-import { existsSync } from "fs"
-import { join } from "path"
-import { homedir } from "os"
-import { createRequire } from "module"
-import {
-  cleanupArchive,
-  downloadArchive,
-  ensureCacheDir,
-  ensureExecutable,
-  extractZipArchive,
-  getCachedBinaryPath as getCachedBinaryPathShared,
-} from "../../shared/binary-downloader"
-import { log } from "../../shared/logger"
-import { CACHE_DIR_NAME, PUBLISHED_PACKAGE_NAME } from "../../shared/plugin-identity"
-
-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.41.1"
-
-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, CACHE_DIR_NAME, "bin")
-  }
-
-  const xdgCache = process.env.XDG_CACHE_HOME
-  const base = xdgCache || join(homedir(), ".cache")
-  return join(base, CACHE_DIR_NAME, "bin")
-}
-
-export function getBinaryName(): string {
-  return process.platform === "win32" ? "sg.exe" : "sg"
-}
-
-export function getCachedBinaryPath(): string | null {
-  return getCachedBinaryPathShared(getCacheDir(), getBinaryName())
-}
-
-
-
-export async function downloadAstGrep(version: string = DEFAULT_VERSION): Promise<string | null> {
-  const platformKey = `${process.platform}-${process.arch}`
-  const platformInfo = PLATFORM_MAP[platformKey]
-
-  if (!platformInfo) {
-    log(`[${PUBLISHED_PACKAGE_NAME}] 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}`
-
-  log(`[${PUBLISHED_PACKAGE_NAME}] Downloading ast-grep binary...`)
-
-  try {
-    const archivePath = join(cacheDir, assetName)
-    ensureCacheDir(cacheDir)
-    await downloadArchive(downloadUrl, archivePath)
-    await extractZipArchive(archivePath, cacheDir)
-    cleanupArchive(archivePath)
-    ensureExecutable(binaryPath)
-
-    log(`[${PUBLISHED_PACKAGE_NAME}] ast-grep binary ready.`)
-
-    return binaryPath
-  } catch (err) {
-    log(
-      `[${PUBLISHED_PACKAGE_NAME}] 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/environment-check.ts

@@ -1,59 +0,0 @@
-import { existsSync } from "fs"
-
-import { CLI_LANGUAGES } from "./language-support"
-import { getSgCliPath } from "./sg-cli-path"
-
-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 ?? "not found",
-		},
-	}
-
-	if (cliPath && existsSync(cliPath)) {
-		result.cli.available = true
-	} else if (!cliPath) {
-		result.cli.error = "ast-grep binary not found. Install with: bun add -D @ast-grep/cli"
-	} 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:", ""]
-
-	// CLI status
-	if (result.cli.available) {
-		lines.push(`[OK] CLI: Available (${result.cli.path})`)
-	} else {
-		lines.push("[X] 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/index.ts

@@ -1,5 +0,0 @@
-export { createAstGrepTools } from "./tools"
-export { ensureAstGrepBinary, getCachedBinaryPath, getCacheDir } from "./downloader"
-export { getAstGrepPath, isCliAvailable, ensureCliAvailable, startBackgroundInit } from "./cli"
-export { checkEnvironment, formatEnvironmentCheck } from "./constants"
-export type { EnvironmentCheckResult } from "./constants"

package/src/tools/ast-grep/language-support.ts

@@ -1,60 +0,0 @@
-// CLI supported languages (25 total)
-export const CLI_LANGUAGES = [
-	"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",
-] as const
-
-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"],
-}

package/src/tools/ast-grep/process-output-timeout.ts

@@ -1,28 +0,0 @@
-type SpawnedProcess = {
-	stdout: ReadableStream | null
-	stderr: ReadableStream | null
-	exited: Promise<number>
-	kill: () => void
-}
-
-export async function collectProcessOutputWithTimeout(
-	process: SpawnedProcess,
-	timeoutMs: number
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-	const timeoutPromise = new Promise<never>((_, reject) => {
-		const timeoutId = setTimeout(() => {
-			process.kill()
-			reject(new Error(`Search timeout after ${timeoutMs}ms`))
-		}, timeoutMs)
-		process.exited.then(() => clearTimeout(timeoutId))
-	})
-
-	const stdoutPromise = process.stdout ? new Response(process.stdout).text() : Promise.resolve("")
-	const stderrPromise = process.stderr ? new Response(process.stderr).text() : Promise.resolve("")
-
-	const stdout = await Promise.race([stdoutPromise, timeoutPromise])
-	const stderr = await stderrPromise
-	const exitCode = await process.exited
-
-	return { stdout, stderr, exitCode }
-}

package/src/tools/ast-grep/result-formatter.ts

@@ -1,102 +0,0 @@
-import type { AnalyzeResult, SgResult } from "./types"
-
-export function formatSearchResult(result: SgResult): string {
-  if (result.error) {
-    return `Error: ${result.error}`
-  }
-
-  if (result.matches.length === 0) {
-    return "No matches found"
-  }
-
-  const lines: string[] = []
-
-  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(`[TRUNCATED] Results truncated (${reason})\n`)
-  }
-
-  lines.push(`Found ${result.matches.length} match(es)${result.truncated ? ` (truncated from ${result.totalMatches})` : ""}:\n`)
-
-  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()}`)
-    lines.push("")
-  }
-
-  return lines.join("\n")
-}
-
-export function formatReplaceResult(result: SgResult, isDryRun: boolean): string {
-  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: string[] = []
-
-  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(`[TRUNCATED] Results truncated (${reason})\n`)
-  }
-
-  lines.push(`${prefix}${result.matches.length} replacement(s):\n`)
-
-  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}`)
-    lines.push("")
-  }
-
-  if (isDryRun) {
-    lines.push("Use dryRun=false to apply changes")
-  }
-
-  return lines.join("\n")
-}
-
-export function formatAnalyzeResult(results: AnalyzeResult[], extractedMetaVars: boolean): string {
-  if (results.length === 0) {
-    return "No matches found"
-  }
-
-  const lines: string[] = [`Found ${results.length} match(es):\n`]
-
-  for (const result of results) {
-    const loc = `L${result.range.start.line + 1}:${result.range.start.column + 1}`
-    lines.push(`[${loc}] (${result.kind})`)
-    lines.push(`  ${result.text}`)
-
-    if (extractedMetaVars && result.metaVariables.length > 0) {
-      lines.push("  Meta-variables:")
-      for (const mv of result.metaVariables) {
-        lines.push(`    $${mv.name} = "${mv.text}" (${mv.kind})`)
-      }
-    }
-    lines.push("")
-  }
-
-  return lines.join("\n")
-}
-
-export function formatTransformResult(_original: string, transformed: string, editCount: number): string {
-  if (editCount === 0) {
-    return "No matches found to transform"
-  }
-
-  return `Transformed (${editCount} edit(s)):\n\`\`\`\n${transformed}\n\`\`\``
-}

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

@@ -1,102 +0,0 @@
-import { createRequire } from "module"
-import { dirname, join } from "path"
-import { existsSync, statSync } from "fs"
-
-import { getCachedBinaryPath } from "./downloader"
-
-type Platform = "darwin" | "linux" | "win32" | "unsupported"
-
-function isValidBinary(filePath: string): boolean {
-	try {
-		return statSync(filePath).size > 10000
-	} 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
-}
-
-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 cliPackageJsonPath = require.resolve("@ast-grep/cli/package.json")
-		const cliDirectory = dirname(cliPackageJsonPath)
-		const sgPath = join(cliDirectory, binaryName)
-
-		if (existsSync(sgPath) && isValidBinary(sgPath)) {
-			return sgPath
-		}
-	} catch {
-		// @ast-grep/cli not installed
-	}
-
-	const platformPackage = getPlatformPackageName()
-	if (platformPackage) {
-		try {
-			const require = createRequire(import.meta.url)
-			const packageJsonPath = require.resolve(`${platformPackage}/package.json`)
-			const packageDirectory = dirname(packageJsonPath)
-			const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep"
-			const binaryPath = join(packageDirectory, astGrepBinaryName)
-
-			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
-}
-
-let resolvedCliPath: string | null = null
-
-export function getSgCliPath(): string | null {
-	if (resolvedCliPath !== null) {
-		return resolvedCliPath
-	}
-
-	const syncPath = findSgCliPathSync()
-	if (syncPath) {
-		resolvedCliPath = syncPath
-		return syncPath
-	}
-
-	return null
-}
-
-export function setSgCliPath(path: string): void {
-	resolvedCliPath = path
-}

package/src/tools/ast-grep/sg-compact-json-output.ts

@@ -1,54 +0,0 @@
-import { DEFAULT_MAX_MATCHES, DEFAULT_MAX_OUTPUT_BYTES } from "./constants"
-import type { CliMatch, SgResult } from "./types"
-
-export function createSgResultFromStdout(stdout: string): SgResult {
-	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,
-	}
-}

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

@@ -1,117 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { CLI_LANGUAGES } from "./constants"
-import { runSg } from "./cli"
-import { formatSearchResult, formatReplaceResult } from "./result-formatter"
-import type { CliLanguage } from "./types"
-
-async function showOutputToUser(context: unknown, output: string): Promise<void> {
-  const ctx = context as {
-    metadata?: (input: { metadata: { output: string } }) => void | Promise<void>
-  }
-  await ctx.metadata?.({ metadata: { output } })
-}
-
-function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null {
-  const src = pattern.trim()
-
-  if (lang === "python") {
-    if (src.startsWith("class ") && src.endsWith(":")) {
-      const withoutColon = src.slice(0, -1)
-      return `Hint: Remove trailing colon. Try: "${withoutColon}"`
-    }
-    if ((src.startsWith("def ") || src.startsWith("async def ")) && src.endsWith(":")) {
-      const withoutColon = src.slice(0, -1)
-      return `Hint: Remove trailing colon. Try: "${withoutColon}"`
-    }
-  }
-
-  if (["javascript", "typescript", "tsx"].includes(lang)) {
-    if (/^(export\s+)?(async\s+)?function\s+\$[A-Z_]+\s*$/i.test(src)) {
-      return `Hint: Function patterns need params and body. Try "function $NAME($$$) { $$$ }"`
-    }
-  }
-
-  return null
-}
-
-export function createAstGrepTools(ctx: PluginInput): Record<string, ToolDefinition> {
-  const ast_grep_search: ToolDefinition = 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($$$)'",
-    args: {
-      pattern: tool.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
-      lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-      paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search (default: ['.'])"),
-      globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-      context: tool.schema.number().optional().describe("Context lines around match"),
-    },
-    execute: async (args, context) => {
-      try {
-        const result = await runSg({
-          pattern: args.pattern,
-          lang: args.lang as CliLanguage,
-          paths: args.paths ?? [ctx.directory],
-          globs: args.globs,
-          context: args.context,
-        })
-
-        let output = formatSearchResult(result)
-
-        if (result.matches.length === 0 && !result.error) {
-          const hint = getEmptyResultHint(args.pattern, args.lang as CliLanguage)
-          if (hint) {
-            output += `\n\n${hint}`
-          }
-        }
-
-        await showOutputToUser(context, output)
-        return output
-      } catch (e) {
-        const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-        await showOutputToUser(context, output)
-        return output
-      }
-    },
-  })
-
-  const ast_grep_replace: ToolDefinition = tool({
-    description:
-      "Replace code patterns across filesystem with AST-aware rewriting. " +
-      "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " +
-      "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
-    args: {
-      pattern: tool.schema.string().describe("AST pattern to match"),
-      rewrite: tool.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
-      lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-      paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
-      globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs"),
-      dryRun: tool.schema.boolean().optional().describe("Preview changes without applying (default: true)"),
-    },
-    execute: async (args, context) => {
-      try {
-        const result = await runSg({
-          pattern: args.pattern,
-          rewrite: args.rewrite,
-          lang: args.lang as CliLanguage,
-          paths: args.paths ?? [ctx.directory],
-          globs: args.globs,
-          updateAll: args.dryRun === false,
-        })
-        const output = formatReplaceResult(result, args.dryRun !== false)
-        await showOutputToUser(context, output)
-        return output
-      } catch (e) {
-        const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-        await showOutputToUser(context, output)
-        return output
-      }
-    },
-  })
-
-  return { ast_grep_search, ast_grep_replace }
-}