ttsc 0.14.0-dev.20260528.1 → 0.14.0-dev.20260529.2

package/README.md

@@ -2,17 +2,11 @@
 
 ![banner of ttsc](https://ttsc.dev/og.jpg)
 
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/ttsc/blob/master/LICENSE)
-[![NPM Version](https://img.shields.io/npm/v/ttsc.svg)](https://www.npmjs.com/package/ttsc)
-[![NPM Downloads](https://img.shields.io/npm/dm/ttsc.svg)](https://www.npmjs.com/package/ttsc)
-[![Build Status](https://github.com/samchon/ttsc/workflows/test/badge.svg)](https://github.com/samchon/ttsc/actions?query=workflow%3Atest)
-[![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://ttsc.dev/docs)
-[![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/ttsc/blob/master/LICENSE) [![NPM Version](https://img.shields.io/npm/v/ttsc.svg)](https://www.npmjs.com/package/ttsc) [![NPM Downloads](https://img.shields.io/npm/dm/ttsc.svg)](https://www.npmjs.com/package/ttsc) [![Build Status](https://github.com/samchon/ttsc/workflows/test/badge.svg)](https://github.com/samchon/ttsc/actions?query=workflow%3Atest) [![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://ttsc.dev/docs) [![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
 
 A `typescript-go` toolchain for compiler-powered plugins and type-safe execution.
 
-Benchmarked on the VS Code fixture: up to **10x** faster type checks and a
-**500x** faster measured lint pass.
+Benchmarked on the VS Code fixture: up to **10x** faster type checks and a **500x** faster measured lint pass.
 
 - **`ttsc`**: build, check, and transform.
 - **`ttsx`**: execute TypeScript with type checking.
@@ -55,14 +49,23 @@ Rewrite source files in place with the `@ttsc/lint` format rules:
 npx ttsc format
 ```
 
-### Editor
+### VSCode Extension
 
-Install the VS Code extension for live TypeScript-Go editor features plus
-saved-state ttsc plugin diagnostics and actions:
+Install the VS Code extension for live TypeScript-Go editor features plus saved-state ttsc plugin diagnostics and actions:
 
 ```bash
+npm install -D ttsc @ttsc/lint @typescript/native-preview
 npm install -D @ttsc/vscode
-npx ttsc-vscode
+npx @ttsc/vscode
+```
+
+Then turn on format-on-save in `.vscode/settings.json`:
+
+```jsonc
+"[typescript][typescriptreact]": {
+  "editor.defaultFormatter": "samchon.ttsc",
+  "editor.formatOnSave": true
+}
 ```
 
 See [`@ttsc/vscode`](https://github.com/samchon/ttsc/tree/master/packages/vscode) for requirements, settings, and uninstall.
@@ -191,11 +194,7 @@ if (result.type === "success") {
 }
 ```
 
-See the [Programmatic API guide](https://ttsc.dev/docs/ttsc/api) for the full
-lifecycle, plugin overrides, and patterns. For browser embedding, see
-[`@ttsc/wasm`](https://github.com/samchon/ttsc/tree/master/packages/wasm) and
-the higher-level [`@ttsc/playground`](https://github.com/samchon/ttsc/tree/master/packages/playground)
-package.
+See the [Programmatic API guide](https://ttsc.dev/docs/ttsc/api) for the full lifecycle, plugin overrides, and patterns. For browser embedding, see [`@ttsc/wasm`](https://github.com/samchon/ttsc/tree/master/packages/wasm) and the higher-level [`@ttsc/playground`](https://github.com/samchon/ttsc/tree/master/packages/playground) package.
 
 ### List of Plugins
 

package/internal/lspserver/lsp_native_plugin_source.go

@@ -191,6 +191,19 @@ func (s *NativePluginSource) CodeActions(uri string, rng LSPRange, ctx LSPCodeAc
 // ExecuteCommand routes a ttsc-owned workspace command to the sidecar that
 // advertised it through lsp-command-ids.
 func (s *NativePluginSource) ExecuteCommand(command string, args []json.RawMessage) (*LSPWorkspaceEdit, error) {
+  return s.ExecuteCommandWithContent(command, args, "", false)
+}
+
+// ExecuteCommandWithContent runs a ttsc-owned workspace command like
+// ExecuteCommand, but when hasContent is true it asks the sidecar to format the
+// supplied buffer text instead of the on-disk file. The buffer is passed by
+// adding the --content-stdin flag and piping content to the sidecar's stdin, so
+// the proxy can format dirty editor buffers (formatOnSave) without first writing
+// them to disk. hasContent — not content != "" — gates the in-memory path: an
+// empty buffer the user cleared is a valid document state and must still format
+// in-memory (to a no-op) rather than falling through to stale disk content.
+// Decoding of the returned WorkspaceEdit is identical to ExecuteCommand.
+func (s *NativePluginSource) ExecuteCommandWithContent(command string, args []json.RawMessage, content string, hasContent bool) (*LSPWorkspaceEdit, error) {
   if s == nil {
     return nil, ErrCommandNotHandled
   }
@@ -199,12 +212,16 @@ func (s *NativePluginSource) ExecuteCommand(command string, args []json.RawMessa
     return nil, ErrCommandNotHandled
   }
   argsJSON, _ := json.Marshal(args)
-  body, err := s.run(
-    plugin,
-    "lsp-execute-command",
-    "--command="+command,
-    "--arguments-json="+string(argsJSON),
-  )
+  cmdArgs := []string{
+    "--command=" + command,
+    "--arguments-json=" + string(argsJSON),
+  }
+  var stdin io.Reader
+  if hasContent {
+    cmdArgs = append(cmdArgs, "--content-stdin")
+    stdin = strings.NewReader(content)
+  }
+  body, err := s.runWithStdin(plugin, "lsp-execute-command", stdin, cmdArgs...)
   if err != nil {
     return nil, err
   }
@@ -317,6 +334,14 @@ func (s *NativePluginSource) pluginOwnsCommand(plugin NativeLSPPluginEntry, comm
 }
 
 func (s *NativePluginSource) run(plugin NativeLSPPluginEntry, command string, args ...string) ([]byte, error) {
+  return s.runWithStdin(plugin, command, nil, args...)
+}
+
+// runWithStdin runs a sidecar subcommand like run, additionally wiring stdin to
+// the supplied reader when it is non-nil. Callers that do not pass buffer text
+// (Diagnostics, CodeActions, discovery) reach this through run with a nil
+// reader, leaving the sidecar's stdin unset exactly as before.
+func (s *NativePluginSource) runWithStdin(plugin NativeLSPPluginEntry, command string, stdin io.Reader, args ...string) ([]byte, error) {
   if strings.TrimSpace(plugin.Binary) == "" {
     return nil, fmt.Errorf("ttscserver: %s has no binary", pluginLabel(plugin))
   }
@@ -332,6 +357,9 @@ func (s *NativePluginSource) run(plugin NativeLSPPluginEntry, command string, ar
   cmd := exec.CommandContext(ctx, plugin.Binary, allArgs...)
   cmd.Dir = s.cwd
   cmd.Env = os.Environ()
+  if stdin != nil {
+    cmd.Stdin = stdin
+  }
   stdout := limitedBuffer{limit: nativePluginCommandStdoutLimit}
   stderr := limitedBuffer{limit: nativePluginCommandStderrLimit}
   cmd.Stdout = &stdout

package/internal/lspserver/lsp_proxy.go

@@ -31,8 +31,15 @@ const (
   methodCodeAction         = "textDocument/codeAction"
   methodExecuteCommand     = "workspace/executeCommand"
   methodCancelRequest      = "$/cancelRequest"
+  methodFormatting         = "textDocument/formatting"
 )
 
+// formatDocumentCommand is the ttsc-owned workspace command that the lint
+// sidecar advertises for whole-document formatting. The textDocument/formatting
+// handler routes the cached editor buffer through this command so formatOnSave
+// formats the live (possibly dirty) buffer rather than the on-disk file.
+const formatDocumentCommand = "ttsc.format.document"
+
 // ProxyOptions wires the byte-level proxy together. ttscserver creates
 // the upstream pipes around `tsgo --lsp --stdio` and hands the proxy
 // editor stdio plus those pipe ends.
@@ -88,6 +95,15 @@ type Proxy struct {
   documentGeneration   map[string]uint64
   dirtyDocuments       map[string]struct{}
   dirtyVersions        map[string]*int
+  // documentText caches the live editor buffer per uri so the
+  // textDocument/formatting handler can format the in-memory text instead
+  // of the on-disk file. Entries are present only while the proxy holds a
+  // trustworthy full-document copy: didOpen / full-sync didChange populate
+  // it, incremental didChange (a contentChange carrying a range) and
+  // didClose evict it, and the formatting handler falls back to a disk read
+  // when no entry is cached. Guarded by diagnosticsMu like the other
+  // per-uri document state.
+  documentText map[string]string
 }
 
 type pendingCodeActionRequest struct {
@@ -137,6 +153,7 @@ func NewProxy(opts ProxyOptions) *Proxy {
     documentGeneration:             make(map[string]uint64),
     dirtyDocuments:                 make(map[string]struct{}),
     dirtyVersions:                  make(map[string]*int),
+    documentText:                   make(map[string]string),
   }
 }
 
@@ -232,6 +249,7 @@ func (p *Proxy) handleEditorEnvelope(env Envelope, body []byte) (bool, error) {
     }
   case methodDidOpen:
     if env.IsNotification() {
+      p.cacheDidOpenText(env)
       if err := p.publishPluginDiagnosticsForDidOpen(env); err != nil {
         return false, err
       }
@@ -242,18 +260,24 @@ func (p *Proxy) handleEditorEnvelope(env Envelope, body []byte) (bool, error) {
     }
   case methodDidChange:
     if env.IsNotification() {
+      p.cacheDidChangeText(env)
       if err := p.markDocumentDirty(env); err != nil {
         return false, err
       }
     }
   case methodDidClose:
     if env.IsNotification() {
+      p.evictDocumentText(env)
       p.clearDocumentDiagnostics(env)
     }
   case methodExecuteCommand:
     if env.IsRequest() {
       return p.tryExecuteCommand(env)
     }
+  case methodFormatting:
+    if env.IsRequest() {
+      return p.handleFormattingRequest(env)
+    }
   case methodCodeAction:
     if env.IsRequest() {
       return p.handleCodeActionRequest(env)
@@ -433,7 +457,7 @@ func (p *Proxy) pluginOnlyCodeActionKinds() map[string]struct{} {
   kinds := map[string]struct{}{
     "source.fixAll.ttsc": {},
   }
-  if p.ownsCommand("ttsc.format.document") {
+  if p.ownsCommand(formatDocumentCommand) {
     kinds["source.format"] = struct{}{}
   }
   return kinds
@@ -493,6 +517,102 @@ func (p *Proxy) completeExecuteCommand(env Envelope, key string, command string,
   p.reportAsyncError(p.writeExecuteCommandResultIfClean(env.ID, pending, edit))
 }
 
+// contentExecutor is the optional capability a PluginSource exposes to format an
+// in-memory buffer instead of the on-disk file. NativePluginSource implements it
+// by piping the buffer to the sidecar's stdin with --content-stdin; sources that
+// do not implement it fall back to plain ExecuteCommand (disk).
+type contentExecutor interface {
+  ExecuteCommandWithContent(command string, args []json.RawMessage, content string, hasContent bool) (*LSPWorkspaceEdit, error)
+}
+
+// handleFormattingRequest answers textDocument/formatting for the ttsc-owned
+// document formatter. Unlike the workspace/executeCommand path, this handler
+// intentionally formats the live (possibly dirty) editor buffer: it reads the
+// cached buffer text and passes it to the sidecar so formatOnSave works before
+// the file is written to disk. It therefore does NOT go through the
+// dirty-document guard that writeExecuteCommandResultIfClean applies to the
+// executeCommand path.
+//
+// When ttsc does not own ttsc.format.document the request is forwarded to
+// upstream tsgo (return false). The handler never surfaces an error to the
+// editor: on any failure it replies with an empty TextEdit array so a failed
+// formatter cannot break the save.
+func (p *Proxy) handleFormattingRequest(env Envelope) (bool, error) {
+  if !p.ownsCommand(formatDocumentCommand) {
+    return false, nil
+  }
+  var params struct {
+    TextDocument struct {
+      URI string `json:"uri"`
+    } `json:"textDocument"`
+  }
+  if err := json.Unmarshal(env.Params, &params); err != nil || params.TextDocument.URI == "" {
+    return false, nil
+  }
+  uri := params.TextDocument.URI
+  go p.completeFormattingRequest(env, uri)
+  return true, nil
+}
+
+func (p *Proxy) completeFormattingRequest(env Envelope, uri string) {
+  // hasContent distinguishes "the proxy has a buffer to format in-memory" from
+  // "no buffer; let the sidecar read disk". An empty cached buffer is a valid
+  // document state (the user cleared the file), so the empty string must NOT be
+  // overloaded as the no-buffer sentinel: a cache hit always yields
+  // hasContent=true even when the buffer is "".
+  content, hasContent := p.cachedDocumentText(uri)
+  if !hasContent {
+    if file, fileOK := filePathFromURI(uri); fileOK {
+      if disk, err := os.ReadFile(file); err == nil {
+        // Preserve the existing disk-fallback behavior: pipe the disk bytes
+        // via stdin so the sidecar formats exactly what the proxy read.
+        content = string(disk)
+        hasContent = true
+      }
+    }
+  }
+  // A formatter failure must never break the editor's save: reply with an
+  // empty TextEdit[] regardless of the error. The NativePluginSource already
+  // logs the underlying sidecar failure to its own stderr writer, so the proxy
+  // does not need a separate log sink here.
+  edit, err := p.executeFormatCommand(uri, content, hasContent)
+  if err != nil {
+    p.reportAsyncError(p.writeResult(env.ID, []LSPTextEdit{}))
+    return
+  }
+  edits := formattingTextEdits(edit, uri)
+  p.reportAsyncError(p.writeResult(env.ID, edits))
+}
+
+// executeFormatCommand runs ttsc.format.document against the supplied buffer
+// text. The single command argument is the document uri, matching the
+// executeCommand path the sidecar already implements; --content-stdin makes the
+// sidecar format the piped text instead of the disk file when the source
+// supports it.
+func (p *Proxy) executeFormatCommand(uri string, content string, hasContent bool) (*LSPWorkspaceEdit, error) {
+  arg, _ := json.Marshal(uri)
+  args := []json.RawMessage{arg}
+  if executor, ok := p.source.(contentExecutor); ok {
+    return executor.ExecuteCommandWithContent(formatDocumentCommand, args, content, hasContent)
+  }
+  return p.source.ExecuteCommand(formatDocumentCommand, args)
+}
+
+// formattingTextEdits projects a WorkspaceEdit returned by the formatter onto
+// the LSP textDocument/formatting response shape: the array of TextEdits that
+// target uri. A nil edit or a no-op (no changes for uri) yields an empty,
+// non-nil slice so the editor always receives a valid TextEdit[].
+func formattingTextEdits(edit *LSPWorkspaceEdit, uri string) []LSPTextEdit {
+  if edit == nil {
+    return []LSPTextEdit{}
+  }
+  edits, ok := edit.Changes[uri]
+  if !ok || edits == nil {
+    return []LSPTextEdit{}
+  }
+  return edits
+}
+
 // ownsCommand reports whether command is registered with the PluginSource
 // and should be handled locally rather than forwarded to upstream tsgo.
 func (p *Proxy) ownsCommand(command string) bool {
@@ -928,6 +1048,89 @@ func (p *Proxy) clearDocumentDiagnostics(env Envelope) {
   p.documentGeneration[params.TextDocument.URI]++
 }
 
+// cacheDidOpenText stores the buffer text the editor opened so the
+// formatting handler can format the live document. didOpen always carries the
+// full text, so the cache is unconditionally trustworthy here.
+func (p *Proxy) cacheDidOpenText(env Envelope) {
+  var params struct {
+    TextDocument struct {
+      URI  string `json:"uri"`
+      Text string `json:"text"`
+    } `json:"textDocument"`
+  }
+  if err := json.Unmarshal(env.Params, &params); err != nil || params.TextDocument.URI == "" {
+    return
+  }
+  p.diagnosticsMu.Lock()
+  defer p.diagnosticsMu.Unlock()
+  p.documentText[params.TextDocument.URI] = params.TextDocument.Text
+}
+
+// cacheDidChangeText refreshes the buffer cache from a didChange notification.
+// LSP delivers contentChanges either as full-document replacements (no range)
+// or incremental range edits (a range present). The proxy does not control the
+// advertised textDocumentSync kind — tsgo owns the initialize response and ttsc
+// only augments code-action/executeCommand capabilities — so a client may send
+// either shape. The cache is only trustworthy when every change is a full
+// replacement; on an incremental change the proxy evicts the entry so the
+// formatting handler falls back to reading disk rather than formatting stale
+// text.
+func (p *Proxy) cacheDidChangeText(env Envelope) {
+  var params struct {
+    TextDocument struct {
+      URI string `json:"uri"`
+    } `json:"textDocument"`
+    ContentChanges []struct {
+      Range *json.RawMessage `json:"range"`
+      Text  string           `json:"text"`
+    } `json:"contentChanges"`
+  }
+  if err := json.Unmarshal(env.Params, &params); err != nil || params.TextDocument.URI == "" {
+    return
+  }
+  if len(params.ContentChanges) == 0 {
+    return
+  }
+  fullText := ""
+  for _, change := range params.ContentChanges {
+    if change.Range != nil {
+      p.diagnosticsMu.Lock()
+      delete(p.documentText, params.TextDocument.URI)
+      p.diagnosticsMu.Unlock()
+      return
+    }
+    fullText = change.Text
+  }
+  p.diagnosticsMu.Lock()
+  defer p.diagnosticsMu.Unlock()
+  p.documentText[params.TextDocument.URI] = fullText
+}
+
+// evictDocumentText drops the cached buffer for a closed document so a later
+// reopen does not format against the previous session's text.
+func (p *Proxy) evictDocumentText(env Envelope) {
+  var params struct {
+    TextDocument struct {
+      URI string `json:"uri"`
+    } `json:"textDocument"`
+  }
+  if err := json.Unmarshal(env.Params, &params); err != nil || params.TextDocument.URI == "" {
+    return
+  }
+  p.diagnosticsMu.Lock()
+  defer p.diagnosticsMu.Unlock()
+  delete(p.documentText, params.TextDocument.URI)
+}
+
+// cachedDocumentText returns the cached buffer text for uri and whether an
+// entry was present.
+func (p *Proxy) cachedDocumentText(uri string) (string, bool) {
+  p.diagnosticsMu.Lock()
+  defer p.diagnosticsMu.Unlock()
+  text, ok := p.documentText[uri]
+  return text, ok
+}
+
 func (p *Proxy) markDocumentDirty(env Envelope) error {
   var params struct {
     TextDocument struct {
@@ -1176,6 +1379,17 @@ func (p *Proxy) augmentInitializeResult(env Envelope) ([]byte, bool) {
     caps["executeCommandProvider"] = provider
     changed = true
   }
+  // Advertise documentFormattingProvider when ttsc owns the document
+  // formatter so editors send textDocument/formatting (formatOnSave). The
+  // proxy intercepts that method and formats the live buffer, so it forces
+  // the capability on even if upstream tsgo already advertised one — tsgo's
+  // formatter would otherwise format the on-disk file and lose unsaved edits.
+  if p.ownsCommand(formatDocumentCommand) {
+    if existing, ok := caps["documentFormattingProvider"].(bool); !ok || !existing {
+      caps["documentFormattingProvider"] = true
+      changed = true
+    }
+  }
   if !changed {
     return nil, false
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.14.0-dev.20260528.1",
+  "version": "0.14.0-dev.20260529.2",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,13 +32,13 @@
     "rimraf": "^6.1.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.14.0-dev.20260528.1",
-    "@ttsc/linux-arm": "0.14.0-dev.20260528.1",
-    "@ttsc/linux-arm64": "0.14.0-dev.20260528.1",
-    "@ttsc/darwin-x64": "0.14.0-dev.20260528.1",
-    "@ttsc/darwin-arm64": "0.14.0-dev.20260528.1",
-    "@ttsc/win32-x64": "0.14.0-dev.20260528.1",
-    "@ttsc/win32-arm64": "0.14.0-dev.20260528.1"
+    "@ttsc/linux-x64": "0.14.0-dev.20260529.2",
+    "@ttsc/linux-arm": "0.14.0-dev.20260529.2",
+    "@ttsc/linux-arm64": "0.14.0-dev.20260529.2",
+    "@ttsc/darwin-x64": "0.14.0-dev.20260529.2",
+    "@ttsc/darwin-arm64": "0.14.0-dev.20260529.2",
+    "@ttsc/win32-x64": "0.14.0-dev.20260529.2",
+    "@ttsc/win32-arm64": "0.14.0-dev.20260529.2"
   },
   "sideEffects": false,
   "files": [