@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/grep/constants.ts

@@ -1,141 +0,0 @@
-import { existsSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { spawnSync } from "node:child_process"
-import { getInstalledRipgrepPath, downloadAndInstallRipgrep } from "./downloader"
-import { getDataDir } from "../../shared/data-path"
-import { log } from "../../shared/logger"
-import { PUBLISHED_PACKAGE_NAME } from "../../shared/plugin-identity"
-
-export type GrepBackend = "rg" | "grep"
-
-export interface ResolvedCli {
-  path: string
-  backend: GrepBackend
-}
-
-let cachedCli: ResolvedCli | null = null
-let autoInstallAttempted = false
-
-function findExecutable(name: string): string | null {
-  const isWindows = process.platform === "win32"
-  const cmd = isWindows ? "where" : "which"
-
-  try {
-    const result = spawnSync(cmd, [name], { encoding: "utf-8", timeout: 5000 })
-    if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim().split("\n")[0]
-    }
-  } catch {
-    // Command execution failed
-  }
-  return null
-}
-
-function getOpenCodeBundledRg(): string | null {
-  const execPath = process.execPath
-  const execDir = dirname(execPath)
-
-  const isWindows = process.platform === "win32"
-  const rgName = isWindows ? "rg.exe" : "rg"
-
-  const candidates = [
-    // OpenCode XDG data path (highest priority - where OpenCode installs rg)
-    join(getDataDir(), "opencode", "bin", rgName),
-    // Legacy paths relative to execPath
-    join(execDir, rgName),
-    join(execDir, "bin", rgName),
-    join(execDir, "..", "bin", rgName),
-    join(execDir, "..", "libexec", rgName),
-  ]
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate
-    }
-  }
-
-  return null
-}
-
-export function resolveGrepCli(): ResolvedCli {
-  if (cachedCli) return cachedCli
-
-  const bundledRg = getOpenCodeBundledRg()
-  if (bundledRg) {
-    cachedCli = { path: bundledRg, backend: "rg" }
-    return cachedCli
-  }
-
-  const systemRg = findExecutable("rg")
-  if (systemRg) {
-    cachedCli = { path: systemRg, backend: "rg" }
-    return cachedCli
-  }
-
-  const installedRg = getInstalledRipgrepPath()
-  if (installedRg) {
-    cachedCli = { path: installedRg, backend: "rg" }
-    return cachedCli
-  }
-
-  const grep = findExecutable("grep")
-  if (grep) {
-    cachedCli = { path: grep, backend: "grep" }
-    return cachedCli
-  }
-
-  cachedCli = { path: "rg", backend: "rg" }
-  return cachedCli
-}
-
-export async function resolveGrepCliWithAutoInstall(): Promise<ResolvedCli> {
-  const current = resolveGrepCli()
-
-  if (current.backend === "rg" && current.path !== "rg") {
-    return current
-  }
-
-  if (autoInstallAttempted) {
-    return current
-  }
-
-  autoInstallAttempted = true
-
-  try {
-    const rgPath = await downloadAndInstallRipgrep()
-    cachedCli = { path: rgPath, backend: "rg" }
-    return cachedCli
-  } catch (error) {
-    if (current.backend === "grep") {
-      log(`[${PUBLISHED_PACKAGE_NAME}] Failed to auto-install ripgrep. Falling back to GNU grep.`, {
-        error: error instanceof Error ? error.message : String(error),
-        grep_path: current.path,
-      })
-    } else {
-      log(`[${PUBLISHED_PACKAGE_NAME}] Failed to auto-install ripgrep and GNU grep was not found.`, {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-
-    return current
-  }
-}
-
-export const DEFAULT_MAX_DEPTH = 20
-export const DEFAULT_MAX_FILESIZE = "10M"
-export const DEFAULT_MAX_COUNT = 500
-export const DEFAULT_MAX_COLUMNS = 1000
-export const DEFAULT_CONTEXT = 2
-export const DEFAULT_TIMEOUT_MS = 60_000
-export const DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024
-export const DEFAULT_RG_THREADS = 4
-
-export const RG_SAFETY_FLAGS = [
-  "--no-follow",
-  "--color=never",
-  "--no-heading",
-  "--line-number",
-  "--with-filename",
-] as const
-
-export const GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"] as const

package/src/tools/grep/downloader.ts

@@ -1,128 +0,0 @@
-import { existsSync, readdirSync } from "node:fs"
-import { join } from "node:path"
-import { extractZip as extractZipBase } from "../../shared"
-import { CACHE_DIR_NAME } from "../../shared/plugin-identity"
-import {
-  cleanupArchive,
-  downloadArchive,
-  ensureCacheDir,
-  ensureExecutable,
-  extractTarGz as extractTarGzArchive,
-} from "../../shared/binary-downloader"
-
-export function findFileRecursive(dir: string, filename: string): string | null {
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true, recursive: true })
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === filename) {
-        return join(entry.parentPath ?? dir, entry.name)
-      }
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-const RG_VERSION = "14.1.1"
-
-const PLATFORM_CONFIG: Record<string, { platform: string; extension: "tar.gz" | "zip" } | undefined> = {
-  "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
-  "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
-  "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
-  "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
-  "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
-}
-
-function getPlatformKey(): string {
-  return `${process.arch}-${process.platform}`
-}
-
-function getInstallDir(): string {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "."
-  return join(homeDir, ".cache", CACHE_DIR_NAME, "bin")
-}
-
-function getRgPath(): string {
-  const isWindows = process.platform === "win32"
-  return join(getInstallDir(), isWindows ? "rg.exe" : "rg")
-}
-
-async function extractTarGz(archivePath: string, destDir: string): Promise<void> {
-  const platformKey = getPlatformKey()
-
-  const args = ["tar", "-xzf", archivePath, "--strip-components=1"]
-
-  if (platformKey.endsWith("-darwin")) {
-    args.push("--include=*/rg")
-  } else if (platformKey.endsWith("-linux")) {
-    args.push("--wildcards", "*/rg")
-  }
-
-  await extractTarGzArchive(archivePath, destDir, { args, cwd: destDir })
-}
-
-async function extractZip(archivePath: string, destDir: string): Promise<void> {
-  await extractZipBase(archivePath, destDir)
-
-  const binaryName = process.platform === "win32" ? "rg.exe" : "rg"
-  const foundPath = findFileRecursive(destDir, binaryName)
-  if (foundPath) {
-    const destPath = join(destDir, binaryName)
-    if (foundPath !== destPath) {
-      const { renameSync } = await import("node:fs")
-      renameSync(foundPath, destPath)
-    }
-  }
-}
-
-export async function downloadAndInstallRipgrep(): Promise<string> {
-  const platformKey = getPlatformKey()
-  const config = PLATFORM_CONFIG[platformKey]
-
-  if (!config) {
-    throw new Error(`Unsupported platform: ${platformKey}`)
-  }
-
-  const installDir = getInstallDir()
-  const rgPath = getRgPath()
-
-  if (existsSync(rgPath)) {
-    return rgPath
-  }
-
-  ensureCacheDir(installDir)
-
-  const filename = `ripgrep-${RG_VERSION}-${config.platform}.${config.extension}`
-  const url = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`
-  const archivePath = join(installDir, filename)
-
-  try {
-    await downloadArchive(url, archivePath)
-
-    if (config.extension === "tar.gz") {
-      await extractTarGz(archivePath, installDir)
-    } else {
-      await extractZip(archivePath, installDir)
-    }
-
-    ensureExecutable(rgPath)
-
-    if (!existsSync(rgPath)) {
-      throw new Error("ripgrep binary not found after extraction")
-    }
-
-    return rgPath
-  } finally {
-    try {
-      cleanupArchive(archivePath)
-    } catch {
-      // Cleanup failures are non-critical
-    }
-  }
-}
-
-export function getInstalledRipgrepPath(): string | null {
-  const rgPath = getRgPath()
-  return existsSync(rgPath) ? rgPath : null
-}

package/src/tools/grep/index.ts

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

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

@@ -1,60 +0,0 @@
-import type { GrepResult, GrepMatch, CountResult } from "./types"
-
-export function formatGrepResult(result: GrepResult): string {
-  if (result.error) {
-    return `Error: ${result.error}`
-  }
-
-  if (result.matches.length === 0) {
-    return "No matches found"
-  }
-
-  const lines: string[] = []
-  const isFilesOnlyMode = result.matches.every((match) => match.line === 0 && match.text.trim() === "")
-
-  lines.push(`Found ${result.totalMatches} match(es) in ${result.filesSearched} file(s)`)
-  if (result.truncated) {
-    lines.push("[Output truncated due to size limit]")
-  }
-  lines.push("")
-
-  const byFile = new Map<string, GrepMatch[]>()
-  for (const match of result.matches) {
-    const existing = byFile.get(match.file) || []
-    existing.push(match)
-    byFile.set(match.file, existing)
-  }
-
-  for (const [file, matches] of byFile) {
-    lines.push(file)
-    if (!isFilesOnlyMode) {
-      for (const match of matches) {
-        const trimmedText = match.text.trim()
-        if (match.line === 0 && trimmedText === "") {
-          continue
-        }
-        lines.push(`  ${match.line}: ${trimmedText}`)
-      }
-    }
-    lines.push("")
-  }
-
-  return lines.join("\n")
-}
-
-export function formatCountResult(results: CountResult[]): string {
-  if (results.length === 0) {
-    return "No matches found"
-  }
-
-  const total = results.reduce((sum, r) => sum + r.count, 0)
-  const lines: string[] = [`Found ${total} match(es) in ${results.length} file(s):`, ""]
-
-  const sorted = [...results].sort((a, b) => b.count - a.count)
-
-  for (const { file, count } of sorted) {
-    lines.push(`  ${count.toString().padStart(6)}: ${file}`)
-  }
-
-  return lines.join("\n")
-}

package/src/tools/grep/tools.ts

@@ -1,75 +0,0 @@
-import { resolve } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { runRg, runRgCount } from "./cli"
-import { resolveGrepCliWithAutoInstall } from "./constants"
-import { formatGrepResult, formatCountResult } from "./result-formatter"
-
-export function createGrepTools(ctx: PluginInput): Record<string, ToolDefinition> {
-  const grep: ToolDefinition = tool({
-    description:
-      "Fast content search tool with safety limits (60s timeout, 256KB output). " +
-      "Searches file contents using regular expressions. " +
-      "Supports full regex syntax (eg. \"log.*Error\", \"function\\s+\\w+\", etc.). " +
-      "Filter files by pattern with the include parameter (eg. \"*.js\", \"*.{ts,tsx}\"). " +
-      "Output modes: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts per file.",
-    args: {
-      pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
-      include: tool.schema
-        .string()
-        .optional()
-        .describe("File pattern to include in the search (e.g. \"*.js\", \"*.{ts,tsx}\")"),
-      path: tool.schema
-        .string()
-        .optional()
-        .describe("The directory to search in. Defaults to the current working directory."),
-      output_mode: tool.schema
-        .enum(["content", "files_with_matches", "count"])
-        .optional()
-        .describe(
-          "Output mode: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts per file."
-        ),
-      head_limit: tool.schema
-        .number()
-        .optional()
-        .describe("Limit output to first N entries. 0 or omitted means no limit."),
-    },
-    execute: async (args, context) => {
-      try {
-        const globs = args.include ? [args.include] : undefined
-        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 paths = [searchPath]
-        const outputMode = args.output_mode ?? "files_with_matches"
-        const headLimit = args.head_limit ?? 0
-        const cli = await resolveGrepCliWithAutoInstall()
-
-        if (outputMode === "count") {
-          const results = await runRgCount({
-            pattern: args.pattern,
-            paths,
-            globs,
-          }, cli)
-          const limited = headLimit > 0 ? results.slice(0, headLimit) : results
-          return formatCountResult(limited)
-        }
-
-        const result = await runRg({
-          pattern: args.pattern,
-          paths,
-          globs,
-          context: 0,
-          outputMode,
-          headLimit,
-        }, cli)
-
-        return formatGrepResult(result)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  return { grep }
-}

package/src/tools/grep/types.ts

@@ -1,42 +0,0 @@
-export interface GrepMatch {
-  file: string
-  line: number
-  column?: number
-  text: string
-}
-
-export interface GrepResult {
-  matches: GrepMatch[]
-  totalMatches: number
-  filesSearched: number
-  truncated: boolean
-  error?: string
-}
-
-export interface GrepOptions {
-  pattern: string
-  paths?: string[]
-  globs?: string[]
-  excludeGlobs?: string[]
-  context?: number
-  maxDepth?: number
-  maxFilesize?: string
-  maxCount?: number
-  maxColumns?: number
-  caseSensitive?: boolean
-  wholeWord?: boolean
-  fixedStrings?: boolean
-  multiline?: boolean
-  hidden?: boolean
-  noIgnore?: boolean
-  fileType?: string[]
-  timeout?: number
-  threads?: number
-  outputMode?: "content" | "files_with_matches" | "count"
-  headLimit?: number
-}
-
-export interface CountResult {
-  file: string
-  count: number
-}

package/src/tools/hashline-edit/AGENTS.md

@@ -1,92 +0,0 @@
-# src/tools/hashline-edit/ — Hash-Anchored File Edit Tool
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-24 files. Implements the `hashline_edit` tool — hash-anchored file editing where every line reference includes a content hash (`LINE#ID`). Validates hashes before applying edits, rejecting stale references.
-
-## THREE-OP MODEL
-
-All edits use exactly 3 operations:
-
-| Op | pos | end | lines | Effect |
-|----|-----|-----|-------|--------|
-| `replace` | required | optional | required | Replace single line or range pos..end |
-| `append` | optional | optional | required | Insert after anchor (or EOF if no anchor) |
-| `prepend` | optional | optional | required | Insert before anchor (or BOF if no anchor) |
-
-`lines: null` or `lines: []` with `replace` = delete. `delete: true` at tool level = delete file.
-
-## EXECUTION PIPELINE
-
-```
-hashline-edit-executor.ts
-  → normalize-edits.ts       # Parse RawHashlineEdit → HashlineEdit (validate op schema)
-  → validation.ts            # Validate LINE#ID references (hash match, line exists)
-  → edit-ordering.ts         # Sort bottom-up (by line number, descending)
-  → edit-deduplication.ts    # Remove duplicate ops
-  → edit-operations.ts       # Apply each op using edit-operation-primitives.ts
-  → autocorrect-replacement-lines.ts  # Auto-fix indentation/formatting
-  → hashline-edit-diff.ts    # Build diff output using diff-utils.ts
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `tools.ts` | `createHashlineEditTool()` factory — tool schema + entry point |
-| `hashline-edit-executor.ts` | Main execution: normalize → validate → order → apply → diff |
-| `normalize-edits.ts` | Parse `RawHashlineEdit[]` (allows string `op` variants) → typed `HashlineEdit[]` |
-| `validation.ts` | Validate LINE#ID: parse hash, verify line content matches stored hash |
-| `hash-computation.ts` | `computeLineHash(line)` → 2-char CID from set `ZPMQVRWSNKTXJBYH` |
-| `edit-operations.ts` | Apply replace/append/prepend to file lines array |
-| `edit-operation-primitives.ts` | Low-level line array mutation primitives |
-| `edit-ordering.ts` | Sort edits bottom-up to preserve line numbers during multi-edit |
-| `edit-deduplication.ts` | Deduplicate overlapping/identical operations |
-| `edit-text-normalization.ts` | Normalize line content (CRLF, BOM, trailing whitespace) |
-| `file-text-canonicalization.ts` | Canonicalize full file content before hashing |
-| `autocorrect-replacement-lines.ts` | Auto-restore indentation from original lines |
-| `hashline-edit-diff.ts` | Generate unified diff for error/success messages |
-| `diff-utils.ts` | Thin wrapper around `diff` npm library |
-| `hashline-chunk-formatter.ts` | Format line chunks with `LINE#ID` tags |
-| `tool-description.ts` | `HASHLINE_EDIT_DESCRIPTION` constant |
-| `types.ts` | `HashlineEdit`, `ReplaceEdit`, `AppendEdit`, `PrependEdit` |
-| `constants.ts` | Hash alphabet, separator character (`#`), pipe separator (`|`) |
-
-## LINE#ID FORMAT
-
-```
-{line_number}#{hash_id}
-```
-
-- `hash_id`: two chars from `ZPMQVRWSNKTXJBYH` (CID letters)
-- Example: `42#VK` means line 42 with hash `VK`
-- Validation: recompute hash of current line content → must match stored hash
-- Content separator: `|` (pipe) between hash tag and content in read output
-
-## AUTOCORRECT BEHAVIORS (built-in)
-
-- Merged lines auto-expanded back to original count
-- Indentation restored from original lines
-- BOM and CRLF line endings preserved
-- `>>>` prefix and diff markers in `lines` text auto-stripped
-
-## ERROR CASES
-
-- Hash mismatch → edit rejected, diff shown with current state
-- Overlapping ranges → detected and rejected
-- Missing `pos` for `replace` → schema error
-- `lines: null` with `append`/`prepend` → schema error
-
-## HOW LINE HASHES WORK
-
-```typescript
-// Reading: every line gets tagged
-"42#VK| function hello() {"
-
-// Editing: reference by tag
-{ op: "replace", pos: "42#VK", lines: "function hello(name: string) {" }
-
-// If file changed since read: hash won't match → rejected before corruption
-```