feat(lsp): add native TypeScript 7 (typescript-go) LSP support

.claude/agent-memory/review-review-pr-test-analyzer/lsp-test-patterns.md

@@ -13,3 +13,5 @@ LSP package test layout: `packages/lsp/test/unit/{client,multiplexer,index,serve
 - The multiplexer tests use a hand-written `FakeManager` (in multiplexer.test.ts), NOT the real `LSPManager`. So the multiplexer's upstream protocol + relay wiring are covered, but the real `LSPManager.getClients` spawn/dedup logic and `diagnosticsForFile`/`diagnostics` merge across heterogeneous real servers are NOT exercised by these tests.
 - Recurring untested branches to check on any LSP PR: `LSPManager` constructor `serverIds` scoping + the "empty array = no restriction" guard (index.ts ~L267); `getClients` filename matching for extensionless files (Dockerfile/Containerfile, index.ts ~L378-389); `closeFile`/`openWithText` on the real manager; `didChange` empty `contentChanges` early-return (multiplexer.ts ~L209-211).
 - Concurrent-open fix lives in client.ts (`files[filePath] = 0` set BEFORE the didOpen await). The regression test in client.test.ts genuinely guards it: reverting the order makes the count assertion fail. Treat this as the reference pattern for async-ordering regression tests here.
+- Native TypeScript tests cover resolver behavior (classic/no-tsgo, v7 and file markers, native-preview, missing tsc, parent-hoisted TypeScript), but not `TypescriptServer.spawn` command/arguments or the Windows `.cmd` branch.
+- The pull-diagnostics fixture advertises `diagnosticProvider` unconditionally and always returns one fixed `full` report. It does not expose request counts or model `unchanged`, errors, or changing/empty reports; the push fixture answers unknown requests, so current client tests cannot prove capability negotiation/gating, didChange refresh, preservation, failure swallowing, or `onDiagnostics` relay side effects.

ARCHITECTURE.md

@@ -121,7 +121,7 @@ packages/lsp/src/
 ├── language.ts         # File extension → language ID mapping
 └── server/             # Server definitions (30+ files)
     ├── index.ts        # LSP_SERVERS registry array
-    ├── typescript.ts   # TypeScript/JavaScript server
+    ├── typescript.ts   # TypeScript/JavaScript server (auto-selects native TS 7)
     ├── pyright.ts      # Python server
     └── ...             # One file per language server
 ```

CLAUDE.md

@@ -129,7 +129,7 @@ Claude/MCP Client <-> StdioTransport <-> McpServer <-> Providers
 
 | Language | Server | Root Detection |
 |----------|--------|----------------|
-| TypeScript/JavaScript | typescript-language-server | package-lock.json, bun.lock, etc. |
+| TypeScript/JavaScript | typescript-language-server (auto-upgrades to native TypeScript 7 `tsc --lsp` when the project ships it) | package-lock.json, bun.lock, etc. |
 | TypeScript/JavaScript | oxlint | .oxlintrc.json, package.json |
 | Deno | deno lsp | deno.json, deno.jsonc |
 | Python | pyright-langserver | pyproject.toml, setup.py, requirements.txt |

apps/docs/content/docs/3.configuration/1.overview.md

