plugsuits 1.0.0

package/src/tools/utils/execute/shell-detection.ts

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { platform } from "node:os";
+import { basename, win32 } from "node:path";
+
+const REJECTED_SHELL_BASENAMES = new Set(["fish", "nu", "csh", "tcsh"]);
+const WINDOWS_GIT_BASH_PATH = "C:\\Program Files\\Git\\bin\\bash.exe";
+const WINDOWS_CMD_PATH = "cmd.exe";
+
+let cachedShell: string | null = null;
+
+function resolveShellBasenames(shellPath: string): Set<string> {
+  const primary = basename(shellPath).toLowerCase();
+  const windows = win32.basename(shellPath).toLowerCase();
+  return primary === windows ? new Set([primary]) : new Set([primary, windows]);
+}
+
+function isRejectedShell(shellPath: string): boolean {
+  return [...resolveShellBasenames(shellPath)].some((name) =>
+    REJECTED_SHELL_BASENAMES.has(name)
+  );
+}
+
+function getPlatformShellOptions(): string[] {
+  if (platform() === "darwin") {
+    return ["/bin/zsh", "/bin/bash", "/bin/sh"];
+  }
+
+  if (platform() === "linux") {
+    return ["/bin/bash", "/bin/sh"];
+  }
+
+  return [WINDOWS_GIT_BASH_PATH, WINDOWS_CMD_PATH];
+}
+
+function firstExistingShell(shells: string[]): string | null {
+  for (const shell of shells) {
+    if (existsSync(shell)) {
+      return shell;
+    }
+  }
+
+  return null;
+}
+
+export function getShell(): string {
+  if (cachedShell) {
+    return cachedShell;
+  }
+
+  const envShell = process.env.SHELL?.trim();
+  if (envShell && existsSync(envShell) && !isRejectedShell(envShell)) {
+    cachedShell = envShell;
+    return cachedShell;
+  }
+
+  const shell = firstExistingShell(getPlatformShellOptions());
+  if (shell) {
+    cachedShell = shell;
+    return shell;
+  }
+
+  cachedShell = platform() === "win32" ? WINDOWS_CMD_PATH : "/bin/sh";
+  return cachedShell;
+}
+
+export function getShellArgs(shell: string): string[] {
+  if (resolveShellBasenames(shell).has("cmd.exe")) {
+    return ["/c"];
+  }
+
+  return ["-c"];
+}

package/src/tools/utils/hashline/autocorrect-replacement-lines.ts

@@ -0,0 +1,159 @@
+import { maybeExpandSingleLineMerge } from "./merge-expansion";
+
+const LEADING_WS_REGEX = /^\s*/;
+
+function normalizeTokens(text: string): string {
+  return text.replace(/\s+/g, "");
+}
+
+function stripAllWhitespace(text: string): string {
+  return normalizeTokens(text);
+}
+
+// biome-ignore lint/performance/noBarrelFile: intentional re-export for module API surface
+export {
+  maybeExpandSingleLineMerge,
+  stripMergeOperatorChars,
+  stripTrailingContinuationTokens,
+} from "./merge-expansion";
+
+function leadingWhitespace(text: string): string {
+  if (!text) {
+    return "";
+  }
+  const match = text.match(LEADING_WS_REGEX);
+  return match ? match[0] : "";
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: line-wrapping restoration algorithm
+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);
+  // Filter overlapping candidates — walk sorted list and skip any whose range overlaps
+  const accepted: typeof uniqueCandidates = [];
+  let nextAvailable = Number.POSITIVE_INFINITY;
+  for (const candidate of uniqueCandidates) {
+    const candidateEnd = candidate.start + candidate.len;
+    if (candidateEnd <= nextAvailable) {
+      accepted.push(candidate);
+      nextAvailable = candidate.start;
+    }
+  }
+  const correctedLines = [...replacementLines];
+  for (const candidate of accepted) {
+    correctedLines.splice(
+      candidate.start,
+      candidate.len,
+      candidate.replacement
+    );
+  }
+  return correctedLines;
+}
+
+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;
+    }
+    // Original line is whitespace-only (no real content) — not meaningful indentation
+    if (originalLines[idx].trim().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;
+}

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

@@ -0,0 +1,13 @@
+export const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
+
+export const HASHLINE_DICT = Array.from({ length: 256 }, (_, i) => {
+  // biome-ignore lint/suspicious/noBitwiseOperators: intentional bit shift for hash nibble extraction
+  const high = i >>> 4;
+  // biome-ignore lint/suspicious/noBitwiseOperators: intentional bit shift for hash nibble extraction
+  const low = i & 0x0f;
+  return `${NIBBLE_STR[high]}${NIBBLE_STR[low]}`;
+});
+
+export const HASHLINE_REF_PATTERN = /^([0-9]+)#([ZPMQVRWSNKTXJBYH]{2})$/;
+export const HASHLINE_OUTPUT_PATTERN =
+  /^([0-9]+)#([ZPMQVRWSNKTXJBYH]{2})\|(.*)$/;

