@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/hashline-edit/file-text-canonicalization.ts

@@ -1,44 +0,0 @@
-export interface FileTextEnvelope {
-  content: string
-  hadBom: boolean
-  lineEnding: "\n" | "\r\n"
-}
-
-function detectLineEnding(content: string): "\n" | "\r\n" {
-  const crlfIndex = content.indexOf("\r\n")
-  const lfIndex = content.indexOf("\n")
-  if (lfIndex === -1) return "\n"
-  if (crlfIndex === -1) return "\n"
-  return crlfIndex < lfIndex ? "\r\n" : "\n"
-}
-
-function stripBom(content: string): { content: string; hadBom: boolean } {
-  if (!content.startsWith("\uFEFF")) {
-    return { content, hadBom: false }
-  }
-  return { content: content.slice(1), hadBom: true }
-}
-
-function normalizeToLf(content: string): string {
-  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
-}
-
-function restoreLineEndings(content: string, lineEnding: "\n" | "\r\n"): string {
-  if (lineEnding === "\n") return content
-  return content.replace(/\n/g, "\r\n")
-}
-
-export function canonicalizeFileText(content: string): FileTextEnvelope {
-  const stripped = stripBom(content)
-  return {
-    content: normalizeToLf(stripped.content),
-    hadBom: stripped.hadBom,
-    lineEnding: detectLineEnding(stripped.content),
-  }
-}
-
-export function restoreFileText(content: string, envelope: FileTextEnvelope): string {
-  const withLineEnding = restoreLineEndings(content, envelope.lineEnding)
-  if (!envelope.hadBom) return withLineEnding
-  return `\uFEFF${withLineEnding}`
-}

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