@@ -80,6 +80,31 @@ formatter: false
 lsp: false
 ```
 
+## Native TypeScript 7 (typescript-go)
+
+The `typescript` server automatically uses the native TypeScript 7 compiler
+([typescript-go](https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/))
+when your project ships one — no configuration needed. At startup it inspects
+the project's `node_modules` and, if it finds a native build, spawns
+`tsc --lsp --stdio` (or `tsgo --lsp --stdio` from
+[`@typescript/native-preview`](https://www.npmjs.com/package/@typescript/native-preview)).
+Otherwise it falls back to the classic `typescript-language-server --stdio`.
+
+A project is treated as native TypeScript 7 when any of these hold:
+
+- `node_modules/typescript` is at major version 7 or higher
+- the `typescript` package ships `lib/getExePath.js` (native launcher)
+- the `typescript` package is missing `lib/tsserver.js` (classic entry point)
+- a `node_modules/.bin/tsgo` binary is present (`@typescript/native-preview`)
+
+Because it is one server that swaps its own binary, there is a single set of
+diagnostics either way — you never get duplicates. To use it, just install a
+native TypeScript 7 build in your project:
+
+```bash
+npm install --save-dev @typescript/native-preview
+```
+
 ## Environment Variables
 
 | Variable | Description | Default |

apps/docs/content/docs/4.reference/2.supported-languages.md

@@ -11,8 +11,8 @@ Code Please supports formatting and LSP diagnostics for many languages.
 
 | Language | Formatter | LSP Server |
 |----------|-----------|------------|
-| TypeScript | Biome, Prettier | typescript-language-server |
-| JavaScript | Biome, Prettier | typescript-language-server |
+| TypeScript | Biome, Prettier | native `tsc` / `tsgo` (TypeScript 7, auto-selected) or typescript-language-server |
+| JavaScript | Biome, Prettier | native `tsc` / `tsgo` (TypeScript 7, auto-selected) or typescript-language-server |
 | Python | ruff, uv | pyright |
 | Go | gofmt | gopls |
 | Rust | - | rust-analyzer |
@@ -34,6 +34,7 @@ Code Please supports formatting and LSP diagnostics for many languages.
 | Server | Extensions | Root Detection |
 |--------|------------|----------------|
 | typescript-language-server | `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs` | `package.json`, `tsconfig.json` |
+| tsc / tsgo (native TypeScript 7, auto-selected when the project ships it) | `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.mts`, `.cts` | `package.json`, `tsconfig.json` |
 | oxlint | `.ts`, `.tsx`, `.js`, `.jsx` | `.oxlintrc.json`, `package.json` |
 | deno | `.ts`, `.tsx`, `.js`, `.jsx` | `deno.json`, `deno.jsonc` |
 | eslint | `.ts`, `.tsx`, `.js`, `.jsx`, `.vue` | `eslint.config.js`, `.eslintrc` |

packages/lsp/CLAUDE.md

@@ -231,6 +231,16 @@ lsp:
 - `root: string` - Custom project root path (must be non-empty)
 - `command: string[]` - Custom spawn command (must have at least one element)
 
+**Native TypeScript 7 (typescript-go):** The single `typescript` server auto-selects
+its binary per project root at spawn time. When the workspace ships a native
+TypeScript 7 build — `node_modules/typescript` at major version ≥ 7 (or missing
+`lib/tsserver.js` / carrying `lib/getExePath.js`), or a `@typescript/native-preview`
+`tsgo` bin — it spawns `tsc --lsp --stdio` (or `tsgo --lsp --stdio`); otherwise it
+falls back to the classic `typescript-language-server --stdio`. There is no separate
+server id or config toggle, so there are never duplicate diagnostics. The native
+servers report diagnostics via the LSP pull model (`textDocument/diagnostic`), which
+the client handles transparently alongside push (`publishDiagnostics`).
+
 **Config Utilities:**
 ```typescript
 import { getServerRoot, isServerEnabled, loadLspConfig } from '@pleaseai/code-lsp'

packages/lsp/src/client.ts