package/src/tools/utils/hashline/diff-utils.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "bun:test";
+import { generateUnifiedDiff } from "./diff-utils";
+
+function createNumberedLines(totalLineCount: number): string {
+  return Array.from(
+    { length: totalLineCount },
+    (_, index) => `line ${index + 1}`
+  ).join("\n");
+}
+
+describe("generateUnifiedDiff", () => {
+  it("creates separate hunks for distant changes", () => {
+    const oldContent = createNumberedLines(60);
+    const newLines = oldContent.split("\n");
+    newLines[4] = "line 5 updated";
+    newLines[49] = "line 50 updated";
+    const newContent = newLines.join("\n");
+
+    const diff = generateUnifiedDiff(oldContent, newContent, "sample.txt");
+
+    const hunkHeaders = diff.match(/^@@/gm) ?? [];
+    expect(hunkHeaders.length).toBe(2);
+  });
+
+  it("creates a single hunk for adjacent changes", () => {
+    const oldContent = createNumberedLines(20);
+    const newLines = oldContent.split("\n");
+    newLines[9] = "line 10 updated";
+    newLines[10] = "line 11 updated";
+    const newContent = newLines.join("\n");
+
+    const diff = generateUnifiedDiff(oldContent, newContent, "sample.txt");
+
+    const hunkHeaders = diff.match(/^@@/gm) ?? [];
+    expect(hunkHeaders.length).toBe(1);
+    expect(diff).toContain(" line 8");
+    expect(diff).toContain(" line 13");
+  });
+
+  it("returns a diff string for identical content", () => {
+    const oldContent = "alpha\nbeta\ngamma";
+    const newContent = "alpha\nbeta\ngamma";
+
+    const diff = generateUnifiedDiff(oldContent, newContent, "sample.txt");
+
+    expect(typeof diff).toBe("string");
+    expect(diff).toContain("--- sample.txt");
+    expect(diff).toContain("+++ sample.txt");
+  });
+
+  it("returns a valid diff when old content is empty", () => {
+    const oldContent = "";
+    const newContent = "first line\nsecond line";
+
+    const diff = generateUnifiedDiff(oldContent, newContent, "sample.txt");
+
+    expect(diff).toContain("--- sample.txt");
+    expect(diff).toContain("+++ sample.txt");
+    expect(diff).toContain("+first line");
+  });
+});

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

@@ -0,0 +1,64 @@
+import { createTwoFilesPatch } from "diff";
+import { computeLineHash } from "./hash-computation";
+
+export function toHashlineContent(content: string): string {
+  if (!content) {
+    return content;
+  }
+  const lines = content.split("\n");
+  const lastLine = lines.at(-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 {
+  return createTwoFilesPatch(filePath, filePath, oldContent, newContent);
+}
+
+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 };
+}

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

@@ -0,0 +1,40 @@
+import { toNewLines } from "./edit-text-normalization";
+import type { HashlineEdit } from "./types";
+
+function normalizeEditPayload(payload: string | string[]): string {
+  return toNewLines(payload).join("\n");
+}
+
+function buildDedupeKey(edit: HashlineEdit): string {
+  switch (edit.op) {
+    case "replace":
+      return `replace|${edit.pos}|${edit.end ?? ""}|${normalizeEditPayload(edit.lines)}`;
+    case "append":
+      return `append|${edit.pos ?? ""}|${normalizeEditPayload(edit.lines)}`;
+    case "prepend":
+      return `prepend|${edit.pos ?? ""}|${normalizeEditPayload(edit.lines)}`;
+    default:
+      return JSON.stringify(edit);
+  }
+}
+
+export function dedupeEdits(edits: HashlineEdit[]): {
+  edits: HashlineEdit[];
+  deduplicatedEdits: number;
+} {
+  const seen = new Set<string>();
+  const deduped: HashlineEdit[] = [];
+  let deduplicatedEdits = 0;
+
+  for (const edit of edits) {
+    const key = buildDedupeKey(edit);
+    if (seen.has(key)) {
+      deduplicatedEdits += 1;
+      continue;
+    }
+    seen.add(key);
+    deduped.push(edit);
+  }
+
+  return { edits: deduped, deduplicatedEdits };
+}

package/src/tools/utils/hashline/edit-operation-primitives.ts

