@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/hashline-edit/normalize-edits.ts

@@ -1,95 +0,0 @@
-import type { AppendEdit, HashlineEdit, PrependEdit, ReplaceEdit } from "./types"
-
-type HashlineToolOp = "replace" | "append" | "prepend"
-
-export interface RawHashlineEdit {
-  op?: HashlineToolOp
-  pos?: string
-  end?: string
-  lines?: string | string[] | null
-}
-
-function normalizeAnchor(value: string | undefined): string | undefined {
-  if (typeof value !== "string") return undefined
-  const trimmed = value.trim()
-  return trimmed === "" ? undefined : trimmed
-}
-
-function requireLines(edit: RawHashlineEdit, index: number): string | string[] {
-  if (edit.lines === undefined) {
-    throw new Error(`Edit ${index}: lines is required for ${edit.op ?? "unknown"}`)
-  }
-  if (edit.lines === null) {
-    return []
-  }
-  return edit.lines
-}
-
-function requireLine(anchor: string | undefined, index: number, op: HashlineToolOp): string {
-  if (!anchor) {
-    throw new Error(`Edit ${index}: ${op} requires at least one anchor line reference (pos or end)`)
-  }
-  return anchor
-}
-
-function normalizeReplaceEdit(edit: RawHashlineEdit, index: number): HashlineEdit {
-  const pos = normalizeAnchor(edit.pos)
-  const end = normalizeAnchor(edit.end)
-  const anchor = requireLine(pos ?? end, index, "replace")
-  const lines = requireLines(edit, index)
-
-  const normalized: ReplaceEdit = {
-    op: "replace",
-    pos: anchor,
-    lines,
-  }
-  if (end) normalized.end = end
-  return normalized
-}
-
-function normalizeAppendEdit(edit: RawHashlineEdit, index: number): HashlineEdit {
-  const pos = normalizeAnchor(edit.pos)
-  const end = normalizeAnchor(edit.end)
-  const anchor = pos ?? end
-  const lines = requireLines(edit, index)
-
-  const normalized: AppendEdit = {
-    op: "append",
-    lines,
-  }
-  if (anchor) normalized.pos = anchor
-  return normalized
-}
-
-function normalizePrependEdit(edit: RawHashlineEdit, index: number): HashlineEdit {
-  const pos = normalizeAnchor(edit.pos)
-  const end = normalizeAnchor(edit.end)
-  const anchor = pos ?? end
-  const lines = requireLines(edit, index)
-
-  const normalized: PrependEdit = {
-    op: "prepend",
-    lines,
-  }
-  if (anchor) normalized.pos = anchor
-  return normalized
-}
-
-export function normalizeHashlineEdits(rawEdits: RawHashlineEdit[]): HashlineEdit[] {
-  return rawEdits.map((rawEdit, index) => {
-    const edit = rawEdit ?? {}
-
-    switch (edit.op) {
-      case "replace":
-        return normalizeReplaceEdit(edit, index)
-      case "append":
-        return normalizeAppendEdit(edit, index)
-      case "prepend":
-        return normalizePrependEdit(edit, index)
-      default:
-        throw new Error(
-          `Edit ${index}: unsupported op "${String(edit.op)}". Legacy format was removed; use op/pos/end/lines.`
-        )
-    }
-  })
-}

package/src/tools/hashline-edit/tool-description.ts