@@ -1,132 +0,0 @@
-import path from "path"
-import { log } from "../../shared"
-
-interface FormatterConfig {
-  disabled?: boolean
-  command?: string[]
-  environment?: Record<string, string>
-  extensions?: string[]
-}
-
-interface OpencodeConfig {
-  formatter?:
-    | false
-    | Record<string, FormatterConfig>
-  experimental?: {
-    hook?: {
-      file_edited?: Record<string, Array<{ command: string[]; environment?: Record<string, string> }>>
-    }
-  }
-}
-
-export interface FormatterClient {
-  config: {
-    get: (options?: { query?: { directory?: string } }) => Promise<{ data?: OpencodeConfig }>
-  }
-}
-
-type FormatterDefinition = { command: string[]; environment: Record<string, string> }
-type FormatterMap = Map<string, FormatterDefinition[]>
-
-const cachedFormattersByDirectory = new Map<string, FormatterMap>()
-
-function getFormatterCacheKey(directory: string): string {
-  return path.resolve(directory)
-}
-
-export async function resolveFormatters(
-  client: FormatterClient,
-  directory: string,
-): Promise<FormatterMap> {
-  const cacheKey = getFormatterCacheKey(directory)
-  const cachedFormatters = cachedFormattersByDirectory.get(cacheKey)
-  if (cachedFormatters) return cachedFormatters
-
-  const result = new Map<string, FormatterDefinition[]>()
-
-  try {
-    const response = await client.config.get({ query: { directory } })
-    const config = response.data
-    if (!config) return result
-
-    if (config.formatter && typeof config.formatter === "object") {
-      for (const [, formatter] of Object.entries(config.formatter)) {
-        if (formatter.disabled || !formatter.command?.length || !formatter.extensions?.length) continue
-        for (const ext of formatter.extensions) {
-          const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`
-          const existing = result.get(normalizedExt) ?? []
-          existing.push({
-            command: formatter.command,
-            environment: formatter.environment ?? {},
-          })
-          result.set(normalizedExt, existing)
-        }
-      }
-    }
-
-    if (config.experimental?.hook?.file_edited) {
-      for (const [ext, commands] of Object.entries(config.experimental.hook.file_edited)) {
-        const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`
-        const existing = result.get(normalizedExt) ?? []
-        for (const cmd of commands) {
-          existing.push({
-            command: cmd.command,
-            environment: cmd.environment ?? {},
-          })
-        }
-        result.set(normalizedExt, existing)
-      }
-    }
-
-    cachedFormattersByDirectory.set(cacheKey, result)
-  } catch (error) {
-    log("[formatter-trigger] Failed to fetch formatter config", { error })
-  }
-
-  return result
-}
-
-export function buildFormatterCommand(command: string[], filePath: string): string[] {
-  return command.map((arg) => arg.replace(/\$FILE/g, filePath))
-}
-
-export async function runFormattersForFile(
-  client: FormatterClient,
-  directory: string,
-  filePath: string,
-): Promise<void> {
-  const ext = path.extname(filePath)
-  if (!ext) return
-
-  const formatters = await resolveFormatters(client, directory)
-  const matching = formatters.get(ext)
-  if (!matching?.length) return
-
-  for (const formatter of matching) {
-    const cmd = buildFormatterCommand(formatter.command, filePath)
-    try {
-      log("[formatter-trigger] Running formatter", { command: cmd, file: filePath })
-      const proc = Bun.spawn(cmd, {
-        cwd: directory,
-        env: { ...process.env, ...formatter.environment },
-        stdout: "ignore",
-        stderr: "pipe",
-      })
-      await proc.exited
-      if (proc.exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text()
-        log("[formatter-trigger] Formatter failed", {
-          command: cmd,
-          exitCode: proc.exitCode,
-          stderr: stderr.slice(0, 500),
-        })
-      }
-    } catch (error) {
-      log("[formatter-trigger] Formatter execution error", { command: cmd, error })
-    }
-  }
-}
-
-export function clearFormatterCache(): void {
-  cachedFormattersByDirectory.clear()
-}

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

@@ -1,154 +0,0 @@
-import { HASHLINE_DICT } from "./constants"
-import { createHashlineChunkFormatter } from "./hashline-chunk-formatter"
-
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u
-
-function computeNormalizedLineHash(lineNumber: number, normalizedContent: string): string {
-  const stripped = normalizedContent
-  const seed = RE_SIGNIFICANT.test(stripped) ? 0 : lineNumber
-  const hash = Bun.hash.xxHash32(stripped, seed)
-  const index = hash % 256
-  return HASHLINE_DICT[index]
-}
-
-export function computeLineHash(lineNumber: number, content: string): string {
-  return computeNormalizedLineHash(lineNumber, content.replace(/\r/g, "").trimEnd())
-}
-
-export function computeLegacyLineHash(lineNumber: number, content: string): string {
-  return computeNormalizedLineHash(lineNumber, content.replace(/\r/g, "").replace(/\s+/g, ""))
-}
-
-export function formatHashLine(lineNumber: number, content: string): string {
-  const hash = computeLineHash(lineNumber, content)
-  return `${lineNumber}#${hash}|${content}`
-}
-
-export function formatHashLines(content: string): string {
-  if (!content) return ""
-  const lines = content.split("\n")
-  return lines.map((line, index) => formatHashLine(index + 1, line)).join("\n")
-}
-
-export interface HashlineStreamOptions {
-  startLine?: number
-  maxChunkLines?: number
-  maxChunkBytes?: number
-}
-
-function isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "getReader" in value &&
-    typeof (value as { getReader?: unknown }).getReader === "function"
-  )
-}
-
-async function* bytesFromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array> {
-  const reader = stream.getReader()
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) return
-      if (value) yield value
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-export async function* streamHashLinesFromUtf8(
-  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
-  options: HashlineStreamOptions = {}
-): AsyncGenerator<string> {
-  const startLine = options.startLine ?? 1
-  const maxChunkLines = options.maxChunkLines ?? 200
-  const maxChunkBytes = options.maxChunkBytes ?? 64 * 1024
-  const decoder = new TextDecoder("utf-8")
-  const chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source
-
-  let lineNumber = startLine
-  let pending = ""
-  let sawAnyText = false
-  let endedWithNewline = false
-  const chunkFormatter = createHashlineChunkFormatter({ maxChunkLines, maxChunkBytes })
-
-  const pushLine = (line: string): string[] => {
-    const formatted = formatHashLine(lineNumber, line)
-    lineNumber += 1
-    return chunkFormatter.push(formatted)
-  }
-
-  const consumeText = (text: string): string[] => {
-    if (text.length === 0) return []
-    sawAnyText = true
-    pending += text
-    const chunksToYield: string[] = []
-
-    let lastIdx = 0
-    while (true) {
-      const idx = pending.indexOf("\n", lastIdx)
-      if (idx === -1) break
-      const line = pending.slice(lastIdx, idx)
-      lastIdx = idx + 1
-      endedWithNewline = true
-      chunksToYield.push(...pushLine(line))
-    }
-
-    pending = pending.slice(lastIdx)
-    if (pending.length > 0) endedWithNewline = false
-    return chunksToYield
-  }
-
-  for await (const chunk of chunks) {
-    for (const out of consumeText(decoder.decode(chunk, { stream: true }))) {
-      yield out
-    }
-  }
-
-  for (const out of consumeText(decoder.decode())) {
-    yield out
-  }
-
-  if (sawAnyText && (pending.length > 0 || endedWithNewline)) {
-    for (const out of pushLine(pending)) {
-      yield out
-    }
-  }
-
-  const finalChunk = chunkFormatter.flush()
-  if (finalChunk) yield finalChunk
-}
-
-export async function* streamHashLinesFromLines(
-  lines: Iterable<string> | AsyncIterable<string>,
-  options: HashlineStreamOptions = {}
-): AsyncGenerator<string> {
-  const startLine = options.startLine ?? 1
-  const maxChunkLines = options.maxChunkLines ?? 200
-  const maxChunkBytes = options.maxChunkBytes ?? 64 * 1024
-
-  let lineNumber = startLine
-  const chunkFormatter = createHashlineChunkFormatter({ maxChunkLines, maxChunkBytes })
-
-  const pushLine = (line: string): string[] => {
-    const formatted = formatHashLine(lineNumber, line)
-    lineNumber += 1
-    return chunkFormatter.push(formatted)
-  }
-
-  const asyncIterator = (lines as AsyncIterable<string>)[Symbol.asyncIterator]
-  if (typeof asyncIterator === "function") {
-    for await (const line of lines as AsyncIterable<string>) {
-      for (const out of pushLine(line)) yield out
-    }
-  } else {
-    for (const line of lines as Iterable<string>) {
-      for (const out of pushLine(line)) yield out
-    }
-  }
-
-  const finalChunk = chunkFormatter.flush()
-  if (finalChunk) yield finalChunk
-}

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

