@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/tools/glob/cli.ts

@@ -1,206 +0,0 @@
-import { resolve } from "node:path"
-import { spawn } from "bun"
-import {
-  resolveGrepCli,
-  type GrepBackend,
-  DEFAULT_TIMEOUT_MS,
-  DEFAULT_LIMIT,
-  DEFAULT_MAX_DEPTH,
-  DEFAULT_MAX_OUTPUT_BYTES,
-  RG_FILES_FLAGS,
-  DEFAULT_RG_THREADS,
-} from "./constants"
-import type { GlobOptions, GlobResult, FileMatch } from "./types"
-import { stat } from "node:fs/promises"
-import { rgSemaphore } from "../shared/semaphore"
-
-export interface ResolvedCli {
-  path: string
-  backend: GrepBackend
-}
-
-function buildRgArgs(options: GlobOptions): string[] {
-  const args: string[] = [
-    ...RG_FILES_FLAGS,
-    `--threads=${Math.min(options.threads ?? DEFAULT_RG_THREADS, DEFAULT_RG_THREADS)}`,
-    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
-  ]
-
-  if (options.hidden !== false) args.push("--hidden")
-  if (options.follow !== false) args.push("--follow")
-  if (options.noIgnore) args.push("--no-ignore")
-
-  args.push(`--glob=${options.pattern}`)
-
-  return args
-}
-
-function buildFindArgs(options: GlobOptions): string[] {
-  const args: string[] = []
-
-  if (options.follow !== false) {
-    args.push("-L")
-  }
-
-  args.push(".")
-
-  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)
-  args.push("-maxdepth", String(maxDepth))
-
-  args.push("-type", "f")
-  args.push("-name", options.pattern)
-
-  if (options.hidden === false) {
-    args.push("-not", "-path", "*/.*")
-  }
-
-  return args
-}
-
-function buildPowerShellCommand(options: GlobOptions): string[] {
-  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)
-  const paths = options.paths?.length ? options.paths : ["."]
-  const searchPath = paths[0] || "."
-
-  const escapedPath = searchPath.replace(/'/g, "''")
-  const escapedPattern = options.pattern.replace(/'/g, "''")
-
-  let psCommand = `Get-ChildItem -Path '${escapedPath}' -File -Recurse -Depth ${maxDepth - 1} -Filter '${escapedPattern}'`
-
-  if (options.hidden !== false) {
-    psCommand += " -Force"
-  }
-
-  // NOTE: Symlink following (-FollowSymlink) is NOT supported in PowerShell backend.
-  // -FollowSymlink was introduced in PowerShell Core 6.0+ and is unavailable in
-  // Windows PowerShell 5.1 (default on Windows). OpenCode auto-downloads ripgrep
-  // which handles symlinks via --follow. This fallback rarely triggers in practice.
-
-  psCommand += " -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName"
-
-  return ["powershell", "-NoProfile", "-Command", psCommand]
-}
-
-async function getFileMtime(filePath: string): Promise<number> {
-  try {
-    const stats = await stat(filePath)
-    return stats.mtime.getTime()
-  } catch {
-    return 0
-  }
-}
-
-export { buildRgArgs, buildFindArgs, buildPowerShellCommand }
-
-export async function runRgFiles(
-  options: GlobOptions,
-  resolvedCli?: ResolvedCli
-): Promise<GlobResult> {
-  await rgSemaphore.acquire()
-  try {
-    return await runRgFilesInternal(options, resolvedCli)
-  } finally {
-    rgSemaphore.release()
-  }
-}
-
-async function runRgFilesInternal(
-  options: GlobOptions,
-  resolvedCli?: ResolvedCli
-): Promise<GlobResult> {
-  const cli = resolvedCli ?? resolveGrepCli()
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)
-  const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT)
-
-  const isRg = cli.backend === "rg"
-  const isWindows = process.platform === "win32"
-
-  let command: string[]
-  let cwd: string | undefined
-
-  if (isRg) {
-    const args = buildRgArgs(options)
-    cwd = options.paths?.[0] || "."
-    args.push(".")
-    command = [cli.path, ...args]
-  } else if (isWindows) {
-    command = buildPowerShellCommand(options)
-    cwd = undefined
-  } else {
-    const args = buildFindArgs(options)
-    const paths = options.paths?.length ? options.paths : ["."]
-    cwd = paths[0] || "."
-    command = [cli.path, ...args]
-  }
-
-  const proc = spawn(command, {
-    stdout: "pipe",
-    stderr: "pipe",
-    cwd,
-  })
-
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill()
-      reject(new Error(`Glob search timeout after ${timeout}ms`))
-    }, timeout)
-    proc.exited.then(() => clearTimeout(id))
-  })
-
-  try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise])
-    const stderr = await new Response(proc.stderr).text()
-    const exitCode = await proc.exited
-
-    if (exitCode > 1 && stderr.trim()) {
-      return {
-        files: [],
-        totalFiles: 0,
-        truncated: false,
-        error: stderr.trim(),
-      }
-    }
-
-    const truncatedOutput = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES
-    const outputToProcess = truncatedOutput ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES) : stdout
-
-    const lines = outputToProcess.trim().split("\n").filter(Boolean)
-
-    const files: FileMatch[] = []
-    let truncated = false
-
-    for (const line of lines) {
-      if (files.length >= limit) {
-        truncated = true
-        break
-      }
-
-      let filePath: string
-      if (isRg) {
-        filePath = cwd ? resolve(cwd, line) : line
-      } else if (isWindows) {
-        filePath = line.trim()
-      } else {
-        filePath = `${cwd}/${line}`
-      }
-
-      const mtime = await getFileMtime(filePath)
-      files.push({ path: filePath, mtime })
-    }
-
-    files.sort((a, b) => b.mtime - a.mtime)
-
-    return {
-      files,
-      totalFiles: files.length,
-      truncated: truncated || truncatedOutput,
-    }
-  } catch (e) {
-    return {
-      files: [],
-      totalFiles: 0,
-      truncated: false,
-      error: e instanceof Error ? e.message : String(e),
-    }
-  }
-}

