@h-rig/validator-kit 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/checks.d.ts

@@ -1,4 +1,5 @@
 import { Checker } from "./result";
+import { type RunCommand } from "./exec";
 /** Check a file exists. */
 export declare function requireFileCheck(checker: Checker, path: string, checkName: string): void;
 /** Check a directory exists. */
@@ -7,3 +8,10 @@ export declare function requireDirCheck(checker: Checker, path: string, checkNam
 export declare function requirePackageStructure(checker: Checker, serviceDir: string, prefix: string): void;
 /** Check test files exist in a project directory. */
 export declare function checkTestsExist(checker: Checker, projectDir: string, checkName: string): void;
+/**
+ * Check that a TypeScript project compiles cleanly (`tsc --noEmit`). Runs the
+ * compile through the injectable {@link RunCommand} primitive — the default is
+ * exec.ts's minimal Bun.spawn runner; callers may inject a richer runtime
+ * runner. Records a pass/fail on the {@link Checker}; never throws.
+ */
+export declare function checkTypescriptCompiles(checker: Checker, projectDir: string, checkName: string, run?: RunCommand): Promise<void>;

package/dist/src/checks.js

@@ -30,6 +30,22 @@ function countTestFiles(dir) {
   return count;
 }
 
+// packages/validator-kit/src/exec.ts
+var runCommand = async (cmd, cwd) => {
+  const proc = Bun.spawn([...cmd], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, PWD: cwd, INIT_CWD: cwd }
+  });
+  const exitCode = await proc.exited;
+  return {
+    exitCode,
+    stdout: await new Response(proc.stdout).text(),
+    stderr: await new Response(proc.stderr).text()
+  };
+};
+
 // packages/validator-kit/src/checks.ts
 function requireFileCheck(checker, path, checkName) {
   if (existsSync2(path)) {
@@ -58,9 +74,42 @@ function checkTestsExist(checker, projectDir, checkName) {
     checker.fail(checkName, "no test files found");
   }
 }
+function resolveTypescriptCommand(projectDir) {
+  const tsconfigPath = resolve2(projectDir, "tsconfig.json");
+  const candidates = [
+    resolve2(projectDir, "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "..", "..", "node_modules", "typescript", "lib", "tsc.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return [process.execPath, candidate, "--noEmit", "--project", tsconfigPath];
+    }
+  }
+  return ["bunx", "tsc", "--noEmit", "--project", tsconfigPath];
+}
+async function checkTypescriptCompiles(checker, projectDir, checkName, run = runCommand) {
+  if (!existsSync2(resolve2(projectDir, "tsconfig.json"))) {
+    checker.fail(checkName, "no tsconfig.json found");
+    return;
+  }
+  const command = resolveTypescriptCommand(projectDir);
+  const result = await run(command, projectDir);
+  if (result.exitCode === 0) {
+    checker.pass(checkName);
+    return;
+  }
+  const combined = result.stdout + result.stderr;
+  const errorCount = combined.split(`
+`).filter((line) => line.includes("error TS")).length;
+  const detail = errorCount > 0 ? `${errorCount} TypeScript errors` : `TypeScript command exited ${result.exitCode} without TS diagnostics`;
+  checker.fail(checkName, detail);
+}
 export {
   requirePackageStructure,
   requireFileCheck,
   requireDirCheck,
+  checkTypescriptCompiles,
   checkTestsExist
 };

package/dist/src/exec.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal honest command-runner for validator checks.
+ *
+ * @rig/validator-kit is floor-neutral (contracts-only deps), so it does NOT
+ * depend on @rig/runtime's `resolveBunCli`/build-macro machinery. There is no
+ * shared `runCommand` PRIMITIVE for this floor to wire to yet, so this is the
+ * minimal honest implementation: a thin Bun.spawn wrapper that captures exit
+ * code + stdout + stderr. It is INJECTABLE — every check that needs to run a
+ * command accepts a `RunCommand` so a caller (or test) can substitute the
+ * runtime's richer runner. When a real shared primitive lands, swap the default.
+ */
+export type RunCommandResult = {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export type RunCommand = (cmd: readonly string[], cwd: string) => Promise<RunCommandResult>;
+/**
+ * Default runner: spawn the command verbatim and capture output. Honest about
+ * its limits — it does not resolve a baked bun path or inject build env; it runs
+ * exactly what it is handed. Callers needing that resolution inject their own.
+ */
+export declare const runCommand: RunCommand;

package/dist/src/exec.js

@@ -0,0 +1,19 @@
+// @bun
+// packages/validator-kit/src/exec.ts
+var runCommand = async (cmd, cwd) => {
+  const proc = Bun.spawn([...cmd], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, PWD: cwd, INIT_CWD: cwd }
+  });
+  const exitCode = await proc.exited;
+  return {
+    exitCode,
+    stdout: await new Response(proc.stdout).text(),
+    stderr: await new Response(proc.stderr).text()
+  };
+};
+export {
+  runCommand
+};

