@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/admission-strategy-provider/provider.ts

@@ -0,0 +1,45 @@
+import type {
+  AdmissionPolicy,
+  SchedulerGraphSnapshot
+} from "../../project-definition/project-definition.ts";
+import { staticAdmissionSelectionPolicy } from "../task-scheduler/admission-selection-policy.ts";
+import { prepareCustomAdmissionStrategy } from "./custom-strategy-preparation.ts";
+import type { PreparedAdmissionStrategy } from "./prepared-admission-strategy.ts";
+
+export interface PrivateAdmissionStrategyProvider {
+  prepare: () => Promise<PreparedAdmissionStrategy>;
+}
+
+/** Product-private test seam; package `run` never accepts a provider factory. */
+export type AdmissionStrategyProviderFactory = (
+  input: AdmissionStrategyProviderInput
+) => PrivateAdmissionStrategyProvider;
+
+export interface AdmissionStrategyProviderInput {
+  readonly admissionPolicy: AdmissionPolicy;
+  readonly graph: SchedulerGraphSnapshot;
+}
+
+/** Resolves the closed Product policy union to one invocation-scoped prepared strategy. */
+export function createAdmissionStrategyProvider(
+  input: AdmissionStrategyProviderInput
+): PrivateAdmissionStrategyProvider {
+  return Object.freeze({
+    prepare: async () => {
+      switch (input.admissionPolicy.kind) {
+        case "static":
+          return staticPreparedStrategy();
+        case "custom":
+          return prepareCustomAdmissionStrategy(input.admissionPolicy, input.graph);
+      }
+    }
+  });
+}
+
+function staticPreparedStrategy(): PreparedAdmissionStrategy {
+  return Object.freeze({
+    admissionPolicy: staticAdmissionSelectionPolicy,
+    completion: Object.freeze({ kind: "none" as const }),
+    requiresTerminalMeasurement: false
+  });
+}

package/src/project-run/aggregation.ts

@@ -1,90 +1,72 @@
-import type {
-  RunControlDiagnostic,
-  RunControlValidationResult
-} from "./controls/validation-result.ts";
-import type { CheckAggregate, CheckAggregation } from "./controls/contract.ts";
 import type { CoreCheck, CoreSnapshot } from "../check-settlement/facts.ts";
+import type { CheckAggregate, CheckAggregation } from "./controls/contract.ts";
 
