lazycodex-ai 5.0.0-beta.49 → 5.0.0-beta.50

package/packages/lsp-daemon/dist/client.js

@@ -684,7 +684,7 @@ async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
 function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const socket = new Socket;
     let settled = false;
     let timer;
@@ -696,7 +696,7 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
         clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
       socket.destroy();
-      resolve2(value);
+      resolve(value);
     };
     const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
@@ -759,7 +759,7 @@ function defaultEnsureDaemonDeps() {
   };
 }
 function sleepWithSignal(ms, signal) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     let settled = false;
     const finish = () => {
       if (settled)
@@ -767,7 +767,7 @@ function sleepWithSignal(ms, signal) {
       settled = true;
       clearTimeout(timer);
       signal?.removeEventListener("abort", finish);
-      resolve2();
+      resolve();
     };
     const timer = setTimeout(finish, ms);
     if (signal?.aborted) {
@@ -782,7 +782,7 @@ function awaitWithSignal(promise, signal) {
     return promise;
   if (signal.aborted)
     return Promise.reject(abortError(signal));
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -793,7 +793,7 @@ function awaitWithSignal(promise, signal) {
     };
     const onAbort = () => finish(() => reject(abortError(signal)));
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then((value) => finish(() => resolve2(value)), (error) => finish(() => reject(error)));
+    promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
   });
 }
 function throwIfAborted(signal) {
@@ -822,18 +822,18 @@ function parsePingResponse(message) {
     return null;
   if (!endpoint || typeof endpoint !== "object" || Array.isArray(endpoint))
     return null;
-  const path2 = Reflect.get(endpoint, "path");
+  const path = Reflect.get(endpoint, "path");
   const kind = Reflect.get(endpoint, "kind");
-  if (typeof path2 !== "string")
+  if (typeof path !== "string")
     return null;
   if (kind === "windows")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   if (kind === "missing")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   const dev = Reflect.get(endpoint, "dev");
   const ino = Reflect.get(endpoint, "ino");
   if (kind === "unix" && typeof dev === "number" && typeof ino === "number") {
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2, dev, ino } };
+    return { pid, nonce, startedAt, endpoint: { kind, path, dev, ino } };
   }
   return null;
 }
