plugsuits 1.0.0

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

@@ -0,0 +1,199 @@
+import { HASHLINE_DICT } from "./constants";
+import { createHashlineChunkFormatter } from "./hashline-chunk-formatter";
+
+const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
+export function computeLineHash(lineNumber: number, content: string): string {
+  const stripped = content.endsWith("\r")
+    ? content.slice(0, -1).replace(/\s+/g, "")
+    : content.replace(/\s+/g, "");
+  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 computeFileHash(content: string): string {
+  const rawHash = Bun.hash.xxHash32(content, 0);
+  const normalized =
+    ((rawHash % 0x1_00_00_00_00) + 0x1_00_00_00_00) % 0x1_00_00_00_00;
+  return normalized.toString(16).padStart(8, "0");
+}
+
+export function formatHashLine(lineNumber: number, content: string): string {
+  const hash = computeLineHash(lineNumber, content);
+  return `${lineNumber}#${hash}|${content}`;
+}
+
+export function formatLineTag(lineNumber: number, lineText: string): string {
+  return `${lineNumber}#${computeLineHash(lineNumber, lineText)}`;
+}
+
+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 function formatHashlineNumberedLines(
+  lines: string[],
+  startLine: number
+): string {
+  return lines
+    .map((line, index) => {
+      const lineNumber = startLine + index;
+      return formatHashLine(lineNumber, line);
+    })
+    .join("\n");
+}
+
+export interface HashlineStreamOptions {
+  maxChunkBytes?: number;
+  maxChunkLines?: number;
+  startLine?: 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[] = [];
+
+    while (true) {
+      const idx = pending.indexOf("\n");
+      if (idx === -1) {
+        break;
+      }
+      const line = pending.slice(0, idx);
+      pending = pending.slice(idx + 1);
+      endedWithNewline = true;
+      chunksToYield.push(...pushLine(line));
+    }
+
+    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/utils/hashline/hashline-chunk-formatter.ts

@@ -0,0 +1,61 @@
+export interface HashlineChunkFormatter {
+  flush(): string | undefined;
+  push(formattedLine: string): string[];
+}
+
+interface HashlineChunkFormatterOptions {
+  maxChunkBytes: number;
+  maxChunkLines: 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/utils/hashline/hashline-edit-diff.ts

@@ -0,0 +1,35 @@
+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");
+
+  let diff = `--- ${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) {
+      diff += `+ ${lineNum}#${hash}|${newLine}\n`;
+      continue;
+    }
+    if (i >= newLines.length) {
+      diff += `- ${lineNum}#  |${oldLine}\n`;
+      continue;
+    }
+    if (oldLine !== newLine) {
+      diff += `- ${lineNum}#  |${oldLine}\n`;
+      diff += `+ ${lineNum}#${hash}|${newLine}\n`;
+    }
+  }
+
+  return diff;
+}

package/src/tools/utils/hashline/index.ts

@@ -0,0 +1,55 @@
+// === Source-matching re-exports (1:1 from oh-my-opencode) ===
+
+// biome-ignore lint/performance/noBarrelFile: intentional barrel file for hashline module public API
+export {
+  HASHLINE_DICT,
+  HASHLINE_OUTPUT_PATTERN,
+  HASHLINE_REF_PATTERN,
+  NIBBLE_STR,
+} from "./constants";
+export type { HashlineApplyReport } from "./edit-operations";
+export {
+  applyHashlineEdits,
+  applyHashlineEditsWithReport,
+} from "./edit-operations";
+export {
+  parseHashlineText,
+  stripLinePrefixes,
+  toNewLines,
+} from "./edit-text-normalization";
+export type { FileTextEnvelope } from "./file-text-canonicalization";
+export {
+  canonicalizeFileText,
+  restoreFileText,
+} from "./file-text-canonicalization";
+export type { HashlineStreamOptions } from "./hash-computation";
+export {
+  computeFileHash,
+  computeLineHash,
+  formatHashLine,
+  formatHashLines,
+  formatHashlineNumberedLines,
+  formatLineTag,
+  streamHashLinesFromLines,
+  streamHashLinesFromLines as streamHashlineNumberedLinesFromLines,
+  streamHashLinesFromUtf8,
+  streamHashLinesFromUtf8 as streamHashlineNumberedLinesFromUtf8,
+} from "./hash-computation";
+export type { RawHashlineEdit } from "./normalize-edits";
+export { normalizeHashlineEdits } from "./normalize-edits";
+export type {
+  AppendEdit,
+  HashlineEdit,
+  PrependEdit,
+  ReplaceEdit,
+} from "./types";
+export type { LineRef, LineRef as LineTag } from "./validation";
+// parseLineRef wrappers with old names
+export {
+  HashlineMismatchError,
+  parseLineRef,
+  parseLineRef as parseLineTag,
+  tryParseLineTag,
+  validateLineRef,
+  validateLineRefs,
+} from "./validation";

package/src/tools/utils/hashline/merge-expansion.ts

@@ -0,0 +1,120 @@
+const CONTINUATION_TOKEN_REGEX =
+  /(?:&&|\|\||\?\?|\?|:|=|,|\+|-|\*|\/|\.|\()\s*$/u;
+const MERGE_OPERATOR_REGEX = /[|&?]/;
+const MERGE_OPERATOR_REGEX_GLOBAL = /[|&?]/g;
+const SEMICOLON_SPLIT_REGEX = /;\s+/;
+
+export function stripTrailingContinuationTokens(text: string): string {
+  return text.replace(CONTINUATION_TOKEN_REGEX, "");
+}
+
+export function stripMergeOperatorChars(text: string): string {
+  return text.replace(MERGE_OPERATOR_REGEX_GLOBAL, "");
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: merge expansion algorithm
+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 (!MERGE_OPERATOR_REGEX.test(segment[originalPos])) {
+            strippedPos += 1;
+          }
+          originalPos += 1;
+        }
+        idx = offset + originalPos;
+        // Compute actual consumed length in original string by walking through
+        // until partStripped.length non-operator characters are consumed
+        let consumed = 0;
+        let realLen = 0;
+        while (
+          consumed < partStripped.length &&
+          originalPos + realLen < segment.length
+        ) {
+          if (!MERGE_OPERATOR_REGEX.test(segment[originalPos + realLen])) {
+            consumed += 1;
+          }
+          realLen += 1;
+        }
+        matchedLen = realLen;
+      }
+    }
+    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(SEMICOLON_SPLIT_REGEX)
+    .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;
+}

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

@@ -0,0 +1,127 @@
+import type {
+  AppendEdit,
+  HashlineEdit,
+  PrependEdit,
+  ReplaceEdit,
+} from "./types";
+
+type HashlineToolOp = "replace" | "append" | "prepend";
+
+export interface RawHashlineEdit {
+  end?: string;
+  lines?: string | string[] | null;
+  op?: HashlineToolOp;
+  pos?: string;
+}
+
+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/utils/hashline/types.ts

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