fix(hashline-edit): stabilize TUI diff metadata and output flow

Align edit/write hashline handling with TUI expectations by preserving metadata through tool execution, keeping unified diff raw to avoid duplicated line numbers, and tightening read/write/edit outputs plus tests for reliable agent operation.

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

@@ -0,0 +1,104 @@
+import { computeLineHash } from "./hash-computation"
+
+export function toHashlineContent(content: string): string {
+	if (!content) return content
+	const lines = content.split("\n")
+	const lastLine = lines[lines.length - 1]
+	const hasTrailingNewline = lastLine === ""
+	const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines
+	const hashlined = contentLines.map((line, i) => {
+		const lineNum = i + 1
+		const hash = computeLineHash(lineNum, line)
+		return `${lineNum}:${hash}|${line}`
+	})
+	return hasTrailingNewline ? hashlined.join("\n") + "\n" : hashlined.join("\n")
+}
+
+export function generateUnifiedDiff(oldContent: string, newContent: string, filePath: string): string {
+	const oldLines = oldContent.split("\n")
+	const newLines = newContent.split("\n")
+	const maxLines = Math.max(oldLines.length, newLines.length)
+
+	let diff = `--- ${filePath}\n+++ ${filePath}\n`
+	let inHunk = false
+	let oldStart = 1
+	let newStart = 1
+	let oldCount = 0
+	let newCount = 0
+	let hunkLines: string[] = []
+
+	for (let i = 0; i < maxLines; i++) {
+		const oldLine = oldLines[i] ?? ""
+		const newLine = newLines[i] ?? ""
+
+		if (oldLine !== newLine) {
+			if (!inHunk) {
+				oldStart = i + 1
+				newStart = i + 1
+				oldCount = 0
+				newCount = 0
+				hunkLines = []
+				inHunk = true
+			}
+
+			if (oldLines[i] !== undefined) {
+				hunkLines.push(`-${oldLine}`)
+				oldCount++
+			}
+			if (newLines[i] !== undefined) {
+				hunkLines.push(`+${newLine}`)
+				newCount++
+			}
+		} else if (inHunk) {
+			hunkLines.push(` ${oldLine}`)
+			oldCount++
+			newCount++
+
+			if (hunkLines.length > 6) {
+				diff += `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@\n`
+				diff += hunkLines.join("\n") + "\n"
+				inHunk = false
+			}
+		}
+	}
+
+	if (inHunk && hunkLines.length > 0) {
+		diff += `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@\n`
+		diff += hunkLines.join("\n") + "\n"
+	}
+
+	return diff || `--- ${filePath}\n+++ ${filePath}\n`
+}
+
+export function countLineDiffs(oldContent: string, newContent: string): { additions: number; deletions: number } {
+	const oldLines = oldContent.split("\n")
+	const newLines = newContent.split("\n")
+
+	const oldSet = new Map<string, number>()
+	for (const line of oldLines) {
+		oldSet.set(line, (oldSet.get(line) ?? 0) + 1)
+	}
+
+	const newSet = new Map<string, number>()
+	for (const line of newLines) {
+		newSet.set(line, (newSet.get(line) ?? 0) + 1)
+	}
+
+	let deletions = 0
+	for (const [line, count] of oldSet) {
+		const newCount = newSet.get(line) ?? 0
+		if (count > newCount) {
+			deletions += count - newCount
+		}
+	}
+
+	let additions = 0
+	for (const [line, count] of newSet) {
+		const oldCount = oldSet.get(line) ?? 0
+		if (count > oldCount) {
+			additions += count - oldCount
+		}
+	}
+
+	return { additions, deletions }
+}