refactor(packages): extract hashline-core package

Move the hash-anchored edit core (hash computation, validation, edit operations, text normalization, chunk formatter, diff utilities, and a runtime-aware xxHash32 binding) into a new @oh-my-opencode/hashline-core workspace package.

The src/tools/hashline-edit/ surface becomes a set of thin re-export shims, so existing import paths in the plugin keep working while the pure logic lives behind a stable package boundary that has no opencode runtime dependencies.

Tests: bun test packages/hashline-core src/tools/hashline-edit

packages/hashline-core/src/autocorrect-replacement-lines.ts

@@ -0,0 +1,179 @@
+function normalizeTokens(text: string): string {
+  return text.replace(/\s+/g, "")
+}
+
+function stripAllWhitespace(text: string): string {
+  return normalizeTokens(text)
+}
+
+export function stripTrailingContinuationTokens(text: string): string {
+  return text.replace(/(?:&&|\|\||\?\?|\?|:|=|,|\+|-|\*|\/|\.|\()\s*$/u, "")
+}
+
+export function stripMergeOperatorChars(text: string): string {
+  return text.replace(/[|&?]/g, "")
+}
+
+function leadingWhitespace(text: string): string {
+  if (!text) return ""
+  const match = text.match(/^\s*/)
+  return match ? match[0] : ""
+}
+
+export function restoreOldWrappedLines(originalLines: string[], replacementLines: string[]): string[] {
+  if (originalLines.length === 0 || replacementLines.length < 2) return replacementLines
+
+  const canonicalToOriginal = new Map<string, { line: string; count: number }>()
+  for (const line of originalLines) {
+    const canonical = stripAllWhitespace(line)
+    const existing = canonicalToOriginal.get(canonical)
+    if (existing) {
+      existing.count += 1
+    } else {
+      canonicalToOriginal.set(canonical, { line, count: 1 })
+    }
+  }
+
+  const candidates: { start: number; len: number; replacement: string; canonical: string }[] = []
+  for (let start = 0; start < replacementLines.length; start += 1) {
+    for (let len = 2; len <= 10 && start + len <= replacementLines.length; len += 1) {
+      const span = replacementLines.slice(start, start + len)
+      if (span.some((line) => line.trim().length === 0)) continue
+      const canonicalSpan = stripAllWhitespace(span.join(""))
+      const original = canonicalToOriginal.get(canonicalSpan)
+      if (original && original.count === 1 && canonicalSpan.length >= 6) {
+        candidates.push({ start, len, replacement: original.line, canonical: canonicalSpan })
+      }
+    }
+  }
+  if (candidates.length === 0) return replacementLines
+
+  const canonicalCounts = new Map<string, number>()
+  for (const candidate of candidates) {
+    canonicalCounts.set(candidate.canonical, (canonicalCounts.get(candidate.canonical) ?? 0) + 1)
+  }
+
+  const uniqueCandidates = candidates.filter((candidate) => (canonicalCounts.get(candidate.canonical) ?? 0) === 1)
+  if (uniqueCandidates.length === 0) return replacementLines
+
+  uniqueCandidates.sort((a, b) => b.start - a.start)
+  const correctedLines = [...replacementLines]
+  for (const candidate of uniqueCandidates) {
+    correctedLines.splice(candidate.start, candidate.len, candidate.replacement)
+  }
+  return correctedLines
+}
+
+export function maybeExpandSingleLineMerge(
+  originalLines: string[],
+  replacementLines: string[]
+): string[] {
+  if (replacementLines.length !== 1 || originalLines.length <= 1) {
+    return replacementLines
+  }
+
+  const merged = replacementLines[0]
+  const parts = originalLines.map((line) => line.trim()).filter((line) => line.length > 0)
+  if (parts.length !== originalLines.length) return replacementLines
+
+  const indices: number[] = []
+  let offset = 0
+  let orderedMatch = true
+  for (const part of parts) {
+    let idx = merged.indexOf(part, offset)
+    let matchedLen = part.length
+    if (idx === -1) {
+      const stripped = stripTrailingContinuationTokens(part)
+      if (stripped !== part) {
+        idx = merged.indexOf(stripped, offset)
+        if (idx !== -1) matchedLen = stripped.length
+      }
+    }
+    if (idx === -1) {
+      const segment = merged.slice(offset)
+      const segmentStripped = stripMergeOperatorChars(segment)
+      const partStripped = stripMergeOperatorChars(part)
+      const fuzzyIdx = segmentStripped.indexOf(partStripped)
+      if (fuzzyIdx !== -1) {
+        let strippedPos = 0
+        let originalPos = 0
+        while (strippedPos < fuzzyIdx && originalPos < segment.length) {
+          if (!/[|&?]/.test(segment[originalPos])) strippedPos += 1
+          originalPos += 1
+        }
+        idx = offset + originalPos
+        matchedLen = part.length
+      }
+    }
+    if (idx === -1) {
+      orderedMatch = false
+      break
+    }
+    indices.push(idx)
+    offset = idx + matchedLen
+  }
+
+  const expanded: string[] = []
+  if (orderedMatch) {
+    for (let i = 0; i < indices.length; i += 1) {
+      const start = indices[i]
+      const end = i + 1 < indices.length ? indices[i + 1] : merged.length
+      const candidate = merged.slice(start, end).trim()
+      if (candidate.length === 0) {
+        orderedMatch = false
+        break
+      }
+      expanded.push(candidate)
+    }
+  }
+
+  if (orderedMatch && expanded.length === originalLines.length) {
+    return expanded
+  }
+
+  const semicolonSplit = merged
+    .split(/;\s+/)
+    .map((line, idx, arr) => {
+      if (idx < arr.length - 1 && !line.endsWith(";")) {
+        return `${line};`
+      }
+      return line
+    })
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+
+  if (semicolonSplit.length === originalLines.length) {
+    return semicolonSplit
+  }
+
+  return replacementLines
+}
+
+export function restoreIndentForPairedReplacement(
+  originalLines: string[],
+  replacementLines: string[]
+): string[] {
+  if (originalLines.length !== replacementLines.length) {
+    return replacementLines
+  }
+
+  return replacementLines.map((line, idx) => {
+    if (line.length === 0) return line
+    if (leadingWhitespace(line).length > 0) return line
+    const indent = leadingWhitespace(originalLines[idx])
+    if (indent.length === 0) return line
+    if (originalLines[idx].trim() === line.trim()) return line
+    return `${indent}${line}`
+  })
+}
+
+export function autocorrectReplacementLines(
+  originalLines: string[],
+  replacementLines: string[]
+): string[] {
+  let next = replacementLines
+  next = maybeExpandSingleLineMerge(originalLines, next)
+  next = restoreOldWrappedLines(originalLines, next)
+  next = restoreIndentForPairedReplacement(originalLines, next)
+  return next
+}