oh-my-opencode 5.0.0-beta.23 → 5.0.0-beta.25

package/dist/skills/debugging/references/scripts/dap.test.ts

@@ -1,86 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-
-const dir = import.meta.dir;
-const client = join(dir, "dap.mjs");
-const fixture = join(dir, "fixture-adapter.mjs");
-
-test("treats Windows drive-letter paths as executable specs, not host-port specs", async () => {
-  const { isTcpAdapterSpec } = await import("./dap.mjs");
-  expect(isTcpAdapterSpec("C:\\workspace\\fixture-adapter.mjs")).toBe(false);
-  expect(isTcpAdapterSpec("127.0.0.1:5678")).toBe(true);
-});
-
-function frame(message: unknown) {
-  const body = Buffer.from(JSON.stringify(message));
-  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body]);
-}
-
-describe("DAP framing", () => {
-  test("parses multiple frames and frames split across chunks", async () => {
-    const { DapFrameParser } = await import("./dap.mjs");
-    const parser = new DapFrameParser();
-    const first = frame({ type: "event", event: "one" });
-    const second = frame({ type: "event", event: "two", body: { ok: true } });
-    expect(parser.push(Buffer.concat([first, second]))).toEqual([{ type: "event", event: "one" }, { type: "event", event: "two", body: { ok: true } }]);
-    const third = frame({ type: "response", seq: 3 });
-    expect(parser.push(third.subarray(0, 9))).toEqual([]);
-    expect(parser.push(third.subarray(9, 17))).toEqual([]);
-    expect(parser.push(third.subarray(17))).toEqual([{ type: "response", seq: 3 }]);
-  });
-});
-
-function session(...fixtureArgs: string[]) {
-  // 300ms request timeout ONLY for the --no-answer session, whose test asserts the
-  // timeout classification and needs it to fire fast. Answering sessions get 5s:
-  // the vars-8 fixture response is ~130KB over a pipe, and on a loaded Windows CI
-  // runner that transfer exceeded 300ms, so the request timed out and TRUNCATED
-  // output could never appear (run 33065571760: byte-cap test burned its full
-  // 15s wait while vars-7's ~5KB response stayed under 300ms and passed).
-  const noAnswer = fixtureArgs.includes("--no-answer");
-  const child = spawn("bun", [client], { cwd: dir, env: { ...process.env, DAP_TIMEOUT_MS: noAnswer ? "300" : "5000", ...(noAnswer ? { DAP_FIXTURE_NO_ANSWER: "1" } : {}) } });
-  let output = "";
-  child.stdout.on("data", data => { output += data.toString(); });
-  const api = { child, get output() { return output; }, command(line: string) { child.stdin.write(`${line}\n`); } };
-  api.command(`launch ${fixture} /tmp/program.py`);
-  return api;
-}
-async function until(s: ReturnType<typeof session>, predicate: (out: string) => boolean) {
-  // 15s, not 3s: the file's first `spawn("bun", ...)` on a cold Windows CI runner
-  // (bun.exe cold launch + AV scan + fixture adapter spawn) was observed at just
-  // over 3s (dev run 33064234392: first READY wait failed at 3024ms while the
-  // warm sessions of later tests passed). `until` returns as soon as the
-  // predicate holds, so the raise costs nothing on the green path.
-  const deadline = Date.now() + 15_000;
-  while (!predicate(s.output) && Date.now() < deadline) await Bun.sleep(10);
-  expect(predicate(s.output)).toBe(true);
-}
-
-test("full session emits stop snapshot, stack and capped variables", async () => {
-  const s = session();
-  await until(s, out => out.includes("READY: launch"));
-  s.command("break /tmp/program.py:12"); await until(s, out => out.includes("BREAK:"));
-  s.command("continue"); await until(s, out => out.includes("STOP: stopped reason=breakpoint threadId=1 main at /tmp/program.py:12:3"));
-  s.command("stack"); await until(s, out => out.includes("FRAME\t"));
-  s.command("vars 7"); await until(s, out => out.includes("TRUNCATED: rows dropped=150"));
-  expect((s.output.match(/^v\d+\t/gm) ?? []).length).toBe(100);
-  s.command("terminate"); await until(s, out => out.includes("EXIT:"));
-  s.command("quit");
-}, 60_000);
-
-test("byte cap reports dropped bytes", async () => {
-  const s = session();
-  await until(s, out => out.includes("READY: launch"));
-  s.command("vars 8"); await until(s, out => out.includes("TRUNCATED: rows dropped=") && out.includes("bytes dropped="));
-  s.command("quit");
-}, 60_000);
-
-test("unverified breakpoint and timeout are classified", async () => {
-  const s = session();
-  await until(s, out => out.includes("READY: launch"));
-  s.command("break /tmp/unverified.py:9"); await until(s, out => out.includes("ERR: unverified-breakpoint"));
-  const t = session("--no-answer");
-  await until(t, out => out.includes("ERR: timeout"));
-  s.command("quit"); t.command("quit");
-}, 60_000);