-type AggregateStatus = Exclude<CheckAggregate, "not-applicable">;
+/** Identifies a callback failure so the invocation boundary can close outputs before rethrowing it. */
+export class CheckAggregationFailure extends Error {
+  readonly originalError: Error;
 
-/** Validates that aggregation selects only normalized executable Check IDs. */
-export function validateCheckAggregationSelection(
-  aggregation: CheckAggregation | undefined,
-  checkIds: readonly string[]
-): RunControlValidationResult<CheckAggregation | undefined> {
-  if (aggregation === undefined) return Object.freeze({ ok: true, value: undefined });
-  if (aggregation.checks === "all") return Object.freeze({ ok: true, value: aggregation });
-  const knownCheckIds = new Set(checkIds);
-  const selectedCheckIds = new Set<string>();
-  for (const checkId of aggregation.checks) {
-    if (!knownCheckIds.has(checkId) || selectedCheckIds.has(checkId)) {
-      return invalidControls("controls.checkAggregation.checks");
-    }
-    selectedCheckIds.add(checkId);
+  public constructor(originalError: Error) {
+    super("Check aggregation failed", { cause: originalError });
+    this.originalError = originalError;
   }
-  return Object.freeze({ ok: true, value: aggregation });
 }
 
-/** Derives one explicit consumer-selected aggregate from settled Check statuses only. */
-export function aggregateCheckOutcomes(
+/** Builds the canonical ordered, read-only effective Check list and derives its invocation aggregate. */
+export function aggregateEffectiveChecks(
   snapshot: CoreSnapshot,
-  aggregation: CheckAggregation
+  effectiveCheckIds: readonly string[],
+  aggregation: CheckAggregation | undefined
 ): CheckAggregate {
-  const statuses = selectedChecks(snapshot, aggregation.checks).map((check) =>
-    aggregateStatus(check, aggregation)
-  );
-  if (statuses.includes("unavailable")) return "unavailable";
-  return aggregateSelectedStatuses(
-    statuses.filter(
-      (status): status is Exclude<AggregateStatus, "unavailable"> =>
-        status !== null && status !== "unavailable"
-    ),
-    aggregation
-  );
+  const checks = effectiveChecks(snapshot, effectiveCheckIds);
+  return aggregation === undefined
+    ? strictAggregate(checks)
+    : invokeAggregation(aggregation, checks);
 }
 
-function selectedChecks(
+function effectiveChecks(
   snapshot: CoreSnapshot,
-  selection: CheckAggregation["checks"]
+  effectiveCheckIds: readonly string[]
 ): readonly CoreCheck[] {
-  if (selection === "all") return snapshot.checks;
-  return selection.map((checkId) => {
-    const check = snapshot.checks.find((candidate) => candidate.checkId === checkId);
-    if (check === undefined) throw new TypeError("Aggregation selection was not validated");
-    return check;
-  });
+  const effectiveCheckIdSet = new Set(effectiveCheckIds);
+  return Object.freeze(snapshot.checks.filter((check) => effectiveCheckIdSet.has(check.checkId)));
 }
 
-function aggregateStatus(check: CoreCheck, aggregation: CheckAggregation): AggregateStatus | null {
-  switch (check.outcome.status) {
-    case "passed":
-    case "failed":
-      return check.outcome.status;
-    case "unavailable": {
-      if (aggregation.unavailable === "propagate") return "unavailable";
-      return aggregation.unavailable === "fail" ? "failed" : null;
-    }
-    case "not-applicable": {
-      if (aggregation.notApplicable === "pass") return "passed";
-      return aggregation.notApplicable === "fail" ? "failed" : null;
-    }
-  }
+function strictAggregate(checks: readonly CoreCheck[]): CheckAggregate {
+  return checks.length > 0 && checks.every((check) => check.outcome.status === "passed")
+    ? "passed"
+    : "failed";
 }
 
-function aggregateSelectedStatuses(
-  statuses: readonly Exclude<AggregateStatus, "unavailable">[],
-  aggregation: CheckAggregation
+function invokeAggregation(
+  aggregation: CheckAggregation,
+  checks: readonly CoreCheck[]
 ): CheckAggregate {
-  if (statuses.length === 0) return aggregation.empty;
-  if (aggregation.mode === "all") return statuses.includes("failed") ? "failed" : "passed";
-  return statuses.includes("passed") ? "passed" : "failed";
+  let aggregate: unknown;
+  try {
+    aggregate = aggregation(checks);
+  } catch (error) {
+    throw new CheckAggregationFailure(errorFromThrownValue(error));
+  }
+  if (isCheckAggregate(aggregate)) return aggregate;
+  discardPromiseRejection(aggregate);
+  throw new CheckAggregationFailure(
+    new TypeError("Check aggregation must synchronously return a CheckAggregate")
+  );
+}
+
+function isCheckAggregate(value: unknown): value is CheckAggregate {
+  return (
+    value === "passed" ||
+    value === "failed" ||
+    value === "not-applicable" ||
+    value === "unavailable"
+  );
+}
+
+function discardPromiseRejection(value: unknown): void {
+  if (value instanceof Promise) void value.catch(() => undefined);
 }
 
-function invalidControls(path: string): RunControlValidationResult<never> {
-  const error: RunControlDiagnostic = Object.freeze({
-    kind: "invalid-run-controls",
-    path,
-    reason: "invalid-value"
-  });
-  return Object.freeze({ ok: false, error });
+function errorFromThrownValue(value: unknown): Error {
+  return value instanceof Error ? value : new Error("Check aggregation threw a non-Error value");
 }

package/src/project-run/changes/git.ts

@@ -0,0 +1,206 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+import { execaSync } from "execa";
+
+import { matchesAnyConfigGlob } from "../../data-boundary/config-glob.ts";
+import { isNormalizedProjectRelativePath } from "../../data-boundary/project-path.ts";
+import type { ProjectChanges } from "../../check/check.ts";
+import type { NormalizedProjectChangesConfiguration } from "../../project-definition/project-changes.ts";
+
+export const CHANGE_FLAG_PREFIX = "vibe-check:change:";
+export const GIT_CHANGES_UNAVAILABLE_CODE = "git-changes-unavailable";
+
+export type PreparedProjectChanges = Readonly<{
+  readonly effectiveFlags: readonly string[];
+  readonly projectChanges: ProjectChanges;
+}>;
+
+/** Prepares one configured Git change snapshot before Run flag selection. */
+export function prepareProjectChanges(
+  input: Readonly<{
+    readonly callerFlags: readonly string[];
+    readonly changes: NormalizedProjectChangesConfiguration;
+    readonly projectRoot: string;
+  }>
+): PreparedProjectChanges {
+  const declaredFlags = declaredChangeFlags(input.changes);
+  try {
+    const paths = collectGitChangedPaths(input.projectRoot, input.changes.source.compareWith);
+    const projectChanges = matchedProjectChanges(paths, input.changes);
+    return Object.freeze({
+      effectiveFlags: combineFlags(
+        input.callerFlags,
+        projectChanges.files.flatMap(({ flags }) => flags)
+      ),
+      projectChanges
+    });
+  } catch {
+    return Object.freeze({
+      effectiveFlags: combineFlags(input.callerFlags, declaredFlags),
+      projectChanges: Object.freeze({
+        ok: false,
+        reason: Object.freeze({ code: GIT_CHANGES_UNAVAILABLE_CODE })
+      })
+    });
+  }
+}
+
+function declaredChangeFlags(changes: NormalizedProjectChangesConfiguration): readonly string[] {
+  return Object.freeze(
+    Object.keys(changes.flags)
+      .sort(compareText)
+      .map((flagId) => `${CHANGE_FLAG_PREFIX}${flagId}`)
+  );
+}
+
+function collectGitChangedPaths(projectRoot: string, compareWith: string): readonly string[] {
+  const root = resolve(projectRoot);
+  const repositoryRoot = gitText(root, ["rev-parse", "--show-toplevel"]);
+  if (!isProjectRootInRepository(root, resolve(repositoryRoot))) {
+    throw new Error("project root is outside the Git repository");
+  }
+
+  const committed = gitNameStatus(root, [
+    "diff",
+    "--relative",
+    "--name-status",
+    "-z",
+    "--find-renames",
+    `${compareWith}...HEAD`
+  ]);
+  const staged = gitNameStatus(root, [
+    "diff",
+    "--cached",
+    "--relative",
+    "--name-status",
+    "-z",
+    "--find-renames"
+  ]);
+  const unstaged = gitNameStatus(root, [
+    "diff",
+    "--relative",
+    "--name-status",
+    "-z",
+    "--find-renames"
+  ]);
+  const untracked = gitNulPaths(root, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    "."
+  ]);
+  return Object.freeze(
+    [
+      ...new Set([...committed, ...staged, ...unstaged, ...untracked].map(normalizedChangedPath))
+    ].sort(compareText)
+  );
+}
+
+function isProjectRootInRepository(projectRoot: string, repositoryRoot: string): boolean {
+  const fromRepository = relative(repositoryRoot, projectRoot);
+  return (
+    !isAbsolute(fromRepository) && fromRepository !== ".." && !fromRepository.startsWith(`..${sep}`)
+  );
+}
+
+function gitText(cwd: string, args: readonly string[]): string {
+  const text = gitOutput(cwd, args).trim();
+  if (text.length === 0) throw new Error("Git command returned no text");
+  return text;
+}
+
+function gitOutput(cwd: string, args: readonly string[]): string {
+  const result = execaSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    reject: false,
+    stripFinalNewline: false,
+    windowsHide: true
+  });
+  if (result.failed || result.exitCode !== 0) throw new Error("Git command failed");
+  if (typeof result.stdout !== "string") throw new Error("Git command returned non-text output");
+  return result.stdout;
+}
+
+function gitNameStatus(cwd: string, args: readonly string[]): readonly string[] {
+  return parseGitNameStatus(gitOutput(cwd, args));
+}
+
+function gitNulPaths(cwd: string, args: readonly string[]): readonly string[] {
+  return gitOutput(cwd, args)
+    .split("\0")
+    .filter((path) => path.length > 0);
+}
+
+/** Parses Git's `--name-status -z` protocol without line or tab splitting. */
+function parseGitNameStatus(stdout: string): readonly string[] {
+  const tokens = stdout.split("\0");
+  if (tokens.at(-1) === "") tokens.pop();
+  const paths: string[] = [];
+  for (let index = 0; index < tokens.length;) {
+    const entry = parseGitNameStatusEntry(tokens, index);
+    paths.push(...entry.paths);
+    index = entry.nextIndex;
+  }
+  return Object.freeze(paths);
+}
+
+function parseGitNameStatusEntry(
+  tokens: readonly string[],
+  statusIndex: number
+): Readonly<{ readonly nextIndex: number; readonly paths: readonly string[] }> {
+  const status = tokens[statusIndex];
+  if (status === undefined || !isNameStatus(status))
+    throw new Error("invalid Git name-status output");
+  const pathCount = nameStatusPathCount(status);
+  const paths = tokens.slice(statusIndex + 1, statusIndex + 1 + pathCount);
+  if (paths.length !== pathCount || paths.some((path) => path.length === 0))
+    throw new Error("missing Git changed path");
+  return Object.freeze({ nextIndex: statusIndex + 1 + pathCount, paths: Object.freeze(paths) });
+}
+
+function nameStatusPathCount(status: string): 1 | 2 {
+  return status.startsWith("R") || status.startsWith("C") ? 2 : 1;
+}
+
+function isNameStatus(value: string): boolean {
+  return /^(?:[ACDMRTUXB][0-9]*|[RC][0-9]+)$/u.test(value);
+}
+
+function normalizedChangedPath(path: string): string {
+  if (!isNormalizedProjectRelativePath(path)) throw new Error("invalid Git project-relative path");
+  return path;
+}
+
+function matchedProjectChanges(
+  paths: readonly string[],
+  changes: NormalizedProjectChangesConfiguration
+): Extract<ProjectChanges, { readonly ok: true }> {
+  const regions = Object.entries(changes.flags).sort(([left], [right]) => compareText(left, right));
+  const files = paths.flatMap((path) => {
+    const flags = regions.flatMap(([flagId, region]) =>
+      matchesRegion(path, region) ? [`${CHANGE_FLAG_PREFIX}${flagId}`] : []
+    );
+    return flags.length === 0 ? [] : [Object.freeze({ flags: Object.freeze(flags), path })];
+  });
+  return Object.freeze({ ok: true, files: Object.freeze(files) });
+}
+
+function matchesRegion(
+  path: string,
+  region: NormalizedProjectChangesConfiguration["flags"][string]
+): boolean {
+  return matchesAnyConfigGlob(path, region.include) && !matchesAnyConfigGlob(path, region.exclude);
+}
+
+function combineFlags(...sets: readonly (readonly string[])[]): readonly string[] {
+  return Object.freeze([...new Set(sets.flat())].sort(compareText));
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

package/src/project-run/check-execution/admitted-check-execution.ts

@@ -0,0 +1,62 @@
+/** Handles one admitted Check's preparation boundary and ready callback handoff. */
+
+import type { CheckProjectContext } from "../../check/check.ts";
+import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
+import type { ResolvedInvocationPaths } from "../invocation/paths.ts";
+import { checkIdentity } from "./execution-finalization.ts";
+import { recordSettledCheck, type CheckExecutionState } from "./execution-settlement.ts";
+import { prepareCheck, type CheckPreparationResolution } from "./preparation.ts";
+import { executeReadyCheck } from "./ready-check-execution.ts";
+
+export type CheckExecutionClock = Readonly<{ now(): number }>;
+
+export type AdmittedCheckExecutionInput = CheckExecutionState &
+  Readonly<{
+    readonly check: NormalizedCheck;
+    readonly clock: CheckExecutionClock;
+    readonly onAdmittedCheck: ((check: NormalizedCheck) => void) | undefined;
+    readonly invocationId: string;
+    readonly paths: ResolvedInvocationPaths | undefined;
+    readonly project: CheckProjectContext;
+    readonly signal: AbortSignal;
+  }>;
+
+export async function executeAdmittedCheck(input: AdmittedCheckExecutionInput): Promise<boolean> {
+  observeAdmittedCheck(input);
+  const preparation = await prepareCheck({
+    check: input.check,
+    diagnosticLogger: input.diagnosticLogger,
+    project: input.project,
+    signal: input.signal
+  });
+  if (preparation.kind === "blocked") {
+    settleBlockedPreparation(input, preparation);
+    return false;
+  }
+  return executeReadyCheck({ ...input, prepare: preparation });
+}
+
+function settleBlockedPreparation(
+  state: CheckExecutionState,
+  prepare: Extract<CheckPreparationResolution, { readonly kind: "blocked" }>
+): void {
+  const scope = state.session.openCheckScope(prepare.check.definition.checkId);
+  const outcome = scope.settleProduct(prepare.outcome);
+  recordSettledCheck({
+    check: checkIdentity(prepare.check),
+    durationMs: null,
+    messages: prepare.check.preparationMessages,
+    outcome,
+    phase: "preparation",
+    state
+  });
+}
+
+/** Diagnostic observation belongs to the invocation; it cannot revise admitted Task facts. */
+function observeAdmittedCheck(input: AdmittedCheckExecutionInput): void {
+  try {
+    input.onAdmittedCheck?.(input.check);
+  } catch {
+    // Learned diagnostic output is best-effort and has no execution consequence.
+  }
+}

package/src/project-run/check-execution/callback.ts

@@ -1,30 +1,40 @@
 import type {
   CheckDependencies,
   CheckExecutionContext,
+  CheckMessage,
   CheckOutcome,
   CheckProjectContext
 } from "../../check/check.ts";
 import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
 import { CoreInvariantFailure, type TrustedCheckScope } from "../../check-settlement/session.ts";
 import { diagnosticTags, type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
+import { invokeWithCapturedConsole } from "./console-capture.ts";
+import { diagnosticCallbackResult } from "./terminal-result.ts";
+
+const EMPTY_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
 
 export type CallbackExecution = Readonly<
   | {
       /** Raw author result; Core owns its sole validation and canonicalization. */
       readonly source: "author";
       readonly result: unknown;
+      readonly consoleMessages: readonly CheckMessage[];
     }
   | {
       /** Only callback containment may create a Product-controlled outcome. */
       readonly source: "product";
       readonly result: CheckOutcome;
+      readonly consoleMessages: readonly CheckMessage[];
     }
 >;
 
 interface CheckCallbackInput {
+  readonly artifactDirectory: string | null;
   readonly check: NormalizedCheck;
   readonly dependencies: CheckDependencies;
   readonly diagnosticLogger?: DiagnosticLogger;
+  readonly invocationId: string;
   readonly project: CheckProjectContext;
   readonly scope: TrustedCheckScope;
   readonly signal: AbortSignal;
@@ -39,27 +49,37 @@ interface CheckReporterLifecycle {
 export async function executeCheckCallback(input: CheckCallbackInput): Promise<CallbackExecution> {
   const checkId = input.check.definition.checkId;
   const checkTags = diagnosticTags(`CHECK:${checkId}`, "EXECUTION");
-  const reporter = createCheckReporter(input.scope, input.diagnosticLogger, checkTags);
+  const reporter = createCheckReporter(input.scope, input.diagnosticLogger, checkTags, checkId);
   let result: CallbackExecution;
+  let consoleMessages = EMPTY_MESSAGES;
   try {
     const context = Object.freeze({
+      artifactDirectory: input.artifactDirectory,
       dependencies: input.dependencies,
+      invocationId: input.invocationId,
       options: input.check.options,
       project: input.project,
       records: reporter.records,
       signal: input.signal
     });
-    const callbackResult = await input.check.execution(context);
+    const invocation = await invokeWithCapturedConsole(() => input.check.execute(context));
+    consoleMessages = invocation.messages;
+    if (invocation.kind === "threw") throw invocation.error;
+    const callbackResult = invocation.output;
     if (input.signal.aborted) {
       input.diagnosticLogger?.observe({
         event: "callback.cancelled",
         tags: diagnosticTags(...checkTags, "CANCELLED"),
-        details: { result: callbackResult }
+        details: { result: diagnosticCallbackResult(callbackResult, input.check.handoff) }
       });
     }
     result = input.signal.aborted
-      ? productResult("execution-cancelled")
-      : Object.freeze({ source: "author", result: callbackResult });
+      ? productResult("execution-cancelled", consoleMessages)
+      : Object.freeze({
+          source: "author",
+          result: callbackResult,
+          consoleMessages
+        });
   } catch (error) {
     if (error instanceof CoreInvariantFailure) throw error;
     input.diagnosticLogger?.observe({
@@ -67,7 +87,10 @@ export async function executeCheckCallback(input: CheckCallbackInput): Promise<C
       tags: diagnosticTags(...checkTags, input.signal.aborted ? "CANCELLED" : "THREW"),
       details: { error }
     });
-    result = productResult(input.signal.aborted ? "execution-cancelled" : "execution-threw");
+    result = productResult(
+      input.signal.aborted ? "execution-cancelled" : "execution-threw",
+      consoleMessages
+    );
   } finally {
     reporter.close();
   }
@@ -77,7 +100,8 @@ export async function executeCheckCallback(input: CheckCallbackInput): Promise<C
 function createCheckReporter(
   scope: TrustedCheckScope,
   diagnosticLogger: DiagnosticLogger | undefined,
-  checkTags: readonly string[]
+  checkTags: readonly string[],
+  checkId: string
 ): CheckReporterLifecycle {
   let isOpen = true;
   return Object.freeze({
@@ -91,16 +115,35 @@ function createCheckReporter(
         diagnosticLogger?.observe({
           event: "record.reported",
           tags: diagnosticTags(...checkTags, "RECORD", result.toUpperCase()),
-          details: { data, identity, result }
+          details: recordDiagnosticDetails(checkId, identity, result)
         });
       }
     })
   });
 }
 
-function productResult(code: string): CallbackExecution {
+function productResult(code: string, consoleMessages: readonly CheckMessage[]): CallbackExecution {
   return Object.freeze({
+    consoleMessages,
     source: "product",
     result: Object.freeze({ status: "unavailable", reason: Object.freeze({ code }) })
   });
 }
+
+function recordDiagnosticDetails(
+  checkId: string,
+  identity: unknown,
+  result: "committed" | "rejected"
+): Readonly<Record<string, unknown>> {
+  const record = snapshotClosedRecord(identity);
+  const recordId =
+    record !== undefined &&
+    Object.keys(record).length === 1 &&
+    Object.hasOwn(record, "id") &&
+    typeof record.id === "string"
+      ? record.id
+      : null;
+  return result === "committed"
+    ? Object.freeze({ checkId, recordId, result })
+    : Object.freeze({ checkId, rejectionCategory: "record-invalid-or-conflict", result });
+}