@h-rig/validator-kit 0.0.6-alpha.16 → 0.0.6-alpha.161

package/dist/src/checks.d.ts

@@ -0,0 +1,17 @@
+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. */
+export declare function requireDirCheck(checker: Checker, path: string, checkName: string): void;
+/** Validate standard package structure: package.json + tsconfig.json + src/. */
+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/content.d.ts

@@ -0,0 +1,7 @@
+import { Checker } from "./result";
+/** Check markdown file has section headings matching each term. */
+export declare function requireMarkdownSections(checker: Checker, filePath: string, sections: string[]): void;
+/** Check document contains terms (case-insensitive). Pattern can include | for alternation. */
+export declare function requireTerms(checker: Checker, filePath: string, terms: Record<string, string>): void;
+/** Parse JSON and check key paths exist (dot-separated, e.g. ".summary.total"). */
+export declare function requireJsonKeys(checker: Checker, filePath: string, keys: string[]): void;

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/fs.d.ts

@@ -0,0 +1,19 @@
+/** Return the first existing path from candidates, or null. */
+export declare function findFirstFile(candidates: string[]): string | null;
+/** Read a file as UTF-8 or return null if missing. */
+export declare function readFileSafe(path: string): string | null;
+export declare function requireFile(path: string, id: string, description: string): string;
+/** Check if file content matches a pattern. */
+export declare function fileContains(path: string, pattern: RegExp): boolean;
+/** Walk a directory tree, calling fn for each file. Skips node_modules/.git. */
+export declare function walkDir(dir: string, fn: (filePath: string) => void): void;
+/** List subdirectories of a directory. */
+export declare function listSubdirs(dir: string): string[];
+/** Count .ts files in a directory (excluding tests). */
+export declare function countTsFiles(dir: string): number;
+/** Count test files (.test.ts / .spec.ts) in a directory. */
+export declare function countTestFiles(dir: string): number;
+/** Find first directory matching candidates. */
+export declare function findFirstDir(candidates: string[]): string | null;
+/** Find files by name pattern (glob-free, recursive). */
+export declare function findFilesByName(dir: string, namePattern: RegExp): string[];

package/dist/src/grep.d.ts

@@ -0,0 +1,6 @@
+/** Find files whose content matches pattern. Optionally filter by extension. */
+export declare function grepFiles(dir: string, pattern: RegExp, extensions?: string[]): string[];
+/** Count files matching pattern. */
+export declare function grepCount(dir: string, pattern: RegExp, extensions?: string[]): number;
+/** Get matching lines from files in a directory. */
+export declare function grepLines(dir: string, pattern: RegExp, extensions?: string[], maxLines?: number): string[];

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export type { ValidatorOutput } from "./result";
+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, 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/result.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Validator output contract and result helpers.
+ *
+ * Provides the `ValidatorOutput` shape, single-shot exit helpers (`pass`,
+ * `fail`, `error`), and the multi-check `Checker` accumulator.
+ *
+ * Moved from packages/runtime/src/control-plane/validators/shared.ts
+ * in Phase 3 Task 3.3 of the Rig extraction.
+ */
+export type ValidatorOutput = {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+};
+export declare function pass(id: string, summary: string): never;
+export declare function fail(id: string, summary: string, details?: string): never;
+export declare function error(id: string, message: string): never;
+export declare class Checker {
+    private results;
+    pass(name: string): void;
+    fail(name: string, reason: string): void;
+    /** Fail and immediately emit — for fatal precondition failures. */
+    fatal(id: string, reason: string): never;
+    /** Print JSON result and exit. */
+    emit(id: string): never;
+}

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,8 +1,8 @@
 {
   "name": "@h-rig/validator-kit",
-  "version": "0.0.6-alpha.16",
+  "version": "0.0.6-alpha.161",
   "type": "module",
-  "description": "Rig package",
+  "description": "Validator schema helpers for Rig plugin contributions; not a validation runtime.",
   "license": "UNLICENSED",
   "files": [
     "dist",
@@ -10,6 +10,7 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     }
   },
@@ -18,8 +19,9 @@
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.16",
-    "effect": "4.0.0-beta.78"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.161",
+    "effect": "4.0.0-beta.90"
   }
 }