package/dist/skills/debugging/references/scripts/fixture-adapter.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// Deterministic DAP fixture used by dap.test.ts.
-import { stdin, stdout, argv } from "node:process";
-
-let seq = 1;
-let buffer = Buffer.alloc(0);
-const noAnswer = argv.includes("--no-answer") || process.env.DAP_FIXTURE_NO_ANSWER === "1";
-
-function send(message) {
-  const body = Buffer.from(JSON.stringify(message));
-  stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
-  stdout.write(body);
-}
-function response(request, body = {}, success = true, message) {
-  send({ type: "response", seq: seq++, request_seq: request.seq, success, command: request.command, body, ...(message ? { message } : {}) });
-}
-function event(event, body = {}) { send({ type: "event", seq: seq++, event, body }); }
-function handle(request) {
-  if (noAnswer && request.command === "initialize") return;
-  switch (request.command) {
-    case "initialize":
-      response(request, { supportsConfigurationDoneRequest: true, supportsEvaluateForHovers: true });
-      event("initialized");
-      break;
-    case "setBreakpoints": {
-      const bps = request.arguments?.breakpoints ?? [];
-      response(request, { breakpoints: bps.map((bp, i) => ({ id: i + 1, verified: !request.arguments?.source?.path?.includes("unverified"), line: bp.line, column: bp.column ?? 1, message: "fixture" })) });
-      break;
-    }
-    case "configurationDone": response(request); break;
-    case "launch": response(request); break;
-    case "continue": response(request, { allThreadsContinued: true }); event("stopped", { reason: "breakpoint", threadId: 1, allThreadsStopped: true }); break;
-    case "next": case "stepIn": case "stepOut": response(request); event("stopped", { reason: "step", threadId: 1 }); break;
-    case "pause": response(request); event("stopped", { reason: "pause", threadId: 1 }); break;
-    case "threads": response(request, { threads: [{ id: 1, name: "main" }] }); break;
-    case "stackTrace": response(request, { stackFrames: [{ id: 42, name: "main", source: { path: "/tmp/program.py" }, line: 12, column: 3 }] }); break;
-    case "scopes": response(request, { scopes: [{ name: "Locals", variablesReference: 7, expensive: false }] }); break;
-    case "variables": response(request, { variables: Array.from({ length: 250 }, (_, i) => ({ name: `v${i + 1}`, value: request.arguments?.variablesReference === 8 ? `${String(i + 1)} ${"x".repeat(500)}` : String(i + 1), variablesReference: 0 })) }); break;
-    case "evaluate": response(request, { result: "42", type: "int", variablesReference: 0 }); break;
-    case "terminate": response(request); event("terminated", {}); break;
-    default: response(request, {}, false, `unsupported ${request.command}`);
-  }
-}
-stdin.on("data", chunk => {
-  buffer = Buffer.concat([buffer, chunk]);
-  while (true) {
-    const marker = buffer.indexOf(Buffer.from("\r\n\r\n"));
-    if (marker < 0) return;
-    const header = buffer.subarray(0, marker).toString();
-    const match = header.match(/Content-Length:\s*(\d+)/i);
-    if (!match) { buffer = buffer.subarray(marker + 4); continue; }
-    const length = Number(match[1]);
-    const start = marker + 4;
-    if (buffer.length < start + length) return;
-    const body = buffer.subarray(start, start + length);
-    buffer = buffer.subarray(start + length);
-    try { handle(JSON.parse(body.toString("utf8"))); } catch { /* fixture input is controlled */ }
-  }
-});

