ttsc 0.12.4 → 0.13.0

package/src/launcher/internal/runTtsc.ts

@@ -8,6 +8,12 @@ import { resolveProjectConfig } from "../../compiler/internal/project/resolvePro
 import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { runBuild } from "../../compiler/internal/runBuild";
 import { runSingleFileEmit } from "../../compiler/internal/runSingleFileEmit";
+import {
+  getBoolean,
+  getNumber,
+  getString,
+  parseFlags,
+} from "../../flags/parser";
 import { defaultPluginCacheCleanTargets } from "../../plugin/internal/buildSourcePlugin";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import { getCompilerVersionText } from "./getCompilerVersionText";
@@ -282,144 +288,80 @@ function ensureExecutable(binary: string): void {
 }
 
 function parseProjectArgs(argv: readonly string[]) {
-  let cacheDir: string | undefined;
-  let cwd: string | undefined;
-  let tsconfig: string | undefined;
-
-  const rest = [...argv];
-  while (rest.length !== 0) {
-    const current = rest.shift()!;
-    switch (current) {
-      case "--cwd":
-        cwd = takeValue(current, rest);
-        break;
-      case "--cache-dir":
-        cacheDir = takeValue(current, rest);
-        break;
-      case "-p":
-      case "--tsconfig":
-      case "--project":
-        tsconfig = takeValue(current, rest);
-        break;
-      default:
-        if (current.startsWith("--cwd=")) {
-          cwd = current.slice("--cwd=".length);
-        } else if (current.startsWith("--cache-dir=")) {
-          cacheDir = current.slice("--cache-dir=".length);
-        } else if (current.startsWith("--tsconfig=")) {
-          tsconfig = current.slice("--tsconfig=".length);
-        } else if (current.startsWith("--project=")) {
-          tsconfig = current.slice("--project=".length);
-        } else {
-          throw new Error(`ttsc: unknown option ${current}`);
-        }
-        break;
-    }
-  }
-  return { cacheDir, cwd, tsconfig };
+  // `prepare` and `clean` are project-shaped commands. They share the same
+  // schema as the build lane; the engine forwards unknown flags as well as
+  // build-only flags (e.g. `--strict`) to the launcher's passthrough list
+  // so the legacy "unknown option" behaviour is no longer a separate trap
+  // (RC-3 + RC-4 prevention; see issue #125 §5 in the RCA).
+  const result = parseFlags({
+    argv,
+    errorPrefix: "ttsc:",
+    subcommand: "prepare",
+  });
+  return {
+    cacheDir: getString(result, "--cache-dir"),
+    cwd: getString(result, "--cwd"),
+    tsconfig: getString(result, "--tsconfig"),
+  };
 }
 
 function parseBuildArgs(argv: readonly string[], checkOnly: boolean) {
-  let binary: string | undefined;
-  let cacheDir: string | undefined;
-  let cwd: string | undefined;
-  let emit: boolean | undefined = checkOnly ? false : undefined;
-  const files: string[] = [];
-  let fix = false;
-  let format = false;
-  let outDir: string | undefined;
-  let preserveWatchOutput = false;
-  let quiet = true;
-  let tsconfig: string | undefined;
-  let watch = false;
-
-  const rest = [...argv];
-  while (rest.length !== 0) {
-    const current = rest.shift()!;
-    switch (current) {
-      case "--emit":
-        emit = true;
-        break;
-      case "--noEmit":
-        emit = false;
-        break;
-      case "--quiet":
-        quiet = true;
-        break;
-      case "--verbose":
-        quiet = false;
-        break;
-      case "-w":
-      case "--watch":
-        watch = true;
-        break;
-      case "--preserveWatchOutput":
-        preserveWatchOutput = true;
-        break;
-      case "--cwd":
-        cwd = takeValue(current, rest);
-        break;
-      case "--outDir":
-        outDir = takeValue(current, rest);
-        break;
-      case "-p":
-      case "--tsconfig":
-      case "--project":
-        tsconfig = takeValue(current, rest);
-        break;
-      case "--binary":
-        binary = takeValue(current, rest);
-        break;
-      case "--cache-dir":
-        cacheDir = takeValue(current, rest);
-        break;
-      default:
-        if (current.startsWith("--cwd=")) {
-          cwd = current.slice("--cwd=".length);
-        } else if (current.startsWith("--outDir=")) {
-          outDir = current.slice("--outDir=".length);
-        } else if (current === "-w") {
-          // Unreachable: `-w` is handled by the switch case above. Kept here
-          // as a guard in case the switch is refactored in the future.
-          watch = true;
-        } else if (current.startsWith("--tsconfig=")) {
-          tsconfig = current.slice("--tsconfig=".length);
-        } else if (current.startsWith("--project=")) {
-          tsconfig = current.slice("--project=".length);
-        } else if (current.startsWith("--preserveWatchOutput=")) {
-          preserveWatchOutput =
-            current.slice("--preserveWatchOutput=".length) !== "false";
-        } else if (current.startsWith("--binary=")) {
-          binary = current.slice("--binary=".length);
-        } else if (current.startsWith("--cache-dir=")) {
-          cacheDir = current.slice("--cache-dir=".length);
-        } else if (current === "--verbose") {
-          // Unreachable: `--verbose` is handled by the switch case above.
-          quiet = false;
-        } else if (current.startsWith("-")) {
-          throw new Error(`ttsc: unknown option ${current}`);
-        } else {
-          files.push(current);
-        }
-        break;
-    }
-  }
+  const result = parseFlags({
+    argv,
+    errorPrefix: "ttsc:",
+    subcommand: "build",
+  });
+  // Defaults: pinned by the previous hand-parser. `quiet` defaults true,
+  // `--verbose` flips it to false; `emit` defaults `undefined` in build
+  // mode (let tsconfig decide) and `false` in check/fix/format mode.
+  const verbose = getBoolean(result, "--verbose");
+  const quietFlag = getBoolean(result, "--quiet");
+  const quiet = verbose === true ? false : (quietFlag ?? true);
+  const explicitEmit = getBoolean(result, "--emit");
+  const explicitNoEmit = getBoolean(result, "--noEmit");
+  let emit: boolean | undefined;
+  if (explicitEmit === true) emit = true;
+  else if (explicitNoEmit === true) emit = false;
+  if (emit === undefined && checkOnly) emit = false;
+
+  const files = result.positional.filter(looksLikeInputFile);
+  // Bare non-file positionals are flag values (e.g. the `es2020` in
+  // `--target es2020`). The engine left them in `positional` because the
+  // forwarded flag is unknown to the schema; route them back into
+  // passthrough so the user's pair reaches tsgo intact.
+  const trailingValues = result.positional.filter(
+    (token) => !looksLikeInputFile(token),
+  );
+  const passthrough = [...result.passthrough, ...trailingValues];
+
   return {
-    binary,
-    cacheDir,
-    cwd,
+    binary: getString(result, "--binary"),
+    cacheDir: getString(result, "--cache-dir"),
+    checkers: getNumber(result, "--checkers"),
+    cwd: getString(result, "--cwd"),
     emit,
     files,
-    fix,
-    format,
-    outDir,
-    preserveWatchOutput,
+    fix: false,
+    format: false,
+    outDir: getString(result, "--outDir"),
+    passthrough,
+    preserveWatchOutput: getBoolean(result, "--preserveWatchOutput") === true,
     quiet,
-    tsconfig,
-    watch,
+    singleThreaded: getBoolean(result, "--singleThreaded") === true,
+    tsconfig: getString(result, "--tsconfig"),
+    watch: getBoolean(result, "--watch") === true,
   };
 }
 
