webnav-ts-mcp 0.1.0 → 0.2.0

package/README.md

@@ -2,9 +2,9 @@
 
 An MCP server that gives AI agents JS/TS/HTML/CSS navigation, plus a
 cross-file index of CSS custom properties and `#id`/`.class` selectors that
-single-file language servers can't provide. It is the TypeScript port of the
-Python [`webnav-mcp`](https://pypi.org/project/webnav-mcp/), so a web project can
-add it with its own package manager and have no Python or `uv` in the chain.
+single-file language servers can't provide, and write tools that type-check an
+edit before it is written. It needs only Node.js and installs with a web
+project's own package manager.
 
 ## Quick start
 
@@ -93,6 +93,53 @@ Then use the position tools once you have a `path:line:col`:
 Positions are **1-indexed**; `column` is a UTF-16 character offset (a leading
 tab counts as one character).
 
+## Write tools: change code with a type check before every write
+
+The navigation tools above are read-only. These change code, and share one rule:
+**the edit is shown to the language servers as an in-memory overlay first, the
+edited files and the script files importing them are re-checked, and the
+response says which diagnostics the edit would add or fix. Nothing is written
+until that is on the table.**
+
+| Tool | Does |
+|------|------|
+| `edit` | Type-checked text edit of a JS/TS/HTML/CSS file: `old_string`/`new_string` or a whole `new_text` (also creates a file). For anything that is not a whole definition. Line endings follow the file |
+| `edit_symbol` | `action="replace"` / `"insert"` / `"delete"` a function, class, interface, enum, const or member by name: re-indented to the file's own style (tabs or spaces), doc comment kept, `imports=[...]` merged into the file, blank-line spacing handled. Delete refuses while anything uses the symbol and prunes imports only the deleted code used |
+| `rename_symbol` | JS/TS: rename through the TypeScript language server (imports, aliases, overriding members; `parameter=` for one parameter). CSS/HTML: a name starting with `--`, `#` or `.` renames that custom property / id / class across stylesheets, `<style>` and `style=""`, markup (`class`, `id`, `for`, `aria-*`, `href="#id"`) and scripts (`getElementById`, `classList`, `querySelector`, `className`, `setProperty`, markup in strings). Names built dynamically and script strings that merely equal the name are listed, not renamed; other places still using the old name (docs, `.vue`/`.scss`, strings) are listed too |
+| `move` | With `name`: move a top-level function/class/interface/type/const to another file with the imports it needs, repoint every importer and re-export, drop imports only the moved code used, warn about import cycles. Without it: move or rename the file `file_path` (any file): imports (the language server's own rewrite), `<script src>`/`<link href>`/`<img src>` and CSS `url()`/`@import` follow, and the moved file's own relative references are re-based |
+| `quick_fix` | Apply the language server's own fixes (missing imports, misspellings, ...) one by one, re-checking after each; or a source action: `organize_imports`, `remove_unused_imports`, `sort_imports`, `fix_all`. Ambiguous fixes are listed instead of guessed |
+| `verify_changes` | After editing with any tool (your own included): which diagnostics the working tree gained or lost since a git revision (default `HEAD`) |
+| `apply_edit` / `undo_edit` | Write a previewed edit by id; revert an applied one |
+
+One rule for every write tool: it writes when the edit adds no more than
+`max_new_errors` (default 0) errors in the edited files and their importers and
+the result parses. Otherwise nothing is written and you get the diagnostics plus
+an id for `apply_edit`. `apply=false` always previews. Hints and warnings are
+shown but not counted. Syntax errors (TypeScript's 1xxx codes, any CSS error)
+block a write even with `max_new_errors=null`.
+
+Safety rules, enforced in code:
+
+- Only `.js`/`.mjs`/`.cjs`/`.jsx`/`.ts`/`.mts`/`.cts`/`.tsx`/`.html`/`.css` files inside the
+  workspace are edited (`move` also carries any file, such as an image a stylesheet
+  uses); `node_modules`, `dist`, `.git` and the other skipped folders, generated output
+  (`WEBNAV_MCP_EXCLUDE`) and symlinks are refused.
+- A preview remembers the exact bytes of every file; `apply_edit` refuses if any file
+  changed since. Files are replaced atomically (temp file + rename), and a failure
+  part-way restores the ones already written.
+- Every applied edit is undoable (`undo_edit`) unless a file was changed after it.
+- Line endings and a leading BOM are preserved.
+- Edits touching more than 40 files need `allow_large=true`.
+- `WEBNAV_MCP_READ_ONLY=1` turns every write into a refusal (previews still work).
+
+Scope: the importers that get re-checked are found by relative `import`/`export
+... from`/`require()`/`import()` specifiers (`./a`, `./a.js` for `a.ts`, `./dir`
+for `dir/index.ts`); a file reached only through a path alias is checked with its
+own edit alone. `move`'s HTML/CSS rewrite understands relative and root-absolute
+(`/src/main.ts`) references; bundler config, path aliases and string paths are
+listed as mentions, not rewritten. HTML/CSS edits are checked by their language
+servers (syntax and CSS lint), not against the cross-file index.
+
 ## Environment
 
 | Variable | Default | Purpose |
@@ -100,158 +147,94 @@ tab counts as one character).
 | `WEBNAV_MCP_WORKSPACE` | unset: follows the client's MCP roots when they name a worktree of the same git repository, else `CLAUDE_PROJECT_DIR`, else the working directory | Pins the project root (never overridden). See the `workspace` tool |
 | `WEBNAV_MCP_ROOTS` | the whole workspace as one root, labelled `web` | Comma-separated `label=relative/path` pairs to index separately, e.g. `app=src,prototypes=design` |
 | `WEBNAV_MCP_EXCLUDE` | nothing | Comma-separated workspace-relative paths of generated script output (e.g. the JS a TS build emits). Not opened, hidden from `search_symbol`, rejected by the position tools; the CSS/selector index still reads them |
-
-Tool names, parameter names and environment variables are identical to the
-Python package, so existing prompts, hosts and configs keep working.
-
-## Differences from the Python package
-
-| | Python `webnav-mcp` | webnav-ts-mcp |
-|---|---|---|
-| Runtime | Python ≥ 3.11 **and** Node ≥ 18 | Node ≥ 20 only (tested on 22) |
-| Language servers | found in the project's `node_modules`, then the package dir, then `PATH`, then `npx --yes` (downloads at first use) | ordinary npm dependencies: a TypeScript ≥ 7 in the *project* wins, else the copy installed with webnav. Nothing is downloaded at runtime |
-| Launch | `.bin` shims (`.cmd` special case on Windows) | `node <server>.js`, no shims, no `PATH` dependence |
-| JSON-RPC framing | hand-written | [`vscode-jsonrpc`](https://www.npmjs.com/package/vscode-jsonrpc) |
-| UTF-16 columns | encode/decode helpers | JS strings already are UTF-16 |
-| Cold start (init handshake) | ~530 ms | ~100 ms (see [Speed](#speed)) |
+| `WEBNAV_MCP_READ_ONLY` | unset | `1`/`true`: write tools refuse to write (previews and checks still work) |
+| `WEBNAV_MCP_PUBLIC` | nothing | Comma-separated workspace-relative stylesheets (files or directories) that are a public API, e.g. a design-token file consumed by other projects. `diagnostics` stops reporting their custom properties as "declared but never used" and their selectors as "never referenced"; undefined `var()` usages are still reported |
 
 ## Layout
 
 ```
 src/
   cli.ts          stdio entry point (exits when the host closes stdin)
-  server.ts       registers the twelve tools on the MCP SDK
+  server.ts       registers the tools on the MCP SDK
   webnav.ts       the tools as plain async functions returning text; owns all state
-  webIndex.ts     CSS var / selector index (port of web_index.py)
+  webIndex.ts     CSS var / selector index
   langCommand.ts  how to launch tsc / html / css language servers
   glob.ts         just enough glob for jsconfig `include`
-  shared/         port of mcp_nav_shared: lspClient, format, resolve, workspace,
-                  notices, errors, params, exclude
+  shared/         lspClient, format, resolve, workspace, notices, errors,
+                  params, exclude
+  write/          the write tools: edits (plans, diffs), transaction (guard,
+                  journal, undo), simulate + diagnosticsDelta (the type check),
+                  finish (preview/apply), one module per tool, webTokens
+                  (CSS var/id/class finder), jsImports (import rewriting)
 tests/            vitest; fixtures/sample-app is the shared fixture
-scripts/parity.mjs  drives Python and TS servers side by side and diffs the output
 ```
 
-`shared/` is deliberately a directory, not a second package: see
-[Shared library](#the-shared-library).
-
 ## Development
 
 ```bash
 npm install
 npm run check     # biome + tsc + vitest (pretest builds dist/)
-npm run bench     # speed/memory vs the Python package (same sibling checkout requirement)
-npm run parity    # needs the Python webnav-mcp checked out at ../webnav-mcp with `uv sync`; see the script header
+npm run upload    # check + publish to npm (--build-only / --dry-run / --otp CODE after `--`); needs `npm login`
+npm run test-package  # install the published version in a throwaway project and drive it over MCP stdio
 node bin/launch.mjs   # checkout launcher: installs + builds when needed, then starts the server
 ```
 
 Source: [github.com/illescasDaniel/webnav-ts-mcp](https://github.com/illescasDaniel/webnav-ts-mcp).
 
-## Speed
-
-Measured with `npm run bench` on Linux (Node 24, Python venv binary started directly so `uv`'s ~20 ms
-is excluded), real MCP over stdio against a real web project (SpaceMaker: 3 roots, ~60 JS/TS/CSS/HTML
-files, a 3k-line wireframe), median of 7 alternating runs, 15 warm calls per tool:
-
-| Metric | Python | TypeScript | |
-|---|---|---|---|
-| Cold start (spawn → `initialize`) | 528 ms | 103 ms | 5.1× |
-| First `symbol_info` (spawns `tsc` LSP) | 717 ms | 106 ms | 6.7× |
-| First HTML `diagnostics` (spawns HTML server) | 1197 ms | 978 ms | 1.2× |
-| Warm `symbol_info` / `references` / `hover` | 8.3 / 7.9 / 7.2 ms | 4.4 / 3.6 / 2.7 ms | ~2× |
-| Warm `outline` / `search_symbol` | 7.1 / 8.7 ms | 2.0 / 4.0 ms | 2–3.5× |
-| Warm `css_var` / `selector` (own index) | 2.6 / 2.6 ms | 0.5 / 0.7 ms | 4–5× |
-| Whole session (connect + every tool once + 15 warm calls each) | 3.5 s | 1.6 s | 2.2× |
-| Memory, server + language servers | 477 MiB | 359 MiB | 1.3× |
-| Shutdown after stdin closes | 61 ms | 13 ms | 4.6× |
-
-Warm calls are dominated by the language servers, which are identical in both, so the gap there is
-the fixed cost of the MCP layer. Launching through `npx webnav-ts-mcp` adds roughly 0.2 s to the
-cold start (npm resolving the `.bin` shim); a locally installed copy started with `node` does not.
-
-## Notes from the port
+## Design notes
 
 `webnav` is glue: it spawns three Node language servers and formats their answers,
-plus a regex-grade index. Nothing in it depends on Python. The MCP SDK, the LSP
-plumbing and the file scanning all have first-class Node equivalents.
-
-**Behavioural parity**, measured by `scripts/parity.mjs` (real MCP over stdio,
-identical calls, diffed text):
-
-- A real web project ([SpaceMaker](https://github.com/illescasDaniel/SpaceMaker)'s assets, three roots): **37 / 37 identical**
-- `tests/fixtures/sample-app`, including edits behind the servers' backs (fix a
-  type error, create/delete a file, change a stylesheet, change `jsconfig.json`
-  and get the restart notice): **71 / 71 identical** (counting the one intentional
-  inherited-member difference below)
-
-The one intentional difference is the reason string of "Cannot read file as
-UTF-8 text: …", which is a Python codec detail; the parity script masks it.
+plus a regex-grade index.
 
-**Tests:** 152 vitest tests (unit ports of the index/format tests, real
-language servers against the fixture, MCP protocol over an in-memory transport
-incl. worktree selection via client roots with a real `git worktree`, LSP
-client failure modes, and the built executable). The Python side has ~260 tests
-across the two packages; the port covers the behaviour that matters for the
-tools, not every case one-to-one.
+**Tests:** vitest (unit tests for the index/format code and the pure parts of the
+write tools, real language servers against the fixture and temporary projects,
+MCP protocol over an in-memory transport incl. worktree selection via client roots
+with a real `git worktree`, LSP client failure modes, and the built executable).
 
-### Things the port surfaced
+### Things worth knowing
 
 - **The MCP SDK's stdio server does not treat stdin EOF as a close.** With a
   language server child alive, the process kept running after the host went
   away (found by installing the tarball and launching via `npx`). `cli.ts` now
   handles `stdin` `end`/`close`; `tests/cli.test.ts` fails without it.
-- **UTF-16 handling gets simpler:** JS strings are UTF-16, so the column
-  conversion helpers in the Python `format.py`/`lsp_client.py` disappear.
-- **One known regex divergence:** Python's `\w` is Unicode-aware, JS's is ASCII.
-  The index regexes use `(?<![\w-])` to avoid matching `data-id=`; a non-ASCII
-  letter directly before `id=`/`class=`/`style=` is treated differently (a
-  match in JS, none in Python). Vanishingly rare in real markup, not covered by
-  parity fixtures.
-- **Inherited-member lookup needed a different approach.** The Python package
-  finds `Class.member` for a member declared on a base class through the LSP's
-  type hierarchy, but TypeScript 7's language server advertises no type
-  hierarchy (checked against its `initialize` capabilities), so
-  `symbol_info("Widget.greet")` used to say "not found" in both implementations.
-  This port reads the `extends`/`implements` clauses from the source and resolves
+- **Columns are UTF-16 offsets,** which is what LSP uses and what JS strings
+  already are, so no conversion is needed.
+- **Regex index limit:** `\w` is ASCII in JS. The index regexes use
+  `(?<![\w-])` to avoid matching `data-id=`, so a non-ASCII letter directly
+  before `id=`/`class=`/`style=` still counts as a match. Vanishingly rare in
+  real markup.
+- **Inherited-member lookup needs a different approach.** TypeScript 7's
+  language server advertises no type hierarchy (checked against its `initialize`
+  capabilities), so a member declared on a base class can't be found that way.
+  webnav reads the `extends`/`implements` clauses from the source and resolves
   each base with `textDocument/definition`, breadth-first across files (generic
   bases, qualified names and mixin calls handled; `.d.ts`/`node_modules` bases
-  aren't followed). It is the one intentional difference the parity script
-  shows.
-- **Two tools the Python webnav never had:** the same capability check showed the
-  server offers `callHierarchyProvider` and `implementationProvider`, so this
-  port adds `callers` and `implementations` (12 tools now; the Python one has 10).
+  aren't followed).
+- **`callers` and `implementations`** are offered because the server advertises
+  `callHierarchyProvider` and `implementationProvider`.
+- **Type-checking an edit without writing it** relies on documents the client
+  opens with `didOpen`/`didChange` shadowing the disk (`LspClient.withOverlay`).
+  tsc's native server resolves imports of a file that exists only as an overlay,
+  but needs its *directory* to exist and remembers a failed resolution, so the
+  overlay opens new files first and creates (then removes) empty directories.
+- **A file with no `import`/`export` is a global script** to TypeScript. Moving
+  the last export out of a module turns it into one, and every top-level name in
+  it becomes visible everywhere; the type check can then miss references that
+  should have broken.
+- **Symbol ranges from `documentSymbol` are tight:** no doc comment, no
+  `export const` keyword, one symbol per declarator. `edit_symbol` and `move`
+  widen them (`extentOf`) and refuse declarators that share a statement.
+- **The server's unused-import hints identify what a deletion orphaned:** hints
+  after the edit minus hints before it, so imports that were already unused stay.
 
 ### Costs
 
 - **Install size:** a fresh app installing this next to its own TypeScript 5:
   177 MB `node_modules` (`vscode-langservers-extracted` 66 MB, TypeScript 7
   ~50 MB with its native binary). An app already on TypeScript ≥ 7 shares that
-  copy. The Python package had the same npm payload, plus Python.
-- **Code size:** ~4.2k lines of TypeScript (2.3k of it in `shared/`) vs ~3.7k
-  lines of Python for webnav + the shared library (which also carries
-  codenav-only code that wasn't ported).
-- **Not ported** (codenav-only in the shared library): `typeDefinition`,
-  scratch documents, source-root helpers. (Call hierarchy was ported after all,
-  for `callers`.)
+  copy.
 - **Not verified:** Windows, macOS, Node 20/24. Only Linux + Node 22.
 
-### The shared library
-
-The user-visible downside of the port is that `mcp-nav-shared` (LSP client,
-formatting, symbol resolution, workspace selection) now exists twice. Options,
-roughly in order of effort:
-
-1. **Keep `src/shared/` internal to the TS package** (what this package does).
-   Zero coordination cost; the two copies can drift. Mitigated by
-   `scripts/parity.mjs`, which fails when their output diverges.
-2. **Publish it as its own npm package** (`mcp-nav-shared`) only if a second TS
-   server appears. `codenav` is tied to `ty` (Python) and has no reason to move.
-3. **Retire the Python `webnav-mcp`** and keep only the TS one, leaving
-   `mcp-nav-shared` for `codenav-mcp` alone. Removes the duplication, breaks
-   `uvx webnav-mcp` users.
-
-The Python shared library's webnav-relevant part is small (LSP client, format,
-resolve, workspace, notices), which is why the duplication is tolerable.
-
 ## License
 
 MIT. See [LICENSE](https://github.com/illescasDaniel/webnav-ts-mcp/blob/main/LICENSE).

package/dist/langCommand.js

@@ -1,7 +1,7 @@
 /**
  * Resolves how to launch the Node-based language servers webnav multiplexes to.
  *
- * Unlike the Python distribution, the servers are ordinary npm dependencies of
+ * The servers are ordinary npm dependencies of
  * this package, so there is nothing to download at runtime: a TypeScript 7+
  * install in the navigated project wins (it matches the project's own
  * compiler), else the copy that came with webnav. Both are launched through

package/dist/server.js

@@ -1,8 +1,7 @@
 /**
  * MCP surface of webnav: registers `Webnav` methods as tools.
  *
- * Tool names and parameter names (snake_case) match the Python `webnav-mcp`
- * so hosts and prompts written against either keep working. Name-ish
+ * Tool and parameter names are snake_case. Name-ish
  * parameters are all optional in the schema: a missing one is answered with a
  * short hint by the tool itself, which beats the SDK's schema-validation error
  * for agents that guess `query` vs `name`.
@@ -12,6 +11,17 @@ import { z } from "zod";
 import { INSTRUCTIONS, Webnav } from "./webnav.js";
 const POSITION_DOC = "`line` and `column` are 1-indexed. `column` is a UTF-16 character offset on the line " +
     "(not a visual/display column): a leading tab counts as one character.";
+const WRITE_RULE = "The edit is shown to the language servers as an in-memory overlay first and the edited files and the " +
+    "files importing them are re-checked: it is written only when that adds no more errors than " +
+    "`max_new_errors` (default 0; null = no limit) and the result parses. Otherwise nothing is written and " +
+    "you get the new diagnostics plus a preview id for `apply_edit`. `apply=false` always previews. " +
+    "`undo_edit` reverts an applied edit.";
+const WRITES = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+const READS = { readOnlyHint: true, openWorldHint: false };
+const writeParams = {
+    apply: z.boolean().default(true),
+    max_new_errors: z.number().int().min(0).nullable().optional(),
+};
 const text = (value) => ({
     content: [{ type: "text", text: value }],
 });
@@ -161,5 +171,189 @@ export function createServer(version) {
             "accepted as an alias for `name`.",
         inputSchema: { name: z.string().optional(), query: z.string().optional() },
     }, async (args) => text(await webnav.selectorLookup(args)));
+    registerWriteTools(server, webnav);
     return { server, webnav };
 }
+function registerWriteTools(server, webnav) {
+    server.registerTool("edit", {
+        description: 'Edit text in a JS/TS/HTML/CSS file, type-checked: `edit(file_path="src/app.ts", old_string="x = 1", new_string="x = 2")`.\n\n' +
+            "For changes that are not a whole definition (a few lines, an import, a rule, markup) or for rewriting a " +
+            "whole file (`new_text`, which also creates a new file). To replace, add or delete a function/class/method " +
+            "by name use `edit_symbol`. `old_string` must match exactly once unless `replace_all=true` " +
+            "(line endings follow the file). `include_dependents=false` skips checking the importers. " +
+            WRITE_RULE,
+        inputSchema: {
+            file_path: z.string().optional(),
+            old_string: z.string().optional(),
+            new_string: z.string().optional(),
+            replace_all: z.boolean().default(false),
+            new_text: z.string().optional(),
+            include_dependents: z.boolean().default(true),
+            ...writeParams,
+        },
+        annotations: WRITES,
+    }, async ({ max_new_errors, ...a }) => text(await webnav.edit({
+        filePath: a.file_path,
+        oldString: a.old_string,
+        newString: a.new_string,
+        replaceAll: a.replace_all,
+        newText: a.new_text,
+        includeDependents: a.include_dependents,
+        apply: a.apply,
+        maxNewErrors: max_new_errors,
+    })));
+    server.registerTool("edit_symbol", {
+        description: "Replace, add or delete a JS/TS function, class, interface, enum, const or member by name. Examples: " +
+            '`edit_symbol(action="replace", name="Cart.total", source="total(): number { ... }")`, ' +
+            '`edit_symbol(action="insert", file_path="src/utils.ts", name="parse", source="function helper() {}")`, ' +
+            '`edit_symbol(action="delete", name="legacyParse")`.\n\n' +
+            '- `action="replace"`: `name` (dotted `Class.method` ok) and `source` (the complete new definition, ' +
+            "decorators included; re-indented to the old one's place in the file's own indent style). The doc comment " +
+            "above is kept unless `source` brings its own. A changed signature shows up as errors at call sites.\n" +
+            '- `action="insert"`: `source` and `file_path`. `position` is relative to `name`: "after" (default when ' +
+            '`name` is given) / "before" a symbol, "into" a class/interface/enum/namespace (appended to its body), or ' +
+            '"end" of the file (default without `name`; creates the file if missing). Refuses a name that already exists there.\n' +
+            '- `action="delete"`: `name` only. Refuses while anything still uses it and lists the users (`force=true` ' +
+            "deletes anyway and shows what breaks). Imports only the deleted code used are removed (`prune_imports`). " +
+            "Strings, comments and docs naming it are listed and the deletion is previewed instead of applied.\n\n" +
+            "`file_path` narrows `name` when several symbols share it. `imports` (replace/insert) is a list of " +
+            'import statements the new code needs (`["import { Money } from \\"./money\\""]`), merged into the file if missing. ' +
+            WRITE_RULE,
+        inputSchema: {
+            action: z.enum(["replace", "insert", "delete"]).optional(),
+            name: z.string().optional(),
+            source: z.string().optional(),
+            file_path: z.string().optional(),
+            position: z.enum(["after", "before", "into", "end"]).optional(),
+            imports: z.array(z.string()).optional(),
+            force: z.boolean().default(false),
+            prune_imports: z.boolean().default(true),
+            ...writeParams,
+        },
+        annotations: WRITES,
+    }, async ({ max_new_errors, ...a }) => text(await webnav.editSymbol({
+        action: a.action,
+        name: a.name,
+        source: a.source,
+        filePath: a.file_path,
+        position: a.position,
+        imports: a.imports,
+        force: a.force,
+        pruneImports: a.prune_imports,
+        apply: a.apply,
+        maxNewErrors: max_new_errors,
+    })));
+    server.registerTool("rename_symbol", {
+        description: 'Rename a symbol everywhere it is used. Examples: `rename_symbol(name="Cart.total", new_name="sum")`, ' +
+            '`rename_symbol(name="--accent", new_name="--brand")`, `rename_symbol(name=".card-title", new_name="heading")`.\n\n' +
+            "JS/TS: give `name` (dotted `Class.method` ok; `file_path` narrows it) or `file_path` + `line` + `column` " +
+            "(1-indexed). Built on the TypeScript language server's rename (imports, aliases, overriding members); " +
+            '`parameter="x"` with a function\'s name renames one parameter. Places that still say the old name that ' +
+            "the type checker cannot link (strings, comments, docs, other languages) are listed.\n\n" +
+            "CSS/HTML: a `name` starting with `--`, `#` or `.` renames that custom property / id / class across " +
+            "stylesheets (declarations, `var()`, selectors), HTML (`class`, `id`, and the attributes that refer to ids: " +
+            '`for`, `aria-*`, `href="#id"`) and scripts (`getElementById`, `classList`, `querySelector`, `className`, ' +
+            '`setProperty`/`getPropertyValue`, markup inside strings). Names built dynamically (`"row-" + id`) are listed, ' +
+            "not renamed; script string literals that merely equal the name are listed and renamed only with " +
+            "`include_string_literals=true`. Refuses a new name that already exists (`force=true` merges). With several " +
+            "`WEBNAV_MCP_ROOTS` pass `file_path` to say which root. " +
+            WRITE_RULE,
+        inputSchema: {
+            new_name: z.string().optional(),
+            name: z.string().optional(),
+            file_path: z.string().optional(),
+            line: z.number().int().optional(),
+            column: z.number().int().optional(),
+            parameter: z.string().optional(),
+            force: z.boolean().default(false),
+            include_string_literals: z.boolean().default(false),
+            allow_large: z.boolean().default(false),
+            ...writeParams,
+        },
+        annotations: WRITES,
+    }, async ({ max_new_errors, ...a }) => text(await webnav.renameSymbol({
+        newName: a.new_name,
+        name: a.name,
+        filePath: a.file_path,
+        line: a.line,
+        column: a.column,
+        parameter: a.parameter,
+        force: a.force,
+        includeStringLiterals: a.include_string_literals,
+        allowLarge: a.allow_large,
+        apply: a.apply,
+        maxNewErrors: max_new_errors,
+    })));
+    server.registerTool("move", {
+        description: "Move a declaration to another file, or a whole file, and fix every reference. Examples: " +
+            '`move(name="parseDate", to_file="src/app/dates.ts")`, `move(file_path="src/old/util.ts", to_file="src/lib/util.ts")`.\n\n' +
+            "With `name`: moves that top-level function/class/interface/enum/type/const (`file_path` narrows which). " +
+            "The destination is created if missing; the code gets the imports it needs (found by the language server), " +
+            '`export` is added if it was private, every `import { name } from "old"` elsewhere is repointed, the old ' +
+            "file imports it from the new place if it still uses it (`keep_reexport=true` also leaves `export { name } " +
+            'from "new"`), and imports only the moved code used are dropped. Import cycles are warned about.\n\n' +
+            "Without `name`: `file_path` is the file to move or rename (any file; `to_file` may be a directory). Every " +
+            "import/re-export in JS/TS (the language server's own rewrite), `<script src>`/`<link href>`/`<img src>` in " +
+            "HTML (relative and root-absolute), and `url()`/`@import` in CSS follow, and the moved file's own relative " +
+            "references are re-based. Configs, path aliases and string paths are listed, not rewritten. " +
+            WRITE_RULE,
+        inputSchema: {
+            to_file: z.string().optional(),
+            name: z.string().optional(),
+            file_path: z.string().optional(),
+            keep_reexport: z.boolean().default(false),
+            allow_large: z.boolean().default(false),
+            ...writeParams,
+        },
+        annotations: WRITES,
+    }, async ({ max_new_errors, ...a }) => text(await webnav.move({
+        toFile: a.to_file,
+        name: a.name,
+        filePath: a.file_path,
+        keepReexport: a.keep_reexport,
+        allowLarge: a.allow_large,
+        apply: a.apply,
+        maxNewErrors: max_new_errors,
+    })));
+    server.registerTool("quick_fix", {
+        description: 'Apply the TypeScript language server\'s own fixes to a JS/TS file: `quick_fix(file_path="src/app.ts")`.\n\n' +
+            "`action=\"fix\"` (default) fixes the file's errors one by one with the server's code actions (missing " +
+            "imports, misspelled names, ...), re-checking after each; `line` limits it to errors starting on that line. " +
+            "A fix with several candidates is listed, not guessed. The other actions are source actions on the whole " +
+            "file: `organize_imports`, `remove_unused_imports`, `sort_imports`, `fix_all`. " +
+            WRITE_RULE,
+        inputSchema: {
+            file_path: z.string().optional(),
+            line: z.number().int().optional(),
+            action: z.enum(["fix", "organize_imports", "remove_unused_imports", "sort_imports", "fix_all"]).optional(),
+            ...writeParams,
+        },
+        annotations: WRITES,
+    }, async ({ max_new_errors, ...a }) => text(await webnav.quickFix({
+        filePath: a.file_path,
+        line: a.line,
+        action: a.action,
+        apply: a.apply,
+        maxNewErrors: max_new_errors,
+    })));
+    server.registerTool("verify_changes", {
+        description: "What did the edits since a git revision break? Compares the language servers' diagnostics now against " +
+            "`since` (default `HEAD`).\n\nRun it after editing with any tool (your own Edit/Write included): the " +
+            "changed JS/TS/HTML/CSS files and the script files importing them are checked, with the committed versions " +
+            'substituted in for the "before" side. Read-only.',
+        inputSchema: { since: z.string().default("HEAD"), include_dependents: z.boolean().default(true) },
+        annotations: READS,
+    }, async ({ since, include_dependents }) => text(await webnav.verifyChanges({ since, includeDependents: include_dependents })));
+    server.registerTool("apply_edit", {
+        description: "Write a previewed edit (the id comes from a write tool's preview). Fails, writing nothing, if any file " +
+            "changed since the preview.",
+        inputSchema: { id: z.string().optional(), allow_large: z.boolean().default(false) },
+        annotations: WRITES,
+    }, async ({ id, allow_large }) => text(await webnav.applyEdit(id ?? "", allow_large)));
+    server.registerTool("undo_edit", {
+        description: "Revert an edit applied by the write tools (the latest one by default). Refuses when any of its files " +
+            "changed after the edit, so later work is never overwritten.",
+        inputSchema: { id: z.string().optional() },
+        annotations: WRITES,
+    }, async ({ id }) => text(await webnav.undoEdit(id)));
+}