ttsc 0.18.4 → 0.19.0

package/README.md

@@ -8,8 +8,8 @@ A `typescript-go` toolchain for compiler-powered plugins and type-safe execution
 
 - **`ttsc`**: build, check, and transform.
 - **`ttsx`**: execute TypeScript with type checking.
-- **`@ttsc/lint`**: lint violations as compiler errors.
-- **`@ttsc/graph`**: MCP code graph that reduce token usage.
+- [**`@ttsc/lint`**](https://github.com/samchon/ttsc/tree/master/packages/lint): lint violations as compiler errors.
+- [**`@ttsc/graph`**](https://github.com/samchon/ttsc/tree/master/packages/graph): MCP code graph that reduce token usage.
 - **plugin support**: compiler-powered libraries, such as `typia`.
 
 ## Setup
@@ -76,6 +76,7 @@ Supported bundlers:
 - Webpack
 - Rspack
 - Next.js
+- Turbopack
 - Farm
 - Bun
 
@@ -127,12 +128,10 @@ See [`@ttsc/vscode`](https://github.com/samchon/ttsc/tree/master/packages/vscode
 
 ### Coding Agents (MCP)
 
-`@ttsc/graph` gives a coding agent a checker-resolved map of your project, over MCP.
+`@ttsc/graph` gives a coding agent a checker-resolved graph of your project, over MCP.
 
 It answers what relates to a symbol and what a change affects, straight from the type checker, so the agent stops grepping and re-reading files.
 
-It also carries the project's full diagnostics: type errors, `@ttsc/lint` violations, and plugin findings. They are fused onto the graph, so an agent sees a change's reach over what is already broken before editing.
-
 ```bash
 npm install -D ttsc @ttsc/graph typescript
 ```
@@ -266,7 +265,7 @@ See the [Programmatic API guide](https://ttsc.dev/docs/ttsc/api) for the full li
 
 - [`@ttsc/banner`](https://github.com/samchon/ttsc/tree/master/packages/banner): adds `@packageDocumentation` JSDoc banners.
 - [`@ttsc/lint`](https://github.com/samchon/ttsc/tree/master/packages/lint): lints and formats TypeScript source.
-- [`@ttsc/graph`](https://github.com/samchon/ttsc/tree/master/packages/graph): MCP server exposing a checker-resolved code graph and diagnostics to coding agents.
+- [`@ttsc/graph`](https://github.com/samchon/ttsc/tree/master/packages/graph): MCP server exposing a checker-resolved code graph to coding agents.
 - [`@ttsc/paths`](https://github.com/samchon/ttsc/tree/master/packages/paths): rewrites source path aliases so JS and declaration emit receive relative imports.
 - [`@ttsc/strip`](https://github.com/samchon/ttsc/tree/master/packages/strip): removes configured calls and `debugger` statements.
 - [`@ttsc/unplugin`](https://github.com/samchon/ttsc/tree/master/packages/unplugin): runs `ttsc` plugins inside bundlers supported by `unplugin`.

package/cmd/graphbench/main.go

@@ -6,7 +6,7 @@
 // it N times and take medians.
 //
 // Counts and coverage are deterministic; timings are indicative and only
-// meaningful on a quiet host (see .codex/skills/benchmark).
+// meaningful on a quiet host (see .agents/skills/benchmark/SKILL.md).
 package main
 
 import (

package/cmd/platform/main.go

@@ -2,12 +2,10 @@
 //
 // The real compiler and runner commands live in the JavaScript launchers so
 // they can resolve the consuming project's `typescript` and
-// plugin descriptors. This binary only supplies version/platform metadata and
-// a tiny demo command for package smoke tests.
+// plugin descriptors. This binary only supplies version/platform metadata.
 package main
 
 import (
-  "flag"
   "fmt"
   "io"
   "os"
@@ -50,8 +48,6 @@ func run(args []string) int {
   case "-v", "--version", "version":
     printVersion(stdout)
     return 0
-  case "demo":
-    return runDemo(args[1:])
   case "build", "check":
     fmt.Fprintf(
       stderr,
@@ -90,48 +86,5 @@ plugin-selected native sidecar.
 
 Usage:
   ttsc --version
-  ttsc demo --type=string
 `))
 }
-
-// runDemo implements the demo sub-command, printing a synthetic JavaScript
-// arrow function for the requested atomic type. Smoke tests in CI invoke this
-// to verify the binary executes correctly.
-func runDemo(args []string) int {
-  fs := flag.NewFlagSet("demo", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  typ := fs.String("type", "string", "atomic type to simulate")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
-
-  arrow, err := demoArrow(*typ)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc platform helper demo: %v\n", err)
-    return 2
-  }
-
-  fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc platform helper %s\n", *typ, version)
-  fmt.Fprintln(stdout, arrow)
-  return 0
-}
-
-// demoArrow returns a JavaScript arrow-function expression for the named
-// atomic TypeScript type. It is the platform-helper counterpart of the same
-// function in cmd/ttsc, kept separate to avoid a shared-binary dependency.
-func demoArrow(name string) (string, error) {
-  switch strings.ToLower(name) {
-  case "any":
-    return "(input) => true", nil
-  case "boolean":
-    return `(input) => "boolean" === typeof input`, nil
-  case "number":
-    return `(input) => "number" === typeof input`, nil
-  case "bigint":
-    return `(input) => "bigint" === typeof input`, nil
-  case "string", "":
-    return `(input) => "string" === typeof input`, nil
-  default:
-    return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
-  }
-}

package/cmd/ttsc/build_branches_test.go

@@ -84,7 +84,11 @@ export { value };
   code, _, errText = captureCommand(t, func() int {
     return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "blocked"})
   })
-  if code != 2 || !strings.Contains(errText, "not a directory") {
+  // The write fails because outDir is a regular file. Assert on the exit code
+  // and the platform-agnostic TS5033 "Could not write file" diagnostic prefix,
+  // not the OS errno, which differs by platform (POSIX ENOTDIR "not a
+  // directory" vs Windows "The system cannot find the path specified").
+  if code != 2 || !strings.Contains(errText, "Could not write file") {
     t.Fatalf("emit failure mismatch: code=%d stderr=%q", code, errText)
   }
 

package/cmd/ttsc/main.go

@@ -2,8 +2,6 @@
 //
 // Current responsibilities:
 //   - Report version and platform (`ttsc --version`).
-//   - Exercise a native rewrite backend end-to-end (`ttsc demo --type=string`)
-//     so smoke tests can verify the Go binary really runs.
 //   - Host the native project build and check paths used by plugin-selected
 //     sidecars and smoke tests.
 //
@@ -12,7 +10,6 @@
 package main
 
 import (
-  "flag"
   "fmt"
   "io"
   "os"
@@ -51,8 +48,6 @@ func run(args []string) int {
   case "-v", "--version", "version":
     printVersion(stdout)
     return 0
-  case "demo":
-    return runDemo(args[1:])
   case "build":
     return runBuild(args[1:])
   case "api-compile":
@@ -126,7 +121,6 @@ Project build:
   ttsc compiles the current tsconfig.json, matching the tsc/tsgo shape.
   build         Compatibility alias for the same project build lane.
   check         Compatibility alias for --noEmit validation.
-  demo          Run a native backend smoke pipeline with synthetic input.
   version       Print version, build info, and platform.
   help          Show this help.
 
@@ -139,16 +133,11 @@ Build options:
   --verbose         Print the per-call summary banner and emitted file list.
   --manifest=FILE   Write emitted file paths as JSON to FILE after build --emit.
 
-Demo options:
-  --type=T          Atomic TypeScript type to simulate. One of:
-                      string, number, boolean, bigint, any (default: string).
-
 Examples:
   ttsc --version
   ttsc
   ttsc -p ./tsconfig.json
   ttsc --noEmit
-  ttsc demo --type=number
 
 Integration guide (bundlers):
   - Next.js / Nuxt / Bun: "ttsc" in your pipeline replaces tsc and
@@ -157,42 +146,3 @@ Integration guide (bundlers):
     per-package tsconfig.json references work unchanged.
 `))
 }
-
-func runDemo(args []string) int {
-  fs := flag.NewFlagSet("demo", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  typ := fs.String("type", "string", "atomic type to simulate")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
-
-  arrow, err := demoArrow(*typ)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
-    return 2
-  }
-
-  fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
-  fmt.Fprintln(stdout, arrow)
-  return 0
-}
-
-// demoArrow returns a JavaScript arrow-function expression that validates the
-// named atomic TypeScript type at runtime. Used by the demo sub-command to
-// produce a small synthetic emit that smoke tests can assert on.
-func demoArrow(name string) (string, error) {
-  switch strings.ToLower(name) {
-  case "any":
-    return "(input) => true", nil
-  case "boolean":
-    return `(input) => "boolean" === typeof input`, nil
-  case "number":
-    return `(input) => "number" === typeof input`, nil
-  case "bigint":
-    return `(input) => "bigint" === typeof input`, nil
-  case "string", "":
-    return `(input) => "string" === typeof input`, nil
-  default:
-    return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
-  }
-}

package/cmd/ttsc/main_alias_branches_test.go

@@ -2,23 +2,17 @@ package main
 
 import "testing"
 
-// TestMainAliasBranches verifies main command aliases cover flag-shaped demo and cts project inputs.
+// TestMainAliasBranches verifies `.cts` project inputs remain build aliases.
 //
 // 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.
+// so `ttsc ./tsconfig.cts` stays compatible with tsc-style invocations instead
+// of being rejected as an unknown command.
 //
-// 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.
+// 1. Dispatch a `.cts` argument through the build alias path.
+// 2. Let project discovery inspect the missing file.
+// 3. Assert the build lane reports its command-error status.
 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 {

package/cmd/ttscgraph/dump.go

@@ -59,11 +59,21 @@ func runDump(args []string) int {
 
   g := graph.Build(prog)
   ignored := graph.GitIgnoredFiles(cwd, g)
-  data, err := graph.MarshalDump(g, cwd, tsconfig, ignored, graph.SourceTexts(prog), *prettyFlag)
-  if err != nil {
+  // Stream the document out instead of marshalling it into one byte slice and
+  // then copying that slice into a string: on VS Code the dump is 323 MB, so
+  // the string conversion alone was a second full copy of it, for nothing. The
+  // encoder writes through a buffer straight to stdout.
+  if err := graph.EncodeDump(
+    stdout,
+    g,
+    cwd,
+    tsconfig,
+    ignored,
+    graph.SourceTexts(prog),
+    *prettyFlag,
+  ); err != nil {
     fmt.Fprintf(stderr, "ttscgraph: %v\n", err)
     return 1
   }
-  fmt.Fprintln(stdout, string(data))
   return 0
 }

package/cmd/ttscserver/main.go

@@ -133,9 +133,11 @@ func runLSP(args []string) int {
   }
 
   // The SymbolProvider answers textDocument/documentSymbol and
-  // textDocument/references locally from ttsc's compiler-backed code graph;
-  // tsgo's native LSP does not implement them. It loads the program lazily on
-  // the first such request, so wiring it here adds no startup cost.
+  // textDocument/references from ttsc's compiler-backed code graph. tsgo
+  // implements both methods itself, so the proxy forwards to tsgo whenever it
+  // advertises the capability and consults this provider only as a fallback
+  // (tsgo did not advertise). It loads the program lazily on the first such
+  // request, so wiring it here adds no startup cost.
   symbolProvider := graphsymbols.NewProvider(cwd, strings.TrimSpace(*tsconfigFlag))
 
   err = runLSPServer(ctx, lspserver.LSPServerOptions{

package/driver/lsp.go

@@ -49,6 +49,12 @@ type LSPTextEdit = lspserver.LSPTextEdit
 // LSPDocumentVersion is the driver-level alias for lspserver.LSPDocumentVersion.
 type LSPDocumentVersion = lspserver.LSPDocumentVersion
 
+// LSPProjectDiagnostics is the driver-level alias for a project publication.
+type LSPProjectDiagnostics = lspserver.LSPProjectDiagnostics
+
+// LSPDiagnosticsResult separates document and project plugin diagnostics.
+type LSPDiagnosticsResult = lspserver.LSPDiagnosticsResult
+
 // LSPSymbolKind is the driver-level alias for lspserver.LSPSymbolKind.
 type LSPSymbolKind = lspserver.LSPSymbolKind
 
@@ -104,6 +110,12 @@ type LSPServerOptions = lspserver.LSPServerOptions
 // LSPUpstreamRunner is the driver-level alias for lspserver.LSPUpstreamRunner.
 type LSPUpstreamRunner = lspserver.LSPUpstreamRunner
 
+// LSPUpstreamValidator is the driver-level alias for lspserver.LSPUpstreamValidator.
+type LSPUpstreamValidator = lspserver.LSPUpstreamValidator
+
+// LSPUpstream is the driver-level alias for lspserver.LSPUpstream.
+type LSPUpstream = lspserver.LSPUpstream
+
 // MaxFrameBytes is the maximum byte length of a single JSON-RPC frame
 // the proxy will read without returning ErrFrameTooLarge.
 const MaxFrameBytes = lspserver.MaxFrameBytes
@@ -118,6 +130,7 @@ var ErrFrameClosed = lspserver.ErrFrameClosed
 var ErrFrameTooLarge = lspserver.ErrFrameTooLarge
 var ErrInvalidJSONRPC = lspserver.ErrInvalidJSONRPC
 var ErrLSPUpstreamPanic = lspserver.ErrLSPUpstreamPanic
+var ErrLSPUpstreamRunnerRequired = lspserver.ErrLSPUpstreamRunnerRequired
 var ErrLSPCwdRequired = lspserver.ErrLSPCwdRequired
 var ErrLSPTsgoBinaryRequired = lspserver.ErrLSPTsgoBinaryRequired
 
@@ -128,7 +141,6 @@ 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
 

package/driver/plugins.go

@@ -4,6 +4,7 @@ import (
   "encoding/json"
   "fmt"
   "os"
+  "path/filepath"
   "strings"
 )
 
@@ -13,6 +14,40 @@ import (
 // linked plugins are active.
 const LinkedPluginsEnv = "TTSC_LINKED_PLUGINS_JSON"
 
+// PluginConfigDirEnv is the environment variable through which the ttsc
+// launcher passes the project root that plugin config-file discovery and
+// relative "configFile" resolution anchor at. The launcher sets it on every
+// native plugin spawn; it matters when the compiled tsconfig is a generated
+// wrapper outside the project — e.g. @ttsc/unplugin writes a compiler-options
+// overlay into the system temp directory that `extends` the real project
+// config — where the tsconfig directory no longer identifies the project and
+// an unanchored discovery walk would climb the temp tree instead. It rides
+// the environment rather than a CLI flag so third-party native hosts with
+// strict flag sets are unaffected and linked plugins running inside them
+// still receive it.
+const PluginConfigDirEnv = "TTSC_PLUGIN_CONFIG_DIR"
+
+// PluginConfigBaseDir returns the directory where a plugin anchors its
+// config-file discovery walk and resolves relative "configFile" paths.
+// The explicit PluginConfigDirEnv channel wins when set; otherwise the
+// tsconfig's directory is used, falling back to cwd when no tsconfig is set.
+func PluginConfigBaseDir(cwd, tsconfigPath string) string {
+  if dir := strings.TrimSpace(os.Getenv(PluginConfigDirEnv)); dir != "" {
+    if !filepath.IsAbs(dir) && cwd != "" {
+      dir = filepath.Join(cwd, dir)
+    }
+    return filepath.Clean(dir)
+  }
+  if tsconfigPath != "" {
+    resolved := tsconfigPath
+    if !filepath.IsAbs(resolved) {
+      resolved = filepath.Join(cwd, resolved)
+    }
+    return filepath.Dir(resolved)
+  }
+  return cwd
+}
+
 // PluginEntry is the manifest shape ttsc passes to driver-level plugins.
 type PluginEntry struct {
   Config map[string]any `json:"config"`

package/driver/program.go

@@ -81,15 +81,14 @@ func NewLintDiagnostic(
     lint:     lint,
   }
   if file != nil {
+    pos = lint.Pos()
     d.File = file.FileName()
-    if pos >= 0 {
-      length := lint.Len()
-      d.Start = &pos
-      d.Length = &length
-      line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
-      d.Line = line + 1
-      d.Column = col + 1
-    }
+    length := lint.Len()
+    d.Start = &pos
+    d.Length = &length
+    line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+    d.Line = line + 1
+    d.Column = col + 1
   }
   return d
 }