ttsc 0.18.3 → 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/ttscgraph/main.go

@@ -1,9 +1,7 @@
-// Command ttscgraph builds the checker-resolved code graph for a project and
-// prints it as JSON (`ttscgraph dump`). It is the native data provider for
-// @ttsc/graph: the JavaScript launcher runs `ttscgraph dump` once, then serves
-// the Model Context Protocol from the in-memory graph itself. The MCP server,
-// its tools, and their schemas live in @ttsc/graph (TypeScript); nothing here
-// answers tool calls.
+// Command ttscgraph builds the checker-resolved code graph for a project. The
+// one-shot `dump` command prints JSON; the internal `serve` command keeps an
+// incremental compiler session resident for @ttsc/graph. MCP tools and schemas
+// remain in the TypeScript package.
 package main
 
 import (
@@ -35,9 +33,9 @@ func main() {
   os.Exit(run(os.Args[1:]))
 }
 
-// run dispatches the top-level command and returns an exit code. ttscgraph is
-// dump-only; anything that is not help/version/dump prints usage and exits 2,
-// since serving MCP is the launcher's job.
+// run dispatches the top-level command and returns an exit code. Anything that
+// is not help, version, dump, or the internal serve protocol prints usage and
+// exits 2; serving MCP itself remains the launcher's job.
 func run(args []string) int {
   if len(args) > 0 {
     switch args[0] {
@@ -49,6 +47,8 @@ func run(args []string) int {
       return 0
     case "dump":
       return runDump(args[1:])
+    case "serve":
+      return runServe(args[1:])
     }
   }
   printHelp(stderr)
@@ -72,12 +72,12 @@ func printHelp(w io.Writer) {
   fmt.Fprintln(w, strings.TrimSpace(`
 ttscgraph — checker-resolved code graph for ttsc.
 
-Builds the project's code graph and prints it as JSON. The @ttsc/graph launcher
-runs this and serves the Model Context Protocol from the result; the MCP tools
-live in @ttsc/graph, not here.
+Builds the project's code graph as JSON or keeps an incremental compiler session
+for the @ttsc/graph launcher. The MCP tools live in @ttsc/graph, not here.
 
 Usage:
   ttscgraph dump [--cwd <dir>] [--tsconfig <path>] [--pretty] > graph.json
+  ttscgraph serve [--cwd <dir>] [--tsconfig <path>]
   ttscgraph --version
   ttscgraph --help
 
@@ -87,5 +87,11 @@ Dump:
   --cwd <dir>          Project root (defaults to the process working directory).
   --tsconfig <path>    Project tsconfig path (default: tsconfig.json).
   --pretty             Indent the JSON output.
+
+Serve:
+  serve                Internal newline-delimited snapshot protocol used by
+                       @ttsc/graph. Keeps the compiler Program resident, applies
+                       source edits incrementally, and reloads on structural
+                       project changes.
 `))
 }

package/cmd/ttscgraph/run_help_version_and_bad_flags_exit_codes_test.go

@@ -8,9 +8,10 @@ import (
 )
 
 // TestRunHelpVersionAndBadFlagsExitCodes verifies the top-level run dispatcher
-// returns the documented exit codes for the dump-only command surface: help and
-// version short-circuit to 0, an unknown command prints usage and exits 2, and a
-// dump that cannot resolve its working directory exits 2 with an explanation.
+// returns the documented exit codes for the command surface: help and version
+// short-circuit to 0, an unknown command prints usage and exits 2, and dump or
+// serve invocations that cannot parse flags or resolve their working directory
+// exit 2 with an explanation.
 //
 // These are the non-load paths a user hits with a typo or `--help`; each must
 // resolve to a code without building a Program. The getwd seam stands in for an
@@ -19,8 +20,8 @@ import (
 //
 //  1. run --help and run --version exit 0, printing the command name / version.
 //  2. run --bogus (unknown command) exits 2 and prints usage.
-//  3. run dump --nope exits 2 (dump flag parse failure).
-//  4. With getwd forced to fail, run dump exits 2 and explains why.
+//  3. run dump --nope and run serve --nope exit 2 (flag parse failure).
+//  4. With getwd forced to fail, run dump and run serve exit 2 and explain why.
 func TestRunHelpVersionAndBadFlagsExitCodes(t *testing.T) {
   oldStdout, oldStderr, oldGetwd := stdout, stderr, getwd
   defer func() { stdout, stderr, getwd = oldStdout, oldStderr, oldGetwd }()
@@ -62,6 +63,13 @@ func TestRunHelpVersionAndBadFlagsExitCodes(t *testing.T) {
     t.Fatalf("run dump --nope exit = %d, want 2", code)
   }
 
+  // An unknown serve flag is an invalid invocation: serve's flag.Parse fails -> 2.
+  var serveFlagErr bytes.Buffer
+  stderr = &serveFlagErr
+  if code := run([]string{"serve", "--nope"}); code != 2 {
+    t.Fatalf("run serve --nope exit = %d, want 2", code)
+  }
+
   // A getwd failure (no --cwd given) is an invalid invocation -> 2, explained.
   var wdErr bytes.Buffer
   stderr = &wdErr
@@ -72,4 +80,14 @@ func TestRunHelpVersionAndBadFlagsExitCodes(t *testing.T) {
   if !strings.Contains(wdErr.String(), "could not resolve working directory") {
     t.Fatalf("getwd failure did not explain itself:\n%s", wdErr.String())
   }
+
+  // serve resolves the working directory the same way before touching stdin.
+  var serveWdErr bytes.Buffer
+  stderr = &serveWdErr
+  if code := run([]string{"serve"}); code != 2 {
+    t.Fatalf("run serve with getwd failure exit = %d, want 2", code)
+  }
+  if !strings.Contains(serveWdErr.String(), "could not resolve working directory") {
+    t.Fatalf("serve getwd failure did not explain itself:\n%s", serveWdErr.String())
+  }
 }