@h-rig/task-sources-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/control-plane/native/utils.d.ts

@@ -0,0 +1,7 @@
+export { type CaptureResult, runCapture, runCaptureAsync, runInherit, getValidationTimeoutMs, readJsonFile, nowIso, unique, fileLines, } from "@rig/core/exec";
+export { resolveCheckoutRoot as resolveMonorepoRoot } from "@rig/core/checkout-root";
+export { resolveHarnessPaths } from "@rig/core/harness-paths";
+export declare function normalizePathToScope(projectRoot: string, monorepoRoot: string, inputPath: string): string;
+export declare function monorepoSearchCandidates(inputPath: string): string[];
+export declare function scopeGlobToRegex(glob: string): RegExp;
+export declare function scopeMatches(path: string, scopes: string[]): boolean;

package/dist/src/control-plane/native/utils.js

@@ -0,0 +1,110 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/native/utils.ts
+import { getScopeRules } from "@rig/core/scope-rules";
+import { unique } from "@rig/core/exec";
+import {
+  runCapture,
+  runCaptureAsync,
+  runInherit,
+  getValidationTimeoutMs,
+  readJsonFile,
+  nowIso,
+  unique as unique2,
+  fileLines
+} from "@rig/core/exec";
+import { resolveCheckoutRoot } from "@rig/core/checkout-root";
+import { resolveHarnessPaths } from "@rig/core/harness-paths";
+var scopeRegexCache = new Map;
+function normalizeRelativeScopePath(inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  const rules = getScopeRules();
+  if (rules?.stripPrefixes) {
+    for (const prefix of rules.stripPrefixes) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+      }
+    }
+  }
+  return normalized;
+}
+function normalizePathToScope(projectRoot, monorepoRoot, inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  if (normalized.startsWith(projectRoot + "/")) {
+    normalized = normalized.slice(projectRoot.length + 1);
+  }
+  if (normalized.startsWith(monorepoRoot + "/")) {
+    normalized = normalized.slice(monorepoRoot.length + 1);
+  }
+  return normalizeRelativeScopePath(normalized);
+}
+function monorepoSearchCandidates(inputPath) {
+  const normalized = inputPath.replace(/^\.\//, "");
+  const candidates = new Set;
+  const add = (value) => {
+    const trimmed = value.replace(/^\.\//, "");
+    if (trimmed) {
+      candidates.add(trimmed);
+    }
+  };
+  add(normalized);
+  const stripped = normalizeRelativeScopePath(normalized);
+  add(stripped);
+  const rules = getScopeRules();
+  if (rules?.stripPrefixes) {
+    for (const prefix of rules.stripPrefixes) {
+      if (normalized.startsWith(prefix)) {
+        add(normalized.slice(prefix.length));
+      }
+    }
+  }
+  if (rules?.searchPrefixes) {
+    for (const rule of rules.searchPrefixes) {
+      const matchesStart = rule.matchStartsWith?.some((prefix) => stripped.startsWith(prefix)) ?? false;
+      const matchesExact = rule.matchExact?.includes(stripped) ?? false;
+      if (matchesStart || matchesExact) {
+        add(`${rule.prefix}${stripped}`);
+      }
+    }
+  }
+  return [...candidates];
+}
+function scopeGlobToRegex(glob) {
+  const cached = scopeRegexCache.get(glob);
+  if (cached) {
+    return cached;
+  }
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/__GLOBSTAR__/g, ".*");
+  const compiled = new RegExp(`^${escaped}$`);
+  scopeRegexCache.set(glob, compiled);
+  return compiled;
+}
+function scopeMatches(path, scopes) {
+  const pathVariants = unique([path, normalizeRelativeScopePath(path)]);
+  for (const scope of scopes) {
+    const scopeVariants = unique([scope, normalizeRelativeScopePath(scope)]);
+    for (const candidatePath of pathVariants) {
+      for (const candidateScope of scopeVariants) {
+        if (candidatePath === candidateScope || scopeGlobToRegex(candidateScope).test(candidatePath)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+export {
+  unique2 as unique,
+  scopeMatches,
+  scopeGlobToRegex,
+  runInherit,
+  runCaptureAsync,
+  runCapture,
+  resolveCheckoutRoot as resolveMonorepoRoot,
+  resolveHarnessPaths,
+  readJsonFile,
+  nowIso,
+  normalizePathToScope,
+  monorepoSearchCandidates,
+  getValidationTimeoutMs,
+  fileLines
+};

package/dist/src/control-plane/native/validator-binaries.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeTaskContext } from "@rig/core/runtime-context";
+export declare function resolveValidatorBinaryPath(projectRoot: string, binaryName: string, runtimeContext: RuntimeTaskContext | null): string;
+export declare function ensureValidatorBinary(projectRoot: string, checkId: string, runtimeContext: RuntimeTaskContext | null): Promise<string | null>;

package/dist/src/control-plane/native/validator-binaries.js

@@ -0,0 +1,175 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/native/validator-binaries.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync as rmSync2, statSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { runtimeProvisioningEnv } from "@rig/core/runtime-provisioning-env";
+import { resolveBunBinaryPath } from "@rig/core/runtime-paths";
+
+// packages/task-sources-plugin/src/control-plane/native/runtime-binary-build.ts
+import { chmodSync, existsSync, mkdirSync, renameSync, rmSync } from "fs";
+import { basename, dirname, isAbsolute, resolve } from "path";
+var runtimeBinaryBuildQueue = Promise.resolve();
+async function buildRuntimeBinary(options) {
+  await runSerializedRuntimeBinaryBuild(async () => {
+    const entrypoint = isAbsolute(options.sourcePath) ? options.sourcePath : resolve(options.cwd, options.sourcePath);
+    const outputPath = resolve(options.outputPath);
+    const tempBuildDir = resolve(dirname(outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const tempOutputPath = resolve(tempBuildDir, basename(outputPath));
+    mkdirSync(tempBuildDir, { recursive: true });
+    await withTemporaryEnv({
+      ...options.env,
+      ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+    }, async () => withTemporaryCwd(tempBuildDir, async () => {
+      const buildResult = await Bun.build({
+        entrypoints: [entrypoint],
+        compile: {
+          target: currentCompileTarget(),
+          outfile: tempOutputPath
+        },
+        target: "bun",
+        format: "esm",
+        minify: true,
+        bytecode: true,
+        ...options.external ? { external: options.external } : {},
+        ...options.define ? { define: { __RIG_BUILD_CONFIG__: JSON.stringify(options.define) } } : {}
+      });
+      if (!buildResult.success) {
+        const details = buildResult.logs.map((log) => [
+          log.message,
+          log.position?.file ? `${log.position.file}:${log.position.line}:${log.position.column}` : ""
+        ].filter(Boolean).join(" ")).filter(Boolean).join(`
+`);
+        throw new Error(`Failed to build ${entrypoint}: ${details || "Bun.build() returned errors"}`);
+      }
+      if (!existsSync(tempOutputPath)) {
+        const emitted = buildResult.outputs.map((output) => output.path).join(", ") || "(none)";
+        throw new Error(`Failed to build ${entrypoint}: Bun.build() did not emit ${tempOutputPath}. Emitted: ${emitted}`);
+      }
+      renameSync(tempOutputPath, outputPath);
+      chmodSync(outputPath, 493);
+    })).finally(() => {
+      rmSync(tempBuildDir, { recursive: true, force: true });
+    });
+  });
+}
+function currentCompileTarget() {
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "bun-darwin-arm64" : "bun-darwin-x64";
+  }
+  if (process.platform === "linux") {
+    return process.arch === "arm64" ? "bun-linux-arm64" : "bun-linux-x64";
+  }
+  return "bun-windows-x64";
+}
+async function runSerializedRuntimeBinaryBuild(action) {
+  const previous = runtimeBinaryBuildQueue;
+  let release;
+  runtimeBinaryBuildQueue = new Promise((resolveRelease) => {
+    release = resolveRelease;
+  });
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+  }
+}
+async function withTemporaryEnv(env, action) {
+  if (!env) {
+    return action();
+  }
+  const previousValues = new Map;
+  for (const [key, value] of Object.entries(env)) {
+    previousValues.set(key, process.env[key]);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    for (const [key, value] of previousValues.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function withTemporaryCwd(cwd, action) {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+// packages/task-sources-plugin/src/control-plane/native/utils.ts
+import { getScopeRules } from "@rig/core/scope-rules";
+import { unique } from "@rig/core/exec";
+import {
+  runCapture,
+  runCaptureAsync,
+  runInherit,
+  getValidationTimeoutMs,
+  readJsonFile,
+  nowIso,
+  unique as unique2,
+  fileLines
+} from "@rig/core/exec";
+import { resolveCheckoutRoot } from "@rig/core/checkout-root";
+import { resolveHarnessPaths } from "@rig/core/harness-paths";
+var scopeRegexCache = new Map;
+
+// packages/task-sources-plugin/src/control-plane/native/validator-binaries.ts
+function resolveValidatorBinaryPath(projectRoot, binaryName, runtimeContext) {
+  if (runtimeContext) {
+    return resolve2(runtimeContext.binDir, "validators", binaryName);
+  }
+  return resolve2(resolveHarnessPaths(projectRoot).binDir, "validators", binaryName);
+}
+async function ensureValidatorBinary(projectRoot, checkId, runtimeContext) {
+  const match = checkId.match(/^([a-z][\w-]*):([a-z][\w-]*)$/);
+  if (!match) {
+    return null;
+  }
+  const category = match[1];
+  const check = match[2];
+  if (!category || !check) {
+    return null;
+  }
+  const binaryName = `${category}-${check}`;
+  const binaryPath = resolveValidatorBinaryPath(projectRoot, binaryName, runtimeContext);
+  const hostProjectRoot = runtimeContext?.hostProjectRoot?.trim() || projectRoot;
+  const sourcePath = resolve2(hostProjectRoot, "packages/validator-kit/src/validators", category, `${check}.ts`);
+  if (!existsSync2(sourcePath)) {
+    return null;
+  }
+  const sourceMtime = statSync(sourcePath).mtimeMs;
+  const binaryExists = existsSync2(binaryPath);
+  const binaryMtime = binaryExists ? statSync(binaryPath).mtimeMs : 0;
+  if (!binaryExists || sourceMtime > binaryMtime) {
+    if (binaryExists) {
+      rmSync2(binaryPath, { force: true });
+      rmSync2(`${binaryPath}.build-manifest.json`, { force: true });
+    }
+    mkdirSync2(dirname2(binaryPath), { recursive: true });
+    await buildRuntimeBinary({
+      sourcePath: `packages/validator-kit/src/validators/${category}/${check}.ts`,
+      outputPath: binaryPath,
+      cwd: hostProjectRoot,
+      define: { AGENT_BUN_PATH: resolveBunBinaryPath() },
+      env: runtimeProvisioningEnv()
+    });
+  }
+  return existsSync2(binaryPath) ? binaryPath : null;
+}
+export {
+  resolveValidatorBinaryPath,
+  ensureValidatorBinary
+};

package/dist/src/control-plane/native/validator.d.ts

@@ -0,0 +1,44 @@
+import type { RuntimeTaskContext } from "@rig/core/runtime-context";
+import { readTaskConfig } from "./task-state";
+import type { ValidatorContext, ValidatorRegistry } from "@rig/validator-kit";
+export type ValidatorOutput = {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+};
+export type ValidationCategoryResult = {
+    category: string;
+    status: "pass" | "fail";
+    exit_code?: number;
+    duration_seconds: number;
+};
+export type ValidationSummary = {
+    status: "pass" | "fail" | "skipped";
+    total: number;
+    passed: number;
+    failed: number;
+    categories: ValidationCategoryResult[];
+};
+/**
+ * Two-phase validator dispatch.
+ *
+ * Phase 1 (in-process): if `registry` has a validator registered for `checkId`, build a
+ * `ValidatorContext` from the ambient task data and call `.run(ctx)` directly.
+ *
+ * Phase 2 (subprocess fallback): if the registry does not know `checkId` (throws
+ * "not registered"), delegate to the existing `runValidatorBinary` subprocess path.
+ *
+ * The `ValidatorOutput` shape is identical for both paths so the caller sees no difference.
+ */
+export declare function dispatchValidator(checkId: string, registry: ValidatorRegistry, ctx: ValidatorContext, subprocessFallback: (checkId: string) => Promise<{
+    result: ValidatorOutput;
+    exitCode: number;
+}>): Promise<{
+    result: ValidatorOutput;
+    exitCode: number;
+}>;
+export declare function validateTask(projectRoot: string, taskId: string, runtimeContext?: RuntimeTaskContext | null, registry?: ValidatorRegistry, options?: {
+    taskConfig?: ReturnType<typeof readTaskConfig>;
+    validationDescriptions?: Record<string, string>;
+}): Promise<ValidationSummary>;