package/src/tools/glob/constants.ts

@@ -1,12 +0,0 @@
-export { resolveGrepCli, resolveGrepCliWithAutoInstall, type GrepBackend, DEFAULT_RG_THREADS } from "../grep/constants"
-
-export const DEFAULT_TIMEOUT_MS = 60_000
-export const DEFAULT_LIMIT = 100
-export const DEFAULT_MAX_DEPTH = 20
-export const DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024
-
-export const RG_FILES_FLAGS = [
-  "--files",
-  "--color=never",
-  "--glob=!.git/*",
-] as const

package/src/tools/glob/index.ts

@@ -1 +0,0 @@
-export { createGlobTools } from "./tools"

package/src/tools/glob/result-formatter.ts

@@ -1,26 +0,0 @@
-import type { GlobResult } from "./types"
-
-export function formatGlobResult(result: GlobResult): string {
-  if (result.error) {
-    return `Error: ${result.error}`
-  }
-
-  if (result.files.length === 0) {
-    return "No files found"
-  }
-
-  const lines: string[] = []
-  lines.push(`Found ${result.totalFiles} file(s)`)
-  lines.push("")
-
-  for (const file of result.files) {
-    lines.push(file.path)
-  }
-
-  if (result.truncated) {
-    lines.push("")
-    lines.push("(Results are truncated. Consider using a more specific path or pattern.)")
-  }
-
-  return lines.join("\n")
-}

package/src/tools/glob/tools.ts

