breakpoint-mcp 1.0.0

package/dist/tools/csdap.js

@@ -0,0 +1,377 @@
+import { z } from "zod";
+import { DapError } from "../dap.js";
+import { toFsPath } from "../paths.js";
+import { gate } from "../confirm.js";
+import { ok } from "./lsp-common.js";
+// How long step/continue wait for the program to settle (hit a breakpoint,
+// finish a step, or terminate) before returning. On timeout the tool reports
+// the current state — e.g. `continue` with no further breakpoint stays running.
+const RESUME_WAIT_MS = 15000;
+function fail(err) {
+    const e = err;
+    return {
+        isError: true,
+        content: [{ type: "text", text: `C# DAP error [${e.command ?? "error"}]: ${e.message ?? String(err)}` }],
+    };
+}
+/**
+ * True when `err` is a DAP request that hit its own request deadline (not an
+ * adapter-reported failure or a dropped connection). Used to turn a
+ * setVariable / evaluate non-response into a clear message rather than the
+ * generic timeout — the same F1 discipline the GDScript DAP plane uses.
+ */
+function isDapTimeout(err) {
+    return err instanceof DapError && /timed out after/.test(err.message);
+}
+/**
+ * D4 C3 — the C#/.NET debugging plane. `cs_dbg_*` tools mirroring the read/inspect
+ * GDScript `dbg_*` surface, but driven by **netcoredbg** (Samsung, MIT — spawned
+ * over stdio by the host) attached to / launching a C# Godot game, instead of
+ * Godot's built-in TCP debug adapter.
+ *
+ * Same disciplines as the GDScript plane: destructive tools (`cs_dbg_evaluate`,
+ * `cs_dbg_set_variable`) are elicitation-gated; those two also carry a short
+ * bounded deadline so a non-answering adapter fails fast with a clear message
+ * (the F1 fix) instead of hanging the full DAP timeout. Adapter absent → the
+ * lazy stdio spawn fails with an actionable hint, never a hang. On top of the
+ * read/inspect surface this now carries the GDScript extras netcoredbg backs —
+ * `cs_dbg_watch`, `cs_dbg_set_exception_breakpoints` (netcoredbg advertises the
+ * `all` / `user-unhandled` filters) and `cs_dbg_restart` (terminate + relaunch,
+ * since netcoredbg advertises no `supportsRestartRequest`). `goto` and data
+ * breakpoints are deliberately NOT ported: netcoredbg advertises neither
+ * `supportsGotoTargetsRequest` nor `supportsDataBreakpoints`, so those tools
+ * would only ever return "unsupported" here.
+ */
+export function registerCsDapTools(server, dap, cfg) {
+    server.registerTool("cs_dbg_launch", {
+        title: "Launch C# debug session",
+        description: "Start a C# Godot game under netcoredbg. `program` defaults to the configured Mono/.NET Godot binary " +
+            "(GODOT_CSHARP_BIN) and `args` to ['--path', <C# project>]; override either to debug a different .NET program. " +
+            "Any breakpoints set beforehand are applied during the handshake. Requires netcoredbg (GODOT_CSDAP_CMD) — " +
+            "absent, the lazy spawn fails with an actionable hint rather than hanging.",
+        inputSchema: {
+            program: z.string().optional().describe("Path to the program to launch (default: the Mono/.NET Godot binary)"),
+            args: z.array(z.string()).optional().describe("Program arguments (default: ['--path', <C# project>])"),
+            stop_on_entry: z.boolean().optional().describe("Break at entry (default false)"),
+            just_my_code: z.boolean().optional().describe("Restrict stepping/breakpoints to user code (netcoredbg justMyCode; default true)"),
+        },
+    }, async ({ program, args, stop_on_entry, just_my_code }) => {
+        try {
+            await dap.start("launch", {
+                program: program ?? cfg.csDapProgram,
+                args: args ?? ["--path", cfg.csDapProjectPath],
+                cwd: cfg.csDapProjectPath,
+                stopAtEntry: stop_on_entry ?? false,
+                justMyCode: just_my_code ?? true,
+            });
+            return ok({ session_id: "csharp", state: dap.state });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_attach", {
+        title: "Attach C# debug session",
+        description: "Attach netcoredbg to an already-running .NET process (e.g. a C# Godot game launched separately) by its OS process id. " +
+            "Any breakpoints set beforehand are applied during the handshake.",
+        inputSchema: {
+            process_id: z.number().int().describe("OS process id of the running .NET process to attach to"),
+        },
+    }, async ({ process_id }) => {
+        try {
+            await dap.start("attach", { processId: process_id });
+            return ok({ session_id: "csharp", state: dap.state });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_set_breakpoints", {
+        title: "Set C# breakpoints",
+        description: "Set (replace) the breakpoints for a C# source file. Applied immediately if a session is running, else buffered until launch/attach. " +
+            "Feature-detected: the per-line `conditions` modifier is only sent when the connected adapter advertises supportsConditionalBreakpoints " +
+            "(netcoredbg does); on an adapter that advertises it unsupported the modifier is dropped and the result carries `unsupported_modifiers` " +
+            "plus a `warning`. Detection needs a live session, so set conditions after cs_dbg_launch/cs_dbg_attach.",
+        inputSchema: {
+            path: z.string().describe("C# script path (res://..., absolute, or relative to the C# project root)"),
+            lines: z.array(z.number().int().positive()).describe("1-based line numbers"),
+            conditions: z.array(z.string().nullable()).optional().describe("Optional per-line condition expressions (aligned to lines, null to skip); break only when the expression is true"),
+        },
+    }, async ({ path, lines, conditions }) => {
+        try {
+            const fsPath = toFsPath(path, cfg.csDapProjectPath);
+            // Feature-detect the condition modifier against the connected adapter. Only when it does
+            // not advertise supportsConditionalBreakpoints do we DROP conditions and warn — otherwise
+            // a "conditional" breakpoint could halt unconditionally on an adapter that ignores them.
+            const wantsCondition = Array.isArray(conditions) && conditions.some((c) => c != null && c !== "");
+            const conditionUnsupported = wantsCondition && dap.capabilities != null && dap.capabilities["supportsConditionalBreakpoints"] !== true;
+            const body = await dap.setBreakpoints(fsPath, lines, conditionUnsupported ? undefined : conditions);
+            const verified = Array.isArray(body["breakpoints"])
+                ? body["breakpoints"].map((b) => ({ line: b.line ?? 0, verified: Boolean(b.verified) }))
+                : [];
+            const result = { path: fsPath, buffered: body["buffered"] === true, breakpoints: verified };
+            if (conditionUnsupported) {
+                result.unsupported_modifiers = ["condition"];
+                result.warning =
+                    "The connected C# debug adapter does not advertise supportsConditionalBreakpoints, so the per-line conditions were " +
+                        "dropped — the affected breakpoint(s) will halt unconditionally.";
+            }
+            return ok(result);
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_continue", {
+        title: "Continue (C#)",
+        description: "Resume execution and wait for the program to settle again (next breakpoint or termination). " +
+            "Returns the resulting state; if it runs on with no further breakpoint, reports state 'running'.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const r = await dap.resume("continue", { threadId: dap.threadId() }, RESUME_WAIT_MS);
+            return ok({ state: r.state, stopped_reason: r.reason });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_step", {
+        title: "Step (C#)",
+        description: "Step execution: 'over' (next), 'in' (stepIn), or 'out' (stepOut), then wait for the step to land. " +
+            "Returns the resulting state and stop reason.",
+        inputSchema: { kind: z.enum(["in", "over", "out"]).describe("Step kind") },
+    }, async ({ kind }) => {
+        try {
+            const command = kind === "in" ? "stepIn" : kind === "out" ? "stepOut" : "next";
+            const r = await dap.resume(command, { threadId: dap.threadId() }, RESUME_WAIT_MS);
+            return ok({ state: r.state, stopped_reason: r.reason });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_stack_trace", {
+        title: "Stack trace (C#)",
+        description: "Return the current C# call stack (only meaningful while stopped at a breakpoint).",
+        inputSchema: { levels: z.number().int().positive().optional().describe("Max frames (default 20)") },
+    }, async ({ levels }) => {
+        try {
+            const body = await dap.request("stackTrace", { threadId: dap.threadId(), startFrame: 0, levels: levels ?? 20 });
+            const frames = Array.isArray(body["stackFrames"])
+                ? body["stackFrames"].map((f) => ({
+                    id: f.id ?? 0, name: f.name ?? "", source: f.source?.path ?? f.source?.name ?? "", line: f.line ?? 0,
+                }))
+                : [];
+            return ok({ frames });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_scopes", {
+        title: "Scopes (C#)",
+        description: "Return the variable scopes (Locals, etc.) for a C# stack frame.",
+        inputSchema: { frame_id: z.number().int().describe("Frame id from cs_dbg_stack_trace") },
+    }, async ({ frame_id }) => {
+        try {
+            const body = await dap.request("scopes", { frameId: frame_id });
+            const scopes = Array.isArray(body["scopes"])
+                ? body["scopes"].map((s) => ({ name: s.name ?? "", variables_ref: s.variablesReference ?? 0 }))
+                : [];
+            return ok({ scopes });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_variables", {
+        title: "Variables (C#)",
+        description: "List variables under a scope or a complex value (via its variables_ref).",
+        inputSchema: { variables_ref: z.number().int().describe("variablesReference from cs_dbg_scopes or a parent variable") },
+    }, async ({ variables_ref }) => {
+        try {
+            const body = await dap.request("variables", { variablesReference: variables_ref });
+            const variables = Array.isArray(body["variables"])
+                ? body["variables"].map((v) => ({
+                    name: v.name ?? "", value: v.value ?? "", type: v.type ?? "", variables_ref: v.variablesReference ?? 0,
+                }))
+                : [];
+            return ok({ variables });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_evaluate", {
+        title: "Evaluate C# expression",
+        description: "Evaluate a C# expression in the context of a stopped frame. DESTRUCTIVE: arbitrary code execution — confirm with the user and keep this gated. " +
+            "Bounded by a short deadline so a non-answering adapter fails fast rather than hanging the full DAP timeout.",
+        inputSchema: {
+            expression: z.string().describe("C# expression to evaluate"),
+            frame_id: z.number().int().optional().describe("Frame id (from cs_dbg_stack_trace); omit for the top frame"),
+            confirm: z.boolean().optional().describe("Auto-approve this arbitrary-code evaluation (skip the confirmation prompt)"),
+        },
+    }, async ({ expression, frame_id, confirm }) => {
+        try {
+            const blocked = await gate(server, confirm, `Evaluate C# expression in the running game: ${expression}`);
+            if (blocked)
+                return blocked;
+            let body;
+            try {
+                body = await dap.request("evaluate", { expression, frameId: frame_id, context: "repl" }, cfg.csDapEvaluateTimeoutMs);
+            }
+            catch (err) {
+                if (isDapTimeout(err)) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `The C# debug adapter did not answer the evaluate request within ${cfg.csDapEvaluateTimeoutMs}ms — no result was returned. The debug session is still alive; use cs_dbg_variables to inspect state.` }],
+                    };
+                }
+                throw err;
+            }
+            return ok({ result: String(body["result"] ?? ""), type: String(body["type"] ?? ""), variables_ref: body["variablesReference"] ?? 0 });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_set_variable", {
+        title: "Set C# variable value",
+        description: "Change a variable's value in a stopped C# frame (DAP setVariable). DESTRUCTIVE: mutates live program state — confirm with the user and keep this gated. " +
+            "`variables_ref` is the container's variablesReference (from cs_dbg_scopes, or a complex cs_dbg_variables entry), `name` is the variable within it, " +
+            "`value` is the new value as a C# literal/expression. Feature-detected: on an adapter that advertises supportsSetVariable:false it returns a clear " +
+            "\"unsupported\" message WITHOUT prompting; otherwise a bounded deadline turns a non-answering adapter into a clear message rather than a hang.",
+        inputSchema: {
+            variables_ref: z.number().int().describe("variablesReference of the containing scope/variable (from cs_dbg_scopes or cs_dbg_variables)"),
+            name: z.string().describe("Variable name within that container"),
+            value: z.string().describe("New value as a C# literal/expression"),
+            confirm: z.boolean().optional().describe("Auto-approve this mutation (skip the confirmation prompt)"),
+        },
+    }, async ({ variables_ref, name, value, confirm }) => {
+        try {
+            if (dap.capabilities && dap.capabilities["supportsSetVariable"] === false) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "cs_dbg_set_variable is unsupported by the connected C# debug adapter (it does not advertise supportsSetVariable). Read-only inspection (cs_dbg_variables) still works." }],
+                };
+            }
+            const blocked = await gate(server, confirm, `Set C# variable ${name} = ${value} in the running game`);
+            if (blocked)
+                return blocked;
+            let body;
+            try {
+                body = await dap.request("setVariable", { variablesReference: variables_ref, name, value }, cfg.csDapSetVarTimeoutMs);
+            }
+            catch (err) {
+                if (isDapTimeout(err)) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `The C# debug adapter did not answer the setVariable request within ${cfg.csDapSetVarTimeoutMs}ms — no change was made; the variable is unchanged. Read-only inspection (cs_dbg_variables) still works.` }],
+                    };
+                }
+                throw err;
+            }
+            return ok({ name, value: String(body["value"] ?? value), type: String(body["type"] ?? ""), variables_ref: body["variablesReference"] ?? 0 });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_watch", {
+        title: "Watch expressions (C#)",
+        description: "Manage a persistent set of C# watch expressions and evaluate them in the current stopped frame. " +
+            "Pass `add`/`remove`/`clear` to mutate the set (all optional), then every current watch is re-evaluated " +
+            "and returned. Call with no mutation args to just re-read the watches after a step/continue. Expressions " +
+            "are evaluated in DAP `watch` context (intended to be side-effect-free), so this is not gated; the results " +
+            "are only meaningful while the program is stopped at a breakpoint.",
+        inputSchema: {
+            add: z.array(z.string()).optional().describe("Expressions to add to the watch set"),
+            remove: z.array(z.string()).optional().describe("Expressions to remove from the watch set"),
+            clear: z.boolean().optional().describe("Clear all watches before applying add (default false)"),
+            frame_id: z.number().int().optional().describe("Frame id from cs_dbg_stack_trace; omit for the top frame"),
+        },
+    }, async ({ add, remove, clear, frame_id }) => {
+        try {
+            if (clear)
+                dap.clearWatches();
+            if (remove && remove.length)
+                dap.removeWatches(remove);
+            if (add && add.length)
+                dap.addWatches(add);
+            // Bound each watch's evaluate to the short deadline (mirrors cs_dbg_evaluate): a watch
+            // the adapter never answers fails fast on that entry instead of hanging the full DAP
+            // timeout at every stop, while other watches still resolve normally.
+            const watches = await dap.evaluateWatches(frame_id, cfg.csDapEvaluateTimeoutMs);
+            return ok({ watches });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_set_exception_breakpoints", {
+        title: "Set C# exception breakpoints",
+        description: "Enable (replace) the debugger's exception breakpoint filters so execution halts when a matching .NET exception is thrown " +
+            "(DAP setExceptionBreakpoints). Pass the filter IDs to enable; call with no filters (or []) to clear them. The result echoes the " +
+            "active filters and lists `available_filters` — the exception filters the connected adapter advertises (netcoredbg exposes `all` " +
+            "for every thrown exception and `user-unhandled`). Requires a running debug session. Not gated (it only configures the debugger). " +
+            "Feature-detected: on an adapter that advertises no exceptionBreakpointFilters it returns a clear \"unsupported\" message WITHOUT sending anything.",
+        inputSchema: {
+            filters: z.array(z.string()).optional().describe("Exception filter IDs to enable (default none = clear). Choose from available_filters in the result (netcoredbg: 'all', 'user-unhandled')."),
+        },
+    }, async ({ filters }) => {
+        try {
+            // Per the DAP spec a client should only send setExceptionBreakpoints when the adapter
+            // advertised at least one exception filter. Short-circuit with a clear "unsupported"
+            // message otherwise, matching the GDScript dbg_set_exception_breakpoints discipline.
+            const advertised = dap.capabilities?.["exceptionBreakpointFilters"];
+            const available_filters = Array.isArray(advertised)
+                ? advertised.map((f) => ({ filter: f.filter ?? "", label: f.label ?? "" }))
+                : [];
+            if (available_filters.length === 0) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "cs_dbg_set_exception_breakpoints is unsupported by the connected C# debug adapter (it advertises no exceptionBreakpointFilters). There are no exception filters to enable." }],
+                };
+            }
+            const active = filters ?? [];
+            const body = await dap.request("setExceptionBreakpoints", { filters: active });
+            const breakpoints = Array.isArray(body["breakpoints"])
+                ? body["breakpoints"].map((b) => ({ verified: Boolean(b.verified) }))
+                : [];
+            return ok({ filters: active, available_filters, breakpoints });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_dbg_restart", {
+        title: "Restart C# debug session",
+        description: "Restart the current C# debug session. Uses the DAP `restart` request when the adapter advertises `supportsRestartRequest`, " +
+            "otherwise falls back to terminate + relaunch — so it works on every adapter (netcoredbg advertises none, so the relaunch path runs). " +
+            "Reuses the last cs_dbg_launch/cs_dbg_attach parameters; pass `stop_on_entry` / `program` / `args` to override them for a launched " +
+            "session. `method` in the result reports which path ran ('restart' = native DAP restart, 'relaunch' = terminate + fresh handshake). " +
+            "Requires a session started with cs_dbg_launch/cs_dbg_attach.",
+        inputSchema: {
+            stop_on_entry: z.boolean().optional().describe("Override stop-at-entry for the restart (launched sessions)"),
+            program: z.string().optional().describe("Override the launched program (launched sessions)"),
+            args: z.array(z.string()).optional().describe("Override the program arguments (launched sessions)"),
+        },
+    }, async ({ stop_on_entry, program, args }) => {
+        try {
+            const override = {};
+            if (stop_on_entry !== undefined)
+                override.stopAtEntry = stop_on_entry;
+            if (program !== undefined)
+                override.program = program;
+            if (args !== undefined)
+                override.args = args;
+            const r = await dap.restart(override);
+            return ok({ session_id: "csharp", method: r.method, state: r.state });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+}
+//# sourceMappingURL=csdap.js.map

package/dist/tools/cslsp.js

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import { z } from "zod";
+import { toFileUri, toFsPath, readFileText } from "../paths.js";
+import { gate } from "../confirm.js";
+import { COMPLETION_KIND, SYMBOL_KIND, ok, fail, markupToString, isMethodNotFound, normalizeLocations, applyTextEdits, normalizeWorkspaceEdit, } from "./lsp-common.js";
+/**
+ * D4 C2 — the C#/.NET semantic plane. Read-only `cs_*` tools mirroring the proven
+ * read-only `gd_*` LSP surface, but driven by OmniSharp (spawned over stdio by the
+ * host) against a C# Godot project instead of Godot's built-in GDScript server.
+ *
+ * The tools are feature-detected the same way the `gd_*` tools are: a capability
+ * the server never advertised, or a `-32601 Method not found` from a server that
+ * lied about advertising it, yields a clear "unsupported" message rather than a
+ * raw JSON-RPC error or a hang. The two mutators — `cs_rename` (elicitation-gated
+ * on `apply=true`) and the read-only `cs_code_action` listing — mirror the GDScript
+ * `gd_rename` / `gd_code_action`.
+ */
+/**
+ * Returned when the connected C# language server doesn't implement an optional
+ * LSP method. Same graceful-degradation contract as the GDScript plane, worded
+ * for OmniSharp (which — unlike Godot's GDScript server — is expected to support
+ * workspace/symbol; this only fires on a server that genuinely lacks it).
+ */
+function unsupportedCsLsp(tool, method, capability, alt) {
+    return {
+        isError: true,
+        content: [{
+                type: "text",
+                text: `${tool} is unsupported by the connected C# language server: it does not implement ` +
+                    `LSP '${method}' (advertises no ${capability}, or replies -32601 Method not found). ` +
+                    `This is a language-server limitation, not a host error. ${alt}`,
+            }],
+    };
+}
+export function registerCsLspTools(server, cslsp, cfg) {
+    const root = cfg.csLspProjectPath;
+    const openAndPos = async (path) => {
+        const uri = toFileUri(path, root);
+        await cslsp.ensureOpen(uri, readFileText(toFsPath(path, root)));
+        return uri;
+    };
+    const posSchema = {
+        path: z.string().describe("C# script path (res://..., absolute, or relative to the C# project root)"),
+        line: z.number().int().describe("0-based line"),
+        character: z.number().int().describe("0-based character"),
+    };
+    server.registerTool("cs_completion", { title: "C# completion", description: "Type-aware C# code completion at a position via OmniSharp.", inputSchema: posSchema }, async ({ path, line, character }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = await cslsp.request("textDocument/completion", { textDocument: { uri }, position: { line, character } });
+            const raw = Array.isArray(result) ? result : (result?.items ?? []);
+            const items = raw.map((i) => {
+                const it = i;
+                return { label: it.label ?? "", kind: it.kind ? COMPLETION_KIND[it.kind] ?? String(it.kind) : "", detail: it.detail ?? "", insertText: it.insertText ?? it.label ?? "" };
+            });
+            return ok({ items });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_hover", { title: "C# hover", description: "Hover documentation/type info at a position (e.g. the `Counter : int` type).", inputSchema: posSchema }, async ({ path, line, character }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = (await cslsp.request("textDocument/hover", { textDocument: { uri }, position: { line, character } }));
+            return ok({ contents: markupToString(result?.contents) });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_definition", { title: "C# go-to-definition", description: "Resolve the definition location(s) of the C# symbol at a position.", inputSchema: posSchema }, async ({ path, line, character }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = await cslsp.request("textDocument/definition", { textDocument: { uri }, position: { line, character } });
+            return ok({ locations: normalizeLocations(result) });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_references", {
+        title: "C# find-references",
+        description: "Find all references to the C# symbol at a position.",
+        inputSchema: { ...posSchema, include_declaration: z.boolean().optional().describe("Include the declaration (default true)") },
+    }, async ({ path, line, character, include_declaration }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = await cslsp.request("textDocument/references", {
+                textDocument: { uri }, position: { line, character },
+                context: { includeDeclaration: include_declaration ?? true },
+            });
+            return ok({ locations: normalizeLocations(result) });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_rename", {
+        title: "C# rename symbol",
+        description: "Rename a C# symbol project-wide via OmniSharp. Returns the planned edit; pass apply=true to WRITE the changes to disk (DESTRUCTIVE — confirm with the user).",
+        inputSchema: {
+            ...posSchema,
+            new_name: z.string().describe("New symbol name"),
+            apply: z.boolean().optional().describe("Write edits to disk (default false = dry run)"),
+            confirm: z.boolean().optional().describe("Auto-approve writing edits (skip the confirmation prompt); only relevant with apply=true"),
+        },
+    }, async ({ path, line, character, new_name, apply, confirm }) => {
+        try {
+            const uri = await openAndPos(path);
+            const edit = await cslsp.request("textDocument/rename", {
+                textDocument: { uri }, position: { line, character }, newName: new_name,
+            });
+            // OmniSharp returns a WorkspaceEdit as `documentChanges` (versioned
+            // TextDocumentEdit[]); normalizeWorkspaceEdit also accepts the legacy
+            // `changes` map, so cs_rename handles either encoding.
+            const changes = normalizeWorkspaceEdit(edit);
+            const files = Object.keys(changes);
+            let editCount = 0;
+            for (const f of files)
+                editCount += changes[f].length;
+            let written = [];
+            if (apply) {
+                const blocked = await gate(server, confirm, `Rename to "${new_name}" — write ${editCount} edit(s) across ${files.length} file(s)`);
+                if (blocked)
+                    return blocked;
+                for (const fileUri of files) {
+                    const fsPath = decodeURIComponent(fileUri.replace(/^file:\/\//, ""));
+                    const before = fs.readFileSync(fsPath, "utf8");
+                    fs.writeFileSync(fsPath, applyTextEdits(before, changes[fileUri]), "utf8");
+                    written.push(fsPath);
+                }
+            }
+            return ok({ changed_files: files, edit_count: editCount, applied: Boolean(apply), written });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_document_symbols", {
+        title: "C# document symbols",
+        description: "List the symbols (classes, methods, properties, fields) declared in a C# script.",
+        inputSchema: { path: z.string().describe("C# script path") },
+    }, async ({ path }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = (await cslsp.request("textDocument/documentSymbol", { textDocument: { uri } }));
+            const symbols = (result ?? []).map((s) => {
+                const sym = s;
+                const range = sym.range ?? sym.selectionRange ?? sym.location?.range ?? {};
+                return { name: sym.name ?? "", kind: sym.kind ? SYMBOL_KIND[sym.kind] ?? String(sym.kind) : "", line: range.start?.line ?? 0 };
+            });
+            return ok({ symbols });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_workspace_symbols", {
+        title: "C# workspace symbols",
+        description: "Search C# symbols across the whole project by name. Unlike Godot's GDScript server, " +
+            "OmniSharp implements LSP 'workspace/symbol', so this returns real results; it stays " +
+            "feature-detected (with a -32601 belt-and-suspenders) so a server that lacks it degrades " +
+            "gracefully rather than erroring opaquely.",
+        inputSchema: { query: z.string().describe("Symbol name query") },
+    }, async ({ query }) => {
+        const alt = "Use cs_document_symbols for a single file's symbols, or cs_definition / cs_references to navigate by a known name.";
+        try {
+            const caps = await cslsp.getServerCapabilities();
+            if (!caps.workspaceSymbolProvider)
+                return unsupportedCsLsp("cs_workspace_symbols", "workspace/symbol", "workspaceSymbolProvider", alt);
+            const result = (await cslsp.request("workspace/symbol", { query }));
+            const symbols = (result ?? []).map((s) => {
+                const sym = s;
+                return {
+                    name: sym.name ?? "",
+                    kind: sym.kind ? SYMBOL_KIND[sym.kind] ?? String(sym.kind) : "",
+                    uri: sym.location?.uri ?? "",
+                    line: sym.location?.range?.start?.line ?? 0,
+                };
+            });
+            return ok({ symbols });
+        }
+        catch (err) {
+            if (isMethodNotFound(err))
+                return unsupportedCsLsp("cs_workspace_symbols", "workspace/symbol", "workspaceSymbolProvider", alt);
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_signature_help", {
+        title: "C# signature help",
+        description: "Show the call signature(s) and active parameter at a position (the parameter hints an IDE pops up inside a call).",
+        inputSchema: posSchema,
+    }, async ({ path, line, character }) => {
+        try {
+            const uri = await openAndPos(path);
+            const result = (await cslsp.request("textDocument/signatureHelp", { textDocument: { uri }, position: { line, character } }));
+            const signatures = (result?.signatures ?? []).map((s) => {
+                const sig = s;
+                const sigLabel = sig.label ?? "";
+                const parameters = (sig.parameters ?? []).map((p) => {
+                    const par = p;
+                    let plabel = "";
+                    if (typeof par.label === "string")
+                        plabel = par.label;
+                    // Per LSP, a parameter label may be a [start,end] offset pair into the signature label.
+                    else if (Array.isArray(par.label) && par.label.length === 2)
+                        plabel = sigLabel.slice(Number(par.label[0]), Number(par.label[1]));
+                    return { label: plabel, documentation: markupToString(par.documentation) };
+                });
+                return { label: sigLabel, documentation: markupToString(sig.documentation), parameters };
+            });
+            return ok({ signatures, active_signature: result?.activeSignature ?? 0, active_parameter: result?.activeParameter ?? 0 });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_diagnostics", {
+        title: "C# diagnostics",
+        description: "Return compile/analyzer diagnostics (errors, warnings) for a C# script. Opens the file and waits briefly for OmniSharp to publish.",
+        inputSchema: {
+            path: z.string().describe("C# script path"),
+            wait_ms: z.number().int().positive().optional().describe("Max time to wait for the first publish (default 2000; OmniSharp's first analysis can be slow)"),
+        },
+    }, async ({ path, wait_ms }) => {
+        try {
+            const uri = await openAndPos(path);
+            const diagnostics = await cslsp.waitForDiagnostics(uri, wait_ms ?? 2000);
+            const named = diagnostics.map((d) => ({
+                severity: (["", "error", "warning", "info", "hint"][d.severity] ?? "error"),
+                message: d.message, line: d.line, character: d.character,
+            }));
+            return ok({ uri, diagnostics: named });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    server.registerTool("cs_code_action", {
+        title: "C# code actions",
+        description: "List the code actions (quick fixes / refactors) OmniSharp offers for a range — the lightbulb menu. " +
+            "Read-only: returns the available actions (title, kind, whether each carries a WorkspaceEdit or a Command) without applying any. " +
+            "Unlike Godot's GDScript server, OmniSharp implements code actions, so this returns real results; it stays " +
+            "feature-detected (with a -32601 belt-and-suspenders) so a server that lacks it degrades gracefully. " +
+            "end_line/end_character default to the start position (a caret, not a selection).",
+        inputSchema: {
+            path: z.string().describe("C# script path (res://..., absolute, or relative to the C# project root)"),
+            start_line: z.number().int().describe("0-based start line"),
+            start_character: z.number().int().describe("0-based start character"),
+            end_line: z.number().int().optional().describe("0-based end line (default = start_line)"),
+            end_character: z.number().int().optional().describe("0-based end character (default = start_character)"),
+            only: z.array(z.string()).optional().describe("Restrict to these CodeActionKind prefixes, e.g. 'quickfix', 'refactor'"),
+        },
+    }, async ({ path, start_line, start_character, end_line, end_character, only }) => {
+        const alt = "Use cs_diagnostics to surface issues and cs_completion / cs_rename to make edits.";
+        try {
+            const caps = await cslsp.getServerCapabilities();
+            if (!caps.codeActionProvider)
+                return unsupportedCsLsp("cs_code_action", "textDocument/codeAction", "codeActionProvider", alt);
+            const uri = await openAndPos(path);
+            const range = {
+                start: { line: start_line, character: start_character },
+                end: { line: end_line ?? start_line, character: end_character ?? start_character },
+            };
+            const context = { diagnostics: [] };
+            if (only && only.length)
+                context.only = only;
+            const result = (await cslsp.request("textDocument/codeAction", { textDocument: { uri }, range, context }));
+            const actions = (result ?? []).map((a) => {
+                const act = a;
+                // A bare Command has `command` as a string; a CodeAction nests a Command object under `command`.
+                const command = typeof act.command === "string" ? act.command : act.command?.command ?? null;
+                return { title: act.title ?? "", kind: act.kind ?? "", has_edit: act.edit !== undefined, command };
+            });
+            return ok({ actions });
+        }
+        catch (err) {
+            if (isMethodNotFound(err))
+                return unsupportedCsLsp("cs_code_action", "textDocument/codeAction", "codeActionProvider", alt);
+            return fail(err);
+        }
+    });
+}
+//# sourceMappingURL=cslsp.js.map