package/dist/skills/debugging/references/tools/dap.md

@@ -1,103 +0,0 @@
-# DAP Client (`dap.mjs`) — Drive the Debugger's Protocol, Not Its Text
-
-**Design modeled on the `debug` tool of oh-my-pi (https://github.com/can1357/oh-my-pi, branch omp2).** Their harness proved the shape: one structured debug surface with bounded output, stop snapshots, and classified errors. This script brings the same discipline to any agent with a shell — no harness tool registration required.
-
-Debuggers already speak the Debug Adapter Protocol (DAP), a machine-readable JSON protocol. Driving DAP beats screen-scraping a PTY for the same reason an API beats OCR: structured stops, structured variables, structured errors. **If the debugger speaks DAP, use this script instead of parsing `gdb`/`pdb` output.**
-
-The script is at `references/scripts/dap.mjs` — zero dependencies, runs under Bun or Node.
-
----
-
-## When to use which interface
-
-| Situation | Use |
-|---|---|
-| Source-level debugging of Python / Go / Node / native code, and you need breakpoints, stepping, variables | `dap.mjs` (this file) |
-| Browser-served JS, or anything already in Chrome | Scripted CDP — see `references/runtimes/node.md` |
-| Stripped binary, no source, no symbols | Ghidra (static) + Frida (live) — see `references/tools/` |
-| The debugger has no DAP mode (plain gdb on an exotic target) | pwndbg, with the output-budget rule from `references/methodology/00-setup.md` |
-
----
-
-## How to drive it
-
-`dap.mjs` is a **REPL**, not a one-shot command: a debug session is long-lived, so the script runs as a persistent process reading one command per line on stdin and writing bounded text on stdout. Run it as a background shell session, send commands to its stdin, and subscribe to its output.
-
-```
-bun references/scripts/dap.mjs
-```
-
-Every execution-control answer prints a single snapshot line beginning with `STOP:` — subscribe your watcher to that exact prefix so a breakpoint hit wakes you instead of you polling.
-
-### Commands
-
-| Command | Effect |
-|---|---|
-| `launch <adapter> <program> [args...]` | Spawn a stdio adapter (path to executable or `.mjs` adapter) and launch the program under it |
-| `attach <host:port>` | Connect to a listening adapter over TCP and attach |
-| `break <file>:<line>` / `rmbreak <file>:<line>` | Set / remove a source breakpoint |
-| `continue` / `step` / `next` / `stepin` / `stepout` / `pause` | Execution control; each prints a `STOP:` snapshot when the debuggee next stops |
-| `stack [limit]` | TSV backtrace, bounded |
-| `scopes` | Scopes of the top frame with their variablesReferences |
-| `vars <ref>` | Variables under a variablesReference from `scopes` — refs are session-scoped; always chain `scopes` first |
-| `eval <expr>` | Evaluate in the top frame |
-| `threads` / `sessions` | Thread list / session state |
-| `terminate` / `quit` | End the debuggee / exit the REPL |
-
-### Output contract (what keeps your context alive)
-
-- Tabular results are TSV with a header row.
-- Hard caps: `MAX_ROWS = 100`, `MAX_OUTPUT_BYTES = 32 KB`. Overflow prints an explicit `TRUNCATED: rows dropped=N bytes dropped=M` line — never a silent cut.
-- After every continue/step: `STOP: stopped reason=<why> threadId=<id> <frame> at <file>:<line>:<col>`. On debuggee exit: `EXIT: terminated`.
-- Errors are one line, classified: `ERR: invalid-args | no-session | adapter-failed | unverified-breakpoint | timeout | terminated | adapter-error`. The token tells you the recovery — see the failure taxonomy in `references/methodology/02-investigate.md`.
-- Every request times out after 15 s (override with `DAP_TIMEOUT_MS`) and the session stays alive.
-- `DAP_DEBUG=1` logs raw protocol traffic to stderr for diagnosing a misbehaving adapter.
-
-### Adapter quirks this client already handles
-
-- **debugpy** requires `console: "internalConsole"` in the launch request, and withholds the `initialized` event for unrecognized `adapterID`s — the client sends both correctly. It also flushes `initialized` lazily, so the client launches first and awaits the event after.
-- **lldb-dap** reports the launch response's `success` unreliably (`false` even when the process started and stopped) and reports `threadId: 0` on the entry stop. The events are the real signal; the client tolerates the response flag.
-
----
-
-## Adapter matrix
-
-Translated from oh-my-pi's `builtin_adapters()` (omp2 `crates/docserver/src/dap_adapter.rs`). Install the one matching your runtime; the client speaks to all of them the same way.
-
-| Runtime | Adapter | Install | Launch mode |
-|---|---|---|---|
-| Python | debugpy | `pip install debugpy` | `python -m debugpy.adapter` (stdio) |
-| Go | dlv | `go install github.com/go-delve/delve/cmd/dlv@latest` | `dlv dap` (stdio) |
-| C/C++/Swift/Rust/Zig | lldb-dap | ships with Xcode CLT / LLVM | `lldb-dap` (stdio) |
-| C/C++/Rust/Zig | codelldb | VS Code extension binary | stdio |
-| C/C++/Rust | gdb | `brew install gdb` / apt | via gdb's DAP mode where available |
-| JS/TS | js-debug | `npm i -g @vscode/js-debug` | stdio |
-| .NET | netcoredbg | GitHub releases | stdio |
-| Ruby | rdbg | `gem install debug` | stdio |
-| Kotlin | kotlin-debug-adapter | GitHub releases | stdio |
-| PHP | php-debug-adapter | composer | stdio |
-| Bash | bash-debug-adapter | GitHub releases | stdio |
-| Dart/Flutter | dart debug adapter | ships with Dart SDK | `dart` (stdio) |
-| Elixir | elixir-ls debugger | GitHub releases | stdio |
-
-If an adapter is missing, the install line is the fix — do not fall back to scraping a REPL.
-
----
-
-## Worked example (Python)
-
-```
-launch /path/to/python -m debugpy.adapter myscript.py   # or a wrapper script path
-break myscript.py:12
-continue
-STOP: stopped reason=breakpoint threadId=1 compute at myscript.py:12:1
-stack
-scopes
-vars 6          # the variablesReference scopes just printed for Locals
-eval total
-continue
-terminate
-quit
-```
-
-Cleanup is part of the session: `terminate` the debuggee, `quit` the REPL, and journal any wrapper scripts you created per the skill's cleanup phase.

package/dist/skills/debugging/references/tools/frida.md

@@ -1,193 +0,0 @@
-# Frida — Hook a Live Process and See Real Values at Runtime
-
-**https://frida.re**
-
-Frida injects a JavaScript engine into a running process and lets you intercept function calls, read arguments, patch return values, and trace execution without touching the binary on disk. **When static analysis in Ghidra shows you *what* a function does, Frida shows you what it does *right now*, with real inputs.** The two compose naturally: use Ghidra to find the target function and its offset, then use Frida to hook it and watch live traffic.
-
-Choose Frida over Ghidra when you need runtime values (actual arguments, return codes, heap contents) or when the binary's control flow is too obfuscated for static analysis to resolve.
-
----
-
-## Install
-
-```bash
-pip install frida-tools            # Python 3 required
-frida --version                    # verify
-```
-
-On macOS, attaching to another user's process needs root (`sudo frida ...`). SIP-protected system binaries (`/usr/bin/*`, `/usr/sbin/*`) are off-limits entirely. On Linux, you may need `ptrace` permissions: run as root or set `kernel.yama.ptrace_scope=0`.
-
----
-
-## Target discovery with `frida-ps`
-
-```bash
-frida-ps                         # list local processes
-frida-ps -U                      # USB-connected device (iOS/Android)
-frida-ps | grep -i target        # find your target by name
-```
-
----
-
-## `frida-trace` — zero-code entry point
-
-`frida-trace` auto-generates JavaScript handler stubs for every matched function. You don't write any code to start.
-
-```bash
-frida-trace -p <pid> -i "recv*"                               # trace exported functions by glob
-frida-trace -p <pid> -m "-[NSURLSession dataTaskWithRequest:*]"  # Objective-C method
-frida-trace -U -p <pid> -j "com.example.App!login*"             # Java method (Android)
-frida-trace -f ./target -i "open"                               # spawn + trace from start
-```
-
-Generated handler files land in `__handlers__/`. Each looks like:
-
-```js
-// __handlers__/libSystem.B.dylib/open.js
-{
-  onEnter(log, args, state) {
-    // args[0] is the first argument (a pointer)
-    log(`open("${args[0].readUtf8String()}")`);
-  },
-  onLeave(log, retval, state) {
-    log(`  => ${retval}`);
-  }
-}
-```
-
-Edit that file, save, and `frida-trace` hot-reloads it. This is the fastest path from "I wonder what this function receives" to a concrete answer.
-
----
-
-## The JS agent API
-
-When `frida-trace` isn't enough, you write a JS agent and load it with `frida` or from a Python host script. These are the building blocks.
-
-### Find a function
-
-```js
-// By exported symbol name
-const openPtr = Module.getExportByName(null, "open");  // null = any module
-const sslWritePtr = Module.getExportByName("libssl.so", "SSL_write");
-
-// By offset in a stripped binary (get the offset from Ghidra)
-const base = Module.getBaseAddress("target");
-const funcPtr = base.add(0x1a3c);
-```
-
-### Intercept calls
-
-```js
-Interceptor.attach(openPtr, {
-  onEnter(args) {
-    // args[0], args[1], ... are NativePointer objects
-    const path = args[0].readUtf8String();
-    const flags = args[1].toInt32();
-    send({ event: "open", path: path, flags: flags });
-  },
-  onLeave(retval) {
-    // retval is the return value as a NativePointer
-    send({ event: "open_ret", fd: retval.toInt32() });
-  }
-});
-```
-
-### Read memory
-
-```js
-args[0].readUtf8String()          // read a UTF-8 C string from a pointer
-args[0].readCString()             // read a raw C string (stops at null)
-args[1].readByteArray(len)        // read len raw bytes (returns ArrayBuffer)
-```
-
-### Replace / stub a function
-
-```js
-// Force a function to always return 0 (e.g. bypass a license check)
-Interceptor.replace(checkLicensePtr, new NativeCallback(function () {
-  return 0;
-}, 'int', []));
-```
-
-Use `Interceptor.replace` sparingly. It changes program behavior, so always note in your journal that you patched something and why.
-
----
-
-## Python host script
-
-A host script lets you load a JS agent, receive `send()` messages, and post-process results from the Python side.
-
-```python
-import frida, sys
-
-with open("agent.js") as f:
-    agent_source = f.read()
-
-def on_message(message, data):
-    if message["type"] == "send":
-        print(f"[*] {message['payload']}")
-    else:
-        print(f"[!] {message}")
-
-session = frida.attach(int(sys.argv[1]))
-script = session.create_script(agent_source)
-script.on("message", on_message)
-script.load()
-
-try:
-    sys.stdin.read()                 # block until Ctrl+C
-except KeyboardInterrupt:
-    session.detach()
-```
-
-The agent runs inside the target; the host script stays in your terminal and prints structured output.
-
----
-
-## Output-budget discipline
-
-**Hooking a hot function (e.g. `malloc`, `read`) will flood your context with thousands of lines.** Don't print every call. Aggregate in the agent and report a summary.
-
-```js
-// Count calls, report every 1000
-let callCount = 0;
-Interceptor.attach(mallocPtr, {
-  onEnter(args) {
-    callCount++;
-    if (callCount % 1000 === 0) {
-      send({ event: "malloc_summary", total_calls: callCount });
-    }
-  }
-});
-```
-
-Alternatives: filter by argument value, only log calls from a specific caller module, or batch into an array and `send()` on a timer.
-
----
-
-## ⚠️ Gotchas
-
-**Attach vs. spawn.** `frida -p <pid>` attaches to an already-running process. If you need to catch early initialization (constructors, `main` entry), spawn the process with `frida -f ./target`. Frida pauses it at startup. Resume with `%resume` in the REPL or by calling `device.resume(pid)` from Python.
-
-**Stripped binaries have no symbol names.** `Module.getExportByName` returns null for internal functions. You must find the function offset in Ghidra, then compute the address at runtime:
-
-```js
-const addr = Module.getBaseAddress("target").add(0x4a20);
-Interceptor.attach(addr, { /* ... */ });
-```
-
-**A crashing target kills your session.** If the target segfaults or aborts, Frida's agent dies with it. Script a respawn loop on the Python side if you expect crashes.
-
-**Thread safety.** `onEnter`/`onLeave` fire on multiple threads. Keep shared state to simple counters.
-
----
-
-## Cleanup
-
-```bash
-kill <pid>                         # kill any process you spawned with -f
-rm -rf __handlers__/               # remove generated handler stubs
-rm -f agent.js host.py             # remove session-specific scripts
-```
-
-Always note in your journal which processes you attached to and whether you replaced any functions. A forgotten `Interceptor.replace` in a long-running target will cause confusing behavior later.

package/packages/lsp-core/src/lsp/format-document.test.ts

@@ -1,143 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "bun:test";
-
-import type { LspClient } from "./client.js";
-import { formatDocumentWithClient } from "./format-document.js";
-import type { TextEdit } from "./types.js";
-
-const workspaces: string[] = [];
-
-afterEach(() => {
-	for (const workspace of workspaces.splice(0)) rmSync(workspace, { recursive: true, force: true });
-});
-
-function workspaceWith(fileName: string, content: string): { readonly root: string; readonly filePath: string } {
-	const root = mkdtempSync(join(tmpdir(), "lsp-format-"));
-	workspaces.push(root);
-	const filePath = join(root, fileName);
-	writeFileSync(filePath, content, "utf-8");
-	return { root, filePath };
-}
-
-function stubClient(edits: TextEdit[] | null): LspClient {
-	return {
-		async formatDocument() {
-			return edits;
-		},
-		async openFile() {},
-	} as Pick<LspClient, "formatDocument" | "openFile"> as LspClient;
-}
-
-describe("formatDocumentWithClient", () => {
-	it("#given a server returning text edits #when the document is formatted #then the file is rewritten and line deltas are reported", async () => {
-		// given
-		const { filePath } = workspaceWith("sample.ts", "const a=1\nconst b   =2\nconst c=3\n");
-		const edits: TextEdit[] = [
-			{ range: { start: { line: 0, character: 0 }, end: { line: 1, character: 12 } }, newText: "const a = 1;\nconst b = 2;" },
-		];
-
-		// when
-		const result = await formatDocumentWithClient(stubClient(edits), filePath);
-
-		// then
-		expect(result.status).toBe("formatted");
-		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\nconst b = 2;\nconst c=3\n");
-		expect(result).toMatchObject({ status: "formatted", linesAdded: 2, linesRemoved: 2 });
-	});
-
-	it("#given a server returning an edit that adds lines #when the document is formatted #then the added and removed line counts differ", async () => {
-		// given
-		const { filePath } = workspaceWith("sample.ts", "const a=1;const b=2\n");
-		const edits: TextEdit[] = [
-			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 19 } }, newText: "const a = 1;\nconst b = 2;" },
-		];
-
-		// when
-		const result = await formatDocumentWithClient(stubClient(edits), filePath);
-
-		// then
-		expect(result).toMatchObject({ status: "formatted", linesAdded: 2, linesRemoved: 1 });
-		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\nconst b = 2;\n");
-	});
-
-	it("#given a server that does not advertise document formatting #when the document is formatted #then the result is unavailable and the file bytes are untouched", async () => {
-		// given
-		const original = "const a=1\n";
-		const { filePath } = workspaceWith("sample.ts", original);
-		const before = statSync(filePath);
-
-		// when
-		const result = await formatDocumentWithClient(stubClient(null), filePath);
-
-		// then
-		expect(result).toEqual({ status: "unavailable", reason: "capability_not_advertised" });
-		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
-		expect(statSync(filePath).mtimeMs).toBe(before.mtimeMs);
-	});
-
-	it("#given a server returning no edits #when the document is formatted #then the result is unchanged and the file bytes are untouched", async () => {
-		// given
-		const original = "const a = 1;\n";
-		const { filePath } = workspaceWith("sample.ts", original);
-
-		// when
-		const result = await formatDocumentWithClient(stubClient([]), filePath);
-
-		// then
-		expect(result).toEqual({ status: "unchanged", linesAdded: 0, linesRemoved: 0 });
-		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
-	});
-
-	it("#given edits that reproduce the current bytes #when the document is formatted #then the result is unchanged", async () => {
-		// given
-		const original = "const a = 1;\n";
-		const { filePath } = workspaceWith("sample.ts", original);
-		const edits: TextEdit[] = [
-			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 12 } }, newText: "const a = 1;" },
-		];
-
-		// when
-		const result = await formatDocumentWithClient(stubClient(edits), filePath);
-
-		// then
-		expect(result.status).toBe("unchanged");
-		expect(readFileSync(filePath, "utf-8")).toBe(original);
-	});
-
-	it("#given the file shrinks after the server computed its edits #when the edits are applied #then the stale edit is rejected instead of corrupting the file", async () => {
-		// given
-		const { filePath } = workspaceWith("sample.ts", "const a=1\nconst b=2\n");
-		const staleEdits: TextEdit[] = [
-			{ range: { start: { line: 1, character: 0 }, end: { line: 1, character: 9 } }, newText: "const b = 2;" },
-		];
-		const racingClient = {
-			async formatDocument() {
-				writeFileSync(filePath, "short\n", "utf-8");
-				return staleEdits;
-			},
-			async openFile() {},
-		} as Pick<LspClient, "formatDocument" | "openFile"> as LspClient;
-
-		// when / then
-		await expect(formatDocumentWithClient(racingClient, filePath)).rejects.toThrow(/outside line/);
-		expect(readFileSync(filePath, "utf-8")).toBe("short\n");
-	});
-
-	it("#given a formatted document #when the write completes #then no temporary file is left behind", async () => {
-		// given
-		const { root, filePath } = workspaceWith("sample.ts", "const a=1\n");
-		const edits: TextEdit[] = [
-			{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 9 } }, newText: "const a = 1;" },
-		];
-
-		// when
-		await formatDocumentWithClient(stubClient(edits), filePath);
-
-		// then
-		expect(readFileSync(filePath, "utf-8")).toBe("const a = 1;\n");
-		expect(() => statSync(join(root, "sample.ts.tmp"))).toThrow();
-	});
-});

