@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/types.d.ts

@@ -0,0 +1,157 @@
+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 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";
+export interface Inventory {
+    root: string;
+    files: string[];
+    excluded: string[];
+    fingerprint: string;
+}
+export interface Project {
+    path: string;
+    adapter: string;
+    markers: string[];
+    files: string[];
+}
+export interface Command {
+    temporaryDirectory?: boolean;
+    executable: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+}
+export type ToolSpec = {
+    name: "node";
+    source: "engine-runtime";
+} | {
+    name: string;
+    source: "package-metadata";
+    path: string | null;
+} | {
+    name: string;
+    source: "version-command";
+    command: Command;
+};
+export interface ToolEvidence {
+    name: string;
+    source: ToolSpec["source"];
+    version: string | null;
+    status: "identified" | "unavailable" | "inconclusive";
+    process?: ProcessResult;
+    path?: string;
+}
+export interface Check {
+    external?: ExternalIdentity;
+    id: string;
+    adapter: string;
+    project: string;
+    scope: string[];
+    kind: "format" | "analysis" | "test" | "syntax" | "unsupported";
+    parser: (typeof PARSERS)[number];
+    commands: Command[];
+    reason: string;
+    unavailableReason?: string;
+    tools?: ToolSpec[];
+    environment?: string[];
+}
+export interface Workspace {
+    complete: boolean;
+    dependencies: {
+        consumer: string;
+        producer: string;
+    }[];
+}
+export interface GitIdentity {
+    baseCommit: string;
+    headCommit: string;
+    version: string;
+    worktreeId: string;
+    indexFingerprint: string;
+}
+export interface ChangeSelection {
+    mode: "full" | "affected";
+    reason: string;
+    changedFiles: string[];
+    selectedProjects: string[];
+    git?: GitIdentity;
+}
+export interface Plan {
+    schemaVersion: 1;
+    engineVersion: string;
+    sourceFingerprint: string;
+    policyFingerprint: string;
+    excluded: string[];
+    projects: Project[];
+    checks: Check[];
+    workspace?: Workspace;
+    selection?: ChangeSelection;
+}
+export interface ProcessResult {
+    command: Command;
+    exitCode: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    cancelled: boolean;
+    truncated: boolean;
+    errorCode?: string;
+}
+export interface TestEvidence {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+export interface Finding {
+    ruleId: string;
+    level: "error" | "warning" | "note";
+    message: string;
+    file?: string;
+    line?: number;
+}
+export interface CheckResult {
+    external?: ExternalIdentity & {
+        tools?: {
+            name: string;
+            version: string;
+            source: "adapter-reported";
+        }[];
+    };
+    runtime?: RuntimeInventory;
+    id: string;
+    adapter: string;
+    project: string;
+    scope: string[];
+    status: Status;
+    reason: string;
+    processes: ProcessResult[];
+    tests?: TestEvidence;
+    findings?: Finding[];
+    findingsComplete?: boolean;
+    environment?: {
+        names: string[];
+        fingerprint: string;
+    };
+    tools?: ToolEvidence[];
+}
+export interface Report {
+    selection?: ChangeSelection;
+    schemaVersion: 1;
+    engineVersion: string;
+    runId: string;
+    startedAt: string;
+    durationMs: number;
+    sourceFingerprint: string;
+    finalSourceFingerprint: string | null;
+    policyFingerprint: string;
+    sourceChanged: boolean;
+    sourceError: boolean;
+    excluded: string[];
+    outcome: Outcome;
+    checks: CheckResult[];
+}

package/dist/src/types.js

@@ -0,0 +1,37 @@
+export const VERSION = "0.1.0-alpha.1";
+export const PARSERS = [
+    "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",
+];

package/dist/src/typescript-build-evidence.d.ts

@@ -0,0 +1,2 @@
+import type { Check, CheckResult, ProcessResult } from "./types.js";
+export declare function typescriptBuildEvidence(check: Check, processes: ProcessResult[], root: string | undefined): Pick<CheckResult, "status" | "reason" | "findings" | "findingsComplete">;

package/dist/src/typescript-build-evidence.js

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { z } from "zod";
+const schema = z.object({
+    version: z.literal(1),
+    exitStatus: z.number().int().nonnegative(),
+    programs: z.number().int().nonnegative(),
+    configs: z.array(z.string()),
+    files: z.array(z.string()),
+    diagnostics: z.array(z.object({
+        code: z.number().int(),
+        message: z.string(),
+        file: z.string().optional(),
+        line: z.number().int().positive().optional(),
+    })),
+});
+export function typescriptBuildEvidence(check, processes, root) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "TypeScript solution evidence is incomplete or omits inventoried source.",
+    };
+    if (!root || processes.length !== 1 || !check.scope.length)
+        return incomplete;
+    const process = processes[0];
+    if (![0, 1].includes(process.exitCode ?? -1))
+        return {
+            status: "error",
+            reason: "TypeScript solution configuration or its supported integration could not run.",
+        };
+    try {
+        const report = schema.parse(JSON.parse(process.stdout));
+        const inside = (file) => {
+            const relative = path.relative(root, file);
+            return (path.isAbsolute(file) &&
+                relative !== ".." &&
+                !relative.startsWith(".." + path.sep) &&
+                !path.isAbsolute(relative));
+        };
+        if ([...report.files, ...report.configs].some((file) => !inside(file)) ||
+            new Set(report.files).size !== report.files.length ||
+            new Set(report.configs).size !== report.configs.length)
+            return incomplete;
+        if (report.diagnostics.some((diagnostic) => diagnostic.file && !inside(diagnostic.file)))
+            return incomplete;
+        const findings = report.diagnostics.map((diagnostic) => ({
+            ruleId: "TS" + diagnostic.code,
+            level: "error",
+            message: diagnostic.message,
+            ...(diagnostic.file
+                ? {
+                    file: path
+                        .relative(root, diagnostic.file)
+                        .split(path.sep)
+                        .join("/"),
+                }
+                : {}),
+            ...(diagnostic.line ? { line: diagnostic.line } : {}),
+        }));
+        if (findings.length || report.exitStatus !== 0 || process.exitCode !== 0)
+            return {
+                status: "failed",
+                reason: "TypeScript solution reported compiler or configuration diagnostics.",
+                findings,
+                findingsComplete: report.programs > 0 &&
+                    report.configs.length > 0 &&
+                    !process.stderr.trim() &&
+                    check.scope.every((file) => report.files.includes(path.resolve(root, check.project, file))) &&
+                    process.exitCode === 1 &&
+                    report.diagnostics.length > 0 &&
+                    report.diagnostics.every((diagnostic) => diagnostic.file && diagnostic.code >= 2000),
+            };
+        if (!report.programs ||
+            !report.configs.length ||
+            process.stderr.trim() ||
+            check.scope.some((file) => !report.files.includes(path.resolve(root, check.project, file))))
+            return incomplete;
+        return {
+            status: "passed",
+            reason: "TypeScript checked the inventoried solution source using fresh in-memory build outputs.",
+            findings,
+            findingsComplete: true,
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

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

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

package/dist/src/typescript-build-runner.js

@@ -0,0 +1,132 @@
+import { createRequire } from "node:module";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { withinRoot } from "./inventory.js";
+async function main() {
+    const [entry, root] = process.argv.slice(2);
+    if (!entry || !root)
+        throw new Error("Invalid TypeScript solution arguments");
+    const tool = await withinRoot(root, path.relative(root, entry));
+    const ts = createRequire(tool)(tool);
+    if (ts.version !== "6.0.3")
+        throw new Error("TypeScript solution integration requires verified version 6.0.3");
+    const normalize = (file) => path.resolve(file);
+    const inside = (file) => {
+        const relative = path.relative(root, normalize(file));
+        return (relative !== ".." &&
+            !relative.startsWith(".." + path.sep) &&
+            !path.isAbsolute(relative));
+    };
+    const readable = (file) => {
+        try {
+            return inside(file) && inside(realpathSync(file));
+        }
+        catch {
+            return false;
+        }
+    };
+    const memory = new Map();
+    const directories = new Set();
+    let bytes = 0;
+    const system = {
+        ...ts.sys,
+        fileExists: (file) => memory.has(normalize(file)) ||
+            (!file.endsWith(".tsbuildinfo") &&
+                readable(file) &&
+                ts.sys.fileExists(file)),
+        readFile: (file) => memory.get(normalize(file)) ??
+            (!file.endsWith(".tsbuildinfo") && readable(file)
+                ? ts.sys.readFile(file)
+                : undefined),
+        directoryExists: (directory) => directories.has(normalize(directory)) ||
+            (readable(directory) && ts.sys.directoryExists(directory)),
+        getDirectories: (directory) => readable(directory) ? ts.sys.getDirectories(directory) : [],
+        readDirectory: (directory, ...args) => readable(directory)
+            ? ts.sys.readDirectory(directory, ...args).filter(readable)
+            : [],
+        writeFile: (file, text) => {
+            const target = normalize(file);
+            if (!inside(target))
+                throw new Error("TypeScript output escapes the configured root");
+            bytes +=
+                Buffer.byteLength(text) - Buffer.byteLength(memory.get(target) ?? "");
+            if (bytes > 64 * 1024 * 1024 || memory.size >= 20_000)
+                throw new Error("TypeScript in-memory output limit exceeded");
+            memory.set(target, text);
+            let directory = path.dirname(target);
+            while (inside(directory)) {
+                directories.add(directory);
+                if (directory === root)
+                    break;
+                directory = path.dirname(directory);
+            }
+        },
+        createDirectory: (directory) => {
+            if (!inside(directory))
+                throw new Error("TypeScript output escapes the configured root");
+            directories.add(normalize(directory));
+        },
+        getModifiedTime: (file) => memory.has(normalize(file))
+            ? new Date()
+            : file.endsWith(".tsbuildinfo")
+                ? undefined
+                : readable(file)
+                    ? ts.sys.getModifiedTime?.(file)
+                    : undefined,
+        setModifiedTime: () => { },
+        deleteFile: (file) => {
+            memory.delete(normalize(file));
+        },
+    };
+    const diagnostics = [];
+    const configs = new Set();
+    const files = new Set();
+    let programs = 0;
+    const host = ts.createSolutionBuilderHost(system, undefined, (diagnostic) => diagnostics.push(diagnostic));
+    host.getParsedCommandLine = (file) => {
+        if (!readable(file))
+            throw new Error("TypeScript referenced configuration is missing or outside the configured root");
+        configs.add(normalize(file));
+        return ts.getParsedCommandLineOfConfigFile(file, { noCheck: false, noEmit: false, noEmitOnError: true, incremental: true }, {
+            ...system,
+            onUnRecoverableConfigFileDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+        });
+    };
+    host.afterProgramEmitAndDiagnostics = (program) => {
+        programs++;
+        for (const file of program.getSourceFiles())
+            files.add(normalize(file.fileName));
+    };
+    const exitStatus = ts
+        .createSolutionBuilder(host, [path.resolve("tsconfig.json")], {
+        force: true,
+    })
+        .build();
+    process.stdout.write(JSON.stringify({
+        version: 1,
+        exitStatus,
+        programs,
+        configs: [...configs].sort(),
+        files: [...files].sort(),
+        diagnostics: diagnostics.map((diagnostic) => ({
+            code: diagnostic.code,
+            message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+            ...(diagnostic.file
+                ? {
+                    file: normalize(diagnostic.file.fileName),
+                    ...(diagnostic.start === undefined
+                        ? {}
+                        : {
+                            line: diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1,
+                        }),
+                }
+                : {}),
+        })),
+    }) + "\n");
+    process.exitCode = exitStatus === 0 && !diagnostics.length ? 0 : 1;
+}
+main().catch((error) => {
+    process.stderr.write((error instanceof Error ? error.message : "TypeScript solution failed") +
+        "\n");
+    process.exitCode = 2;
+});

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

@@ -0,0 +1,2 @@
+import type { Check, Inventory, Project } from "./types.js";
+export declare function typescriptBuildCheck(source: Inventory, project: Project): Promise<Check>;

package/dist/src/typescript-build.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { localTool } from "./local-tool.js";
+export async function typescriptBuildCheck(source, project) {
+    const files = source.files
+        .filter((file) => (project.path === "." || file.startsWith(project.path + "/")) &&
+        /\.(?:[cm]?ts|tsx)$/.test(file))
+        .map((file) => path.posix.relative(project.path, file));
+    const tool = await localTool(source.root, project.path, "typescript/lib/typescript.js");
+    const check = {
+        id: "javascript.typescript-build",
+        adapter: project.adapter,
+        project: project.path,
+        scope: files,
+        kind: "analysis",
+        parser: "typescript-build-json",
+        reason: "Type-check the complete TypeScript solution with fresh in-memory declaration outputs and native source accounting.",
+        commands: tool
+            ? [
+                {
+                    executable: process.execPath,
+                    args: [
+                        fileURLToPath(new URL("./typescript-build-runner.js", import.meta.url)),
+                        tool,
+                        source.root,
+                    ],
+                    cwd: project.path,
+                },
+            ]
+            : [],
+    };
+    if (!project.files.includes("tsconfig.json"))
+        check.unavailableReason = "A project-local tsconfig.json is required.";
+    else if (!files.length)
+        check.unavailableReason =
+            "No TypeScript source was inventoried under the solution root.";
+    else if (!tool)
+        check.unavailableReason =
+            "TypeScript is not installed within the configured root.";
+    return check;
+}

package/dist/src/typescript.d.ts

@@ -0,0 +1,2 @@
+import type { Check, Inventory, Project } from "./types.js";
+export declare function typescriptCheck(source: Inventory, project: Project, vue?: boolean): Promise<Check>;

package/dist/src/typescript.js

@@ -0,0 +1,54 @@
+import { fileURLToPath } from "node:url";
+import { localTool } from "./local-tool.js";
+export async function typescriptCheck(source, project, vue = false) {
+    const files = project.files.filter((file) => /\.(?:[cm]?ts|tsx)$/.test(file) || (vue && file.endsWith(".vue")));
+    const compiler = await localTool(source.root, project.path, vue ? "vue-tsc/index.js" : "typescript/bin/tsc");
+    const check = {
+        id: vue ? "javascript.vue-tsc" : "javascript.typescript",
+        adapter: project.adapter,
+        project: project.path,
+        scope: files,
+        kind: "analysis",
+        parser: "tsc-files",
+        reason: "Type-check tsconfig.json without emitting code or incremental state; require every inventoried TypeScript file in the compiler file list.",
+        commands: compiler
+            ? [
+                {
+                    executable: process.execPath,
+                    args: [
+                        ...(vue
+                            ? [
+                                fileURLToPath(new URL("./vue-tsc-runner.js", import.meta.url)),
+                                compiler,
+                                source.root,
+                            ]
+                            : [compiler]),
+                        "--project",
+                        "./tsconfig.json",
+                        "--noEmit",
+                        "--noCheck",
+                        "false",
+                        "--pretty",
+                        "false",
+                        "--incremental",
+                        "false",
+                        "--listFiles",
+                    ],
+                    cwd: project.path,
+                },
+            ]
+            : [],
+    };
+    if (!project.files.includes("tsconfig.json"))
+        check.unavailableReason = "A project-local tsconfig.json is required.";
+    else if (!files.length)
+        check.unavailableReason =
+            "No supported TypeScript or Vue source files were inventoried.";
+    else if (files.some((file) => /[\r\n]/.test(file)))
+        check.unavailableReason =
+            "The compiler file-list format cannot account for filenames containing newlines.";
+    else if (!compiler)
+        check.unavailableReason =
+            "The selected compiler is not installed within the configured root.";
+    return check;
+}

package/dist/src/validation-task-worker.d.ts

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