ttsc 0.11.0 → 0.12.0

package/cmd/ttsc/main_alias_branches_test.go

@@ -0,0 +1,29 @@
+package main
+
+import "testing"
+
+/**
+ * Verifies main command aliases cover flag-shaped demo and cts project inputs.
+ *
+ * The top-level dispatcher treats extension-shaped arguments as build aliases
+ * while demo owns its own flag parser. These small branches keep compatibility
+ * with `ttsc ./tsconfig.cts`-style invocations and malformed demo flags.
+ *
+ * 1. Run demo with a missing flag value.
+ * 2. Dispatch a `.cts` argument through the build alias path.
+ * 3. Assert both routes fail through their intended parser.
+ */
+func TestMainAliasBranches(t *testing.T) {
+	code, _, _ := captureCommand(t, func() int {
+		return run([]string{"demo", "--type"})
+	})
+	if code != 2 {
+		t.Fatalf("demo flag status mismatch: %d", code)
+	}
+	code, _, _ = captureCommand(t, func() int {
+		return run([]string{"project.cts"})
+	})
+	if code != 2 {
+		t.Fatalf("cts build alias status mismatch: %d", code)
+	}
+}

package/cmd/ttscserver/main.go

@@ -1,50 +1,50 @@
-// Command ttscserver is the Go LSP host shipped by ttsc. It embeds
-// TypeScript-Go's LSP server unmodified and proxies traffic between the
-// editor and that server, splicing ttsc-plugin diagnostics, code actions,
-// and ttsc-owned executeCommand handling into the same stream.
+// Command ttscserver is the Go LSP host shipped by ttsc. It wraps the
+// project-selected TypeScript-Go LSP server process and proxies traffic
+// between the editor and that server, splicing ttsc-plugin diagnostics,
+// code actions, and ttsc-owned executeCommand handling into the same stream.
 //
 // The JavaScript launcher (`packages/ttsc/src/launcher/ttscserver.ts`)
 // resolves the native binary and forwards stdio so editors can spawn
 // `ttscserver --stdio` without worrying about platform helper packages.
 //
 // Everything here is deliberately small: flag parsing, version metadata,