@@ -1,52 +0,0 @@
-export interface HashlineChunkFormatter {
-  push(formattedLine: string): string[]
-  flush(): string | undefined
-}
-
-interface HashlineChunkFormatterOptions {
-  maxChunkLines: number
-  maxChunkBytes: number
-}
-
-export function createHashlineChunkFormatter(options: HashlineChunkFormatterOptions): HashlineChunkFormatter {
-  const { maxChunkLines, maxChunkBytes } = options
-  let outputLines: string[] = []
-  let outputBytes = 0
-
-  const flush = (): string | undefined => {
-    if (outputLines.length === 0) return undefined
-    const chunk = outputLines.join("\n")
-    outputLines = []
-    outputBytes = 0
-    return chunk
-  }
-
-  const push = (formattedLine: string): string[] => {
-    const chunksToYield: string[] = []
-    const separatorBytes = outputLines.length === 0 ? 0 : 1
-    const lineBytes = Buffer.byteLength(formattedLine, "utf-8")
-
-    if (
-      outputLines.length > 0 &&
-      (outputLines.length >= maxChunkLines || outputBytes + separatorBytes + lineBytes > maxChunkBytes)
-    ) {
-      const flushed = flush()
-      if (flushed) chunksToYield.push(flushed)
-    }
-
-    outputLines.push(formattedLine)
-    outputBytes += (outputLines.length === 1 ? 0 : 1) + lineBytes
-
-    if (outputLines.length >= maxChunkLines || outputBytes >= maxChunkBytes) {
-      const flushed = flush()
-      if (flushed) chunksToYield.push(flushed)
-    }
-
-    return chunksToYield
-  }
-
-  return {
-    push,
-    flush,
-  }
-}

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

@@ -1,31 +0,0 @@
-import { computeLineHash } from "./hash-computation"
-
-export function generateHashlineDiff(oldContent: string, newContent: string, filePath: string): string {
-  const oldLines = oldContent.split("\n")
-  const newLines = newContent.split("\n")
-
-  const parts: string[] = [`--- ${filePath}\n+++ ${filePath}\n`]
-  const maxLines = Math.max(oldLines.length, newLines.length)
-
-  for (let i = 0; i < maxLines; i += 1) {
-    const oldLine = oldLines[i] ?? ""
-    const newLine = newLines[i] ?? ""
-    const lineNum = i + 1
-    const hash = computeLineHash(lineNum, newLine)
-
-    if (i >= oldLines.length) {
-      parts.push(`+ ${lineNum}#${hash}|${newLine}\n`)
-      continue
-    }
-    if (i >= newLines.length) {
-      parts.push(`- ${lineNum}#  |${oldLine}\n`)
-      continue
-    }
-    if (oldLine !== newLine) {
-      parts.push(`- ${lineNum}#  |${oldLine}\n`)
-      parts.push(`+ ${lineNum}#${hash}|${newLine}\n`)
-    }
-  }
-
-  return parts.join("")
-}

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

