ttsc 0.4.4-dev.20260426 → 0.5.0-dev.20260429

package/README.md

@@ -6,6 +6,7 @@
 [![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)
+[![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 transforms and type-safe execution.
 
@@ -39,21 +40,38 @@ npx ttsc --noEmit
 npx ttsc --watch
 ```
 
-## Transformer Configuration
+Clear cached transformer binaries when developing or debugging a plugin:
 
-`ttsc` reads `compilerOptions.plugins` from `tsconfig.json`.
+```bash
+npx ttsc clean
+```
+
+## Plugin Configuration
+
+Open your project's `tsconfig.json`, then add plugin entries under `compilerOptions.plugins`. If the file already has `compilerOptions`, merge the `plugins` array into the existing object.
+
+Each plugin module is a JavaScript descriptor for an ordered native transformer backend; the transform implementation itself runs in Go.
 
 ```json
 {
   "compilerOptions": {
     "plugins": [
+      {
+        "transform": "@ttsc/lint",
+        "rules": {
+          "no-var": "error",
+          "no-explicit-any": "warning",
+          "no-non-null-assertion": "off"
+        }
+      },
+      { "transform": "@ttsc/paths" },
       { "transform": "typia/lib/transform" }
     ]
   }
 }
 ```
 
-The same configuration is used by both `ttsc` commands.
+The same configuration is used by both `ttsc` and `ttsx` commands.
 
 ```bash
 # compile
@@ -120,6 +138,20 @@ It is transformed into dedicated JavaScript:
 
 `ttsc` runs this transform during build, and `ttsx` runs through the same transform path during execution.
 
+## List of Plugins
+
+`ttsc` ships a few small utility plugins in this repository.
+
+- [`{ "transform": "@ttsc/banner", ... }`](https://github.com/samchon/ttsc/tree/master/packages/banner)
+- [`{ "transform": "@ttsc/lint", ... }`](https://github.com/samchon/ttsc/tree/master/packages/lint)
+- [`{ "transform": "@ttsc/paths" }`](https://github.com/samchon/ttsc/tree/master/packages/paths)
+- [`{ "transform": "@ttsc/strip", ... }`](https://github.com/samchon/ttsc/tree/master/packages/strip)
+
+Ecosystem plugins are listed below; PRs adding `ttsc` plugins are welcome.
+
+- [`{ "transform": "@nestia/core/lib/transform" }`](https://github.com/samchon/nestia)
+- [`{ "transform": "typia/lib/transform" }`](https://github.com/samchon/typia)
+
 ## References
 
 - TypeScript runners: [`ts-node`](https://github.com/TypeStrong/ts-node) and [`tsx`](https://github.com/privatenumber/tsx)

package/cmd/ttsc/main.go

@@ -4,8 +4,8 @@
 //   - 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.
-//   - Act as a placeholder for the eventual `build` / `dev` / `check` / `setup`
-//     subcommands that will land in Week 3+.
+//   - Host the native project build, check, and single-file transform paths used
+//     by plugin-selected sidecars and smoke tests.
 //
 // Everything below is deliberately dependency-free so that the standalone binary
 // stays small and its behavior is trivial to audit.

package/driver/program.go

@@ -20,12 +20,71 @@ import (
 
 // Diagnostic is the compilation diagnostic shape ttsc passes around. Kept
 // dependency-free (no shim types) so callers can render or inspect freely.
+//
+// `raw` carries the original tsgo diagnostic for full color/context
+// rendering. `lint` carries a plugin-emitted lint diagnostic when the
+// diagnostic was produced outside the typecheck pipeline (e.g. by
+// `@ttsc/lint`). At most one of `raw` / `lint` is non-nil; both nil falls
+// back to the legacy single-line form.
 type Diagnostic struct {
-	File    string
-	Line    int
-	Column  int
-	Message string
-	raw     *ast.Diagnostic
+	File     string
+	Line     int
+	Column   int
+	Message  string
+	Severity Severity
+	raw      *ast.Diagnostic
+	lint     *shimdiagnosticwriter.LintDiagnostic
+}
+
+// Severity classifies a diagnostic's blast radius. ttsc treats Error as a
+// build-failing condition; Warning prints but does not flip the exit code.
+type Severity int
+
+const (
+	// SeverityError is the default for tsgo typecheck output and any
+	// plugin-emitted finding that should fail the build.
+	SeverityError Severity = iota
+	// SeverityWarning prints with warning coloring but keeps the build
+	// status at zero.
+	SeverityWarning
+)
+
+// IsError reports whether the diagnostic counts toward the build's error
+// total. Useful when plugins want to gate emit on the lint outcome without
+// re-walking the diagnostic list.
+func (d Diagnostic) IsError() bool { return d.Severity == SeverityError }
+
+// NewLintDiagnostic shapes a plugin finding so it renders alongside tsgo
+// diagnostics with full color / source context. `pos` and `end` are byte
+// offsets into the source file; `code` is a stable rule identifier (e.g. the
+// rule's enum index). Severity controls both the rendered banner color and
+// the exit-code outcome.
+func NewLintDiagnostic(
+	file *ast.SourceFile,
+	pos, end int,
+	code int32,
+	severity Severity,
+	message string,
+) Diagnostic {
+	cat := shimdiagnosticwriter.LintCategoryError
+	if severity == SeverityWarning {
+		cat = shimdiagnosticwriter.LintCategoryWarning
+	}
+	lint := shimdiagnosticwriter.NewLintDiagnostic(file, pos, end, code, cat, message)
+	d := Diagnostic{
+		Message:  message,
+		Severity: severity,
+		lint:     lint,
+	}
+	if file != nil {
+		d.File = file.FileName()
+		if pos >= 0 {
+			line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+			d.Line = line + 1
+			d.Column = col + 1
+		}
+	}
+	return d
 }
 
 // SourceFile returns the program source file matching filename.
@@ -54,21 +113,67 @@ func (d Diagnostic) String() string {
 }
 
 // WritePrettyDiagnostics renders diagnostics with TypeScript-style colors,
-// source snippets and the trailing error summary when raw tsgo diagnostic
-// objects are available. It falls back to the legacy one-line form for
-// diagnostics assembled outside tsgo.
+// source snippets and the trailing error summary when raw tsgo or lint
+// diagnostic objects are available. Mixed batches (e.g. typecheck + lint)
+// are rendered through the same color/context pipeline; entries without
+// either anchor fall back to the legacy `path:line:col: message` form.
 func WritePrettyDiagnostics(w io.Writer, diagnostics []Diagnostic, cwd string) {
-	raw := make([]*ast.Diagnostic, 0, len(diagnostics))
+	if len(diagnostics) == 0 {
+		return
+	}
+	rich := make([]Diagnostic, 0, len(diagnostics))
+	plain := make([]Diagnostic, 0)
 	for _, d := range diagnostics {
-		if d.raw == nil {
-			for _, d := range diagnostics {
-				fmt.Fprintln(w, "  -", d.String())
+		if d.raw != nil || d.lint != nil {
+			rich = append(rich, d)
+		} else {
+			plain = append(plain, d)
+		}
+	}
+	if len(rich) > 0 {
+		astDiags := make([]*ast.Diagnostic, 0, len(rich))
+		lintDiags := make([]*shimdiagnosticwriter.LintDiagnostic, 0, len(rich))
+		for _, d := range rich {
+			if d.raw != nil {
+				astDiags = append(astDiags, d.raw)
+			}
+			if d.lint != nil {
+				lintDiags = append(lintDiags, d.lint)
 			}
-			return
 		}
-		raw = append(raw, d.raw)
+		shimdiagnosticwriter.FormatMixedDiagnostics(w, astDiags, lintDiags, cwd)
+	}
+	for _, d := range plain {
+		fmt.Fprintln(w, "  -", d.String())
+	}
+}
+
+// CountErrors returns the number of diagnostics that should fail the build.
+// tsgo diagnostics carry their own `Error` category; lint diagnostics carry a
+// caller-set Severity. Anything that isn't an explicit warning counts.
+func CountErrors(diagnostics []Diagnostic) int {
+	n := 0
+	for _, d := range diagnostics {
+		if d.lint != nil {
+			if d.lint.IsError() {
+				n++
+			}
+			continue
+		}
+		if d.raw != nil {
+			// tsgo diagnostics use the diagnostics package category. The
+			// renderer shim already mirrors the same Error/Warning split, so
+			// re-categorize via the public IsError shortcut.
+			if d.Severity != SeverityWarning {
+				n++
+			}
+			continue
+		}
+		// Plain text diagnostics (manually assembled): treat as errors so
+		// "ttsc: tsconfig not found"-style failures still flip the exit code.
+		n++
 	}
-	shimdiagnosticwriter.FormatASTDiagnosticsWithColorAndContext(w, raw, cwd)
+	return n
 }
 
 // Program is the shim-agnostic facade the rest of the engine sees.

package/go.mod

@@ -40,9 +40,9 @@ require (
 require (
 	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260424234512-515d036f927a // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
 )

package/go.sum

@@ -4,8 +4,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 h1:iH0TuqCh+yQ95Ea0f9lVM5B1xkTqlmxQhzOEj8QWR6o=
-github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22/go.mod h1:eE2mO7PBRpeR8gWgxwsZq1LOW4tsgIF6zd0iQ5TbsJU=
+github.com/microsoft/typescript-go v0.0.0-20260424234512-515d036f927a h1:3ItFA7V3ZwhdbM1LAW+r3pS/+znGJVKbWTFoiQILuhU=
+github.com/microsoft/typescript-go v0.0.0-20260424234512-515d036f927a/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
 github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
 github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
@@ -14,9 +14,9 @@ github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
 github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/lib/api.d.ts

@@ -85,8 +85,8 @@ export declare function check(options?: CheckOptions): BuildResult;
 /** Ask the binary for its version banner. Handy for user-agent strings. */
 export declare function version(options?: CommonOptions): string;
 /**
- * Promise-facing variant of `transform()`. The plugin host keeps the transform
- * pipeline synchronous so plugin modules can stay dependency-free, but many
- * adapter surfaces still prefer a Promise-returning function.
+ * Promise-facing variant of `transform()`. The host path stays synchronous so
+ * plugin descriptors can stay dependency-free, but many adapter surfaces still
+ * prefer a Promise-returning function.
  */
 export declare function transformAsync(options: TransformOptions): Promise<string>;