@claudiu-ceia/spatch 0.2.0 → 0.3.1

package/src/cli.ts

@@ -1,145 +1,5 @@
 #!/usr/bin/env node
-import { formatPatchOutput, runPatchCommand } from "./command.ts";
-
-type Flags = {
-  "dry-run"?: boolean;
-  interactive?: boolean;
-  json?: boolean;
-  "no-color"?: boolean;
-  cwd?: string;
-  concurrency?: number;
-  verbose?: number;
-};
-
-function parsePositiveInteger(name: string, raw: string | undefined): number {
-  const value = Number(raw);
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${name} must be a positive number`);
-  }
-  return Math.floor(value);
-}
-
-function readFlagValue(argv: string[], index: number): { value: string; consumed: number } {
-  const token = argv[index];
-  if (!token) {
-    throw new Error("Missing flag token");
-  }
-
-  const eqIndex = token.indexOf("=");
-  if (eqIndex >= 0) {
-    const value = token.slice(eqIndex + 1);
-    if (value.length === 0) {
-      throw new Error(`Missing value for ${token.slice(0, eqIndex)}`);
-    }
-    return { value, consumed: 1 };
-  }
-
-  const next = argv[index + 1];
-  if (!next) {
-    throw new Error(`Missing value for ${token}`);
-  }
-  return { value: next, consumed: 2 };
-}
-
-function printHelp(): void {
-  process.stdout.write(
-    [
-      "spatch - structural patch for TS/JS",
-      "",
-      "Usage:",
-      "  spatch [--dry-run] [--interactive] [--json] [--no-color] [--cwd <path>] <patch-input> [scope]",
-      "",
-      "Flags:",
-      "  --dry-run            Preview changes without writing files",
-      "  --interactive        Interactively select which matches to apply",
-      "  --json               Output structured JSON",
-      "  --no-color           Disable colored output",
-      "  --cwd <path>         Working directory for resolving patch and scope",
-      "  --concurrency <n>    Max files processed concurrently (default: 8)",
-      "  --verbose <level>    Perf tracing to stderr (1=summary, 2=slow files)",
-      "",
-    ].join("\n"),
-  );
-}
-
-const argv = process.argv.slice(2);
-if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
-  printHelp();
-  process.exit(0);
-}
-
-const flags: Flags = {};
-const positional: string[] = [];
-
-for (let i = 0; i < argv.length; i += 1) {
-  const token = argv[i];
-  if (!token) continue;
-
-  if (!token.startsWith("-")) {
-    positional.push(token);
-    continue;
-  }
-
-  if (token === "--dry-run") {
-    flags["dry-run"] = true;
-    continue;
-  }
-  if (token === "--interactive") {
-    flags.interactive = true;
-    continue;
-  }
-  if (token === "--json") {
-    flags.json = true;
-    continue;
-  }
-  if (token === "--no-color") {
-    flags["no-color"] = true;
-    continue;
-  }
-
-  if (token === "--cwd" || token.startsWith("--cwd=")) {
-    const { value, consumed } = readFlagValue(argv, i);
-    flags.cwd = value;
-    i += consumed - 1;
-    continue;
-  }
-  if (token === "--concurrency" || token.startsWith("--concurrency=")) {
-    const { value, consumed } = readFlagValue(argv, i);
-    flags.concurrency = parsePositiveInteger("--concurrency", value);
-    i += consumed - 1;
-    continue;
-  }
-  if (token === "--verbose" || token.startsWith("--verbose=")) {
-    const { value, consumed } = readFlagValue(argv, i);
-    const level = Number(value);
-    if (!Number.isFinite(level) || level < 0) {
-      throw new Error("--verbose must be a non-negative number");
-    }
-    flags.verbose = Math.floor(level);
-    i += consumed - 1;
-    continue;
-  }
-
-  throw new Error(`Unknown flag: ${token}`);
-}
-
-const patchInput = positional[0];
-const scope = positional[1];
-if (!patchInput) {
-  printHelp();
-  process.exit(1);
-}
-if (positional.length > 2) {
-  throw new Error("Too many positional arguments.");
-}
-
-const result = await runPatchCommand(patchInput, scope, flags);
-if (flags.json ?? false) {
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-} else {
-  const output = formatPatchOutput(result, {
-    color: Boolean(process.stdout.isTTY) && !(flags["no-color"] ?? false),
-  });
-  process.stdout.write(`${output}\n`);
-}
+import { run } from "@stricli/core";
+import { app } from "./app.ts";
 
+await run(app, process.argv.slice(2), { process });

package/src/command/flags.ts

@@ -0,0 +1,85 @@
+export type PatchCommandFlags = {
+  "dry-run"?: boolean;
+  check?: boolean;
+  interactive?: boolean;
+  json?: boolean;
+  "no-color"?: boolean;
+  cwd?: string;
+  concurrency?: number;
+  verbose?: number;
+};
+
+export const patchCommandFlagParameters = {
+  concurrency: {
+    kind: "parsed" as const,
+    optional: true,
+    brief: "Max files processed concurrently (default: 8)",
+    placeholder: "n",
+    parse: (input: string) => {
+      const value = Number(input);
+      if (!Number.isFinite(value) || value <= 0) {
+        throw new Error("--concurrency must be a positive number");
+      }
+      return Math.floor(value);
+    },
+  },
+  verbose: {
+    kind: "parsed" as const,
+    optional: true,
+    brief: "Print perf tracing (1=summary, 2=includes slow files)",
+    placeholder: "level",
+    parse: (input: string) => {
+      const value = Number(input);
+      if (!Number.isFinite(value) || value < 0) {
+        throw new Error("--verbose must be a non-negative number");
+      }
+      return Math.floor(value);
+    },
+  },
+  interactive: {
+    kind: "boolean" as const,
+    optional: true,
+    withNegated: false,
+    brief: "Interactively select which matches to apply",
+  },
+  json: {
+    kind: "boolean" as const,
+    optional: true,
+    withNegated: false,
+    brief: "Output structured JSON instead of compact diff-style text",
+  },
+  "no-color": {
+    kind: "boolean" as const,
+    optional: true,
+    withNegated: false,
+    brief: "Disable colored output",
+  },
+  "dry-run": {
+    kind: "boolean" as const,
+    optional: true,
+    withNegated: false,
+    brief: "Preview changes without writing files",
+  },
+  check: {
+    kind: "boolean" as const,
+    optional: true,
+    withNegated: false,
+    brief: "Exit non-zero if changes would be made (implies --dry-run)",
+  },
+  cwd: {
+    kind: "parsed" as const,
+    optional: true,
+    brief: "Working directory for resolving patch file and scope",
+    placeholder: "path",
+    parse: (input: string) => input,
+  },
+} as const;
+
+export function validatePatchCommandFlags(flags: PatchCommandFlags): void {
+  if ((flags.interactive ?? false) && (flags["dry-run"] ?? false)) {
+    throw new Error("Cannot combine --interactive with --dry-run.");
+  }
+  if ((flags.interactive ?? false) && (flags.check ?? false)) {
+    throw new Error("Cannot combine --interactive with --check.");
+  }
+}

package/src/command/interactive/path-resolution.ts

@@ -0,0 +1,72 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+
+export async function resolveInteractiveFilePath(
+  file: string,
+  options: { cwd: string; scope: string; scopeKind: "file" | "directory" },
+): Promise<string> {
+  if (path.isAbsolute(file)) {
+    const absolute = path.resolve(file);
+    if (isCandidateInScope(absolute, options)) {
+      return absolute;
+    }
+    throw new Error(`Resolved interactive file is outside selected scope: ${file}`);
+  }
+
+  const candidates = new Set<string>();
+  if (options.scopeKind === "file") {
+    candidates.add(options.scope);
+    candidates.add(path.resolve(path.dirname(options.scope), file));
+  } else {
+    candidates.add(path.resolve(options.scope, file));
+  }
+  candidates.add(path.resolve(options.cwd, file));
+
+  const resolvedCandidates: string[] = [];
+
+  for (const candidate of candidates) {
+    if (!isCandidateInScope(candidate, options)) {
+      continue;
+    }
+
+    try {
+      const candidateStats = await stat(candidate);
+      if (candidateStats.isFile()) {
+        resolvedCandidates.push(candidate);
+      }
+    } catch {
+      // Try next candidate.
+    }
+  }
+
+  if (resolvedCandidates.length === 1) {
+    return resolvedCandidates[0]!;
+  }
+  if (resolvedCandidates.length > 1) {
+    throw new Error(
+      `Ambiguous interactive patch target file: ${file}. Re-run spatch interactive with a narrower scope.`,
+    );
+  }
+
+  throw new Error(
+    `Unable to resolve interactive patch target file: ${file}. Re-run spatch interactive.`,
+  );
+}
+
+function isCandidateInScope(
+  candidate: string,
+  options: { scope: string; scopeKind: "file" | "directory" },
+): boolean {
+  if (options.scopeKind === "file") {
+    return path.resolve(candidate) === options.scope;
+  }
+
+  const relative = path.relative(options.scope, candidate);
+  if (relative.length === 0) {
+    return true;
+  }
+  if (path.isAbsolute(relative)) {
+    return false;
+  }
+  return relative !== ".." && !relative.startsWith(`..${path.sep}`);
+}

package/src/command/interactive/run.ts

@@ -0,0 +1,207 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { writeFileIfUnchangedAtomically } from "../../file-write.ts";
+import { applyReplacementSpans } from "../../replacement-spans.ts";
+import { patchProject } from "../../spatch.ts";
+import type { SpatchFileResult, SpatchOccurrence, SpatchResult } from "../../types.ts";
+import { resolveInteractiveFilePath } from "./path-resolution.ts";
+import { createTerminalInteractiveDecider } from "./terminal.ts";
+import type { RunInteractivePatchCommandOptions } from "./types.ts";
+import { validateSelectedOccurrences } from "./validation.ts";
+
+type PreparedInteractiveFile = {
+  absolutePath: string;
+  originalText: string;
+  rewrittenText: string;
+  changed: boolean;
+  replacementCount: number;
+  selected: SpatchOccurrence[];
+};
+
+export async function runInteractivePatchCommand(
+  patchInput: string,
+  options: RunInteractivePatchCommandOptions,
+): Promise<SpatchResult> {
+  const scope = options.scope ?? ".";
+  const cwd = options.cwd;
+  const resolvedCwd = path.resolve(cwd ?? process.cwd());
+  const resolvedScope = path.resolve(resolvedCwd, scope);
+  const resolvedScopeStats = await stat(resolvedScope);
+  const scopeKind: "file" | "directory" = resolvedScopeStats.isFile()
+    ? "file"
+    : resolvedScopeStats.isDirectory()
+      ? "directory"
+      : (() => {
+          throw new Error(`Scope must resolve to a file or directory: ${resolvedScope}`);
+        })();
+  const encoding = options.encoding ?? "utf8";
+  const noColor = options.noColor;
+  const interactiveDecider = options.interactiveDecider;
+
+  if (!interactiveDecider && (!processStdin.isTTY || !processStdout.isTTY)) {
+    throw new Error("Interactive mode requires a TTY stdin/stdout.");
+  }
+
+  const startedAt = Date.now();
+  const dryResult = await patchProject(patchInput, {
+    concurrency: options.concurrency,
+    cwd,
+    dryRun: true,
+    encoding: options.encoding,
+    logger: options.logger,
+    scope,
+    verbose: options.verbose,
+  });
+  const totalChanges = dryResult.files.reduce(
+    (count, file) =>
+      count +
+      file.occurrences.filter((occurrence) => occurrence.matched !== occurrence.replacement).length,
+    0,
+  );
+
+  let interactivePrompt: Awaited<ReturnType<typeof createTerminalInteractiveDecider>> | null = null;
+  const decider =
+    interactiveDecider ??
+    ((interactivePrompt = await createTerminalInteractiveDecider(noColor)),
+    interactivePrompt.decider);
+  const selectedByFile = new Map<string, SpatchOccurrence[]>();
+  let applyAll = false;
+  let stop = false;
+  let changeNumber = 0;
+
+  try {
+    for (const file of dryResult.files) {
+      const selected: SpatchOccurrence[] = [];
+
+      for (const occurrence of file.occurrences) {
+        if (occurrence.matched === occurrence.replacement) {
+          continue;
+        }
+        changeNumber += 1;
+
+        if (applyAll) {
+          selected.push(occurrence);
+          continue;
+        }
+
+        const choice = await decider({
+          file: file.file,
+          occurrence,
+          changeNumber,
+          totalChanges,
+        });
+
+        if (choice === "yes") {
+          selected.push(occurrence);
+          continue;
+        }
+
+        if (choice === "all") {
+          applyAll = true;
+          selected.push(occurrence);
+          continue;
+        }
+
+        if (choice === "quit") {
+          stop = true;
+          break;
+        }
+      }
+
+      selectedByFile.set(file.file, selected);
+      if (stop) {
+        break;
+      }
+    }
+  } finally {
+    interactivePrompt?.close();
+  }
+
+  const fileResults: SpatchFileResult[] = [];
+  let filesChanged = 0;
+  let totalReplacements = 0;
+  const preparedByFile = new Map<string, PreparedInteractiveFile>();
+
+  for (const file of dryResult.files) {
+    const selected = selectedByFile.get(file.file) ?? [];
+    if (selected.length === 0) {
+      continue;
+    }
+
+    const absolutePath = await resolveInteractiveFilePath(file.file, {
+      cwd: resolvedCwd,
+      scope: resolvedScope,
+      scopeKind,
+    });
+    const originalText = await readFile(absolutePath, encoding);
+    validateSelectedOccurrences(file.file, originalText, selected);
+    const rewrittenText = applyReplacementSpans(originalText, selected);
+    const changed = rewrittenText !== originalText;
+    const replacementCount = selected.filter(
+      (occurrence) => occurrence.matched !== occurrence.replacement,
+    ).length;
+    preparedByFile.set(file.file, {
+      absolutePath,
+      originalText,
+      rewrittenText,
+      changed,
+      replacementCount,
+      selected,
+    });
+  }
+
+  for (const file of dryResult.files) {
+    const selected = selectedByFile.get(file.file) ?? [];
+    if (selected.length === 0) {
+      fileResults.push({
+        ...file,
+        replacementCount: 0,
+        changed: false,
+        byteDelta: 0,
+        occurrences: [],
+      });
+      continue;
+    }
+
+    const prepared = preparedByFile.get(file.file);
+    if (!prepared) {
+      throw new Error(`Missing prepared interactive rewrite state for ${file.file}`);
+    }
+
+    if (prepared.changed) {
+      await writeFileIfUnchangedAtomically({
+        filePath: prepared.absolutePath,
+        originalText: prepared.originalText,
+        rewrittenText: prepared.rewrittenText,
+        encoding,
+        operationName: "interactive patch apply",
+      });
+    }
+
+    fileResults.push({
+      ...file,
+      replacementCount: prepared.replacementCount,
+      changed: prepared.changed,
+      byteDelta: prepared.changed
+        ? Buffer.byteLength(prepared.rewrittenText, encoding) -
+          Buffer.byteLength(prepared.originalText, encoding)
+        : 0,
+      occurrences: prepared.selected,
+    });
+
+    totalReplacements += prepared.replacementCount;
+    if (prepared.changed) {
+      filesChanged += 1;
+    }
+  }
+
+  return {
+    ...dryResult,
+    dryRun: false,
+    filesChanged,
+    totalReplacements,
+    elapsedMs: Date.now() - startedAt,
+    files: fileResults,
+  };
+}

package/src/command/interactive/terminal.ts

@@ -0,0 +1,134 @@
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import type { Readable, Writable } from "node:stream";
+import {
+  buildChalk,
+  countLines,
+  escapeTerminalText,
+  splitDiffLines,
+  type FormatPatchOutputOptions,
+} from "../output.ts";
+import type { InteractiveChoice, InteractiveContext, InteractiveDecider } from "./types.ts";
+
+type PromptInterface = {
+  question(prompt: string): Promise<string>;
+  close(): void;
+};
+
+type TerminalInteractiveDependencies = {
+  stdin: Readable & { isTTY?: boolean };
+  stdout: Writable & { isTTY?: boolean; write(chunk: string): boolean };
+  createPrompt: (options: {
+    input: Readable & { isTTY?: boolean };
+    output: Writable & { isTTY?: boolean; write(chunk: string): boolean };
+  }) => PromptInterface;
+};
+
+const defaultTerminalInteractiveDependencies: TerminalInteractiveDependencies = {
+  stdin: processStdin,
+  stdout: processStdout,
+  createPrompt: ({ input, output }) => createInterface({ input, output }),
+};
+
+export async function createTerminalInteractiveDecider(
+  noColor: boolean,
+  dependencies: TerminalInteractiveDependencies = defaultTerminalInteractiveDependencies,
+): Promise<{
+  decider: InteractiveDecider;
+  close: () => void;
+}> {
+  const chalkInstance = buildChalk({
+    color: Boolean(dependencies.stdout.isTTY) && !noColor,
+  });
+  const useColor = chalkInstance.level > 0;
+  const rl = dependencies.createPrompt({
+    input: dependencies.stdin,
+    output: dependencies.stdout,
+  });
+
+  return {
+    decider: async ({ file, occurrence, changeNumber, totalChanges }) => {
+      dependencies.stdout.write(
+        `\n${formatInteractiveChangeBlock(
+          { file, occurrence, changeNumber, totalChanges },
+          {
+            chalkInstance,
+            color: useColor,
+          },
+        )}\n`,
+      );
+
+      while (true) {
+        const answer = await rl.question(
+          useColor
+            ? chalkInstance.bold("Choice [y/n/a/q] (default: n): ")
+            : "Choice [y/n/a/q] (default: n): ",
+        );
+        const parsed = parseInteractiveChoice(answer);
+        if (parsed) {
+          return parsed;
+        }
+
+        dependencies.stdout.write(
+          useColor
+            ? `${chalkInstance.yellow("Invalid choice.")} Use y, n, a, or q.\n`
+            : "Invalid choice. Use y, n, a, or q.\n",
+        );
+      }
+    },
+    close: () => rl.close(),
+  };
+}
+
+export function formatInteractiveChangeBlock(
+  ctx: InteractiveContext,
+  options: FormatPatchOutputOptions = {},
+): string {
+  const chalkInstance = buildChalk(options);
+  const useColor = chalkInstance.level > 0;
+  const safeFile = escapeTerminalText(ctx.file);
+  const divider = "─".repeat(72);
+  const oldCount = countLines(ctx.occurrence.matched);
+  const newCount = countLines(ctx.occurrence.replacement);
+  const hunkHeader = `@@ -${ctx.occurrence.line},${oldCount} +${ctx.occurrence.line},${newCount} @@`;
+  const lines = [
+    useColor ? chalkInstance.gray(divider) : divider,
+    useColor
+      ? chalkInstance.bold(
+          `Change ${ctx.changeNumber}/${ctx.totalChanges} · ${safeFile}:${ctx.occurrence.line}:${ctx.occurrence.character}`,
+        )
+      : `Change ${ctx.changeNumber}/${ctx.totalChanges} · ${safeFile}:${ctx.occurrence.line}:${ctx.occurrence.character}`,
+    useColor ? chalkInstance.cyan(hunkHeader) : hunkHeader,
+    ...splitDiffLines(ctx.occurrence.matched).map((line) =>
+      useColor ? chalkInstance.red(`-${escapeTerminalText(line)}`) : `-${escapeTerminalText(line)}`,
+    ),
+    ...splitDiffLines(ctx.occurrence.replacement).map((line) =>
+      useColor
+        ? chalkInstance.green(`+${escapeTerminalText(line)}`)
+        : `+${escapeTerminalText(line)}`,
+    ),
+    useColor
+      ? chalkInstance.gray("Actions: [y] apply · [n] skip · [a] apply remaining · [q] quit")
+      : "Actions: [y] apply · [n] skip · [a] apply remaining · [q] quit",
+  ];
+
+  return lines.join("\n");
+}
+
+export function parseInteractiveChoice(answer: string): InteractiveChoice | null {
+  const normalized = answer.trim().toLowerCase();
+  if (normalized.length === 0 || normalized === "n" || normalized === "no") {
+    return "no";
+  }
+  if (normalized === "y" || normalized === "yes") {
+    return "yes";
+  }
+  if (normalized === "a" || normalized === "all") {
+    return "all";
+  }
+  if (normalized === "q" || normalized === "quit") {
+    return "quit";
+  }
+
+  return null;
+}

package/src/command/interactive/types.ts

@@ -0,0 +1,20 @@
+import type { SpatchOccurrence, SpatchOptions } from "../../types.ts";
+
+export type InteractiveChoice = "yes" | "no" | "all" | "quit";
+
+export type InteractiveContext = {
+  file: string;
+  occurrence: SpatchOccurrence;
+  changeNumber: number;
+  totalChanges: number;
+};
+
+export type InteractiveDecider = (ctx: InteractiveContext) => Promise<InteractiveChoice>;
+
+export type RunInteractivePatchCommandOptions = Pick<
+  SpatchOptions,
+  "concurrency" | "cwd" | "encoding" | "logger" | "scope" | "verbose"
+> & {
+  noColor: boolean;
+  interactiveDecider?: InteractiveDecider;
+};

package/src/command/interactive/validation.ts

@@ -0,0 +1,36 @@
+import type { SpatchOccurrence } from "../../types.ts";
+
+export function validateSelectedOccurrences(
+  file: string,
+  source: string,
+  occurrences: readonly SpatchOccurrence[],
+): void {
+  const sorted = [...occurrences].sort((left, right) => left.start - right.start);
+  let cursor = 0;
+
+  for (const occurrence of sorted) {
+    if (
+      occurrence.start < 0 ||
+      occurrence.end < occurrence.start ||
+      occurrence.end > source.length
+    ) {
+      throw new Error(
+        `File changed during interactive patch selection: ${file}. Re-run spatch interactive to refresh match positions.`,
+      );
+    }
+    if (occurrence.start < cursor) {
+      throw new Error(
+        `Invalid overlapping interactive occurrences for ${file}. Re-run spatch interactive.`,
+      );
+    }
+
+    const currentMatched = source.slice(occurrence.start, occurrence.end);
+    if (currentMatched !== occurrence.matched) {
+      throw new Error(
+        `File changed during interactive patch selection: ${file}. Re-run spatch interactive to refresh match positions.`,
+      );
+    }
+
+    cursor = occurrence.end;
+  }
+}

package/src/command/interactive.ts

@@ -0,0 +1 @@
+export { runInteractivePatchCommand } from "./interactive/run.ts";