@@ -9,6 +9,7 @@ import type { Diagnostic } from 'vscode-languageserver-types'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import {
+  CancellationTokenSource,
   createMessageConnection,
 
   StreamMessageReader,
@@ -62,32 +63,95 @@ export async function createLSPClient(input: {
 
   const diagnostics = new Map<string, Diagnostic[]>()
   const files: Record<string, number> = {}
+  const diagnosticPulls: Record<string, number> = {}
+  const diagnosticPullTokens: Record<string, CancellationTokenSource> = {}
+  let nextDiagnosticPullID = 0
   let diagnosticsListeners: Array<{
     path: string
     resolve: () => void
     timer?: ReturnType<typeof setTimeout>
   }> = []
 
+  // Whether the server reports diagnostics via the pull model
+  // (textDocument/diagnostic) rather than pushing publishDiagnostics.
+  // Populated from the initialize result below.
+  let supportsPullDiagnostics = false
+
+  const notifyDiagnosticsListeners = (filePath: string): void => {
+    const listeners = diagnosticsListeners.filter(l => l.path === filePath)
+    for (const listener of listeners) {
+      if (listener.timer) { clearTimeout(listener.timer) }
+      listener.timer = setTimeout(() => {
+        diagnosticsListeners = diagnosticsListeners.filter(
+          l => l !== listener,
+        )
+        listener.resolve()
+      }, DIAGNOSTICS_DEBOUNCE_MS)
+    }
+  }
+
+  // Store diagnostics for a file and notify any waiters. Shared by the push
+  // (publishDiagnostics) handler and the pull (textDocument/diagnostic) path.
+  const applyDiagnostics = (filePath: string, diags: Diagnostic[]): void => {
+    diagnostics.set(filePath, diags)
+    notifyDiagnosticsListeners(filePath)
+    input.onDiagnostics?.(filePath, input.serverID)
+  }
+
+  // Pull diagnostics for a single file (LSP textDocument/diagnostic). Used for
+  // servers that advertise a diagnostic provider instead of pushing them
+  // (e.g. typescript-go / tsgo). Failures are swallowed — absent diagnostics
+  // must never break opening a file. `pullID` uniquely identifies this request;
+  // the response is discarded if a newer open/change/close superseded it, so an
+  // out-of-order reply can't overwrite fresher diagnostics with stale ones.
+  const pullDiagnostics = async (filePath: string): Promise<void> => {
+    if (!supportsPullDiagnostics) { return }
+    const normalizedPath = normalizePath(filePath)
+    diagnosticPullTokens[normalizedPath]?.cancel()
+    diagnosticPullTokens[normalizedPath]?.dispose()
+    const cancellation = new CancellationTokenSource()
+    diagnosticPullTokens[normalizedPath] = cancellation
+    const pullID = ++nextDiagnosticPullID
+    diagnosticPulls[normalizedPath] = pullID
+    try {
+      const report = (await withTimeout(
+        connection.sendRequest('textDocument/diagnostic', {
+          textDocument: { uri: pathToFileURL(normalizedPath).href },
+        }, cancellation.token),
+        DIAGNOSTICS_WAIT_TIMEOUT_MS,
+      )) as { kind?: string, items?: Diagnostic[] } | null
+      // Drop a response superseded by a newer pull or close.
+      if (diagnosticPulls[normalizedPath] !== pullID) { return }
+      // A "full" report carries items; an "unchanged" report means keep the
+      // previously reported set, so leave the map as-is.
+      if (report?.kind === 'full' && Array.isArray(report.items)) {
+        applyDiagnostics(normalizedPath, report.items)
+      }
+      else {
+        notifyDiagnosticsListeners(normalizedPath)
+      }
+    }
+    catch {
+      // Settle waiters with the latest known diagnostics when the server is not
+      // ready or the request fails, unless a newer pull/close superseded it.
+      if (diagnosticPulls[normalizedPath] === pullID) {
+        notifyDiagnosticsListeners(normalizedPath)
+      }
+    }
+    finally {
+      if (diagnosticPulls[normalizedPath] === pullID) {
+        delete diagnosticPullTokens[normalizedPath]
+        cancellation.cancel()
+        cancellation.dispose()
+      }
+    }
+  }
+
   // Handle diagnostics notifications
   connection.onNotification(
     'textDocument/publishDiagnostics',
     (params: { uri: string, diagnostics: Diagnostic[] }) => {
-      const filePath = normalizePath(fileURLToPath(params.uri))
-      diagnostics.set(filePath, params.diagnostics)
-
-      // Notify listeners with debounce
-      const listener = diagnosticsListeners.find(l => l.path === filePath)
-      if (listener) {
-        if (listener.timer) { clearTimeout(listener.timer) }
-        listener.timer = setTimeout(() => {
-          diagnosticsListeners = diagnosticsListeners.filter(
-            l => l !== listener,
-          )
-          listener.resolve()
-        }, DIAGNOSTICS_DEBOUNCE_MS)
-      }
-
-      input.onDiagnostics?.(filePath, input.serverID)
+      applyDiagnostics(normalizePath(fileURLToPath(params.uri)), params.diagnostics)
     },
   )
 
@@ -108,7 +172,7 @@ export async function createLSPClient(input: {
   connection.listen()
 
   // Initialize LSP connection
-  await withTimeout(
+  const initializeResult = (await withTimeout(
     connection.sendRequest('initialize', {
       rootUri: pathToFileURL(input.root).href,
       processId: input.server.process.pid,
@@ -125,12 +189,19 @@ export async function createLSPClient(input: {
         textDocument: {
           synchronization: { didOpen: true, didChange: true },
           publishDiagnostics: { versionSupport: true },
+          // Advertise pull-diagnostics support so servers that report via the
+          // pull model (e.g. typescript-go / tsgo) enable their provider.
+          diagnostic: { dynamicRegistration: false },
           rename: { prepareSupport: true },
         },
       },
     }),
     INITIALIZE_TIMEOUT_MS,
-  )
+  )) as { capabilities?: { diagnosticProvider?: unknown } } | undefined
+
+  // A server that advertises a diagnostic provider reports diagnostics via the
+  // pull model (textDocument/diagnostic) instead of pushing publishDiagnostics.
+  supportsPullDiagnostics = Boolean(initializeResult?.capabilities?.diagnosticProvider)
 
   await connection.sendNotification('initialized', {})
 
@@ -169,6 +240,7 @@ export async function createLSPClient(input: {
             },
             contentChanges: [{ text }],
           })
+          void pullDiagnostics(filePath)
           return
         }
 
@@ -185,6 +257,7 @@ export async function createLSPClient(input: {
             text,
           },
         })
+        void pullDiagnostics(filePath)
       },
 
       async close(fileInput: { path: string }) {
@@ -200,7 +273,12 @@ export async function createLSPClient(input: {
           },
         })
         delete files[filePath]
-        diagnostics.delete(normalizePath(filePath))
+        const normalizedPath = normalizePath(filePath)
+        diagnosticPullTokens[normalizedPath]?.cancel()
+        diagnosticPullTokens[normalizedPath]?.dispose()
+        delete diagnosticPullTokens[normalizedPath]
+        delete diagnosticPulls[normalizedPath]
+        diagnostics.delete(normalizedPath)
       },
     },