package/packages/lsp-core/src/lsp/format-document.ts

@@ -1,90 +0,0 @@
-import { readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-
-import type { LspClient } from "./client.js";
-import type { FormattingOptions, TextEdit } from "./types.js";
-import { normalizeTextEdits } from "./workspace-edit-text.js";
-
-export const DEFAULT_FORMATTING_OPTIONS: FormattingOptions = {
-	tabSize: 4,
-	insertSpaces: false,
-	trimTrailingWhitespace: true,
-	insertFinalNewline: true,
-	trimFinalNewlines: true,
-};
-
-export type FormatDocumentResult =
-	| { readonly status: "formatted"; readonly linesAdded: number; readonly linesRemoved: number }
-	| { readonly status: "unchanged"; readonly linesAdded: 0; readonly linesRemoved: 0 }
-	| { readonly status: "unavailable"; readonly reason: "capability_not_advertised" };
-
-export interface FormatDocumentOptions {
-	readonly formattingOptions?: FormattingOptions;
-	readonly signal?: AbortSignal;
-}
-
-const UNCHANGED: FormatDocumentResult = { status: "unchanged", linesAdded: 0, linesRemoved: 0 };
-
-/**
- * Formats one document through the resident language server and commits the result to disk.
- *
- * The server is asked for whole-document edits rather than formatted text, so the edits are
- * validated and applied with the same normalization the workspace-edit path uses. Nothing is
- * written when the server declines the capability or when the edits reproduce the current bytes,
- * which keeps a no-op format from touching file mtimes that downstream tooling watches.
- */
-export async function formatDocumentWithClient(
-	client: LspClient,
-	filePath: string,
-	options: FormatDocumentOptions = {},
-): Promise<FormatDocumentResult> {
-	const edits = await client.formatDocument(
-		filePath,
-		options.formattingOptions ?? DEFAULT_FORMATTING_OPTIONS,
-		options.signal,
-	);
-	if (edits === null) return { status: "unavailable", reason: "capability_not_advertised" };
-	if (edits.length === 0) return UNCHANGED;
-
-	const before = readFileSync(filePath, "utf-8");
-	const normalized = normalizeTextEdits(before, edits, 0);
-	if (normalized.text === before) return UNCHANGED;
-
-	writeAtomically(filePath, normalized.text);
-	await client.openFile(filePath);
-
-	return {
-		status: "formatted",
-		...lineDelta(normalized.edits),
-	};
-}
-
-/**
- * Counts the lines each edit removes from the document and adds back in its place.
- *
- * Counting from the edits instead of diffing the whole file keeps the report proportional to what
- * the server actually rewrote, so an unrelated line never shows up as churn.
- */
-function lineDelta(edits: readonly TextEdit[]): { readonly linesAdded: number; readonly linesRemoved: number } {
-	let linesAdded = 0;
-	let linesRemoved = 0;
-	for (const edit of edits) {
-		linesRemoved += edit.range.end.line - edit.range.start.line + 1;
-		linesAdded += edit.newText.split("\n").length;
-	}
-	return { linesAdded, linesRemoved };
-}
-
-function writeAtomically(filePath: string, content: string): void {
-	const tempPath = `${filePath}.omo-format.tmp`;
-	writeFileSync(tempPath, content, "utf-8");
-	try {
-		renameSync(tempPath, filePath);
-	} catch (error) {
-		try {
-			unlinkSync(tempPath);
-		} catch {
-			// The rename failure is the actionable error; a leftover temp file must not mask it.
-		}
-		throw error;
-	}
-}