@@ -881,7 +881,7 @@ ${body}` : `${body}
   await writeChunk(output, payload);
 }
 function writeChunk(output, chunk) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const onError = (error) => {
       if (settled)
@@ -901,7 +901,7 @@ function writeChunk(output, chunk) {
           return;
         }
         output.removeListener("error", onError);
-        resolve2();
+        resolve();
       });
     } catch (error) {
       output.removeListener("error", onError);
@@ -1345,7 +1345,7 @@ class JsonRpcConnection {
     let settled = false;
     const writeCancel = () => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
     let rejectAfterCancelWrite;
-    const responsePromise = new Promise((resolve2, reject) => {
+    const responsePromise = new Promise((resolve, reject) => {
       const cleanup = () => {
         options.signal?.removeEventListener("abort", onAbort);
       };
@@ -1375,7 +1375,7 @@ class JsonRpcConnection {
         resolve(result) {
           settled = true;
           cleanup();
-          resolve2(result);
+          resolve(result);
         },
         reject(error) {
           settled = true;
@@ -1534,13 +1534,13 @@ class JsonRpcConnection {
     const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
 ${body}`;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       this.writer.write(payload, (error) => {
         if (error) {
           reject(error);
           return;
         }
-        resolve2();
+        resolve();
       });
     });
   }
@@ -1627,9 +1627,9 @@ function validateCwd(cwd) {
   }
 }
 function wrap(proc) {
-  const exitedPromise = new Promise((resolve2) => {
-    proc.once("close", (code) => resolve2(code ?? 0));
-    proc.once("error", () => resolve2(1));
+  const exitedPromise = new Promise((resolve) => {
+    proc.once("close", (code) => resolve(code ?? 0));
+    proc.once("error", () => resolve(1));
   });
   if (!proc.stdin || !proc.stdout || !proc.stderr) {
     throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
@@ -1791,9 +1791,9 @@ class LspClientNotStartedError extends Error {
 }
 
 class LspClientTransport {
-  constructor(root, server2, timeouts = {}) {
+  constructor(root, server, timeouts = {}) {
     this.root = root;
-    this.server = server2;
+    this.server = server;
     this.proc = null;
     this.connection = null;
     this.stderrBuffer = [];
@@ -1975,8 +1975,8 @@ class LspClientTransport {
       try {
         proc.kill();
         let timeoutId;
-        const timeoutPromise = new Promise((resolve2) => {
-          timeoutId = setTimeout(resolve2, STOP_HARD_KILL_TIMEOUT_MS);
+        const timeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(resolve, STOP_HARD_KILL_TIMEOUT_MS);
         });
         await Promise.race([
           proc.exited.then(() => {
@@ -1992,7 +1992,7 @@ class LspClientTransport {
             proc.kill("SIGKILL");
             await Promise.race([
               proc.exited,
-              new Promise((resolve2) => setTimeout(resolve2, STOP_SIGKILL_GRACE_MS))
+              new Promise((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS))
             ]);
           } catch (error) {
             reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
@@ -2341,16 +2341,16 @@ class WorkspaceDocumentState {
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
-    const path2 = canonicalPath(filePath);
-    const existingOpen = this.openPromises.get(path2);
+    const path = canonicalPath(filePath);
+    const existingOpen = this.openPromises.get(path);
     if (existingOpen) {
       await existingOpen;
-      return this.openFile(path2);
+      return this.openFile(path);
     }
-    const text = readFileSync2(path2, "utf-8");
-    const existing = this.openDocuments.get(path2);
+    const text = readFileSync2(path, "utf-8");
+    const existing = this.openDocuments.get(path);
     if (!existing)
-      return this.openDocumentSingleFlight(path2, text);
+      return this.openDocumentSingleFlight(path, text);
     if (existing.text === text)
       return;
     await this.changeDocument(existing, text);
@@ -2445,7 +2445,7 @@ class WorkspaceDocumentState {
     });
   }
   validateVersions(operations) {
-    const versions = new Map([...this.openDocuments].map(([path2, state]) => [path2, state.version]));
+    const versions = new Map([...this.openDocuments].map(([path, state]) => [path, state.version]));
     for (const operation of operations) {
       if (operation.kind === "text") {
         const current = versions.get(operation.path);
@@ -2461,17 +2461,17 @@ class WorkspaceDocumentState {
         continue;
       }
       if (operation.kind === "rename") {
-        const moved = [...versions].filter(([path2]) => isSameOrDescendant(path2, operation.oldPath));
-        for (const [path2] of moved)
-          versions.delete(path2);
-        for (const [path2] of moved)
-          versions.set(movedPath(path2, operation.oldPath, operation.newPath), 1);
+        const moved = [...versions].filter(([path]) => isSameOrDescendant(path, operation.oldPath));
+        for (const [path] of moved)
+          versions.delete(path);
+        for (const [path] of moved)
+          versions.set(movedPath(path, operation.oldPath, operation.newPath), 1);
         continue;
       }
       if (operation.kind === "delete") {
-        for (const path2 of [...versions.keys()]) {
-          if (isSameOrDescendant(path2, operation.path))
-            versions.delete(path2);
+        for (const path of [...versions.keys()]) {
+          if (isSameOrDescendant(path, operation.path))
+            versions.delete(path);
         }
         continue;
       }
@@ -2515,8 +2515,8 @@ class WorkspaceDocumentState {
       for (const state of moved)
         await this.closeDocument(state);
       for (const state of moved) {
-        const path2 = movedPath(state.path, mutation.oldPath, mutation.newPath);
-        await this.openDocumentSingleFlight(path2, readFileSync2(path2, "utf-8"));
+        const path = movedPath(state.path, mutation.oldPath, mutation.newPath);
+        await this.openDocumentSingleFlight(path, readFileSync2(path, "utf-8"));
       }
       if (moved.length === 0) {
         watched.push({ uri: pathToFileURL2(mutation.oldPath).href, type: 3 });
@@ -2530,31 +2530,31 @@ class WorkspaceDocumentState {
     if (removed.length === 0)
       watched.push({ uri: pathToFileURL2(mutation.path).href, type: 3 });
   }
-  async openDocumentSingleFlight(path2, text) {
-    const existing = this.openPromises.get(path2);
+  async openDocumentSingleFlight(path, text) {
+    const existing = this.openPromises.get(path);
     if (existing)
       return existing;
     const open = (async () => {
       const state = {
-        path: path2,
-        uri: pathToFileURL2(path2).href,
-        languageId: getLanguageId(effectiveExtension(path2)),
+        path,
+        uri: pathToFileURL2(path).href,
+        languageId: getLanguageId(effectiveExtension(path)),
         text,
         version: 1,
         generation: 1,
         publishGeneration: 0,
         waiters: new Set
       };
-      this.openDocuments.set(path2, state);
+      this.openDocuments.set(path, state);
       this.openByUri.set(normalizeDocumentUri(state.uri), state);
       this.notifyWaiters(state);
       await this.sendNotification("textDocument/didOpen", {
         textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
       });
     })().finally(() => {
-      this.openPromises.delete(path2);
+      this.openPromises.delete(path);
     });
-    this.openPromises.set(path2, open);
+    this.openPromises.set(path, open);
     return open;
   }
   async changeDocument(state, text) {
@@ -2600,9 +2600,9 @@ import { dirname as dirname4, isAbsolute as isAbsolute4, relative as relative3,
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 class WorkspaceEditPathError extends Error {
-  constructor(path2, detail) {
-    super(`${detail}: ${path2}`);
-    this.path = path2;
+  constructor(path, detail) {
+    super(`${detail}: ${path}`);
+    this.path = path;
     this.detail = detail;
     this.name = "WorkspaceEditPathError";
   }
@@ -2666,28 +2666,28 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
     return { success: false, error: `${requestedPath}: ${detail}` };
   }
 }
-function snapshotPath(path2, includeChildren) {
-  if (!existsSync4(path2))
+function snapshotPath(path, includeChildren) {
+  if (!existsSync4(path))
     return { kind: "missing" };
-  const stats = lstatSync2(path2);
+  const stats = lstatSync2(path);
   if (stats.isFile())
-    return { kind: "file", content: readFileSync3(path2, "utf-8") };
+    return { kind: "file", content: readFileSync3(path, "utf-8") };
   if (stats.isDirectory()) {
-    return includeChildren ? { kind: "directory", children: readdirSync(path2).sort() } : { kind: "directory" };
+    return includeChildren ? { kind: "directory", children: readdirSync(path).sort() } : { kind: "directory" };
   }
-  throw new WorkspaceEditPathError(path2, "unsupported filesystem entry");
+  throw new WorkspaceEditPathError(path, "unsupported filesystem entry");
 }
 
 // ../lsp-core/src/lsp/workspace-edit-commit.ts
 var DEFAULT_IO = {
-  writeFile(path2, content) {
-    writeFileSync(path2, content, "utf-8");
+  writeFile(path, content) {
+    writeFileSync(path, content, "utf-8");
   },
   rename(oldPath, newPath) {
     renameSync(oldPath, newPath);
   },
-  remove(path2, recursive) {
-    rmSync(path2, { recursive, force: false });
+  remove(path, recursive) {
+    rmSync(path, { recursive, force: false });
   }
 };
 function snapshotsEqual(expected, actual) {
@@ -2700,8 +2700,8 @@ function snapshotsEqual(expected, actual) {
   }
   return true;
 }
-function liveSnapshot(path2, expected) {
-  return snapshotPath(path2, expected.kind === "directory" && expected.children !== undefined);
+function liveSnapshot(path, expected) {
+  return snapshotPath(path, expected.kind === "directory" && expected.children !== undefined);
 }
 function firstOperationIndex(plan) {
   return plan.operations[0]?.changeIndex ?? 0;
@@ -2722,28 +2722,28 @@ function failedCommit(plan, failure) {
   };
 }
 function verifySnapshots(plan) {
-  for (const [path2, expected] of plan.snapshots) {
+  for (const [path, expected] of plan.snapshots) {
     let actual;
     try {
-      actual = liveSnapshot(path2, expected);
+      actual = liveSnapshot(path, expected);
     } catch (error) {
-      const changeIndex = plan.firstChangeByPath.get(path2) ?? firstOperationIndex(plan);
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
       const detail = error instanceof Error ? error.message : String(error);
-      return failedCommit(plan, { message: `cannot verify snapshot for ${path2}: ${detail}`, changeIndex });
+      return failedCommit(plan, { message: `cannot verify snapshot for ${path}: ${detail}`, changeIndex });
     }
     if (!snapshotsEqual(expected, actual)) {
-      const changeIndex = plan.firstChangeByPath.get(path2) ?? firstOperationIndex(plan);
-      return failedCommit(plan, { message: `workspace state changed before commit: ${path2}`, changeIndex });
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
+      return failedCommit(plan, { message: `workspace state changed before commit: ${path}`, changeIndex });
     }
   }
   return null;
 }
-function addModifiedPath(paths, path2) {
-  if (!paths.includes(path2))
-    paths.push(path2);
+function addModifiedPath(paths, path) {
+  if (!paths.includes(path))
+    paths.push(path);
 }
-function reportedPath(plan, path2) {
-  return plan.reportedPathByCanonical.get(path2) ?? path2;
+function reportedPath(plan, path) {
+  return plan.reportedPathByCanonical.get(path) ?? path;
 }
 function changedPathsForMutation(mutation) {
   return mutation.kind === "rename" ? [mutation.oldPath, mutation.newPath] : [mutation.path];
@@ -2751,8 +2751,8 @@ function changedPathsForMutation(mutation) {
 function mutationDelta(operations) {
   const changedPaths = new Set;
   for (const operation of operations) {
-    for (const path2 of changedPathsForMutation(operation))
-      changedPaths.add(path2);
+    for (const path of changedPathsForMutation(operation))
+      changedPaths.add(path);
   }
   return { operations, changedPaths: [...changedPaths].sort() };
 }
@@ -2986,14 +2986,14 @@ function parseSinglePathResource(input, kind) {
     return;
   }
   if (kind === "create") {
-    const options2 = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+    const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
     target.operations.push({
       kind,
       changeIndex,
       path: resolvedPath.path,
       reportedPath: resolvedPath.requestedPath,
-      overwrite: options2["overwrite"] ?? false,
-      ignoreIfExists: options2["ignoreIfExists"] ?? false,
+      overwrite: options["overwrite"] ?? false,
+      ignoreIfExists: options["ignoreIfExists"] ?? false,
       followedSymbolicLink: resolvedPath.followedSymbolicLink
     });
     return;
@@ -3251,12 +3251,12 @@ function isSameOrDescendant2(candidate, parent) {
   const relativePath = relative4(parent, candidate);
   return relativePath === "" || !relativePath.startsWith("..") && relativePath !== "..";
 }
-function removeVirtualSubtree(virtual, path2) {
+function removeVirtualSubtree(virtual, path) {
   for (const candidate of [...virtual.keys()]) {
-    if (isSameOrDescendant2(candidate, path2))
+    if (isSameOrDescendant2(candidate, path))
       virtual.delete(candidate);
   }
-  virtual.set(path2, { kind: "missing" });
+  virtual.set(path, { kind: "missing" });
 }
 function moveVirtualSubtree(virtual, oldPath, newPath) {
   const moved = [...virtual.entries()].filter(([candidate]) => isSameOrDescendant2(candidate, oldPath));
@@ -3267,16 +3267,16 @@ function moveVirtualSubtree(virtual, oldPath, newPath) {
     virtual.set(suffix === "" ? newPath : resolve4(newPath, suffix), entry);
   }
 }
-function virtualDirectoryHasChildren(virtual, path2) {
+function virtualDirectoryHasChildren(virtual, path) {
   for (const [candidate, entry] of virtual) {
-    if (candidate !== path2 && entry.kind !== "missing" && isSameOrDescendant2(candidate, path2))
+    if (candidate !== path && entry.kind !== "missing" && isSameOrDescendant2(candidate, path))
       return true;
   }
   return false;
 }
-function requireVirtualParent(virtual, path2, changeIndex) {
-  if (virtual.get(dirname5(path2))?.kind !== "directory") {
-    throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path2}`);
+function requireVirtualParent(virtual, path, changeIndex) {
+  if (virtual.get(dirname5(path))?.kind !== "directory") {
+    throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
   }
 }
 function simulateOperations(parsed, snapshots) {
@@ -3421,21 +3421,21 @@ class WorkspaceSnapshotBuilder {
     }
     return this.snapshots;
   }
-  add(path2, includeChildren) {
-    let candidate = path2;
+  add(path, includeChildren) {
+    let candidate = path;
     while (true) {
       const existing = this.snapshots.get(candidate);
       if (existing === undefined || includeChildren && existing.kind === "directory" && existing.children === undefined) {
-        this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path2));
+        this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path));
       }
       if (candidate === this.workspaceRoot)
         break;
       candidate = dirname6(candidate);
     }
-    if (!includeChildren || !existsSync6(path2) || !lstatSync4(path2).isDirectory())
+    if (!includeChildren || !existsSync6(path) || !lstatSync4(path).isDirectory())
       return;
-    for (const child of readdirSync2(path2))
-      this.add(resolve5(path2, child), true);
+    for (const child of readdirSync2(path))
+      this.add(resolve5(path, child), true);
   }
 }
 function snapshotOperations(operations, workspaceRoot) {
@@ -3463,11 +3463,11 @@ class PlanPathIndex {
       }
     }
   }
-  add(path2, reportedPath2, changeIndex) {
-    if (!this.firstChangeByPath.has(path2))
-      this.firstChangeByPath.set(path2, changeIndex);
-    if (!this.reportedPathByCanonical.has(path2))
-      this.reportedPathByCanonical.set(path2, reportedPath2);
+  add(path, reportedPath, changeIndex) {
+    if (!this.firstChangeByPath.has(path))
+      this.firstChangeByPath.set(path, changeIndex);
+    if (!this.reportedPathByCanonical.has(path))
+      this.reportedPathByCanonical.set(path, reportedPath);
   }
 }
 function fingerprintWorkspaceEdit(edit, workspaceRoot) {
@@ -3579,15 +3579,15 @@ class WorkspaceMutationController {
       };
     }
     lease.phase = "applying";
-    lease.applyCompletion = new Promise((resolve6) => {
-      lease.resolveApply = resolve6;
+    lease.applyCompletion = new Promise((resolve) => {
+      lease.resolveApply = resolve;
     });
     const edit = isRecord4(params) ? params["edit"] : undefined;
-    const record2 = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
-    lease.serverApply = record2;
+    const record = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
+    lease.serverApply = record;
     lease.phase = "settled";
     lease.resolveApply?.();
-    return responseFor(record2.result);
+    return responseFor(record.result);
   }
   async reconcileRename(leaseToken, edit) {
     const lease = this.requireActiveLease(leaseToken);
@@ -3603,16 +3603,16 @@ class WorkspaceMutationController {
     const applied = await this.applyEdit(edit, lease);
     return { edit, apply: applied.result };
   }
-  reconcileServerApply(record2, edit) {
+  reconcileServerApply(record, edit) {
     if (!edit)
-      return { edit, apply: record2.result };
+      return { edit, apply: record.result };
     const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
-    if (fingerprint.success && record2.fingerprint !== null && fingerprint.fingerprint === record2.fingerprint) {
-      return { edit, apply: record2.result };
+    if (fingerprint.success && record.fingerprint !== null && fingerprint.fingerprint === record.fingerprint) {
+      return { edit, apply: record.result };
     }
     return {
       edit,
-      apply: failure("rename result conflicts with server-applied workspace edit", 0, record2.result)
+      apply: failure("rename result conflicts with server-applied workspace edit", 0, record.result)
     };
   }
   async applyEdit(edit, lease) {
@@ -3653,8 +3653,8 @@ var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
 var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
 
 class LspClient extends LspClientConnection {
-  constructor(root, server2, options = {}) {
-    super(root, server2, options);
+  constructor(root, server, options = {}) {
+    super(root, server, options);
     this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
@@ -3775,13 +3775,13 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - this.timerProvider.now();
-          if (remainingMs2 <= 0)
+          const remainingMs = deadlineAt - this.timerProvider.now();
+          if (remainingMs <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
             textDocument: { uri },
             ...cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }
-          }, { timeoutMs: remainingMs2, ...signal === undefined ? {} : { signal } });
+          }, { timeoutMs: remainingMs, ...signal === undefined ? {} : { signal } });
           if (!this.documents.isCurrentSnapshot(snapshot))
             continue;
           const report = this.parseDiagnosticPullReport(result);
@@ -3862,7 +3862,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     return wait;
   if (signal.aborted)
     return Promise.reject(abortError3(signal));
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
       reject(abortError3(signal));
@@ -3870,7 +3870,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve();
     }, (error) => {
       signal.removeEventListener("abort", onAbort);
       reject(error);
@@ -3938,7 +3938,7 @@ async function stopClientBestEffort(client) {
 function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled)
@@ -3956,7 +3956,7 @@ function awaitWithSignal2(promise, signal) {
         return;
       settled = true;
       signal.removeEventListener("abort", onAbort);
-      resolve7(value);
+      resolve(value);
     }, (err) => {
       if (settled)
         return;
@@ -3979,7 +3979,7 @@ class LspManager {
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
     this.maxResidentClients = options.maxResidentClients ?? MAX_RESIDENT_CLIENTS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
-    this.clientFactory = options.clientFactory ?? ((root, server2) => new LspClient(root, server2));
+    this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
     this.now = options.now ?? (() => Date.now());
     this.startReaper();
     this.signalDisposer = installProcessSignalCleanup(() => this.stopAll());
@@ -4072,12 +4072,12 @@ class LspManager {
       await this.tombstoneStop(key, managed.client);
     }
   }
-  async getClient(root, server2, signal) {
+  async getClient(root, server, signal) {
     if (this.disposed) {
       throw new Error("LspManager has been disposed");
     }
     signal?.throwIfAborted();
-    const key = this.getKey(root, server2.id);
+    const key = this.getKey(root, server.id);
     for (;; ) {
       const pendingStop = this.pendingStops.get(key);
       if (pendingStop === undefined)
@@ -4119,7 +4119,7 @@ class LspManager {
           this.clients.delete(key);
         }
         await this.tombstoneStop(key, managed.client);
-        return this.getClient(root, server2, signal);
+        return this.getClient(root, server, signal);
       }
       this.markHealthyGeneration(key);
       managed.refCount++;
@@ -4127,8 +4127,8 @@ class LspManager {
       return managed.client;
     }
     this.evictForAdmission();
-    this.ensureRespawnAllowed(key, root, server2.id);
-    const client = this.clientFactory(root, server2);
+    this.ensureRespawnAllowed(key, root, server.id);
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -4168,7 +4168,7 @@ class LspManager {
         this.clients.delete(key);
       }
       await this.tombstoneStop(key, client);
-      return this.getClient(root, server2, signal);
+      return this.getClient(root, server, signal);
     }
     this.markHealthyGeneration(key);
     newManaged.refCount++;
@@ -4193,19 +4193,19 @@ class LspManager {
     this.clients.delete(key);
     this.tombstoneStop(key, managed.client);
   }
-  warmupClient(root, server2) {
+  warmupClient(root, server) {
     if (this.disposed)
       return;
-    const key = this.getKey(root, server2.id);
+    const key = this.getKey(root, server.id);
     if (this.clients.has(key) || this.pendingStops.has(key))
       return;
     this.evictForAdmission();
     try {
-      this.ensureRespawnAllowed(key, root, server2.id);
+      this.ensureRespawnAllowed(key, root, server.id);
     } catch {
       return;
     }
-    const client = this.clientFactory(root, server2);
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -4516,11 +4516,11 @@ function getInstallDecisionsPath() {
   return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
-  const path2 = getInstallDecisionsPath();
-  if (!existsSync8(path2))
+  const path = getInstallDecisionsPath();
+  if (!existsSync8(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     return isInstallDecisions(parsed) ? parsed : {};
   } catch {
     return {};
@@ -4538,12 +4538,12 @@ function isInstallDecision(value) {
   return value === "declined" || value === "allowed";
 }
 function writeInstallDecisions(decisions) {
-  const path2 = getInstallDecisionsPath();
-  mkdirSync3(dirname8(path2), { recursive: true });
-  const tmpPath = `${path2}.tmp`;
+  const path = getInstallDecisionsPath();
+  mkdirSync3(dirname8(path), { recursive: true });
+  const tmpPath = `${path}.tmp`;
   writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
 `, "utf8");
-  renameSync2(tmpPath, path2);
+  renameSync2(tmpPath, path);
 }
 function isInstallDecisions(value) {
   return isRecord5(value) && Object.values(value).every(isInstallDecisionRecord);
@@ -4565,11 +4565,11 @@ function getProjectConfigPaths() {
 function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
-function loadJsonFile(path2) {
-  if (!existsSync9(path2))
+function loadJsonFile(path) {
+  if (!existsSync9(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
     return isConfigJson(parsed) ? parsed : null;
   } catch {
     return null;
@@ -4586,8 +4586,8 @@ function loadAllConfigs() {
   return configs;
 }
 function loadFirstJsonFile(paths) {
-  for (const path2 of paths) {
-    const config = loadJsonFile(path2);
+  for (const path of paths) {
+    const config = loadJsonFile(path);
     if (config)
       return config;
   }
@@ -4613,10 +4613,10 @@ function getMergedServers() {
       }
       if (seen.has(id))
         continue;
-      const server2 = createServerFromEntry(id, entry, source);
-      if (!server2)
+      const server = createServerFromEntry(id, entry, source);
+      if (!server)
         continue;
-      servers.push(server2);
+      servers.push(server);
       seen.add(id);
     }
   }
@@ -4648,7 +4648,7 @@ function createServerFromEntry(id, entry, source) {
   if (source === "project") {
     if (!builtin)
       return null;
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: builtin.command,
       extensions: entry.extensions ?? builtin.extensions,
@@ -4656,35 +4656,35 @@ function createServerFromEntry(id, entry, source) {
       source
     });
     if (entry.initialization !== undefined) {
-      server3.initialization = entry.initialization;
+      server.initialization = entry.initialization;
     }
-    return server3;
+    return server;
   }
   if (entry.command && entry.extensions) {
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: entry.command,
       extensions: entry.extensions,
       priority: entry.priority ?? 0,
       source
     });
-    applyOptionalServerFields(server3, entry);
-    return server3;
+    applyOptionalServerFields(server, entry);
+    return server;
   }
   if (!builtin)
     return null;
-  const server2 = createServer({
+  const server = createServer({
     id,
     command: entry.command ?? builtin.command,
     extensions: entry.extensions ?? builtin.extensions,
     priority: entry.priority ?? 0,
     source
   });
-  applyOptionalServerFields(server2, entry);
-  return server2;
+  applyOptionalServerFields(server, entry);
+  return server;
 }
 function createServer(input) {
-  const server2 = {
+  const server = {
     id: input.id,
     command: input.command,
     extensions: input.extensions,
@@ -4692,19 +4692,19 @@ function createServer(input) {
     source: input.source
   };
   if (input.env !== undefined) {
-    server2.env = input.env;
+    server.env = input.env;
   }
   if (input.initialization !== undefined) {
-    server2.initialization = input.initialization;
+    server.initialization = input.initialization;
   }
-  return server2;
+  return server;
 }
-function applyOptionalServerFields(server2, entry) {
+function applyOptionalServerFields(server, entry) {
   if (entry.env !== undefined) {
-    server2.env = entry.env;
+    server.env = entry.env;
   }
   if (entry.initialization !== undefined) {
-    server2.initialization = entry.initialization;
+    server.initialization = entry.initialization;
   }
 }
 function isConfigJson(value) {
@@ -4793,9 +4793,9 @@ var LOCAL_BIN_RULES = [
 ];
 var resolutionCache = new Map;
 var probeCount = 0;
-function probe(path2) {
+function probe(path) {
   probeCount += 1;
-  return existsSync10(path2);
+  return existsSync10(path);
 }
 function executableSuffixes(platform, pathExt) {
   if (platform !== "win32")
@@ -4895,24 +4895,24 @@ function withResolvedCommand(command, binaryPath) {
 function findServerForExtension(ext) {
   const servers = getMergedServers();
   const workingDirectory = contextCwd();
-  for (const server2 of servers) {
-    if (!server2.extensions.includes(ext))
+  for (const server of servers) {
+    if (!server.extensions.includes(ext))
       continue;
-    const binaryPath = resolveServerBinary(server2.command, workingDirectory);
+    const binaryPath = resolveServerBinary(server.command, workingDirectory);
     if (binaryPath !== null) {
       const resolvedServer = {
-        id: server2.id,
-        command: withResolvedCommand(server2.command, binaryPath),
-        extensions: server2.extensions,
-        priority: server2.priority
+        id: server.id,
+        command: withResolvedCommand(server.command, binaryPath),
+        extensions: server.extensions,
+        priority: server.priority
       };
-      if (server2.env !== undefined) {
+      if (server.env !== undefined) {
         return {
           status: "found",
           server: {
             ...resolvedServer,
-            env: server2.env,
-            ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+            env: server.env,
+            ...server.initialization === undefined ? {} : { initialization: server.initialization }
           }
         };
       }
@@ -4920,20 +4920,20 @@ function findServerForExtension(ext) {
         status: "found",
         server: {
           ...resolvedServer,
-          ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+          ...server.initialization === undefined ? {} : { initialization: server.initialization }
         }
       };
     }
   }
-  for (const server2 of servers) {
-    if (server2.extensions.includes(ext)) {
-      const installHint = LSP_INSTALL_HINTS[server2.id] ?? `Install '${server2.command[0]}' and ensure it's in your PATH`;
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      const installHint = LSP_INSTALL_HINTS[server.id] ?? `Install '${server.command[0]}' and ensure it's in your PATH`;
       return {
         status: "not_installed",
         server: {
-          id: server2.id,
-          command: server2.command,
-          extensions: server2.extensions
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions
         },
         installHint
       };
@@ -4952,18 +4952,18 @@ function getAllServers() {
   const workingDirectory = contextCwd();
   const result = [];
   const seen = new Set;
-  for (const server2 of servers) {
-    if (seen.has(server2.id))
+  for (const server of servers) {
+    if (seen.has(server.id))
       continue;
     result.push({
-      id: server2.id,
-      installed: isServerInstalled(server2.command, workingDirectory),
-      extensions: server2.extensions,
+      id: server.id,
+      installed: isServerInstalled(server.command, workingDirectory),
+      extensions: server.extensions,
       disabled: false,
-      source: server2.source,
-      priority: server2.priority
+      source: server.source,
+      priority: server.priority
     });
-    seen.add(server2.id);
+    seen.add(server.id);
   }
   for (const id of disabled) {
     if (seen.has(id))
@@ -5038,8 +5038,8 @@ function resolvePathInsideContext(filePath) {
   }
   return canonical;
 }
-function rebaseThroughCanonicalAncestor(path2, cwd) {
-  let current = path2;
+function rebaseThroughCanonicalAncestor(path, cwd) {
+  let current = path;
   const suffix = [];
   while (true) {
     if (existsSync11(current)) {
@@ -5111,20 +5111,20 @@ function formatInstallOptions(serverId, installHint) {
   ];
 }
 function formatNotInstalled(result) {
-  const { server: server2, installHint } = result;
-  const extensions = server2.extensions.join(", ");
-  const decision = loadInstallDecision(server2.id)?.decision;
+  const { server, installHint } = result;
+  const extensions = server.extensions.join(", ");
+  const decision = loadInstallDecision(server.id)?.decision;
   const context = lspRequestContext();
   if (decision === "declined") {
-    return `LSP server '${server2.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
+    return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
   }
   const header = [
-    `LSP server '${server2.id}' for ${extensions} is NOT INSTALLED.`,
+    `LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
     "",
-    `Command not found: ${server2.command[0]}`,
+    `Command not found: ${server.command[0]}`,
     ""
   ];
-  const installOptions = formatInstallOptions(server2.id, installHint);
+  const installOptions = formatInstallOptions(server.id, installHint);
   if (decision === "allowed") {
     return [
       ...header,
@@ -5150,7 +5150,7 @@ function formatNotInstalled(result) {
     "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
     "- If the user agrees: run the install command above, then retry this tool.",
     "- If the user declines, OR has NOT explicitly asked for LSP installation:",
-    `    call lsp_install_decision { server_id: "${server2.id}", decision: "declined" },`,
+    `    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
     `    which writes to ${context.installDecisionsPath},`,
     "    then ignore this message and proceed WITHOUT LSP."
   ].join(`
@@ -5174,26 +5174,26 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   if (result.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(result), result);
   }
-  const server2 = result.server;
+  const server = result.server;
   const root = findWorkspaceRoot(absPath);
   const manager = options.manager ?? getLspManager();
   const acquireAndCall = async (allowRetry) => {
-    const client = await manager.getClient(root, server2, options.signal);
+    const client = await manager.getClient(root, server, options.signal);
     try {
       return await fn(client, root, absPath);
     } catch (err) {
       if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
-        manager.invalidateClient(root, server2.id, client);
+        manager.invalidateClient(root, server.id, client);
         return acquireAndCall(false);
       }
       if (err instanceof LspRequestTimeoutError) {
-        if (manager.isServerInitializing(root, server2.id)) {
+        if (manager.isServerInitializing(root, server.id)) {
           throw new LspServerInitializingError(err);
         }
       }
       throw err;
     } finally {
-      manager.releaseClient(root, server2.id);
+      manager.releaseClient(root, server.id);
     }
   };
   return acquireAndCall(true);
@@ -5216,10 +5216,10 @@ function uriToPath(uri) {
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
-    const uri2 = uriToPath(loc.targetUri);
-    const line2 = loc.targetRange.start.line + 1;
-    const char2 = loc.targetRange.start.character;
-    return `${uri2}:${line2}:${char2}`;
+    const uri = uriToPath(loc.targetUri);
+    const line = loc.targetRange.start.line + 1;
+    const char = loc.targetRange.start.character;
+    return `${uri}:${line}:${char}`;
   }
   const uri = uriToPath(loc.uri);
   const line = loc.range.start.line + 1;
@@ -5364,7 +5364,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   if (serverResult.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(serverResult));
   }
-  const server2 = serverResult.server;
+  const server = serverResult.server;
   const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
   const wasCapped = allFiles.length > maxFiles;
   const filesToProcess = allFiles.slice(0, maxFiles);
@@ -5384,7 +5384,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2, options.signal);
+  const client = await manager.getClient(root, server, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -5412,7 +5412,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     });
     await Promise.all(workers);
   } finally {
-    manager.releaseClient(root, server2.id);
+    manager.releaseClient(root, server.id);
   }
   const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
   const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
@@ -5621,8 +5621,8 @@ function clientOptions(signal) {
 }
 
 // ../lsp-core/src/tools/result.ts
-function text(text2, details, isError = false) {
-  return { content: [{ type: "text", text: text2 }], details, isError };
+function text(text, details, isError = false) {
+  return { content: [{ type: "text", text }], details, isError };
 }
 
 // ../lsp-core/src/tools/diagnostics.ts
@@ -5642,7 +5642,7 @@ async function executeLspDiagnostics(params, signal) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
         const message = `No supported source files found in directory: ${absPath}`;
-        const details3 = {
+        const details = {
           filePath,
           severity,
           mode: "directory",
@@ -5652,24 +5652,24 @@ async function executeLspDiagnostics(params, signal) {
           error: message,
           errorKind: "no_files"
         };
-        return text(message, details3);
+        return text(message, details);
       }
-      const output2 = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
-      const details2 = {
+      const output = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
+      const details = {
         filePath,
         severity,
         mode: "directory",
         diagnostics: [],
-        totalDiagnostics: output2.totalDiagnostics,
+        totalDiagnostics: output.totalDiagnostics,
         truncated: false,
-        fileFailures: [...output2.fileFailures]
+        fileFailures: [...output.fileFailures]
       };
-      return text(output2.output, details2);
+      return text(output.output, details);
     }
     const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal), "diagnostics", clientOptions(signal));
     if (result.transientError) {
       const message = result.transientError.message;
-      const details2 = {
+      const details = {
         filePath,
         severity,
         mode: "file",
@@ -5679,7 +5679,7 @@ async function executeLspDiagnostics(params, signal) {
         error: message,
         errorKind: result.transientError.kind
       };
-      return text(message, details2, true);
+      return text(message, details, true);
     }
     const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
     const total = diagnostics.length;
@@ -5810,7 +5810,7 @@ async function executeLspInstallDecision(params) {
   if (!isInstallDecision(decision)) {
     return text(`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`, { serverId, errorKind: "invalid_decision" }, true);
   }
-  const serverIds = [...new Set(getMergedServers().map((server2) => server2.id))];
+  const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
   if (!serverIds.includes(serverId)) {
     const preview = serverIds.slice(0, 20).join(", ");
     return text(`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`, { serverId, errorKind: "unknown_server" }, true);
@@ -5950,10 +5950,10 @@ function objectSchema(properties, required = []) {
 async function executeLspStatus() {
   const servers = getAllServers();
   const snapshots = getLspManager().getSnapshot();
-  const installed = servers.filter((server2) => server2.installed && !server2.disabled);
-  const configuredLines = servers.map((server2) => {
-    const state = server2.disabled ? "disabled" : server2.installed ? "installed" : "missing";
-    return `- ${server2.id}: ${state}; source=${server2.source}; extensions=${server2.extensions.join(", ")}`;
+  const installed = servers.filter((server) => server.installed && !server.disabled);
+  const configuredLines = servers.map((server) => {
+    const state = server.disabled ? "disabled" : server.installed ? "installed" : "missing";
+    return `- ${server.id}: ${state}; source=${server.source}; extensions=${server.extensions.join(", ")}`;
   });
   const activeLines = snapshots.map((snapshot) => {
     const state = snapshot.alive ? snapshot.isInitializing ? "initializing" : "alive" : "dead";
@@ -5996,8 +5996,8 @@ async function executeLspSymbols(params, signal) {
           errorKind: "missing_query"
         });
       }
-      const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
-      return formatSymbolsResult(filePath, scope, symbols2, limit, query);
+      const symbols = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
+      return formatSymbolsResult(filePath, scope, symbols, limit, query);
     }
     const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
@@ -6389,7 +6389,7 @@ function withContext(args, context) {
 function ensureDaemonAvailable(paths, ensure, signal) {
   if (!signal)
     return ensure(paths);
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -6404,11 +6404,11 @@ function ensureDaemonAvailable(paths, ensure, signal) {
       return;
     }
     signal.addEventListener("abort", onAbort, { once: true });
-    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve10()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
   });
 }
 function sendToolCall(paths, token, name, args, options) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
@@ -6461,7 +6461,7 @@ function sendToolCall(paths, token, name, args, options) {
       }
       const result = toToolResult(message, requestId);
       if (result)
-        finish(() => resolve10(result));
+        finish(() => resolve(result));
       else
         finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
     });