-// and a single delegation to driver.RunLSPServer.
+// and a single delegation to lspserver.RunLSPServer.
 package main
 
 import (
-  "context"
-  "errors"
-  "flag"
-  "fmt"
-  "io"
-  "os"
-  "os/signal"
-  "runtime"
-  "strings"
-  "syscall"
-  "time"
-
-  "github.com/samchon/ttsc/packages/ttsc/driver"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // Build metadata; overwritten via -ldflags in release builds.
 var (
-  version = "0.0.0-dev"
-  commit  = "dev"
-  date    = "unknown"
+	version = "0.0.0-dev"
+	commit  = "dev"
+	date    = "unknown"
 )
 
 // Package-level writers so command tests can capture output without
 // patching os.Stdout / os.Stderr globally.
 var (
-  stdout io.Writer = os.Stdout
-  stderr io.Writer = os.Stderr
-  stdin  io.Reader = os.Stdin
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+	stdin  io.Reader = os.Stdin
 )
 
 // runLSPServer is the seam command tests use to substitute a fake LSP
-// host. Production wires it to driver.RunLSPServer.
-var runLSPServer = driver.RunLSPServer
+// host. Production wires it to lspserver.RunLSPServer.
+var runLSPServer = lspserver.RunLSPServer
 
 // notifyContext is the seam command tests use to substitute a
 // deterministic context (no signal hookup) for the signal-aware default.
@@ -56,82 +56,89 @@ var notifyContext = signal.NotifyContext
 var getwd = os.Getwd
 
 func main() {
-  os.Exit(run(os.Args[1:]))
+	os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-  if len(args) == 0 {
-    printHelp(stdout)
-    return 0
-  }
-  switch args[0] {
-  case "-h", "--help", "help":
-    printHelp(stdout)
-    return 0
-  case "-v", "--version", "version":
-    printVersion(stdout)
-    return 0
-  }
-  return runLSP(args)
+	if len(args) == 0 {
+		printHelp(stdout)
+		return 0
+	}
+	switch args[0] {
+	case "-h", "--help", "help":
+		printHelp(stdout)
+		return 0
+	case "-v", "--version", "version":
+		printVersion(stdout)
+		return 0
+	}
+	return runLSP(args)
 }
 
 func runLSP(args []string) int {
-  fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
-  cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
-  progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
-  if !*stdioFlag {
-    fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
-    return 2
-  }
-
-  cwd := strings.TrimSpace(*cwdFlag)
-  if cwd == "" {
-    resolved, err := getwd()
-    if err != nil {
-      fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
-      return 2
-    }
-    cwd = resolved
-  }
-
-  ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-  defer stop()
-
-  err := runLSPServer(ctx, driver.LSPServerOptions{
-    In:            stdin,
-    Out:           stdout,
-    Err:           stderr,
-    Cwd:           cwd,
-    Source:        driver.NullPluginSource{},
-    ProgressDelay: *progressDelayFlag,
-  })
-  if err != nil && !errors.Is(err, context.Canceled) {
-    fmt.Fprintf(stderr, "ttscserver: %v\n", err)
-    return 1
-  }
-  return 0
+	fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
+	cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
+	tsgoFlag := fs.String("tsgo", "", "absolute tsgo binary path (defaults to TTSC_TSGO_BINARY)")
+	progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if !*stdioFlag {
+		fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
+		return 2
+	}
+
+	cwd := strings.TrimSpace(*cwdFlag)
+	if cwd == "" {
+		resolved, err := getwd()
+		if err != nil {
+			fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
+			return 2
+		}
+		cwd = resolved
+	}
+
+	ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	tsgoBinary := strings.TrimSpace(*tsgoFlag)
+	if tsgoBinary == "" {
+		tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
+	}
+
+	err := runLSPServer(ctx, lspserver.LSPServerOptions{
+		In:            stdin,
+		Out:           stdout,
+		Err:           stderr,
+		Cwd:           cwd,
+		TsgoBinary:    tsgoBinary,
+		Source:        lspserver.NullPluginSource{},
+		ProgressDelay: *progressDelayFlag,
+	})
+	if err != nil && !errors.Is(err, context.Canceled) {
+		fmt.Fprintf(stderr, "ttscserver: %v\n", err)
+		return 1
+	}
+	return 0
 }
 
 func printVersion(w io.Writer) {
-  fmt.Fprintf(
-    w,
-    "ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
-    version,
-    commit,
-    date,
-    runtime.GOOS,
-    runtime.GOARCH,
-    runtime.Version(),
-  )
+	fmt.Fprintf(
+		w,
+		"ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
+		version,
+		commit,
+		date,
+		runtime.GOOS,
+		runtime.GOARCH,
+		runtime.Version(),
+	)
 }
 
 func printHelp(w io.Writer) {
-  fmt.Fprintln(w, strings.TrimSpace(`
+	fmt.Fprintln(w, strings.TrimSpace(`
 ttscserver — Language Server Protocol host for ttsc.
 
 Usage:
@@ -141,14 +148,15 @@ Usage:
 
 Options:
   --stdio              Communicate with the editor over stdin/stdout.
-  --cwd <dir>          Project root passed to the embedded tsgo server.
-  --progress-delay D   Delay before tsgo shows its progress UI (default 250ms).
+  --cwd <dir>          Project root used as the tsgo server working directory.
+  --tsgo <path>        Absolute tsgo binary path (defaults to TTSC_TSGO_BINARY).
+  --progress-delay D   Accepted for compatibility; tsgo currently owns this value.
 
 Typical embedding:
   Editors spawn ttscserver via the JavaScript launcher (resolves the
-  per-platform native binary) and exchange LSP messages over stdio. The
-  embedded tsgo server provides hover/completion/definitions/diagnostics;
-  ttsc merges plugin (lint/format) diagnostics, code actions, and ttsc-
-  owned executeCommand handlers into the same stream.
+  per-platform native binary and passes the project tsgo path) and exchange
+  LSP messages over stdio. The upstream tsgo server provides hover,
+  completion, definitions, and diagnostics; ttsc merges plugin diagnostics,
+  code actions, and ttsc-owned executeCommand handlers into the same stream.
 `))
 }

package/cmd/ttscserver/run_lsp_prefers_tsgo_flag_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+)
+
+// TestRunLSPPrefersTsgoFlag verifies the native command forwards an explicit
+// upstream tsgo path into the LSP host options.
+//
+// Editors normally enter through the JavaScript launcher, but direct native
+// callers can pass --tsgo. This pins that flag path separately from the
+// TTSC_TSGO_BINARY environment fallback.
+//
+// 1. Substitute the runLSPServer seam and capture its options.
+// 2. Run runLSP with --stdio, --cwd, and --tsgo.
+// 3. Assert the captured TsgoBinary is the flag value.
+func TestRunLSPPrefersTsgoFlag(t *testing.T) {
+	const expected = "/tmp/tsgo-test-binary"
+	prev := runLSPServer
+	var captured lspserver.LSPServerOptions
+	runLSPServer = func(_ context.Context, opts lspserver.LSPServerOptions) error {
+		captured = opts
+		return nil
+	}
+	defer func() { runLSPServer = prev }()
+
+	outBuf := &bytes.Buffer{}
+	errBuf := &bytes.Buffer{}
+	withIO(t, outBuf, errBuf, nil, func() {
+		if code := runLSP([]string{"--stdio", "--cwd", t.TempDir(), "--tsgo", expected}); code != 0 {
+			t.Fatalf("expected exit 0, got %d (stderr=%q)", code, errBuf.String())
+		}
+	})
+
+	if captured.TsgoBinary != expected {
+		t.Fatalf("expected TsgoBinary %q, got %q", expected, captured.TsgoBinary)
+	}
+}

package/cmd/ttscserver/run_lsp_reports_server_error_test.go

@@ -1,18 +1,17 @@
 package main
 
 import (
-  "bytes"
-  "context"
-  "errors"
-  "io"
-  "strings"
-  "testing"
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
 
-  "github.com/samchon/ttsc/packages/ttsc/driver"
+	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // TestRunLSPReportsServerError pins the non-cancellation error path in
-// runLSP. When RunLSPServer reports a real failure (the embedded server
+// runLSP. When RunLSPServer reports a real failure (the upstream server
 // crashed, an unrecoverable IO error, etc.) the launcher must exit 1
 // and copy the error message to stderr.
 //
@@ -20,23 +19,22 @@ import (
 // 2. Run runLSP with --stdio --cwd <tempdir>.
 // 3. Assert exit 1 and the sentinel text on stderr.
 func TestRunLSPReportsServerError(t *testing.T) {
-  sentinel := errors.New("lsp host blew up")
-  prev := runLSPServer
-  runLSPServer = func(_ context.Context, _ driver.LSPServerOptions) error {
-    return sentinel
-  }
-  defer func() { runLSPServer = prev }()
+	sentinel := errors.New("lsp host blew up")
+	prev := runLSPServer
+	runLSPServer = func(_ context.Context, _ lspserver.LSPServerOptions) error {
+		return sentinel
+	}
+	defer func() { runLSPServer = prev }()
 
-  outBuf := &bytes.Buffer{}
-  errBuf := &bytes.Buffer{}
-  withIO(t, outBuf, errBuf, nil, func() {
-    if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 1 {
-      t.Fatalf("expected exit 1, got %d", code)
-    }
-  })
+	outBuf := &bytes.Buffer{}
+	errBuf := &bytes.Buffer{}
+	withIO(t, outBuf, errBuf, nil, func() {
+		if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 1 {
+			t.Fatalf("expected exit 1, got %d", code)
+		}
+	})
 
-  if !strings.Contains(errBuf.String(), sentinel.Error()) {
-    t.Fatalf("expected sentinel on stderr, got: %q", errBuf.String())
-  }
-  _ = io.Discard
+	if !strings.Contains(errBuf.String(), sentinel.Error()) {
+		t.Fatalf("expected sentinel on stderr, got: %q", errBuf.String())
+	}
 }

package/cmd/ttscserver/run_lsp_uses_tsgo_environment_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+)
+
+// TestRunLSPUsesTsgoEnvironment verifies TTSC_TSGO_BINARY feeds the native host
+// when no --tsgo flag is present.
+//
+// The JavaScript launcher resolves @typescript/native-preview and passes the
+// absolute path through this environment variable, keeping the Go binary thin
+// and independent of Node's module resolver.
+//
+// 1. Set TTSC_TSGO_BINARY to a sentinel path.
+// 2. Substitute runLSPServer and capture its options.
+// 3. Assert TsgoBinary is populated from the environment.
+func TestRunLSPUsesTsgoEnvironment(t *testing.T) {
+	const expected = "/tmp/tsgo-env-binary"
+	t.Setenv("TTSC_TSGO_BINARY", expected)
+
+	prev := runLSPServer
+	var captured lspserver.LSPServerOptions
+	runLSPServer = func(_ context.Context, opts lspserver.LSPServerOptions) error {
+		captured = opts
+		return nil
+	}
+	defer func() { runLSPServer = prev }()
+
+	outBuf := &bytes.Buffer{}
+	errBuf := &bytes.Buffer{}
+	withIO(t, outBuf, errBuf, nil, func() {
+		if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 0 {
+			t.Fatalf("expected exit 0, got %d (stderr=%q)", code, errBuf.String())
+		}
+	})
+
+	if captured.TsgoBinary != expected {
+		t.Fatalf("expected TsgoBinary %q, got %q", expected, captured.TsgoBinary)
+	}
+}

package/cmd/utility-host/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/samchon/ttsc/packages/ttsc/utility"
+)
+
+func main() {
+	os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+	if len(args) == 0 {
+		return utility.RunBuild(nil)
+	}
+	switch args[0] {
+	case "build":
+		return utility.RunBuild(args[1:])
+	case "check":
+		return utility.RunCheck(args[1:])
+	case "transform":
+		return utility.RunTransform(args[1:])
+	case "-h", "--help", "help":
+		printHelp()
+		return 0
+	default:
+		fmt.Fprintf(os.Stderr, "ttsc utility: unknown command %q\n", args[0])
+		fmt.Fprintln(os.Stderr, `ttsc utility: run "help" to see supported commands`)
+		return 2
+	}
+}
+
+func printHelp() {
+	fmt.Fprintln(os.Stdout, `ttsc utility host
+
+Usage:
+  utility-host build --tsconfig=tsconfig.json --plugins-json='[...]'
+  utility-host check --tsconfig=tsconfig.json --plugins-json='[...]'
+  utility-host transform --tsconfig=tsconfig.json --plugins-json='[...]'`)
+}

package/driver/lsp.go

@@ -0,0 +1,60 @@
+package driver
+
+import (
+	"encoding/json"
+
+	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+)
+
+type LSPPosition = lspserver.LSPPosition
+type LSPRange = lspserver.LSPRange
+type LSPDiagnosticSeverity = lspserver.LSPDiagnosticSeverity
+
+const (
+	LSPDiagnosticSeverityError       = lspserver.LSPDiagnosticSeverityError
+	LSPDiagnosticSeverityWarning     = lspserver.LSPDiagnosticSeverityWarning
+	LSPDiagnosticSeverityInformation = lspserver.LSPDiagnosticSeverityInformation
+	LSPDiagnosticSeverityHint        = lspserver.LSPDiagnosticSeverityHint
+)
+
+type LSPDiagnostic = lspserver.LSPDiagnostic
+type LSPCodeAction = lspserver.LSPCodeAction
+type LSPCommand = lspserver.LSPCommand
+type LSPCodeActionContext = lspserver.LSPCodeActionContext
+type LSPWorkspaceEdit = lspserver.LSPWorkspaceEdit
+type LSPTextEdit = lspserver.LSPTextEdit
+type LSPDocumentVersion = lspserver.LSPDocumentVersion
+type PluginSource = lspserver.PluginSource
+type NullPluginSource = lspserver.NullPluginSource
+
+type ProxyOptions = lspserver.ProxyOptions
+type Proxy = lspserver.Proxy
+
+type FrameReader = lspserver.FrameReader
+type Envelope = lspserver.Envelope
+
+type LSPServerOptions = lspserver.LSPServerOptions
+type LSPUpstreamRunner = lspserver.LSPUpstreamRunner
+
+const MaxFrameBytes = lspserver.MaxFrameBytes
+
+var ErrCommandNotHandled = lspserver.ErrCommandNotHandled
+var ErrFrameClosed = lspserver.ErrFrameClosed
+var ErrFrameTooLarge = lspserver.ErrFrameTooLarge
+var ErrInvalidJSONRPC = lspserver.ErrInvalidJSONRPC
+var ErrLSPUpstreamPanic = lspserver.ErrLSPUpstreamPanic
+var ErrLSPCwdRequired = lspserver.ErrLSPCwdRequired
+var ErrLSPTsgoBinaryRequired = lspserver.ErrLSPTsgoBinaryRequired
+
+var NewProxy = lspserver.NewProxy
+var NewFrameReader = lspserver.NewFrameReader
+var WriteFrame = lspserver.WriteFrame
+var ParseEnvelope = lspserver.ParseEnvelope
+var RecoverPanicAs = lspserver.RecoverPanicAs
+var WithUpstreamRunnerForTest = lspserver.WithUpstreamRunnerForTest
+var RunLSPServer = lspserver.RunLSPServer
+var DenyNpmInstall = lspserver.DenyNpmInstall
+
+func idKeyFromRaw(raw json.RawMessage) string {
+	return lspserver.IDKeyFromRaw(raw)
+}

package/driver/plugins.go

@@ -0,0 +1,122 @@
+package driver
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+)
+
+const LinkedPluginsEnv = "TTSC_LINKED_PLUGINS_JSON"
+
+// PluginEntry is the manifest shape ttsc passes to driver-level plugins.
+type PluginEntry struct {
+	Config map[string]any `json:"config"`
+	Name   string         `json:"name"`
+	Stage  string         `json:"stage"`
+}
+
+// PluginContext is the per-entry context passed to registered linked plugins.
+type PluginContext struct {
+	Cwd      string
+	Entry    PluginEntry
+	Tsconfig string
+}
+
+// SourcePreamblePlugin can inject source text before TypeScript-Go parses the
+// project. This is intentionally generic: the driver knows only the registered
+// plugin name and the project plugin manifest.
+type SourcePreamblePlugin interface {
+	SourcePreamble(PluginContext) (string, error)
+}
+
+// ProgramPlugin can mutate a loaded Program before source output or emit.
+type ProgramPlugin interface {
+	ApplyProgram(*Program, PluginContext) error
+}
+
+type linkedPluginState struct {
+	cwd      string
+	entries  []PluginEntry
+	tsconfig string
+}
+
+var pluginRegistry []any
+
+// RegisterPlugin registers a driver-level plugin implementation. Linked Go
+// packages call this from init(); ttsc pairs registrations with linked manifest
+// entries by build order, not by package name.
+func RegisterPlugin(plugin any) {
+	if plugin == nil {
+		panic("driver: RegisterPlugin called with nil plugin")
+	}
+	pluginRegistry = append(pluginRegistry, plugin)
+}
+
+func loadLinkedPluginState(cwd, tsconfigPath string) (linkedPluginState, error) {
+	input := strings.TrimSpace(os.Getenv(LinkedPluginsEnv))
+	if input == "" {
+		return linkedPluginState{cwd: cwd, tsconfig: tsconfigPath}, nil
+	}
+	var entries []PluginEntry
+	if err := json.Unmarshal([]byte(input), &entries); err != nil {
+		return linkedPluginState{}, fmt.Errorf("ttsc driver: invalid %s: %w", LinkedPluginsEnv, err)
+	}
+	return linkedPluginState{
+		cwd:      cwd,
+		entries:  entries,
+		tsconfig: tsconfigPath,
+	}, nil
+}
+
+func (state linkedPluginState) sourcePreamble() (string, error) {
+	var out strings.Builder
+	for index, entry := range state.entries {
+		plugin, ok := registeredPlugin(index)
+		if !ok {
+			return "", fmt.Errorf("ttsc driver: linked plugin entry %d was requested but no linked plugin registered at that position", index)
+		}
+		preamble, ok := plugin.(SourcePreamblePlugin)
+		if !ok {
+			continue
+		}
+		text, err := preamble.SourcePreamble(state.context(entry))
+		if err != nil {
+			return "", err
+		}
+		out.WriteString(text)
+	}
+	return out.String(), nil
+}
+
+func (state linkedPluginState) apply(prog *Program) error {
+	for index, entry := range state.entries {
+		plugin, ok := registeredPlugin(index)
+		if !ok {
+			return fmt.Errorf("ttsc driver: linked plugin entry %d was requested but no linked plugin registered at that position", index)
+		}
+		transform, ok := plugin.(ProgramPlugin)
+		if !ok {
+			continue
+		}
+		if err := transform.ApplyProgram(prog, state.context(entry)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func registeredPlugin(index int) (any, bool) {
+	if index < 0 || index >= len(pluginRegistry) {
+		return nil, false
+	}
+	return pluginRegistry[index], true
+}
+
+func (state linkedPluginState) context(entry PluginEntry) PluginContext {
+	return PluginContext{
+		Cwd:      state.cwd,
+		Entry:    entry,
+		Tsconfig: state.tsconfig,
+	}
+}