@@ -0,0 +1,149 @@
+import { autocorrectReplacementLines } from "./autocorrect-replacement-lines";
+import {
+  restoreLeadingIndent,
+  stripInsertAnchorEcho,
+  stripInsertBeforeEcho,
+  stripRangeBoundaryEcho,
+  toNewLines,
+} from "./edit-text-normalization";
+import { parseLineRef, validateLineRef } from "./validation";
+
+interface EditApplyOptions {
+  skipValidation?: boolean;
+}
+
+function shouldValidate(options?: EditApplyOptions): boolean {
+  return options?.skipValidation !== true;
+}
+
+export function applySetLine(
+  lines: string[],
+  anchor: string,
+  newText: string | string[],
+  options?: EditApplyOptions
+): string[] {
+  if (shouldValidate(options)) {
+    validateLineRef(lines, anchor);
+  }
+  const { line } = parseLineRef(anchor);
+  const result = [...lines];
+  const originalLine = lines[line - 1] ?? "";
+  const corrected = autocorrectReplacementLines(
+    [originalLine],
+    toNewLines(newText)
+  );
+  const replacement = corrected.map((entry, idx) => {
+    if (idx !== 0) {
+      return entry;
+    }
+    return restoreLeadingIndent(originalLine, entry);
+  });
+  result.splice(line - 1, 1, ...replacement);
+  return result;
+}
+
+export function applyReplaceLines(
+  lines: string[],
+  startAnchor: string,
+  endAnchor: string,
+  newText: string | string[],
+  options?: EditApplyOptions
+): string[] {
+  if (shouldValidate(options)) {
+    validateLineRef(lines, startAnchor);
+    validateLineRef(lines, endAnchor);
+  }
+
+  const { line: startLine } = parseLineRef(startAnchor);
+  const { line: endLine } = parseLineRef(endAnchor);
+
+  if (startLine > endLine) {
+    throw new Error(
+      `Invalid range: start line ${startLine} cannot be greater than end line ${endLine}`
+    );
+  }
+
+  const result = [...lines];
+  const originalRange = lines.slice(startLine - 1, endLine);
+  const stripped = stripRangeBoundaryEcho(
+    lines,
+    startLine,
+    endLine,
+    toNewLines(newText)
+  );
+  const corrected = autocorrectReplacementLines(originalRange, stripped);
+  const restored = corrected.map((entry, idx) => {
+    if (idx !== 0) {
+      return entry;
+    }
+    return restoreLeadingIndent(lines[startLine - 1] ?? "", entry);
+  });
+  result.splice(startLine - 1, endLine - startLine + 1, ...restored);
+  return result;
+}
+
+export function applyInsertAfter(
+  lines: string[],
+  anchor: string,
+  text: string | string[],
+  options?: EditApplyOptions
+): string[] {
+  if (shouldValidate(options)) {
+    validateLineRef(lines, anchor);
+  }
+  const { line } = parseLineRef(anchor);
+  const result = [...lines];
+  const newLines = stripInsertAnchorEcho(lines[line - 1], toNewLines(text));
+  if (newLines.length === 0) {
+    throw new Error(`append (anchored) requires non-empty text for ${anchor}`);
+  }
+  result.splice(line, 0, ...newLines);
+  return result;
+}
+
+export function applyInsertBefore(
+  lines: string[],
+  anchor: string,
+  text: string | string[],
+  options?: EditApplyOptions
+): string[] {
+  if (shouldValidate(options)) {
+    validateLineRef(lines, anchor);
+  }
+  const { line } = parseLineRef(anchor);
+  const result = [...lines];
+  const newLines = stripInsertBeforeEcho(lines[line - 1], toNewLines(text));
+  if (newLines.length === 0) {
+    throw new Error(`prepend (anchored) requires non-empty text for ${anchor}`);
+  }
+  result.splice(line - 1, 0, ...newLines);
+  return result;
+}
+
+export function applyAppend(
+  lines: string[],
+  text: string | string[]
+): string[] {
+  const normalized = toNewLines(text);
+  if (normalized.length === 0) {
+    throw new Error("append requires non-empty text");
+  }
+  if (lines.length === 1 && lines[0] === "") {
+    return [...normalized];
+  }
+  return [...lines, ...normalized];
+}
+
+export function applyPrepend(
+  lines: string[],
+  text: string | string[]
+): string[] {
+  const normalized = toNewLines(text);
+  if (normalized.length === 0) {
+    throw new Error("prepend requires non-empty text");
+  }
+  if (lines.length === 1 && lines[0] === "") {
+    return [...normalized];
+  }
+  return [...normalized, ...lines];
+}