@@ -1,197 +0,0 @@
-import type { ToolContext } from "@opencode-ai/plugin/tool"
-import { storeToolMetadata } from "../../features/tool-metadata-store"
-import { applyHashlineEditsWithReport } from "./edit-operations"
-import { countLineDiffs, generateUnifiedDiff } from "./diff-utils"
-import { canonicalizeFileText, restoreFileText } from "./file-text-canonicalization"
-import { normalizeHashlineEdits, type RawHashlineEdit } from "./normalize-edits"
-import type { HashlineEdit } from "./types"
-import { HashlineMismatchError } from "./validation"
-import { runFormattersForFile, type FormatterClient } from "./formatter-trigger"
-import type { PluginContext } from "../../plugin/types"
-
-interface HashlineEditArgs {
-  filePath: string
-  edits: RawHashlineEdit[]
-  delete?: boolean
-  rename?: string
-}
-
-type ToolContextWithCallID = ToolContext & {
-  callID?: string
-  callId?: string
-  call_id?: string
-}
-
-type ToolContextWithMetadata = ToolContextWithCallID & {
-  metadata?: (value: unknown) => void
-}
-
-function resolveToolCallID(ctx: ToolContextWithCallID): string | undefined {
-  if (typeof ctx.callID === "string" && ctx.callID.trim() !== "") return ctx.callID
-  if (typeof ctx.callId === "string" && ctx.callId.trim() !== "") return ctx.callId
-  if (typeof ctx.call_id === "string" && ctx.call_id.trim() !== "") return ctx.call_id
-  return undefined
-}
-
-function canCreateFromMissingFile(edits: HashlineEdit[]): boolean {
-  if (edits.length === 0) return false
-  return edits.every((edit) => (edit.op === "append" || edit.op === "prepend") && !edit.pos)
-}
-
-function buildSuccessMeta(
-  effectivePath: string,
-  beforeContent: string,
-  afterContent: string,
-  noopEdits: number,
-  deduplicatedEdits: number
-) {
-  const unifiedDiff = generateUnifiedDiff(beforeContent, afterContent, effectivePath)
-  const { additions, deletions } = countLineDiffs(beforeContent, afterContent)
-  const beforeLines = beforeContent.split("\n")
-  const afterLines = afterContent.split("\n")
-  const maxLength = Math.max(beforeLines.length, afterLines.length)
-  let firstChangedLine: number | undefined
-
-  for (let index = 0; index < maxLength; index += 1) {
-    if ((beforeLines[index] ?? "") !== (afterLines[index] ?? "")) {
-      firstChangedLine = index + 1
-      break
-    }
-  }
-
-  return {
-    title: effectivePath,
-    metadata: {
-      filePath: effectivePath,
-      path: effectivePath,
-      file: effectivePath,
-      diff: unifiedDiff,
-      noopEdits,
-      deduplicatedEdits,
-      firstChangedLine,
-      filediff: {
-        file: effectivePath,
-        path: effectivePath,
-        filePath: effectivePath,
-        before: beforeContent,
-        after: afterContent,
-        additions,
-        deletions,
-      },
-    },
-  }
-}
-
-export async function executeHashlineEditTool(args: HashlineEditArgs, context: ToolContext, pluginCtx?: PluginContext): Promise<string> {
-  try {
-    const metadataContext = context as ToolContextWithMetadata
-    const filePath = args.filePath
-    const { delete: deleteMode, rename } = args
-
-    if (deleteMode && rename) {
-      return "Error: delete and rename cannot be used together"
-    }
-    if (deleteMode && args.edits.length > 0) {
-      return "Error: delete mode requires edits to be an empty array"
-    }
-
-    if (!deleteMode && (!args.edits || !Array.isArray(args.edits) || args.edits.length === 0)) {
-      return "Error: edits parameter must be a non-empty array"
-    }
-
-    const edits = deleteMode ? [] : normalizeHashlineEdits(args.edits)
-
-    const file = Bun.file(filePath)
-    const exists = await file.exists()
-    if (!exists && !deleteMode && !canCreateFromMissingFile(edits)) {
-      return `Error: File not found: ${filePath}`
-    }
-
-    if (deleteMode) {
-      if (!exists) return `Error: File not found: ${filePath}`
-      await Bun.file(filePath).delete()
-      return `Successfully deleted ${filePath}`
-    }
-
-    const rawOldContent = exists ? Buffer.from(await file.arrayBuffer()).toString("utf8") : ""
-    const oldEnvelope = canonicalizeFileText(rawOldContent)
-
-    const applyResult = applyHashlineEditsWithReport(oldEnvelope.content, edits)
-    const canonicalNewContent = applyResult.content
-
-    if (canonicalNewContent === oldEnvelope.content && !rename) {
-      let diagnostic = `No changes made to ${filePath}. The edits produced identical content.`
-      if (applyResult.noopEdits > 0) {
-        diagnostic += ` No-op edits: ${applyResult.noopEdits}. Re-read the file and provide content that differs from current lines.`
-      }
-      return `Error: ${diagnostic}`
-    }
-
-    const writeContent = restoreFileText(canonicalNewContent, oldEnvelope)
-
-    await Bun.write(filePath, writeContent)
-
-    if (pluginCtx?.client) {
-      await runFormattersForFile(pluginCtx.client as FormatterClient, context.directory, filePath)
-      const formattedContent = Buffer.from(await Bun.file(filePath).arrayBuffer()).toString("utf8")
-      if (formattedContent !== writeContent) {
-        const formattedEnvelope = canonicalizeFileText(formattedContent)
-        const formattedMeta = buildSuccessMeta(
-          filePath,
-          oldEnvelope.content,
-          formattedEnvelope.content,
-          applyResult.noopEdits,
-          applyResult.deduplicatedEdits
-        )
-        if (typeof metadataContext.metadata === "function") {
-          metadataContext.metadata(formattedMeta)
-        }
-        const callID = resolveToolCallID(metadataContext)
-        if (callID) {
-          storeToolMetadata(context.sessionID, callID, formattedMeta)
-        }
-        if (rename && rename !== filePath) {
-          await Bun.write(rename, formattedContent)
-          await Bun.file(filePath).delete()
-          return `Moved ${filePath} to ${rename}`
-        }
-        return `Updated ${filePath}`
-      }
-    }
-
-    if (rename && rename !== filePath) {
-      await Bun.write(rename, writeContent)
-      await Bun.file(filePath).delete()
-    }
-
-    const effectivePath = rename && rename !== filePath ? rename : filePath
-    const meta = buildSuccessMeta(
-      effectivePath,
-      oldEnvelope.content,
-      canonicalNewContent,
-      applyResult.noopEdits,
-      applyResult.deduplicatedEdits
-    )
-
-    if (typeof metadataContext.metadata === "function") {
-      metadataContext.metadata(meta)
-    }
-
-    const callID = resolveToolCallID(metadataContext)
-    if (callID) {
-      storeToolMetadata(context.sessionID, callID, meta)
-    }
-
-    if (rename && rename !== filePath) {
-      return `Moved ${filePath} to ${rename}`
-    }
-
-    return `Updated ${effectivePath}`
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    if (error instanceof HashlineMismatchError) {
-      return `Error: hash mismatch - ${message}\nTip: reuse LINE#ID entries from the latest read/edit output, or batch related edits in one call.`
-    }
-    return `Error: ${message}`
-  }
-}

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

@@ -1,20 +0,0 @@
-export {
-  computeLineHash,
-  formatHashLine,
-  formatHashLines,
-  streamHashLinesFromLines,
-  streamHashLinesFromUtf8,
-} from "./hash-computation"
-export { parseLineRef, validateLineRef } from "./validation"
-export type { LineRef } from "./validation"
-export type {
-  ReplaceEdit,
-  AppendEdit,
-  PrependEdit,
-  HashlineEdit,
-} from "./types"
-export { NIBBLE_STR, HASHLINE_DICT, HASHLINE_REF_PATTERN, HASHLINE_OUTPUT_PATTERN } from "./constants"
-export {
-  applyHashlineEdits,
-} from "./edit-operations"
-export { createHashlineEditTool } from "./tools"