ttsc 0.11.0 → 0.12.0

package/{driver → internal/lspserver}/lsp_envelope.go

@@ -1,12 +1,12 @@
-package driver
+package lspserver
 
 import (
-  "bytes"
-  "encoding/json"
-  "errors"
-  "fmt"
-  "strconv"
-  "strings"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
 )
 
 // ErrInvalidJSONRPC is returned by ParseEnvelope when the body has a
@@ -19,12 +19,12 @@ var ErrInvalidJSONRPC = errors.New("lsp: jsonrpc field must be \"2.0\"")
 // because LSP allows both numbers and strings and we must round-trip
 // whichever shape the editor used in correlating responses.
 type Envelope struct {
-  JSONRPC string          `json:"jsonrpc,omitempty"`
-  ID      json.RawMessage `json:"id,omitempty"`
-  Method  string          `json:"method,omitempty"`
-  Params  json.RawMessage `json:"params,omitempty"`
-  Result  json.RawMessage `json:"result,omitempty"`
-  Error   json.RawMessage `json:"error,omitempty"`
+	JSONRPC string          `json:"jsonrpc,omitempty"`
+	ID      json.RawMessage `json:"id,omitempty"`
+	Method  string          `json:"method,omitempty"`
+	Params  json.RawMessage `json:"params,omitempty"`
+	Result  json.RawMessage `json:"result,omitempty"`
+	Error   json.RawMessage `json:"error,omitempty"`
 }
 
 // ParseEnvelope decodes the JSON-RPC envelope without consuming the