@@ -1,95 +0,0 @@
-export const HASHLINE_EDIT_DESCRIPTION = `Edit files using LINE#ID format for precise, safe modifications.
-
-WORKFLOW:
-1. Read target file/range and copy exact LINE#ID tags.
-2. Pick the smallest operation per logical mutation site.
-3. Submit one edit call per file with all related operations.
-4. If same file needs another call, re-read first.
-5. Use anchors as "LINE#ID" only (never include trailing "|content").
-
-<must>
-- SNAPSHOT: All edits in one call reference the ORIGINAL file state. Do NOT adjust line numbers for prior edits in the same call - the system applies them bottom-up automatically.
-- replace removes lines pos..end (inclusive) and inserts lines in their place. Lines BEFORE pos and AFTER end are UNTOUCHED - do NOT include them in lines. If you do, they will appear twice.
-- lines must contain ONLY the content that belongs inside the consumed range. Content after end survives unchanged.
-- Tags MUST be copied exactly from read output or >>> mismatch output. NEVER guess tags.
-- Batch = multiple operations in edits[], NOT one big replace covering everything. Each operation targets the smallest possible change.
-- lines must contain plain replacement text only (no LINE#ID prefixes, no diff + markers).
-</must>
-
-<operations>
-LINE#ID FORMAT:
-  Each line reference must be in "{line_number}#{hash_id}" format where:
-  {line_number}: 1-based line number
-  {hash_id}: Two CID letters from the set ZPMQVRWSNKTXJBYH
-
-OPERATION CHOICE:
-  replace with pos only -> replace one line at pos
-  replace with pos+end -> replace range pos..end inclusive as a block (ranges MUST NOT overlap across edits)
-  append with pos/end anchor -> insert after that anchor
-  prepend with pos/end anchor -> insert before that anchor
-  append/prepend without anchors -> EOF/BOF insertion (also creates missing files)
-
-CONTENT FORMAT:
-  lines can be a string (single line) or string[] (multi-line, preferred).
-  If you pass a multi-line string, it is split by real newline characters.
-  lines: null or lines: [] with replace -> delete those lines.
-
-FILE MODES:
-  delete=true deletes file and requires edits=[] with no rename
-  rename moves final content to a new path and removes old path
-
-RULES:
-  1. Minimize scope: one logical mutation site per operation.
-  2. Preserve formatting: keep indentation, punctuation, line breaks, trailing commas, brace style.
-  3. Prefer insertion over neighbor rewrites: anchor to structural boundaries (}, ], },), not interior property lines.
-  4. No no-ops: replacement content must differ from current content.
-  5. Touch only requested code: avoid incidental edits.
-  6. Use exact current tokens: NEVER rewrite approximately.
-  7. For swaps/moves: prefer one range operation over multiple single-line operations.
-  8. Anchor to structural lines (function/class/brace), NEVER blank lines.
-  9. Re-read after each successful edit call before issuing another on the same file.
-</operations>
-
-<examples>
-Given this file content after read:
-  10#VK|function hello() {
-  11#XJ|  console.log("hi");
-  12#MB|  console.log("bye");
-  13#QR|}
-  14#TN|
-  15#WS|function world() {
-
-Single-line replace (change line 11):
-  { op: "replace", pos: "11#XJ", lines: ["  console.log(\\"hello\\");"] }
-  Result: line 11 replaced. Lines 10, 12-15 unchanged.
-
-Range replace (rewrite function body, lines 11-12):
-  { op: "replace", pos: "11#XJ", end: "12#MB", lines: ["  return \\"hello world\\";"] }
-  Result: lines 11-12 removed, replaced by 1 new line. Lines 10, 13-15 unchanged.
-
-Delete a line:
-  { op: "replace", pos: "12#MB", lines: null }
-  Result: line 12 removed. Lines 10-11, 13-15 unchanged.
-
-Insert after line 13 (between functions):
-  { op: "append", pos: "13#QR", lines: ["", "function added() {", "  return true;", "}"] }
-  Result: 4 new lines inserted after line 13. All existing lines unchanged.
-
-BAD - lines extend past end (DUPLICATES line 13):
-  { op: "replace", pos: "11#XJ", end: "12#MB", lines: ["  return \\"hi\\";", "}"] }
-  Line 13 is "}" which already exists after end. Including "}" in lines duplicates it.
-  CORRECT: { op: "replace", pos: "11#XJ", end: "12#MB", lines: ["  return \\"hi\\";"] }
-</examples>
-
-<auto>
-Built-in autocorrect (you do NOT need to handle these):
-  Merged lines are auto-expanded back to original line count.
-  Indentation is auto-restored from original lines.
-  BOM and CRLF line endings are preserved automatically.
-  Hashline prefixes and diff markers in text are auto-stripped.
-  Boundary echo lines (duplicating adjacent surviving lines) are auto-stripped.
-</auto>
-
-RECOVERY (when >>> mismatch error appears):
-  Copy the updated LINE#ID tags shown in the error output directly.
-  Re-read only if the needed tags are missing from the error snippet.`

package/src/tools/hashline-edit/tools.ts

