@stsepelin/checktrail 0.1.0-alpha.1 → 0.1.0-alpha.3

package/README.md

@@ -4,18 +4,28 @@ Local code validation with a CLI, MCP tools, and evidence of what actually ran.
 
 Formerly Repo Verifier. See the [rename guide](docs/RENAMING.md) for existing source checkouts.
 
-**Experimental preview: 0.1.0-alpha.1.** Public source is available at
+**Published preview: 0.1.0-alpha.2; source candidate: 0.1.0-alpha.3.** Public source is available at
 [stsepelin/checktrail](https://github.com/stsepelin/checktrail).
 See [implementation status](docs/STATUS.md), the [plan](docs/PLAN.md) and the
 [language matrix](docs/LANGUAGES.md) before relying on an adapter.
 [Installation](docs/INSTALLATION.md) covers the CLI, Claude Code and Codex.
+[Agent skills](docs/SKILLS.md) provides setup, validation and review workflows
+installable with `npx skills add stsepelin/checktrail`.
+[Project setup](docs/ONBOARDING.md) covers `init`, `doctor`
+and MCP configuration generator.
 [Release preparation](docs/RELEASE.md) records publication and verification gates. The
 [milestone audit](docs/ACCEPTANCE.md) separates implemented profiles from open
 acceptance work; [client checks](docs/CLIENTS.md) record actual application coverage.
+[Public adoption](docs/PUBLIC-ADOPTION.md) records the published package on five
+pinned libraries, including setup friction and compatibility gaps.
+The alpha.3 candidate fixes the recorded [TypeScript 4.9.5 incompatibility](docs/TYPESCRIPT.md);
+it has not been published.
 
-The [13-job hosted matrix](https://github.com/stsepelin/checktrail/actions/runs/35573066804)
-passed at `52ba415` on Linux and macOS. This identifies a verified source revision;
-it does not imply that a later package version has been published.
+The [hosted matrix](https://github.com/stsepelin/checktrail/actions/runs/35590670960)
+passed at release commit `4ce8398` on Linux and macOS. The exact npm tarball and
+fresh CLI/MCP installations were verified. The
+[MCP Registry entry](https://registry.modelcontextprotocol.io/v0.1/servers/io.github.stsepelin%2Fchecktrail/versions/0.1.0-alpha.2)
+is active; execution remains disabled by default.
 
 Checktrail discovers projects, plans registered checks, invokes native tools
 when explicitly trusted, and reports results without turning skipped or empty
@@ -41,7 +51,7 @@ node dist/src/cli.js run --root examples/javascript --trust-project --detailed
 `--trust-project`: tests, compiler plugins and project configuration can execute
 code with your user privileges. This is not a sandbox.
 
-Commands always return JSON except help/version. Exit codes:
+Successful commands return JSON except help/version; input errors use stderr. Exit codes:
 
 | Code | Meaning                                                                                 |
 | ---- | --------------------------------------------------------------------------------------- |

package/dist/src/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import path from "node:path";
+import { initialize, diagnose, mcpConfiguration, mcpClients, } from "./onboarding.js";
 import { createReviewContext, projectReviewContext, receiveReview, projectReviewReceipt, } from "./review.js";
 import { fetchPolicyPack } from "./fetch-pack.js";
 import { externalReferencesSchema, loadExternalAdapters, } from "./external-adapter.js";
@@ -22,11 +23,15 @@ import { VERSION } from "./types.js";
 import { validateContracts, projectContractReport } from "./contracts.js";
 import { compareRuntimeInventories, projectRuntimeComparison, } from "./runtime-inventory.js";
 async function main() {
-    const { values, positionals } = parseArgs({
+    const { values, positionals, tokens } = parseArgs({
+        tokens: true,
         allowPositionals: true,
         strict: true,
         options: {
             root: { type: "string", default: "." },
+            write: { type: "boolean", default: false },
+            check: { type: "string", multiple: true },
+            client: { type: "string" },
             "trust-project": { type: "boolean", default: false },
             "allow-execution": { type: "boolean", default: false },
             detailed: { type: "boolean", default: false },
@@ -58,12 +63,29 @@ async function main() {
         return;
     }
     if (values.help || positionals.length === 0) {
-        process.stdout.write("checktrail <inspect|plan|run|serve|adapters|import-junit|export-sarif|create-baseline|compare-findings|compare-runtime|check-contracts|check-architecture|guidance|review-context|review-receipt|mutate|fetch-pack> [--root PATH] [--detailed] [--base REVISION] [--policy-overlay PATH] [--adapter PATH#sha256=DIGEST ...]\nRun: --trust-project [--timeout-ms 30000] [--allow-env NAME ...]\nServe: --allow-execution (optional; disabled by default) [--allow-env NAME ...]\nFetch-pack: --url HTTPS_URL --sha256 DIGEST --output RELATIVE_JSON_PATH\nExit: 0 passed/read-only success/completed advisory experiment, 1 failed checks, 2 incomplete/error\n");
+        process.stdout.write("checktrail <init|doctor|mcp-config|inspect|plan|run|serve|adapters|import-junit|export-sarif|create-baseline|compare-findings|compare-runtime|check-contracts|check-architecture|guidance|review-context|review-receipt|mutate|fetch-pack> [--root PATH] [--detailed] [--base REVISION] [--policy-overlay PATH] [--adapter PATH#sha256=DIGEST ...]\nInit: [--write] [--check PATH#CHECK_ID ...] (preview by default; preserves existing config)\nDoctor: [--detailed] [--policy-overlay PATH] [--allow-env NAME ...] [--adapter PATH#sha256=DIGEST ...] (no execution)\nMcp-config: --client codex|claude-code|claude-desktop|cursor|vscode (prints configuration only)\nRun: --trust-project [--timeout-ms 30000] [--allow-env NAME ...]\nServe: --allow-execution (optional; disabled by default) [--allow-env NAME ...]\nFetch-pack: --url HTTPS_URL --sha256 DIGEST --output RELATIVE_JSON_PATH\nExit: 0 passed/read-only success/completed advisory experiment, 1 failed checks, 2 incomplete/error\n");
         return;
     }
     if (positionals.length !== 1)
         throw new Error("Expected exactly one command");
     const command = positionals[0];
+    for (const token of tokens) {
+        if (token.kind !== "option")
+            continue;
+        if (["write", "check"].includes(token.name) && command !== "init")
+            throw new Error(`--${token.name} applies only to init`);
+        if (token.name === "client" && command !== "mcp-config")
+            throw new Error("--client applies only to mcp-config");
+        const allowed = command === "init"
+            ? ["root", "write", "check"]
+            : command === "doctor"
+                ? ["root", "detailed", "policy-overlay", "allow-env", "adapter"]
+                : command === "mcp-config"
+                    ? ["root", "client"]
+                    : undefined;
+        if (allowed && !allowed.includes(token.name))
+            throw new Error(`--${token.name} does not apply to ${command}`);
+    }
     if (values["allow-review-source"] &&
         (!values.detailed ||
             !["review-context", "review-receipt", "serve"].includes(command)))
@@ -85,7 +107,15 @@ async function main() {
         };
     }));
     if (externalAdapters.length &&
-        !["inspect", "plan", "run", "serve", "adapters", "guidance"].includes(command))
+        ![
+            "inspect",
+            "plan",
+            "run",
+            "serve",
+            "adapters",
+            "guidance",
+            "doctor",
+        ].includes(command))
         throw new Error("External adapters apply only to inspection, planning, validation, serving and derived guidance");
     if (externalAdapters.length && command === "guidance" && values.input)
         throw new Error("External adapters require derived guidance, not an imported context");
@@ -103,7 +133,49 @@ async function main() {
         ]);
         return;
     }
+    if (command === "doctor") {
+        const result = await diagnose(values.root, {
+            detailed: values.detailed,
+            externalAdapters,
+            environment: inheritEnvironment(values["allow-env"] ?? []),
+            ...(values["policy-overlay"]
+                ? { policyOverlay: values["policy-overlay"] }
+                : {}),
+        });
+        print(result);
+        process.exitCode = result.status === "no-static-blockers" ? 0 : 2;
+        return;
+    }
     const root = await realpath(values.root);
+    if (command === "init") {
+        const selections = new Map();
+        for (const value of values.check ?? []) {
+            const split = value.lastIndexOf("#");
+            if (split <= 0 || split === value.length - 1)
+                throw new Error("Check selection requires PATH#CHECK_ID");
+            const selectedPath = value.slice(0, split);
+            selections.set(selectedPath, [
+                ...(selections.get(selectedPath) ?? []),
+                value.slice(split + 1),
+            ]);
+        }
+        const result = await initialize(root, {
+            write: values.write,
+            selections: [...selections].map(([selectedPath, checks]) => ({
+                path: selectedPath,
+                checks,
+            })),
+        });
+        print(result);
+        process.exitCode = result.status === "needs-selection" ? 2 : 0;
+        return;
+    }
+    if (command === "mcp-config") {
+        if (!mcpClients.includes(values.client))
+            throw new Error(`mcp-config requires --client ${mcpClients.join("|")}`);
+        print(await mcpConfiguration(root, values.client));
+        return;
+    }
     if (command === "fetch-pack") {
         if (!values.url || !values.sha256 || !values.output)
             throw new Error("fetch-pack requires --url HTTPS_URL --sha256 DIGEST --output RELATIVE_JSON_PATH");

package/dist/src/index.d.ts

@@ -3,6 +3,8 @@ export { validateContracts } from "./contracts.js";
 export type { ContractBundle, ContractReport } from "./contract-schema.js";
 export type { PlanOptions, ValidationOptions } from "./engine.js";
 export { adapters } from "./adapters.js";
+export { initialize, diagnose, mcpConfiguration, mcpClients, } from "./onboarding.js";
+export type { InitOptions, InitResult, DoctorIssue, DoctorResult, McpClient, } from "./onboarding.js";
 export type { PolicyPack, PackReference } from "./policy-pack.js";
 export { fetchPolicyPack } from "./fetch-pack.js";
 export type { FetchPackOptions, FetchedPack } from "./fetch-pack.js";

package/dist/src/index.js

@@ -1,6 +1,7 @@
 export { createPlan, validate, aggregate } from "./engine.js";
 export { validateContracts } from "./contracts.js";
 export { adapters } from "./adapters.js";
+export { initialize, diagnose, mcpConfiguration, mcpClients, } from "./onboarding.js";
 export { fetchPolicyPack } from "./fetch-pack.js";
 export { projectPlan, projectReport } from "./output.js";
 export { importJUnit } from "./junit.js";

package/dist/src/onboarding.d.ts

@@ -0,0 +1,50 @@
+import { type Config } from "./config.js";
+import { type PlanOptions } from "./engine.js";
+export interface InitOptions {
+    write?: boolean;
+    selections?: {
+        path: string;
+        checks: string[];
+    }[];
+}
+export interface InitResult {
+    schemaVersion: 1;
+    engineVersion: string;
+    status: "preview" | "created" | "preserved" | "needs-selection";
+    configuration: Config | null;
+    unresolved: {
+        path: string;
+        adapter: string;
+        choices: string[];
+    }[];
+    executionEnabled: false;
+}
+export declare function initialize(root: string, options?: InitOptions): Promise<InitResult>;
+export interface DoctorIssue {
+    code: "configuration-error" | "empty-plan" | "unselected-project" | "unavailable-check" | "missing-executable" | "package-metadata" | "unsupported-platform";
+    check?: string;
+    adapter?: string;
+    project?: string;
+    detail?: string;
+}
+export interface DoctorResult {
+    schemaVersion: 1;
+    engineVersion: string;
+    status: "no-static-blockers" | "attention-required";
+    validationPerformed: false;
+    projects: number;
+    checks: number;
+    issues: DoctorIssue[];
+    unverified: string[];
+}
+export declare function diagnose(root: string, options?: Omit<PlanOptions, "base"> & {
+    detailed?: boolean;
+}): Promise<DoctorResult>;
+export declare const mcpClients: readonly ["codex", "claude-code", "claude-desktop", "cursor", "vscode"];
+export type McpClient = (typeof mcpClients)[number];
+export declare function mcpConfiguration(root: string, client: McpClient): Promise<{
+    client: McpClient;
+    format: "json" | "toml";
+    configuration: string;
+    executionEnabled: false;
+}>;

package/dist/src/onboarding.js

@@ -0,0 +1,295 @@
+import { constants } from "node:fs";
+import { access, link, lstat, mkdtemp, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { adapters, checksFor } from "./adapters.js";
+import { configSchema } from "./config.js";
+import { createPlan } from "./engine.js";
+import { inventory, readProjectFile } from "./inventory.js";
+import { identifyTool } from "./tool-versions.js";
+import { VERSION } from "./types.js";
+async function configurationExists(root) {
+    try {
+        const entry = await lstat(path.join(root, "checktrail.json"));
+        if (!entry.isFile() || entry.isSymbolicLink())
+            throw new Error("checktrail.json must be a regular file, not a symlink or directory");
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function initialize(root, options = {}) {
+    root = await realpath(root);
+    const exists = await configurationExists(root);
+    const { source, plan } = await createPlan(root);
+    const result = {
+        schemaVersion: 1,
+        engineVersion: VERSION,
+        status: "preview",
+        configuration: null,
+        unresolved: [],
+        executionEnabled: false,
+    };
+    if (exists) {
+        if (options.selections?.length)
+            throw new Error("Existing configuration is preserved; edit its policy explicitly to change checks");
+        return { ...result, status: "preserved" };
+    }
+    const selected = new Map();
+    for (const selection of options.selections ?? []) {
+        if (selected.has(selection.path))
+            throw new Error("Duplicate selection path");
+        if (!selection.checks.length ||
+            new Set(selection.checks).size !== selection.checks.length)
+            throw new Error("Selections require nonempty, unique check IDs");
+        selected.set(selection.path, selection.checks);
+    }
+    for (const selectedPath of selected.keys())
+        if (!plan.projects.some((project) => project.path === selectedPath))
+            throw new Error("Selection does not match a discovered project path");
+    const grouped = new Map();
+    for (const project of plan.projects) {
+        const registered = adapters.find((adapter) => adapter.id === project.adapter).checks;
+        const requested = selected.get(project.path);
+        let ids = requested?.filter((id) => registered.includes(id));
+        if (!requested) {
+            ids = plan.checks
+                .filter((check) => check.project === project.path &&
+                check.adapter === project.adapter &&
+                registered.includes(check.id))
+                .map((check) => check.id);
+            if (project.adapter === "python")
+                ids = [];
+            if (project.adapter === "javascript") {
+                const manifest = JSON.parse(await readProjectFile(root, path.posix.join(project.path, "package.json")));
+                const runners = {
+                    "node --test": "javascript.node-test",
+                    "vitest run": "javascript.vitest",
+                    jest: "javascript.jest",
+                    "playwright test": "javascript.playwright",
+                };
+                const script = manifest?.scripts?.test;
+                ids =
+                    typeof script === "string" && Object.hasOwn(runners, script)
+                        ? [runners[script]]
+                        : [];
+            }
+        }
+        if (!ids?.length ||
+            plan.checks.some((check) => check.project === project.path &&
+                check.adapter === project.adapter &&
+                check.kind === "unsupported")) {
+            result.unresolved.push({
+                path: project.path,
+                adapter: project.adapter,
+                choices: [...registered],
+            });
+            continue;
+        }
+        const candidates = await checksFor(source, project, ids);
+        if (ids.some((id) => !candidates.some((check) => check.id === id)))
+            throw new Error("Selected check is inapplicable to the discovered project");
+        const checks = grouped.get(project.path) ?? new Set();
+        for (const id of ids)
+            checks.add(id);
+        grouped.set(project.path, checks);
+    }
+    for (const [selectedPath, ids] of selected)
+        if (ids.some((id) => !grouped.get(selectedPath)?.has(id)))
+            throw new Error("Selected check is unknown or inapplicable");
+    if (!plan.projects.length || result.unresolved.length)
+        return { ...result, status: "needs-selection" };
+    result.configuration = configSchema.parse({
+        schemaVersion: 1,
+        projects: [...grouped].map(([projectPath, checks]) => ({
+            path: projectPath,
+            checks: [...checks].sort(),
+        })),
+    });
+    if (!options.write)
+        return result;
+    if ((await inventory(root)).fingerprint !== source.fingerprint)
+        throw new Error("Project changed during setup; review a fresh preview");
+    const temporary = await mkdtemp(path.join(root, ".checktrail-init-"));
+    try {
+        const staged = path.join(temporary, "checktrail.json");
+        await writeFile(staged, `${JSON.stringify(result.configuration, null, 2)}\n`, { flag: "wx", mode: 0o600 });
+        // An exclusive link publishes complete bytes without replacing a concurrent writer.
+        await link(staged, path.join(root, "checktrail.json"));
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    return { ...result, status: "created" };
+}
+async function executableAvailable(executable, cwd, searchPath) {
+    const candidates = executable.includes("/") || path.isAbsolute(executable)
+        ? [path.resolve(cwd, executable)]
+        : searchPath
+            .split(path.delimiter)
+            .map((directory) => path.resolve(cwd, directory, executable));
+    for (const candidate of candidates) {
+        try {
+            if (!(await stat(candidate)).isFile())
+                continue;
+            await access(candidate, constants.X_OK);
+            return true;
+        }
+        catch {
+            /* Other PATH entries may provide the executable. */
+        }
+    }
+    return false;
+}
+export async function diagnose(root, options = {}) {
+    const issues = [];
+    const result = {
+        schemaVersion: 1,
+        engineVersion: VERSION,
+        status: "attention-required",
+        validationPerformed: false,
+        projects: 0,
+        checks: 0,
+        issues,
+        unverified: [
+            "Tool versions and runtime compatibility",
+            "Importable modules and runtime services",
+            "Validation results; run with explicit project trust",
+        ],
+    };
+    const add = (issue) => {
+        const summary = { ...issue };
+        delete summary.project;
+        delete summary.detail;
+        issues.push(options.detailed ? issue : summary);
+    };
+    if (process.platform === "win32")
+        add({ code: "unsupported-platform" });
+    try {
+        root = await realpath(root);
+        await configurationExists(root);
+        const { plan } = await createPlan(root, {
+            ...(options.externalAdapters
+                ? { externalAdapters: options.externalAdapters }
+                : {}),
+            ...(options.policyOverlay
+                ? { policyOverlay: options.policyOverlay }
+                : {}),
+            ...(options.environment ? { environment: options.environment } : {}),
+        });
+        result.projects = plan.projects.length;
+        result.checks = plan.checks.length;
+        if (!plan.checks.length)
+            add({ code: "empty-plan" });
+        for (const project of plan.projects)
+            if (!plan.checks.some((check) => check.project === project.path && check.adapter === project.adapter))
+                add({
+                    code: "unselected-project",
+                    project: project.path,
+                    adapter: project.adapter,
+                });
+        for (const check of plan.checks) {
+            const context = {
+                check: check.id,
+                adapter: check.adapter,
+                project: check.project,
+            };
+            if (check.unavailableReason)
+                add({
+                    ...context,
+                    code: "unavailable-check",
+                    detail: check.unavailableReason,
+                });
+            const commands = [...check.commands];
+            for (const tool of check.tools ?? []) {
+                if (tool.source === "version-command")
+                    commands.push(tool.command);
+                else if (tool.source === "package-metadata") {
+                    const identity = await identifyTool(root, tool, async () => {
+                        throw new Error("Doctor must not execute version probes");
+                    });
+                    if (identity.status !== "identified")
+                        add({
+                            ...context,
+                            code: "package-metadata",
+                            detail: `Missing or invalid package metadata: ${tool.name}`,
+                        });
+                }
+            }
+            const wrapped = check.adapter === "jvm"
+                ? ["java"]
+                : check.adapter === "dotnet"
+                    ? ["dotnet"]
+                    : check.id === "infrastructure.actionlint"
+                        ? ["actionlint"]
+                        : [];
+            for (const executable of wrapped)
+                commands.push({ executable, args: [], cwd: check.project });
+            const checked = new Set();
+            for (const command of commands) {
+                const searchPath = command.env?.PATH ??
+                    (check.environment?.includes("PATH")
+                        ? options.environment?.PATH
+                        : undefined) ??
+                    process.env.PATH ??
+                    "/usr/bin:/bin";
+                const cwd = path.resolve(root, command.cwd);
+                const key = JSON.stringify([command.executable, cwd, searchPath]);
+                if (checked.has(key))
+                    continue;
+                checked.add(key);
+                if (!(await executableAvailable(command.executable, cwd, searchPath)))
+                    add({
+                        ...context,
+                        code: "missing-executable",
+                        detail: `Executable unavailable or not executable: ${command.executable}`,
+                    });
+            }
+        }
+    }
+    catch (error) {
+        add({
+            code: "configuration-error",
+            detail: error instanceof Error ? error.message : "Cannot inspect project",
+        });
+    }
+    result.status = issues.length ? "attention-required" : "no-static-blockers";
+    return result;
+}
+export const mcpClients = [
+    "codex",
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "vscode",
+];
+export async function mcpConfiguration(root, client) {
+    if (!mcpClients.includes(client))
+        throw new Error("Unknown MCP client");
+    root = await realpath(root);
+    if (!(await stat(root)).isDirectory())
+        throw new Error("MCP root must be a directory");
+    if (root.includes("${"))
+        throw new Error("MCP root contains client variable syntax; choose a path without ${");
+    const server = {
+        command: "npx",
+        args: [
+            "--yes",
+            "--ignore-scripts",
+            `@stsepelin/checktrail@${VERSION}`,
+            "serve",
+            "--root",
+            root,
+        ],
+    };
+    return {
+        client,
+        executionEnabled: false,
+        format: client === "codex" ? "toml" : "json",
+        configuration: client === "codex"
+            ? `[mcp_servers.checktrail]\ncommand = "npx"\nargs = ${JSON.stringify(server.args)}\n`
+            : `${JSON.stringify(client === "vscode" ? { servers: { checktrail: { type: "stdio", ...server } } } : { mcpServers: { checktrail: server } }, null, 2)}\n`,
+    };
+}

package/dist/src/types.d.ts

@@ -1,6 +1,6 @@
 import type { ExternalIdentity } from "./external-adapter.js";
 import type { RuntimeInventory } from "./runtime-inventory.js";
-export declare const VERSION = "0.1.0-alpha.1";
+export declare const VERSION = "0.1.0-alpha.3";
 export declare const PARSERS: readonly ["vue-router-json", "nuxt-json", "exit", "empty", "node-events", "unittest", "go-scope-test", "go-scope-analysis", "golangci-json", "staticcheck-json", "go-json", "typescript-build-json", "tsc-files", "eslint-json", "vitest-json", "playwright-json", "jest-json", "pytest-json", "fastapi-json", "django-json", "laravel-json", "rust-json", "clang-json", "java-json", "dotnet-json", "actionlint-json", "external-json", "ruby-syntax", "silent-syntax", "ruff-json", "mypy-json", "phpstan-json", "phpunit-junit", "pint-json"];
 export type Status = "passed" | "failed" | "unavailable" | "skipped" | "error" | "inconclusive";
 export type Outcome = "passed" | "failed" | "incomplete";

package/dist/src/types.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.1.0-alpha.1";
+export const VERSION = "0.1.0-alpha.3";
 export const PARSERS = [
     "vue-router-json",
     "nuxt-json",

package/dist/src/typescript-arguments.d.ts

@@ -0,0 +1,4 @@
+import type { parseCommandLine } from "typescript";
+export declare function typecheckArguments(compiler: {
+    parseCommandLine: typeof parseCommandLine;
+}, args: string[]): string[];

package/dist/src/typescript-arguments.js

@@ -0,0 +1,10 @@
+export function typecheckArguments(compiler, args) {
+    const probe = compiler.parseCommandLine(["--noCheck", "false"]);
+    if (probe.errors.length === 0 && probe.options.noCheck === false)
+        return [...args, "--noCheck", "false"];
+    if (probe.errors.length === 1 &&
+        probe.errors[0].code === 5023 &&
+        probe.options.noCheck === undefined)
+        return args;
+    throw new Error("Cannot establish the compiler's noCheck option support");
+}

package/dist/src/typescript-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/typescript-runner.js

@@ -0,0 +1,19 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { withinRoot } from "./inventory.js";
+import { typecheckArguments } from "./typescript-arguments.js";
+async function main() {
+    const [entry, root, ...args] = process.argv.slice(2);
+    if (!entry || !root)
+        throw new Error("Invalid TypeScript compiler arguments");
+    const tool = await withinRoot(root, path.relative(root, entry));
+    const api = await withinRoot(root, path.relative(root, path.resolve(path.dirname(tool), "../lib/typescript.js")));
+    const load = createRequire(tool);
+    const ts = load(api);
+    process.argv = [process.execPath, tool, ...typecheckArguments(ts, args)];
+    load(tool);
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "TypeScript checking failed"}\n`);
+    process.exitCode = 2;
+});

package/dist/src/typescript.js

@@ -16,18 +16,12 @@ export async function typescriptCheck(source, project, vue = false) {
                 {
                     executable: process.execPath,
                     args: [
-                        ...(vue
-                            ? [
-                                fileURLToPath(new URL("./vue-tsc-runner.js", import.meta.url)),
-                                compiler,
-                                source.root,
-                            ]
-                            : [compiler]),
+                        fileURLToPath(new URL(vue ? "./vue-tsc-runner.js" : "./typescript-runner.js", import.meta.url)),
+                        compiler,
+                        source.root,
                         "--project",
                         "./tsconfig.json",
                         "--noEmit",
-                        "--noCheck",
-                        "false",
                         "--pretty",
                         "false",
                         "--incremental",

package/dist/src/vue-tsc-runner.js

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
 import path from "node:path";
+import { typecheckArguments } from "./typescript-arguments.js";
 import { withinRoot } from "./inventory.js";
 async function main() {
     const [entry, root, ...args] = process.argv.slice(2);
@@ -15,7 +16,7 @@ async function main() {
         throw new Error("Vue template checking is disabled by skipTemplateCodegen");
     const compiler = load(tool);
     const tsc = await resolve("typescript/lib/tsc.js");
-    process.argv = [process.execPath, tool, ...args];
+    process.argv = [process.execPath, tool, ...typecheckArguments(ts, args)];
     compiler.run(tsc);
 }
 main().catch((error) => {