@@ -32,31 +32,31 @@ type Envelope struct {
 // matches the LSP base protocol's forward-compatibility expectation. A
 // non-empty `jsonrpc` value other than "2.0" is rejected.
 func ParseEnvelope(body []byte) (Envelope, error) {
-  var env Envelope
-  if err := json.Unmarshal(body, &env); err != nil {
-    return Envelope{}, fmt.Errorf("lsp: envelope decode: %w", err)
-  }
-  if env.JSONRPC != "" && env.JSONRPC != "2.0" {
-    return Envelope{}, fmt.Errorf("%w (got %q)", ErrInvalidJSONRPC, env.JSONRPC)
-  }
-  return env, nil
+	var env Envelope
+	if err := json.Unmarshal(body, &env); err != nil {
+		return Envelope{}, fmt.Errorf("lsp: envelope decode: %w", err)
+	}
+	if env.JSONRPC != "" && env.JSONRPC != "2.0" {
+		return Envelope{}, fmt.Errorf("%w (got %q)", ErrInvalidJSONRPC, env.JSONRPC)
+	}
+	return env, nil
 }
 
 // IsRequest reports whether the envelope represents a request expecting
 // a response (id present, method present).
 func (e Envelope) IsRequest() bool {
-  return len(e.ID) > 0 && e.Method != ""
+	return len(e.ID) > 0 && e.Method != ""
 }
 
 // IsNotification reports whether the envelope is a one-way notification.
 func (e Envelope) IsNotification() bool {
-  return len(e.ID) == 0 && e.Method != ""
+	return len(e.ID) == 0 && e.Method != ""
 }
 
 // IsResponse reports whether the envelope is a response (id present,
 // method absent — either result or error will be set).
 func (e Envelope) IsResponse() bool {
-  return len(e.ID) > 0 && e.Method == ""
+	return len(e.ID) > 0 && e.Method == ""
 }
 
 // IsErrorResponse reports whether a response envelope carries an error
@@ -64,7 +64,7 @@ func (e Envelope) IsResponse() bool {
 // on the same response, so the proxy uses this to skip merging plugin
 // contributions into upstream failures.
 func (e Envelope) IsErrorResponse() bool {
-  return e.IsResponse() && len(e.Error) > 0 && !bytes.Equal(bytes.TrimSpace(e.Error), []byte("null"))
+	return e.IsResponse() && len(e.Error) > 0 && !bytes.Equal(bytes.TrimSpace(e.Error), []byte("null"))
 }
 
 // IDKey returns a stable string key for matching request and response
@@ -76,7 +76,13 @@ func (e Envelope) IsErrorResponse() bool {
 // (LSP forbids these as request ids) produce the empty key, which
 // callers treat as "no entry".
 func (e Envelope) IDKey() string {
-  return idKeyFromRaw(e.ID)
+	return idKeyFromRaw(e.ID)
+}
+
+// IDKeyFromRaw exposes the shared id-key normalizer to the public driver
+// compatibility layer without exporting the helper from that package.
+func IDKeyFromRaw(raw json.RawMessage) string {
+	return idKeyFromRaw(raw)
 }
 
 // idKeyFromRaw normalizes a raw id payload the same way IDKey does so
@@ -95,42 +101,42 @@ func (e Envelope) IDKey() string {
 // (boolean, null, array, object — none of which LSP allows for ids)
 // falls through to the empty key, which callers treat as "no entry".
 func idKeyFromRaw(raw json.RawMessage) string {
-  if len(raw) == 0 {
-    return ""
-  }
-  dec := json.NewDecoder(bytes.NewReader(raw))
-  dec.UseNumber()
-  var decoded any
-  if err := dec.Decode(&decoded); err != nil {
-    return ""
-  }
-  switch v := decoded.(type) {
-  case json.Number:
-    lit := v.String()
-    if !strings.ContainsAny(lit, ".eE") {
-      // Integer-shaped literal. Use int64 when it fits so leading
-      // zeros and minus signs canonicalize, but preserve the literal
-      // for past-int64 ids — Float64 normalization would silently
-      // round 9999999999999999998 and 9999999999999999999 to the
-      // same key.
-      if n, err := v.Int64(); err == nil {
-        return strconv.FormatInt(n, 10)
-      }
-      return lit
-    }
-    // Float-shaped literal (`1.0`, `1.5`, `1e2`). Collapse to integer
-    // form only when the value is exactly representable as int64;
-    // 2^53 bounds the safe range because float64 loses unit precision
-    // past that magnitude.
-    if f, err := v.Float64(); err == nil {
-      const maxSafeFloat = float64(int64(1) << 53)
-      if f >= -maxSafeFloat && f <= maxSafeFloat && f == float64(int64(f)) {
-        return strconv.FormatInt(int64(f), 10)
-      }
-    }
-    return lit
-  case string:
-    return strconv.Quote(v)
-  }
-  return ""
+	if len(raw) == 0 {
+		return ""
+	}
+	dec := json.NewDecoder(bytes.NewReader(raw))
+	dec.UseNumber()
+	var decoded any
+	if err := dec.Decode(&decoded); err != nil {
+		return ""
+	}
+	switch v := decoded.(type) {
+	case json.Number:
+		lit := v.String()
+		if !strings.ContainsAny(lit, ".eE") {
+			// Integer-shaped literal. Use int64 when it fits so leading
+			// zeros and minus signs canonicalize, but preserve the literal
+			// for past-int64 ids — Float64 normalization would silently
+			// round 9999999999999999998 and 9999999999999999999 to the
+			// same key.
+			if n, err := v.Int64(); err == nil {
+				return strconv.FormatInt(n, 10)
+			}
+			return lit
+		}
+		// Float-shaped literal (`1.0`, `1.5`, `1e2`). Collapse to integer
+		// form only when the value is exactly representable as int64;
+		// 2^53 bounds the safe range because float64 loses unit precision
+		// past that magnitude.
+		if f, err := v.Float64(); err == nil {
+			const maxSafeFloat = float64(int64(1) << 53)
+			if f >= -maxSafeFloat && f <= maxSafeFloat && f == float64(int64(f)) {
+				return strconv.FormatInt(int64(f), 10)
+			}
+		}
+		return lit
+	case string:
+		return strconv.Quote(v)
+	}
+	return ""
 }

package/{driver → internal/lspserver}/lsp_frame.go

@@ -1,5 +1,5 @@
 // JSON-RPC Content-Length framing as used by LSP over stdio. ttscserver
-// embeds tsgo's LSP server but sits between it and the editor so it can
+// wraps tsgo's LSP server but sits between it and the editor so it can
 // merge plugin diagnostics into outgoing publishDiagnostics and inject
 // ttsc-owned code actions. Both legs of the proxy work on raw bytes.
 //
@@ -8,15 +8,15 @@
 // by WriteFrame include only Content-Length. That is intentional — the
 // LSP base protocol marks every other header optional and editors in
 // the wild do not require them on server output.
-package driver
+package lspserver
 
 import (
-  "bufio"
-  "errors"
-  "fmt"
-  "io"
-  "strconv"
-  "strings"
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
 )
 
 // ErrFrameClosed reports a clean EOF between frames. Callers use it to
@@ -40,69 +40,69 @@ const MaxFrameBytes = 64 << 20
 // peer sent) and strict about the Content-Length value because tsgo's
 // upstream writer always emits one.
 type FrameReader struct {
-  br *bufio.Reader
+	br *bufio.Reader
 }
 
 // NewFrameReader wraps r with an internal buffered reader. r is consumed
 // lazily; the underlying reader is never closed by the FrameReader.
 func NewFrameReader(r io.Reader) *FrameReader {
-  return &FrameReader{br: bufio.NewReader(r)}
+	return &FrameReader{br: bufio.NewReader(r)}
 }
 
 // Read returns the next message body together with the raw header block
 // (without trailing CRLFCRLF). The header block is preserved so callers
 // that proxy traffic verbatim do not lose Content-Type or vendor headers.
 func (fr *FrameReader) Read() (headers string, body []byte, err error) {
-  var headerBuf strings.Builder
-  contentLength := -1
-  for {
-    line, lineErr := fr.br.ReadString('\n')
-    if lineErr != nil {
-      if lineErr == io.EOF && headerBuf.Len() == 0 && line == "" {
-        return "", nil, ErrFrameClosed
-      }
-      return "", nil, fmt.Errorf("lsp: header read: %w", lineErr)
-    }
-    trimmed := strings.TrimRight(line, "\r\n")
-    if trimmed == "" {
-      break
-    }
-    headerBuf.WriteString(line)
-    if value, ok := parseContentLength(trimmed); ok {
-      contentLength = value
-    }
-  }
-  if contentLength < 0 {
-    return "", nil, errors.New("lsp: missing Content-Length header")
-  }
-  if contentLength > MaxFrameBytes {
-    return "", nil, fmt.Errorf("%w (got %d, max %d)", ErrFrameTooLarge, contentLength, MaxFrameBytes)
-  }
-  body = make([]byte, contentLength)
-  if _, err := io.ReadFull(fr.br, body); err != nil {
-    return "", nil, fmt.Errorf("lsp: body read: %w", err)
-  }
-  return headerBuf.String(), body, nil
+	var headerBuf strings.Builder
+	contentLength := -1
+	for {
+		line, lineErr := fr.br.ReadString('\n')
+		if lineErr != nil {
+			if lineErr == io.EOF && headerBuf.Len() == 0 && line == "" {
+				return "", nil, ErrFrameClosed
+			}
+			return "", nil, fmt.Errorf("lsp: header read: %w", lineErr)
+		}
+		trimmed := strings.TrimRight(line, "\r\n")
+		if trimmed == "" {
+			break
+		}
+		headerBuf.WriteString(line)
+		if value, ok := parseContentLength(trimmed); ok {
+			contentLength = value
+		}
+	}
+	if contentLength < 0 {
+		return "", nil, errors.New("lsp: missing Content-Length header")
+	}
+	if contentLength > MaxFrameBytes {
+		return "", nil, fmt.Errorf("%w (got %d, max %d)", ErrFrameTooLarge, contentLength, MaxFrameBytes)
+	}
+	body = make([]byte, contentLength)
+	if _, err := io.ReadFull(fr.br, body); err != nil {
+		return "", nil, fmt.Errorf("lsp: body read: %w", err)
+	}
+	return headerBuf.String(), body, nil
 }
 
 // parseContentLength extracts the integer value of a Content-Length header.
 // Header names are case-insensitive per the LSP base protocol; tsgo emits
 // "Content-Length" but some clients downcase, so we normalize here.
 func parseContentLength(line string) (int, bool) {
-  colon := strings.IndexByte(line, ':')
-  if colon < 0 {
-    return 0, false
-  }
-  name := strings.TrimSpace(line[:colon])
-  if !strings.EqualFold(name, "Content-Length") {
-    return 0, false
-  }
-  value := strings.TrimSpace(line[colon+1:])
-  n, err := strconv.Atoi(value)
-  if err != nil || n < 0 {
-    return 0, false
-  }
-  return n, true
+	colon := strings.IndexByte(line, ':')
+	if colon < 0 {
+		return 0, false
+	}
+	name := strings.TrimSpace(line[:colon])
+	if !strings.EqualFold(name, "Content-Length") {
+		return 0, false
+	}
+	value := strings.TrimSpace(line[colon+1:])
+	n, err := strconv.Atoi(value)
+	if err != nil || n < 0 {
+		return 0, false
+	}
+	return n, true
 }
 
 // WriteFrame serializes body with a Content-Length header to w. The header
@@ -110,12 +110,12 @@ func parseContentLength(line string) (int, bool) {
 // that strict-parse the header block (notably VSCode's client) accept the
 // message without warnings.
 func WriteFrame(w io.Writer, body []byte) error {
-  header := fmt.Sprintf("Content-Length: %d\r\n\r\n", len(body))
-  if _, err := io.WriteString(w, header); err != nil {
-    return fmt.Errorf("lsp: header write: %w", err)
-  }
-  if _, err := w.Write(body); err != nil {
-    return fmt.Errorf("lsp: body write: %w", err)
-  }
-  return nil
+	header := fmt.Sprintf("Content-Length: %d\r\n\r\n", len(body))
+	if _, err := io.WriteString(w, header); err != nil {
+		return fmt.Errorf("lsp: header write: %w", err)
+	}
+	if _, err := w.Write(body); err != nil {
+		return fmt.Errorf("lsp: body write: %w", err)
+	}
+	return nil
 }

package/{driver → internal/lspserver}/lsp_plugin.go

@@ -1,4 +1,4 @@
-package driver
+package lspserver
 
 import "encoding/json"
 
@@ -7,14 +7,14 @@ import "encoding/json"
 // surface stays narrow; the merger marshals them straight into the array
 // the editor already expects.
 type LSPPosition struct {
-  Line      int `json:"line"`
-  Character int `json:"character"`
+	Line      int `json:"line"`
+	Character int `json:"character"`
 }
 
 // LSPRange is the closed-open [start, end) interval LSP uses for ranges.
 type LSPRange struct {
-  Start LSPPosition `json:"start"`
-  End   LSPPosition `json:"end"`
+	Start LSPPosition `json:"start"`
+	End   LSPPosition `json:"end"`
 }
 
 // LSPDiagnosticSeverity values match the LSP enum exactly so editors
@@ -22,66 +22,66 @@ type LSPRange struct {
 type LSPDiagnosticSeverity int
 
 const (
-  // LSPDiagnosticSeverityError is the most prominent severity; ttsc maps
-  // build-blocking findings (lint errors, parse errors) to it.
-  LSPDiagnosticSeverityError LSPDiagnosticSeverity = 1
-  // LSPDiagnosticSeverityWarning is rendered as a yellow squiggle in
-  // typical editor themes; ttsc maps lint warnings to it.
-  LSPDiagnosticSeverityWarning LSPDiagnosticSeverity = 2
-  // LSPDiagnosticSeverityInformation is rendered as a blue squiggle.
-  LSPDiagnosticSeverityInformation LSPDiagnosticSeverity = 3
-  // LSPDiagnosticSeverityHint is rendered as a faint underline or dots.
-  LSPDiagnosticSeverityHint LSPDiagnosticSeverity = 4
+	// LSPDiagnosticSeverityError is the most prominent severity; ttsc maps
+	// build-blocking findings (lint errors, parse errors) to it.
+	LSPDiagnosticSeverityError LSPDiagnosticSeverity = 1
+	// LSPDiagnosticSeverityWarning is rendered as a yellow squiggle in
+	// typical editor themes; ttsc maps lint warnings to it.
+	LSPDiagnosticSeverityWarning LSPDiagnosticSeverity = 2
+	// LSPDiagnosticSeverityInformation is rendered as a blue squiggle.
+	LSPDiagnosticSeverityInformation LSPDiagnosticSeverity = 3
+	// LSPDiagnosticSeverityHint is rendered as a faint underline or dots.
+	LSPDiagnosticSeverityHint LSPDiagnosticSeverity = 4
 )
 
 // LSPDiagnostic is the minimal subset of the LSP Diagnostic type
 // ttscserver injects into outgoing publishDiagnostics. omitempty is set
 // on optional fields so the merged JSON stays close to what tsgo emits.
 type LSPDiagnostic struct {
-  Range    LSPRange              `json:"range"`
-  Severity LSPDiagnosticSeverity `json:"severity,omitempty"`
-  Code     any                   `json:"code,omitempty"`
-  Source   string                `json:"source,omitempty"`
-  Message  string                `json:"message"`
+	Range    LSPRange              `json:"range"`
+	Severity LSPDiagnosticSeverity `json:"severity,omitempty"`
+	Code     any                   `json:"code,omitempty"`
+	Source   string                `json:"source,omitempty"`
+	Message  string                `json:"message"`
 }
 
 // LSPCodeAction is the minimal Code Action shape ttscserver returns from
 // the textDocument/codeAction handler. ttsc actions are always command-
 // driven (the server side does the heavy lifting) so Edit stays nil.
 type LSPCodeAction struct {
-  Title     string          `json:"title"`
-  Kind      string          `json:"kind,omitempty"`
-  Command   *LSPCommand     `json:"command,omitempty"`
-  Edit      json.RawMessage `json:"edit,omitempty"`
-  IsPreferred bool          `json:"isPreferred,omitempty"`
+	Title       string          `json:"title"`
+	Kind        string          `json:"kind,omitempty"`
+	Command     *LSPCommand     `json:"command,omitempty"`
+	Edit        json.RawMessage `json:"edit,omitempty"`
+	IsPreferred bool            `json:"isPreferred,omitempty"`
 }
 
 // LSPCommand is the wire shape of a workspace/executeCommand target.
 type LSPCommand struct {
-  Title     string            `json:"title"`
-  Command   string            `json:"command"`
-  Arguments []json.RawMessage `json:"arguments,omitempty"`
+	Title     string            `json:"title"`
+	Command   string            `json:"command"`
+	Arguments []json.RawMessage `json:"arguments,omitempty"`
 }
 
 // LSPCodeActionContext mirrors the context object the editor sends with
 // textDocument/codeAction. Only the diagnostics slice is consumed by
 // ttsc; the rest is opaque and forwarded by Proxy verbatim.
 type LSPCodeActionContext struct {
-  Diagnostics []json.RawMessage `json:"diagnostics,omitempty"`
-  Only        []string          `json:"only,omitempty"`
-  TriggerKind int               `json:"triggerKind,omitempty"`
+	Diagnostics []json.RawMessage `json:"diagnostics,omitempty"`
+	Only        []string          `json:"only,omitempty"`
+	TriggerKind int               `json:"triggerKind,omitempty"`
 }
 
 // LSPWorkspaceEdit is the wire shape ttscserver returns from custom
 // executeCommand handlers. It maps URIs to ordered text edits.
 type LSPWorkspaceEdit struct {
-  Changes map[string][]LSPTextEdit `json:"changes,omitempty"`
+	Changes map[string][]LSPTextEdit `json:"changes,omitempty"`
 }
 
 // LSPTextEdit is a single text edit in a workspace edit.
 type LSPTextEdit struct {
-  Range   LSPRange `json:"range"`
-  NewText string   `json:"newText"`
+	Range   LSPRange `json:"range"`
+	NewText string   `json:"newText"`
 }
 
 // LSPDocumentVersion carries the LSP textDocument version associated
@@ -93,8 +93,8 @@ type LSPTextEdit struct {
 // Version is nil when upstream omitted the field — that is legal in
 // LSP and the plugin source should treat it as "version unknown".
 type LSPDocumentVersion struct {
-  URI     string
-  Version *int
+	URI     string
+	Version *int
 }
 
 // PluginSource is the seam between the LSP proxy and ttsc's plugin
@@ -104,26 +104,26 @@ type LSPDocumentVersion struct {
 // The proxy never holds a PluginSource lock across upstream traffic, so
 // implementations must be safe to call from multiple goroutines.
 type PluginSource interface {
-  // Diagnostics returns ttsc plugin diagnostics for the document the
-  // proxy is about to publish. doc.Version is nil when upstream omitted
-  // the field. The proxy appends these to whatever upstream tsgo
-  // published, so duplicates between ttsc and tsgo must be deduplicated
-  // on the source side.
-  Diagnostics(doc LSPDocumentVersion) []LSPDiagnostic
-
-  // CodeActions contributes additional actions for the given range. The
-  // proxy appends them to the upstream tsgo response.
-  CodeActions(uri string, rng LSPRange, ctx LSPCodeActionContext) []LSPCodeAction
-
-  // ExecuteCommand handles workspace/executeCommand requests whose
-  // command id ttsc owns (CommandIDs reports the prefix). A nil edit
-  // means the command ran but produced no workspace changes; a non-nil
-  // error surfaces as an LSP error response.
-  ExecuteCommand(command string, args []json.RawMessage) (*LSPWorkspaceEdit, error)
-
-  // CommandIDs lists the workspace command ids ttsc handles locally so
-  // the proxy never forwards them to upstream tsgo.
-  CommandIDs() []string
+	// Diagnostics returns ttsc plugin diagnostics for the document the
+	// proxy is about to publish. doc.Version is nil when upstream omitted
+	// the field. The proxy appends these to whatever upstream tsgo
+	// published, so duplicates between ttsc and tsgo must be deduplicated
+	// on the source side.
+	Diagnostics(doc LSPDocumentVersion) []LSPDiagnostic
+
+	// CodeActions contributes additional actions for the given range. The
+	// proxy appends them to the upstream tsgo response.
+	CodeActions(uri string, rng LSPRange, ctx LSPCodeActionContext) []LSPCodeAction
+
+	// ExecuteCommand handles workspace/executeCommand requests whose
+	// command id appears in CommandIDs. A nil edit
+	// means the command ran but produced no workspace changes; a non-nil
+	// error surfaces as an LSP error response.
+	ExecuteCommand(command string, args []json.RawMessage) (*LSPWorkspaceEdit, error)
+
+	// CommandIDs lists the workspace command ids ttsc handles locally so
+	// the proxy never forwards them to upstream tsgo.
+	CommandIDs() []string
 }
 
 // NullPluginSource is the zero-contribution PluginSource used when the
@@ -137,12 +137,12 @@ func (NullPluginSource) Diagnostics(LSPDocumentVersion) []LSPDiagnostic { return
 
 // CodeActions returns no plugin code actions.
 func (NullPluginSource) CodeActions(string, LSPRange, LSPCodeActionContext) []LSPCodeAction {
-  return nil
+	return nil
 }
 
 // ExecuteCommand reports that the command is not handled.
 func (NullPluginSource) ExecuteCommand(string, []json.RawMessage) (*LSPWorkspaceEdit, error) {
-  return nil, ErrCommandNotHandled
+	return nil, ErrCommandNotHandled
 }
 
 // CommandIDs returns an empty slice so the proxy forwards every command