@@ -1,49 +0,0 @@
-import { resolve } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { runRgFiles } from "./cli"
-import { resolveGrepCliWithAutoInstall } from "./constants"
-import { formatGlobResult } from "./result-formatter"
-
-export function createGlobTools(ctx: PluginInput): Record<string, ToolDefinition> {
-  const glob: ToolDefinition = tool({
-    description:
-      "Fast file pattern matching tool with safety limits (60s timeout, 100 file limit). " +
-      "Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\". " +
-      "Returns matching file paths sorted by modification time. " +
-      "Use this tool when you need to find files by name patterns.",
-    args: {
-      pattern: tool.schema.string().describe("The glob pattern to match files against"),
-      path: tool.schema
-        .string()
-        .optional()
-        .describe(
-          "The directory to search in. If not specified, the current working directory will be used. " +
-            "IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - " +
-            "simply omit it for the default behavior. Must be a valid directory path if provided."
-        ),
-    },
-    execute: async (args, context) => {
-      try {
-        const cli = await resolveGrepCliWithAutoInstall()
-        const runtimeCtx = context as Record<string, unknown>
-        const dir = typeof runtimeCtx.directory === "string" ? runtimeCtx.directory : ctx.directory
-        const searchPath = args.path ? resolve(dir, args.path) : dir
-
-        const result = await runRgFiles(
-          {
-            pattern: args.pattern,
-            paths: [searchPath],
-          },
-          cli
-        )
-
-        return formatGlobResult(result)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  return { glob }
-}

package/src/tools/glob/types.ts

@@ -1,23 +0,0 @@
-export interface FileMatch {
-  path: string
-  mtime: number
-}
-
-export interface GlobResult {
-  files: FileMatch[]
-  totalFiles: number
-  truncated: boolean
-  error?: string
-}
-
-export interface GlobOptions {
-  pattern: string
-  paths?: string[]
-  hidden?: boolean
-  follow?: boolean
-  noIgnore?: boolean
-  maxDepth?: number
-  timeout?: number
-  limit?: number
-  threads?: number  // limit rg thread count
-}

package/src/tools/grep/cli.ts

@@ -1,279 +0,0 @@
-import { spawn } from "bun"
-import {
-  resolveGrepCli,
-  type ResolvedCli,
-  type GrepBackend,
-  DEFAULT_MAX_DEPTH,
-  DEFAULT_MAX_FILESIZE,
-  DEFAULT_MAX_COUNT,
-  DEFAULT_MAX_COLUMNS,
-  DEFAULT_TIMEOUT_MS,
-  DEFAULT_MAX_OUTPUT_BYTES,
-  DEFAULT_RG_THREADS,
-  RG_SAFETY_FLAGS,
-  GREP_SAFETY_FLAGS,
-} from "./constants"
-import type { GrepOptions, GrepMatch, GrepResult, CountResult } from "./types"
-import { rgSemaphore } from "../shared/semaphore"
-
-function buildRgArgs(options: GrepOptions): string[] {
-  const args: string[] = [
-    ...RG_SAFETY_FLAGS,
-    `--threads=${Math.min(options.threads ?? DEFAULT_RG_THREADS, DEFAULT_RG_THREADS)}`,
-    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
-    `--max-filesize=${options.maxFilesize ?? DEFAULT_MAX_FILESIZE}`,
-    `--max-count=${Math.min(options.maxCount ?? DEFAULT_MAX_COUNT, DEFAULT_MAX_COUNT)}`,
-    `--max-columns=${Math.min(options.maxColumns ?? DEFAULT_MAX_COLUMNS, DEFAULT_MAX_COLUMNS)}`,
-  ]
-
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`)
-  }
-
-  if (options.caseSensitive) args.push("--case-sensitive")
-  if (options.wholeWord) args.push("-w")
-  if (options.fixedStrings) args.push("-F")
-  if (options.multiline) args.push("-U")
-  if (options.hidden) args.push("--hidden")
-  if (options.noIgnore) args.push("--no-ignore")
-
-  if (options.fileType?.length) {
-    for (const type of options.fileType) {
-      args.push(`--type=${type}`)
-    }
-  }
-
-  if (options.globs) {
-    for (const glob of options.globs) {
-      args.push(`--glob=${glob}`)
-    }
-  }
-
-  if (options.excludeGlobs) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--glob=!${glob}`)
-    }
-  }
-
-  if (options.outputMode === "files_with_matches") {
-    args.push("--files-with-matches")
-  } else if (options.outputMode === "count") {
-    args.push("--count")
-  }
-
-  return args
-}
-
-function buildGrepArgs(options: GrepOptions): string[] {
-  const args: string[] = [...GREP_SAFETY_FLAGS, "-r"]
-
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`)
-  }
-
-  if (!options.caseSensitive) args.push("-i")
-  if (options.wholeWord) args.push("-w")
-  if (options.fixedStrings) args.push("-F")
-
-  if (options.globs?.length) {
-    for (const glob of options.globs) {
-      args.push(`--include=${glob}`)
-    }
-  }
-
-  if (options.excludeGlobs?.length) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--exclude=${glob}`)
-    }
-  }
-
-  args.push("--exclude-dir=.git", "--exclude-dir=node_modules")
-
-  return args
-}
-
-function buildArgs(options: GrepOptions, backend: GrepBackend): string[] {
-  return backend === "rg" ? buildRgArgs(options) : buildGrepArgs(options)
-}
-
-function parseOutput(output: string, filesOnly = false): GrepMatch[] {
-  if (!output.trim()) return []
-
-  const matches: GrepMatch[] = []
-  const lines = output.split("\n")
-
-  for (let line of lines) {
-    line = line.replace(/\r$/, "")
-    if (!line.trim()) continue
-
-    if (filesOnly) {
-      // --files-with-matches outputs only file paths, one per line
-      matches.push({
-        file: line.trim(),
-        line: 0,
-        text: "",
-      })
-      continue
-    }
-
-    // Handle Windows drive-letter paths (e.g. C:\path\file.ts:42:content)
-    const match = line.match(/^([A-Za-z]:[\\\/].*?|.+?):(\d+):(.*)$/)
-    if (match) {
-      matches.push({
-        file: match[1],
-        line: parseInt(match[2], 10),
-        text: match[3],
-      })
-    }
-  }
-
-  return matches
-}
-
-function parseCountOutput(output: string): CountResult[] {
-  if (!output.trim()) return []
-
-  const results: CountResult[] = []
-  const lines = output.split("\n")
-
-  for (let line of lines) {
-    line = line.replace(/\r$/, "")
-    if (!line.trim()) continue
-
-    const match = line.match(/^([A-Za-z]:[\\\/].*?|.+?):(\d+)$/)
-    if (match) {
-      results.push({
-        file: match[1],
-        count: parseInt(match[2], 10),
-      })
-    }
-  }
-
-  return results
-}
-
-export async function runRg(options: GrepOptions, resolvedCli?: ResolvedCli): Promise<GrepResult> {
-  await rgSemaphore.acquire()
-  try {
-    return await runRgInternal(options, resolvedCli)
-  } finally {
-    rgSemaphore.release()
-  }
-}
-
-async function runRgInternal(options: GrepOptions, resolvedCli?: ResolvedCli): Promise<GrepResult> {
-  const cli = resolvedCli ?? resolveGrepCli()
-  const args = buildArgs(options, cli.backend)
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)
-
-  if (cli.backend === "rg") {
-    args.push("--", options.pattern)
-  } else {
-    args.push("-e", options.pattern)
-  }
-
-  const paths = options.paths?.length ? options.paths : ["."]
-  args.push(...paths)
-  const proc = spawn([cli.path, ...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))
-  })
-
-  try {
-    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
-
-    if (exitCode > 1 && stderr.trim()) {
-      return {
-        matches: [],
-        totalMatches: 0,
-        filesSearched: 0,
-        truncated: false,
-        error: stderr.trim(),
-      }
-    }
-
-    const matches = parseOutput(outputToProcess, options.outputMode === "files_with_matches")
-    const limited = options.headLimit && options.headLimit > 0
-      ? matches.slice(0, options.headLimit)
-      : matches
-    const filesSearched = new Set(limited.map((m) => m.file)).size
-
-    return {
-      matches: limited,
-      totalMatches: limited.length,
-      filesSearched,
-      truncated: truncated || (options.headLimit ? matches.length > options.headLimit : false),
-    }
-  } catch (e) {
-    return {
-      matches: [],
-      totalMatches: 0,
-      filesSearched: 0,
-      truncated: false,
-      error: e instanceof Error ? e.message : String(e),
-    }
-  }
-}
-
-export async function runRgCount(
-  options: Omit<GrepOptions, "context">,
-  resolvedCli?: ResolvedCli
-): Promise<CountResult[]> {
-  await rgSemaphore.acquire()
-  try {
-    return await runRgCountInternal(options, resolvedCli)
-  } finally {
-    rgSemaphore.release()
-  }
-}
-
-async function runRgCountInternal(
-  options: Omit<GrepOptions, "context">,
-  resolvedCli?: ResolvedCli
-): Promise<CountResult[]> {
-  const cli = resolvedCli ?? resolveGrepCli()
-  const args = buildArgs({ ...options, context: 0 }, cli.backend)
-
-  if (cli.backend === "rg") {
-    args.push("--count", "--", options.pattern)
-  } else {
-    args.push("-c", "-e", options.pattern)
-  }
-
-  const paths = options.paths?.length ? options.paths : ["."]
-  args.push(...paths)
-
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)
-  const proc = spawn([cli.path, ...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))
-  })
-
-  try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise])
-    return parseCountOutput(stdout)
-  } catch (e) {
-    throw new Error(`Count search failed: ${e instanceof Error ? e.message : String(e)}`)
-  }
-}