+/**
+ * Report whether a bare CLI token is a TypeScript source file ttsc should
+ * compile in single-file mode. Anything without a TypeScript source extension
+ * is treated as a forwarded flag value rather than an input file.
+ */
+function looksLikeInputFile(token: string): boolean {
+  return [".ts", ".tsx", ".mts", ".cts"].some((ext) => token.endsWith(ext));
+}
+
 function printHelp(): void {
   process.stdout.write(
     [
@@ -450,6 +392,11 @@ function printHelp(): void {
       "  --verbose              Print the build summary and emitted files",
       "  --binary <path>        Use an explicit tsgo binary",
       "  --cache-dir <dir>      Use this cache root for source-plugin builds",
+      "  --singleThreaded       Run TypeScript-Go single-threaded (one checker)",
+      "  --checkers <n>         Type-checker pool size (default: TypeScript-Go's)",
+      "",
+      "  Any other flag is forwarded to tsgo as-is, so tsgo compiler options",
+      "  such as --strict or --target work directly (e.g. ttsc --strict file.ts).",
       "",
       "Plugin contract:",
       "  ttsc reads compilerOptions.plugins from tsconfig.json.",
@@ -484,9 +431,12 @@ function runSingleFile(options: ReturnType<typeof parseBuildArgs>): number {
   });
   const text = runSingleFileEmit({
     binary: options.binary,
+    checkers: options.checkers,
     cwd,
     file,
     out,
+    passthrough: options.passthrough,
+    singleThreaded: options.singleThreaded,
     tsconfig: options.tsconfig,
   });
   if (!fs.existsSync(out)) {
@@ -694,14 +644,6 @@ function collectWatchDirectories(root: string): string[] {
   return out;
 }
 
-function takeValue(flag: string, rest: string[]): string {
-  const value = rest.shift();
-  if (!value) {
-    throw new Error(`ttsc: ${flag} requires a value`);
-  }
-  return value;
-}
-
 function formatError(error: unknown): string {
   if (error instanceof Error) {
     return error.message;

package/src/launcher/internal/runTtsx.ts

@@ -2,6 +2,12 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
+import {
+  getBoolean,
+  getNumber,
+  getString,
+  parseFlags,
+} from "../../flags/parser";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
 import { resolveCacheDir } from "./resolveCacheDir";
@@ -48,8 +54,20 @@ function run(argv: readonly string[]): number {
   const prepared = prepareExecution(entry, {
     binary: parsed.binary,
     cacheDir: resolveCacheDir(cwd, parsed.cacheDir),
+    checkers: parsed.checkers,
     cwd,
+    passthrough: parsed.tsgoFlags,
+    // `--no-plugins` builds the entry's owning project with plugin
+    // discovery and loading disabled. ttsc's own config loaders use it
+    // when they evaluate a `*.config.ts` through ttsx: that build only
+    // needs to type-check and run the config file, so loading the host
+    // project's transform/check plugins (`@nestia/core`, `typia`, …)
+    // would be both wasteful and wrong — those plugins impose project
+    // requirements (e.g. `strict` mode) the ephemeral config-loader
+    // tsconfig deliberately does not satisfy.
+    plugins: parsed.noPlugins ? false : undefined,
     project: parsed.project,
+    singleThreaded: parsed.singleThreaded,
   });
   return runPreparedEntry(parsed, prepared, cwd);
 }
@@ -62,82 +80,108 @@ function formatError(error: unknown): string {
 }
 
 function parseCLI(argv: readonly string[]) {
-  const preload: string[] = [];
-  const passthroughIndex = argv.indexOf("--");
-  const head =
-    passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
-  const passthrough =
-    passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
-
-  let binary: string | undefined;
-  let cacheDir: string | undefined;
-  let cwd: string | undefined;
-  let entry: string | undefined;
-  let project: string | undefined;
-
-  while (head.length !== 0) {
-    const current = head.shift()!;
-    if (entry) {
-      passthrough.push(current, ...head);
-      break;
-    }
-    switch (current) {
-      case "-h":
-      case "--help":
-        return "help";
-      case "-v":
-      case "--version":
-        return "version";
-      case "-P":
-      case "--project":
-        project = takeValue(current, head);
-        break;
-      case "--cwd":
-        cwd = takeValue(current, head);
-        break;
-      case "--cache-dir":
-        cacheDir = takeValue(current, head);
-        break;
-      case "-r":
-      case "--require":
-        preload.push(takeValue(current, head));
-        break;
-      case "--binary":
-        binary = takeValue(current, head);
-        break;
-      default:
-        if (current.startsWith("--project=")) {
-          project = current.slice("--project=".length);
-        } else if (current.startsWith("--cwd=")) {
-          cwd = current.slice("--cwd=".length);
-        } else if (current.startsWith("--cache-dir=")) {
-          cacheDir = current.slice("--cache-dir=".length);
-        } else if (current.startsWith("--binary=")) {
-          binary = current.slice("--binary=".length);
-        } else if (current.startsWith("-")) {
-          throw new Error(`ttsx: unknown option ${current}`);
-        } else {
-          entry = current;
-        }
-        break;
-    }
-  }
+  // ttsx accepts ttsc-style flags plus its own `--no-plugins` / `--require`.
+  // The shared schema engine recognises both; the engine returns positional
+  // tokens (entry file + flag values that aren't `.ts`) and a passthrough
+  // list mirroring the pre-schema behaviour.
+  //
+  // Order pin: ttsx accepts `-P` as an alias for `--project`. The schema
+  // declares `-p` for ttsc; ttsx's lowercase shape would collide on `-p`
+  // → `--tsconfig`, so the legacy `-P` (uppercase) is treated as `--project`
+  // via a manual rewrite before the engine sees argv. We preserve the
+  // historical behaviour and emit a structural error otherwise.
+  const rewritten = argv.map((token) =>
+    token === "-P"
+      ? "--project"
+      : token.startsWith("-P=")
+        ? `--project=${token.slice("-P=".length)}`
+        : token,
+  );
+  // Terminal flags (--help / --version) short-circuit before parsing so
+  // ttsx prints help text even when the entry file is missing.
+  for (const token of rewritten) {
+    if (token === "-h" || token === "--help") return "help" as const;
+    if (token === "-v" || token === "--version") return "version" as const;
+  }
+  const result = parseFlags({
+    argv: rewritten,
+    errorPrefix: "ttsx:",
+    forwardAfterFirstPositional: true,
+    honorDoubleDashSeparator: true,
+    subcommand: "ttsx",
+  });
 
-  if (!entry) {
+  const entry = result.positional.find(looksLikeEntryFile);
+  if (entry === undefined) {
     throw new Error("ttsx: entry file is required");
   }
+  // With `forwardAfterFirstPositional: true` the parser reports
+  // `result.positional` as just the entry, `result.passthrough` as flags
+  // arriving BEFORE the entry (tsgo-forwarded), and `result.tail` as every
+  // token AFTER the entry — those are the user program's argv (e.g. the
+  // `generate --input src/input` tail of `ttsx typia.ts generate
+  // --input src/input`) and MUST NOT reach tsgo. Anything in positional
+  // that is not the entry is a pre-entry flag value (e.g. `--target es2020`)
+  // that the parser stored positionally; forward those to tsgo with the
+  // rest of `passthrough`.
+  const preEntryValues: string[] = result.positional.filter(
+    (token) => token !== entry && !looksLikeEntryFile(token),
+  );
+  const postEntryArgs: string[] = [...result.tail];
+
+  const preload: string[] = [];
+  // `--require` accepts repeated values; the schema engine writes the
+  // LAST one into `values`, so reconstruct the full list by scanning the
+  // raw argv. Mirrors the legacy parser's `preload.push(takeValue(...))`
+  // behaviour.
+  //
+  // Stop the rescue scan at the first token that begins tail mode —
+  // either the entry file or the `--` separator. Without this guard,
+  // `ttsx entry.ts -r preload.cjs` would BOTH preload `preload.cjs` AND
+  // forward `-r preload.cjs` to the entry's argv, double-effecting the
+  // module load. The schema engine already routes post-entry tokens to
+  // `result.tail`; the rescue scan must respect the same boundary.
+  const scanEnd = rewritten.findIndex(
+    (token) => looksLikeEntryFile(token) || token === "--",
+  );
+  const scanLimit = scanEnd === -1 ? rewritten.length : scanEnd;
+  for (let i = 0; i < scanLimit; i += 1) {
+    const token = rewritten[i]!;
+    if (token === "-r" || token === "--require") {
+      const value = rewritten[i + 1];
+      if (value !== undefined && !value.startsWith("-")) {
+        preload.push(value);
+        i += 1;
+      }
+    } else if (token.startsWith("--require=")) {
+      preload.push(token.slice("--require=".length));
+    }
+  }
 
   return {
-    binary,
-    cacheDir,
-    cwd,
+    binary: getString(result, "--binary"),
+    cacheDir: getString(result, "--cache-dir"),
+    checkers: getNumber(result, "--checkers"),
+    cwd: getString(result, "--cwd"),
     entry,
-    passthrough,
+    noPlugins: getBoolean(result, "--no-plugins") === true,
+    passthrough: postEntryArgs,
     preload,
-    project,
+    project: getString(result, "--tsconfig"),
+    singleThreaded: getBoolean(result, "--singleThreaded") === true,
+    tsgoFlags: [...result.passthrough, ...preEntryValues],
   };
 }
 
+/**
+ * Report whether a bare CLI token is the TypeScript entry file rather than a
+ * forwarded flag's value. ttsx runs a TypeScript entrypoint, so only a token
+ * with a TypeScript source extension is treated as the entry.
+ */
+function looksLikeEntryFile(token: string): boolean {
+  return [".ts", ".tsx", ".mts", ".cts"].some((ext) => token.endsWith(ext));
+}
+
 function printHelp(): void {
   process.stdout.write(
     [
@@ -151,10 +195,16 @@ function printHelp(): void {
       "  --cwd <dir>            Resolve entry/project relative to this directory",
       "  --cache-dir <dir>      Override the runner and source-plugin cache root",
       "  --binary <path>        Use an explicit tsgo binary",
+      "  --no-plugins           Build the project without ttsc plugins",
       "  -r, --require <module> Preload a module before the entrypoint",
+      "  --singleThreaded       Run TypeScript-Go single-threaded (one checker)",
+      "  --checkers <n>         Type-checker pool size (default: TypeScript-Go's)",
       "  -h, --help             Show this help",
       "  -v, --version          Print the runner version",
       "",
+      "  Any other flag before the entry is forwarded to tsgo, so options like",
+      "  --strict apply to the type-check (e.g. ttsx --strict src/index.ts).",
+      "",
       "Examples:",
       "  ttsx src/index.ts",
       "  ttsx --project tsconfig.json src/index.ts -- --port 3000",
@@ -181,14 +231,6 @@ function isRelativeSpecifier(specifier: string): boolean {
   );
 }
 
-function takeValue(flag: string, rest: string[]): string {
-  const value = rest.shift();
-  if (!value) {
-    throw new Error(`ttsx: ${flag} requires a value`);
-  }
-  return value;
-}
-
 function runPreparedEntry(
   parsed: Exclude<ReturnType<typeof parseCLI>, "help" | "version">,
   execution: ReturnType<typeof prepareExecution>,

package/src/plugin/internal/loadProjectPlugins.ts

@@ -120,12 +120,15 @@ export function loadProjectPlugins(options: {
         ? `linked_${String(index).padStart(6, "0")}`
         : undefined;
     return {
+      capabilities: plugin.capabilities,
       contributors,
       config: entries[index]!.config,
       kind,
       label: pluginLabel(plugin, entries[index]!.config, index),
       linkedContributorName,
       name: plugin.name,
+      reportsTypeScriptDiagnostics:
+        plugin.reportsTypeScriptDiagnostics === true,
       source,
       stage,
     };
@@ -196,10 +199,12 @@ export function loadProjectPlugins(options: {
     }
     return {
       binary,
+      capabilities: record.capabilities,
       config: record.config,
       contributors: record.contributors,
       kind: record.kind,
       name: record.name,
+      reportsTypeScriptDiagnostics: record.reportsTypeScriptDiagnostics,
       source: record.source,
       stage: record.stage,
     };
@@ -288,6 +293,14 @@ function composePluginSources(
       ...plugin,
       source: aggregate.plugin.source,
       contributors: aggregate.plugin.contributors,
+      // The composed plugin's runtime BINARY is the aggregate's binary,
+      // so the CLI surface (which flags the sidecar parses) is the
+      // aggregate's. Inherit `capabilities` from the aggregate so a
+      // capability the aggregate declares — e.g. threadingArgs — does
+      // not get silently dropped just because the composed entry's own
+      // descriptor omitted it. If the aggregate did not set capabilities
+      // we keep the composed plugin's own as a fallback.
+      capabilities: aggregate.plugin.capabilities ?? plugin.capabilities,
     };
   });
 }
@@ -545,38 +558,72 @@ function loadPluginEntry(
   context: ITtscPluginFactoryContext,
   baseDir: string,
 ): ITtscPlugin {
-  const specifier = entry.transform;
-  if (typeof specifier !== "string" || specifier.length === 0) {
-    throw new Error(`ttsc: plugin entry is missing a string "transform" field`);
-  }
-
-  const request = resolvePluginRequest(specifier, baseDir);
-  const mod = require(request) as {
-    createTtscPlugin?: TtscPluginFactory;
-    default?: ITtscPlugin | TtscPluginFactory;
-  } & Partial<Record<"plugin", ITtscPlugin | TtscPluginFactory>>;
-  const candidate =
-    mod.createTtscPlugin ??
-    mod.default ??
-    mod.plugin ??
-    (mod as unknown as ITtscPlugin | TtscPluginFactory);
-  if (typeof candidate === "function") {
-    const plugin = candidate(context);
-    if (!isTtscPlugin(plugin)) {
+  return withPluginLoaderEnv(() => {
+    const specifier = entry.transform;
+    if (typeof specifier !== "string" || specifier.length === 0) {
       throw new Error(
-        `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+        `ttsc: plugin entry is missing a string "transform" field`,
       );
     }
-    rejectJsTransformFunctions(specifier, plugin);
-    return plugin;
+
+    const request = resolvePluginRequest(specifier, baseDir);
+    const mod = require(request) as {
+      createTtscPlugin?: TtscPluginFactory;
+      default?: ITtscPlugin | TtscPluginFactory;
+    } & Partial<Record<"plugin", ITtscPlugin | TtscPluginFactory>>;
+    const candidate =
+      mod.createTtscPlugin ??
+      mod.default ??
+      mod.plugin ??
+      (mod as unknown as ITtscPlugin | TtscPluginFactory);
+    if (typeof candidate === "function") {
+      const plugin = candidate(context);
+      if (!isTtscPlugin(plugin)) {
+        throw new Error(
+          `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+        );
+      }
+      rejectJsTransformFunctions(specifier, plugin);
+      return plugin;
+    }
+    if (isTtscPlugin(candidate)) {
+      rejectJsTransformFunctions(specifier, candidate);
+      return candidate;
+    }
+    throw new Error(
+      `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+    );
+  });
+}
+
+function withPluginLoaderEnv<T>(run: () => T): T {
+  const previousNode = process.env.TTSC_NODE_BINARY;
+  const previousTtsx = process.env.TTSC_TTSX_BINARY;
+  process.env.TTSC_NODE_BINARY ??= process.execPath;
+  process.env.TTSC_TTSX_BINARY ??= path.join(
+    __dirname,
+    "..",
+    "..",
+    "launcher",
+    "ttsx.js",
+  );
+  try {
+    return run();
+  } finally {
+    restoreEnv("TTSC_NODE_BINARY", previousNode);
+    restoreEnv("TTSC_TTSX_BINARY", previousTtsx);
   }
-  if (isTtscPlugin(candidate)) {
-    rejectJsTransformFunctions(specifier, candidate);
-    return candidate;
+}
+
+function restoreEnv(
+  key: "TTSC_NODE_BINARY" | "TTSC_TTSX_BINARY",
+  value: string | undefined,
+): void {
+  if (value === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = value;
   }
-  throw new Error(
-    `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
-  );
 }
 
 function isTtscPlugin(value: unknown): value is ITtscPlugin {