@@ -1,42 +0,0 @@
-import { tool, type ToolContext, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { executeHashlineEditTool } from "./hashline-edit-executor"
-import { HASHLINE_EDIT_DESCRIPTION } from "./tool-description"
-import type { RawHashlineEdit } from "./normalize-edits"
-import type { PluginContext } from "../../plugin/types"
-
-interface HashlineEditArgs {
-  filePath: string
-  edits: RawHashlineEdit[]
-  delete?: boolean
-  rename?: string
-}
-
-export function createHashlineEditTool(ctx?: PluginContext): ToolDefinition {
-  return tool({
-    description: HASHLINE_EDIT_DESCRIPTION,
-    args: {
-      filePath: tool.schema.string().describe("Absolute path to the file to edit"),
-      delete: tool.schema.boolean().optional().describe("Delete file instead of editing"),
-      rename: tool.schema.string().optional().describe("Rename output file path after edits"),
-      edits: tool.schema
-        .array(
-          tool.schema.object({
-            op: tool.schema
-              .union([
-                tool.schema.literal("replace"),
-                tool.schema.literal("append"),
-                tool.schema.literal("prepend"),
-              ])
-              .describe("Hashline edit operation mode"),
-            pos: tool.schema.string().optional().describe("Primary anchor in LINE#ID format"),
-            end: tool.schema.string().optional().describe("Range end anchor in LINE#ID format"),
-            lines: tool.schema
-              .union([tool.schema.array(tool.schema.string()), tool.schema.string(), tool.schema.null()])
-              .describe("Replacement or inserted lines as newline-delimited string. null deletes with replace"),
-          })
-        )
-        .describe("Array of edit operations to apply (empty when delete=true)"),
-    },
-    execute: async (args: HashlineEditArgs, context: ToolContext) => executeHashlineEditTool(args, context, ctx),
-  })
-}

package/src/tools/hashline-edit/types.ts

@@ -1,20 +0,0 @@
-export interface ReplaceEdit {
-  op: "replace"
-  pos: string
-  end?: string
-  lines: string | string[]
-}
-
-export interface AppendEdit {
-  op: "append"
-  pos?: string
-  lines: string | string[]
-}
-
-export interface PrependEdit {
-  op: "prepend"
-  pos?: string
-  lines: string | string[]
-}
-
-export type HashlineEdit = ReplaceEdit | AppendEdit | PrependEdit

package/src/tools/hashline-edit/validation.ts

@@ -1,181 +0,0 @@
-import { computeLegacyLineHash, computeLineHash } from "./hash-computation"
-import { HASHLINE_REF_PATTERN } from "./constants"
-
-export interface LineRef {
-  line: number
-  hash: string
-}
-
-interface HashMismatch {
-  line: number
-  expected: string
-}
-
-const MISMATCH_CONTEXT = 2
-
-const LINE_REF_EXTRACT_PATTERN = /([0-9]+#[ZPMQVRWSNKTXJBYH]{2})/
-
-function isCompatibleLineHash(line: number, content: string, hash: string): boolean {
-  return computeLineHash(line, content) === hash || computeLegacyLineHash(line, content) === hash
-}
-
-export function normalizeLineRef(ref: string): string {
-  const originalTrimmed = ref.trim()
-  let trimmed = originalTrimmed
-  trimmed = trimmed.replace(/^(?:>>>|[+-])\s*/, "")
-  trimmed = trimmed.replace(/\s*#\s*/, "#")
-  trimmed = trimmed.replace(/\|.*$/, "")
-  trimmed = trimmed.trim()
-
-  if (HASHLINE_REF_PATTERN.test(trimmed)) {
-    return trimmed
-  }
-
-  const extracted = trimmed.match(LINE_REF_EXTRACT_PATTERN)
-  if (extracted) {
-    return extracted[1]
-  }
-
-  return originalTrimmed
-}
-
-export function parseLineRef(ref: string): LineRef {
-  const normalized = normalizeLineRef(ref)
-  const match = normalized.match(HASHLINE_REF_PATTERN)
-  if (match) {
-    return {
-      line: Number.parseInt(match[1], 10),
-      hash: match[2],
-    }
-  }
-  const hashIdx = normalized.indexOf('#')
-  if (hashIdx > 0) {
-    const prefix = normalized.slice(0, hashIdx)
-    const suffix = normalized.slice(hashIdx + 1)
-    if (!/^\d+$/.test(prefix) && /^[ZPMQVRWSNKTXJBYH]{2}$/.test(suffix)) {
-      throw new Error(
-        `Invalid line reference: "${ref}". "${prefix}" is not a line number. ` +
-          `Use the actual line number from the read output.`
-      )
-    }
-  }
-  throw new Error(
-    `Invalid line reference format: "${ref}". Expected format: "{line_number}#{hash_id}"`
-  )
-}
-
-export function validateLineRef(lines: string[], ref: string): void {
-  const { line, hash } = parseLineRefWithHint(ref, lines)
-
-  if (line < 1 || line > lines.length) {
-    throw new Error(
-      `Line number ${line} out of bounds. File has ${lines.length} lines.`
-    )
-  }
-
-  const content = lines[line - 1]
-  if (!isCompatibleLineHash(line, content, hash)) {
-    throw new HashlineMismatchError([{ line, expected: hash }], lines)
-  }
-}
-
-export class HashlineMismatchError extends Error {
-  readonly remaps: ReadonlyMap<string, string>
-
-  constructor(
-    private readonly mismatches: HashMismatch[],
-    private readonly fileLines: string[]
-  ) {
-    super(HashlineMismatchError.formatMessage(mismatches, fileLines))
-    this.name = "HashlineMismatchError"
-    const remaps = new Map<string, string>()
-    for (const mismatch of mismatches) {
-      const actual = computeLineHash(mismatch.line, fileLines[mismatch.line - 1] ?? "")
-      remaps.set(`${mismatch.line}#${mismatch.expected}`, `${mismatch.line}#${actual}`)
-    }
-    this.remaps = remaps
-  }
-
-  static formatMessage(mismatches: HashMismatch[], fileLines: string[]): string {
-    const mismatchByLine = new Map<number, HashMismatch>()
-    for (const mismatch of mismatches) mismatchByLine.set(mismatch.line, mismatch)
-
-    const displayLines = new Set<number>()
-    for (const mismatch of mismatches) {
-      const low = Math.max(1, mismatch.line - MISMATCH_CONTEXT)
-      const high = Math.min(fileLines.length, mismatch.line + MISMATCH_CONTEXT)
-      for (let line = low; line <= high; line++) displayLines.add(line)
-    }
-
-    const sortedLines = [...displayLines].sort((a, b) => a - b)
-    const output: string[] = []
-    output.push(
-      `${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since last read. ` +
-        "Use updated {line_number}#{hash_id} references below (>>> marks changed lines)."
-    )
-    output.push("")
-
-    let previousLine = -1
-    for (const line of sortedLines) {
-      if (previousLine !== -1 && line > previousLine + 1) {
-        output.push("    ...")
-      }
-      previousLine = line
-
-      const content = fileLines[line - 1] ?? ""
-      const hash = computeLineHash(line, content)
-      const prefix = `${line}#${hash}|${content}`
-      if (mismatchByLine.has(line)) {
-        output.push(`>>> ${prefix}`)
-      } else {
-        output.push(`    ${prefix}`)
-      }
-    }
-
-    return output.join("\n")
-  }
-}
-
-function suggestLineForHash(ref: string, lines: string[]): string | null {
-  const hashMatch = ref.trim().match(/#([ZPMQVRWSNKTXJBYH]{2})$/)
-  if (!hashMatch) return null
-  const hash = hashMatch[1]
-  for (let i = 0; i < lines.length; i++) {
-    if (isCompatibleLineHash(i + 1, lines[i], hash)) {
-      return `Did you mean "${i + 1}#${computeLineHash(i + 1, lines[i])}"?`
-    }
-  }
-  return null
-}
-function parseLineRefWithHint(ref: string, lines: string[]): LineRef {
-  try {
-    return parseLineRef(ref)
-  } catch (parseError) {
-    const hint = suggestLineForHash(ref, lines)
-    if (hint && parseError instanceof Error) {
-      throw new Error(`${parseError.message} ${hint}`)
-    }
-    throw parseError
-  }
-}
-
-export function validateLineRefs(lines: string[], refs: string[]): void {
-  const mismatches: HashMismatch[] = []
-
-  for (const ref of refs) {
-    const { line, hash } = parseLineRefWithHint(ref, lines)
-
-    if (line < 1 || line > lines.length) {
-      throw new Error(`Line number ${line} out of bounds (file has ${lines.length} lines)`)
-    }
-
-    const content = lines[line - 1]
-    if (!isCompatibleLineHash(line, content, hash)) {
-      mismatches.push({ line, expected: hash })
-    }
-  }
-
-  if (mismatches.length > 0) {
-    throw new HashlineMismatchError(mismatches, lines)
-  }
-}

package/src/tools/index.ts

@@ -1,64 +0,0 @@
-import {
-  lsp_goto_definition,
-  lsp_find_references,
-  lsp_symbols,
-  lsp_diagnostics,
-  lsp_prepare_rename,
-  lsp_rename,
-  lspManager,
-} from "./lsp"
-
-export { lspManager }
-
-export { createAstGrepTools } from "./ast-grep"
-export { createGrepTools } from "./grep"
-export { createGlobTools } from "./glob"
-export { createSkillTool } from "./skill"
-export { discoverCommandsSync } from "./slashcommand"
-export { createSessionManagerTools } from "./session-manager"
-
-export { sessionExists } from "./session-manager/storage"
-
-export { interactive_bash, startBackgroundCheck as startTmuxCheck } from "./interactive-bash"
-export { createSkillMcpTool } from "./skill-mcp"
-
-import {
-  createBackgroundOutput,
-  createBackgroundCancel,
-  type BackgroundOutputManager,
-  type BackgroundCancelClient,
-} from "./background-task"
-
-import type { PluginInput, ToolDefinition } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../features/background-agent"
-
-type OpencodeClient = PluginInput["client"]
-
-export { createCallOmoAgent } from "./call-omo-agent"
-export { createLookAt } from "./look-at"
-export { createDelegateTask } from "./delegate-task"
-export {
-  createTaskCreateTool,
-  createTaskGetTool,
-  createTaskList,
-  createTaskUpdateTool,
-} from "./task"
-export { createHashlineEditTool } from "./hashline-edit"
-
-export function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient): Record<string, ToolDefinition> {
-  const outputManager: BackgroundOutputManager = manager
-  const cancelClient: BackgroundCancelClient = client
-  return {
-    background_output: createBackgroundOutput(outputManager, client),
-    background_cancel: createBackgroundCancel(manager, cancelClient),
-  }
-}
-
-export const builtinTools: Record<string, ToolDefinition> = {
-  lsp_goto_definition,
-  lsp_find_references,
-  lsp_symbols,
-  lsp_diagnostics,
-  lsp_prepare_rename,
-  lsp_rename,
-}

package/src/tools/interactive-bash/constants.ts

@@ -1,18 +0,0 @@
-export const DEFAULT_TIMEOUT_MS = 60_000
-
-export const BLOCKED_TMUX_SUBCOMMANDS = [
-  "capture-pane",
-  "capturep",
-  "save-buffer",
-  "saveb",
-  "show-buffer",
-  "showb",
-  "pipe-pane",
-  "pipep",
-]
-
-export const INTERACTIVE_BASH_DESCRIPTION = `WARNING: This is TMUX ONLY. Pass tmux subcommands directly (without 'tmux' prefix).
-
-Examples: new-session -d -s omo-dev, send-keys -t omo-dev "vim" Enter
-
-For TUI apps needing ongoing interaction (vim, htop, pudb). One-shot commands → use Bash with &.`

package/src/tools/interactive-bash/index.ts

@@ -1,4 +0,0 @@
-import { interactive_bash } from "./tools"
-import { startBackgroundCheck } from "./tmux-path-resolver"
-
-export { interactive_bash, startBackgroundCheck }

package/src/tools/interactive-bash/tmux-path-resolver.ts

@@ -1,71 +0,0 @@
-import { spawn } from "bun"
-
-let tmuxPath: string | null = null
-let initPromise: Promise<string | null> | null = null
-
-async function findTmuxPath(): Promise<string | null> {
-  const isWindows = process.platform === "win32"
-  const cmd = isWindows ? "where" : "which"
-
-  try {
-    const proc = spawn([cmd, "tmux"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    const exitCode = await proc.exited
-    if (exitCode !== 0) {
-      return null
-    }
-
-    const stdout = await new Response(proc.stdout).text()
-    const path = stdout.trim().split("\n")[0]
-
-    if (!path) {
-      return null
-    }
-
-    const verifyProc = spawn([path, "-V"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    const verifyExitCode = await verifyProc.exited
-    if (verifyExitCode !== 0) {
-      return null
-    }
-
-    return path
-  } catch {
-    return null
-  }
-}
-
-export async function getTmuxPath(): Promise<string | null> {
-  if (tmuxPath !== null) {
-    return tmuxPath
-  }
-
-  if (initPromise) {
-    return initPromise
-  }
-
-  initPromise = (async () => {
-    const path = await findTmuxPath()
-    tmuxPath = path
-    return path
-  })()
-
-  return initPromise
-}
-
-export function getCachedTmuxPath(): string | null {
-  return tmuxPath
-}
-
-export function startBackgroundCheck(): void {
-  if (!initPromise) {
-    initPromise = getTmuxPath()
-    initPromise.catch(() => {})
-  }
-}