package/dist/src/index.d.ts

@@ -3,4 +3,8 @@ export { pass, fail, error, Checker } from "./result";
 export { findFirstFile, readFileSafe, requireFile, fileContains, walkDir, listSubdirs, countTsFiles, countTestFiles, findFirstDir, findFilesByName, } from "./fs";
 export { grepFiles, grepCount, grepLines } from "./grep";
 export { requireMarkdownSections, requireTerms, requireJsonKeys, } from "./content";
-export { requireFileCheck, requireDirCheck, requirePackageStructure, checkTestsExist, } from "./checks";
+export { requireFileCheck, requireDirCheck, requirePackageStructure, checkTestsExist, checkTypescriptCompiles, } from "./checks";
+export { runCommand } from "./exec";
+export type { RunCommand, RunCommandResult } from "./exec";
+export { createValidatorRegistry } from "./validator-registry";
+export type { ValidatorResult, ValidatorContext, RegisteredValidator, ValidatorRegistry, } from "./validator-registry";

package/dist/src/index.js

@@ -233,6 +233,24 @@ function requireJsonKeys(checker, filePath, keys) {
 // packages/validator-kit/src/checks.ts
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { resolve as resolve2 } from "path";
+
+// packages/validator-kit/src/exec.ts
+var runCommand = async (cmd, cwd) => {
+  const proc = Bun.spawn([...cmd], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, PWD: cwd, INIT_CWD: cwd }
+  });
+  const exitCode = await proc.exited;
+  return {
+    exitCode,
+    stdout: await new Response(proc.stdout).text(),
+    stderr: await new Response(proc.stderr).text()
+  };
+};
+
+// packages/validator-kit/src/checks.ts
 function requireFileCheck(checker, path, checkName) {
   if (existsSync2(path)) {
     checker.pass(checkName);
@@ -260,8 +278,101 @@ function checkTestsExist(checker, projectDir, checkName) {
     checker.fail(checkName, "no test files found");
   }
 }
+function resolveTypescriptCommand(projectDir) {
+  const tsconfigPath = resolve2(projectDir, "tsconfig.json");
+  const candidates = [
+    resolve2(projectDir, "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve2(projectDir, "..", "..", "..", "node_modules", "typescript", "lib", "tsc.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return [process.execPath, candidate, "--noEmit", "--project", tsconfigPath];
+    }
+  }
+  return ["bunx", "tsc", "--noEmit", "--project", tsconfigPath];
+}
+async function checkTypescriptCompiles(checker, projectDir, checkName, run = runCommand) {
+  if (!existsSync2(resolve2(projectDir, "tsconfig.json"))) {
+    checker.fail(checkName, "no tsconfig.json found");
+    return;
+  }
+  const command = resolveTypescriptCommand(projectDir);
+  const result = await run(command, projectDir);
+  if (result.exitCode === 0) {
+    checker.pass(checkName);
+    return;
+  }
+  const combined = result.stdout + result.stderr;
+  const errorCount = combined.split(`
+`).filter((line) => line.includes("error TS")).length;
+  const detail = errorCount > 0 ? `${errorCount} TypeScript errors` : `TypeScript command exited ${result.exitCode} without TS diagnostics`;
+  checker.fail(checkName, detail);
+}
+// packages/validator-kit/src/validator-registry.ts
+import { existsSync as existsSync3 } from "fs";
+import { join } from "path";
+function createValidatorRegistry() {
+  const map = new Map;
+  const order = [];
+  const registry = {
+    register(v) {
+      if (map.has(v.id))
+        throw new Error(`validator already registered: ${v.id}`);
+      map.set(v.id, v);
+      order.push(v);
+    },
+    resolve(id) {
+      const v = map.get(id);
+      if (!v)
+        throw new Error(`validator not registered: ${id}`);
+      return v;
+    },
+    list: () => order
+  };
+  registerBuiltInValidators(registry);
+  return registry;
+}
+function registerBuiltInValidators(registry) {
+  registry.register({
+    id: "std:typecheck",
+    category: "custom",
+    description: "Runs the package typecheck script when present.",
+    run: async (ctx) => runStdTypecheck(ctx)
+  });
+}
+async function runStdTypecheck(ctx) {
+  const packageJsonPath = join(ctx.workspaceRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return {
+      id: "std:typecheck",
+      passed: false,
+      summary: `package.json not found at ${packageJsonPath}`
+    };
+  }
+  const proc = Bun.spawn(["bun", "run", "typecheck"], {
+    cwd: ctx.workspaceRoot,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}${stderr}`.trim();
+  return {
+    id: "std:typecheck",
+    passed: exitCode === 0,
+    summary: exitCode === 0 ? "typecheck passed" : "typecheck failed",
+    ...output ? { details: output.slice(0, 4000) } : {}
+  };
+}
 export {
   walkDir,
+  runCommand,
   requireTerms,
   requirePackageStructure,
   requireMarkdownSections,
@@ -281,8 +392,10 @@ export {
   fileContains,
   fail,
   error,
+  createValidatorRegistry,
   countTsFiles,
   countTestFiles,
+  checkTypescriptCompiles,
   checkTestsExist,
   Checker
 };

package/dist/src/validator-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ValidatorRegistration } from "@rig/contracts";
+export interface ValidatorResult {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+}
+export interface ValidatorContext {
+    taskId: string;
+    workspaceRoot: string;
+    scope: readonly string[];
+    /** Absolute path to the monorepo checkout root (MONOREPO_ROOT / MONOREPO_MAIN_ROOT env equiv). */
+    monorepoRoot?: string;
+    /** Absolute path to the task's artifacts output directory (ARTIFACTS_DIR env equiv). */
+    artifactsDir?: string;
+    /** The full task config entry for this task — opaque to the registry, but available for advanced validators. */
+    taskConfig?: unknown;
+}
+export interface RegisteredValidator extends ValidatorRegistration {
+    run(ctx: ValidatorContext): Promise<ValidatorResult>;
+}
+export interface ValidatorRegistry {
+    register(v: RegisteredValidator): void;
+    resolve(id: string): RegisteredValidator;
+    list(): readonly RegisteredValidator[];
+}
+export declare function createValidatorRegistry(): ValidatorRegistry;

package/dist/src/validator-registry.js

@@ -0,0 +1,64 @@
+// @bun
+// packages/validator-kit/src/validator-registry.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function createValidatorRegistry() {
+  const map = new Map;
+  const order = [];
+  const registry = {
+    register(v) {
+      if (map.has(v.id))
+        throw new Error(`validator already registered: ${v.id}`);
+      map.set(v.id, v);
+      order.push(v);
+    },
+    resolve(id) {
+      const v = map.get(id);
+      if (!v)
+        throw new Error(`validator not registered: ${id}`);
+      return v;
+    },
+    list: () => order
+  };
+  registerBuiltInValidators(registry);
+  return registry;
+}
+function registerBuiltInValidators(registry) {
+  registry.register({
+    id: "std:typecheck",
+    category: "custom",
+    description: "Runs the package typecheck script when present.",
+    run: async (ctx) => runStdTypecheck(ctx)
+  });
+}
+async function runStdTypecheck(ctx) {
+  const packageJsonPath = join(ctx.workspaceRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return {
+      id: "std:typecheck",
+      passed: false,
+      summary: `package.json not found at ${packageJsonPath}`
+    };
+  }
+  const proc = Bun.spawn(["bun", "run", "typecheck"], {
+    cwd: ctx.workspaceRoot,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}${stderr}`.trim();
+  return {
+    id: "std:typecheck",
+    passed: exitCode === 0,
+    summary: exitCode === 0 ? "typecheck passed" : "typecheck failed",
+    ...output ? { details: output.slice(0, 4000) } : {}
+  };
+}
+export {
+  createValidatorRegistry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/validator-kit",
-  "version": "0.0.6-alpha.157",
+  "version": "0.0.6-alpha.158",
   "type": "module",
   "description": "Validator schema helpers for Rig plugin contributions; not a validation runtime.",
   "license": "UNLICENSED",
@@ -21,7 +21,7 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.157",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.158",
     "effect": "4.0.0-beta.90"
   }
 }