@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -13,7 +13,9 @@ export function validateCheckAggregationSelection(
   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 });
+  if (aggregation.checks === "all" || aggregation.checks === "effective") {
+    return Object.freeze({ ok: true, value: aggregation });
+  }
   const knownCheckIds = new Set(checkIds);
   const selectedCheckIds = new Set<string>();
   for (const checkId of aggregation.checks) {
@@ -28,9 +30,10 @@ export function validateCheckAggregationSelection(
 /** Derives one explicit consumer-selected aggregate from settled Check statuses only. */
 export function aggregateCheckOutcomes(
   snapshot: CoreSnapshot,
-  aggregation: CheckAggregation
+  aggregation: CheckAggregation,
+  effectiveCheckIds: readonly string[]
 ): CheckAggregate {
-  const statuses = selectedChecks(snapshot, aggregation.checks).map((check) =>
+  const statuses = selectedChecks(snapshot, aggregation.checks, effectiveCheckIds).map((check) =>
     aggregateStatus(check, aggregation)
   );
   if (statuses.includes("unavailable")) return "unavailable";
@@ -45,10 +48,12 @@ export function aggregateCheckOutcomes(
 
 function selectedChecks(
   snapshot: CoreSnapshot,
-  selection: CheckAggregation["checks"]
+  selection: CheckAggregation["checks"],
+  effectiveCheckIds: readonly string[]
 ): readonly CoreCheck[] {
   if (selection === "all") return snapshot.checks;
-  return selection.map((checkId) => {
+  const selectedCheckIds = selection === "effective" ? effectiveCheckIds : selection;
+  return selectedCheckIds.map((checkId) => {
     const check = snapshot.checks.find((candidate) => candidate.checkId === checkId);
     if (check === undefined) throw new TypeError("Aggregation selection was not validated");
     return check;

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

@@ -1,30 +1,39 @@
 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";
+
+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,17 +48,23 @@ 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.execution(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",
@@ -58,8 +73,12 @@ export async function executeCheckCallback(input: CheckCallbackInput): Promise<C
       });
     }
     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 +86,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 +99,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 +114,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 });
+}

package/src/project-run/check-execution/console-capture.ts

@@ -0,0 +1,262 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Console } from "node:console";
+import { Writable } from "node:stream";
+import { formatWithOptions } from "node:util";
+
+import type { CheckMessage, CheckMessageLevel } from "../../check/check.ts";
+
+type ConsoleInvocation<Result> = Readonly<
+  | {
+      readonly kind: "returned";
+      readonly output: Result;
+      readonly messages: readonly CheckMessage[];
+    }
+  | {
+      readonly kind: "threw";
+      readonly error: unknown;
+      readonly messages: readonly CheckMessage[];
+    }
+>;
+
+type ConsoleStream = "stderr" | "stdout";
+
+interface ActiveConsoleCall {
+  readonly chunks: Array<Readonly<{ readonly stream: ConsoleStream; readonly text: string }>>;
+  readonly method: string;
+}
+
+interface InstalledConsoleMethod {
+  readonly descriptor: PropertyDescriptor | undefined;
+  readonly method: string;
+}
+
+const HOST_CONSOLE = globalThis.console;
+const captureContext = new AsyncLocalStorage<CheckConsoleCapture>();
+let activeRouterOwnerCount = 0;
+let installedMethods: readonly InstalledConsoleMethod[] = Object.freeze([]);
+
+/** Installs one shared router around the complete resolved-Check execution lifecycle. */
+export async function runWithCheckConsoleRouter<Result>(
+  operation: () => Result | Promise<Result>
+): Promise<Result> {
+  const release = acquireConsoleRouter();
+  try {
+    return await operation();
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Runs one author-owned Check function in an isolated console capture context. Concurrent contexts
+ * keep separate buffers; the resolved-Check lifecycle owns router installation and restoration.
+ */
+export async function invokeWithCapturedConsole<Result>(
+  operation: () => Result | Promise<Result>
+): Promise<ConsoleInvocation<Result>> {
+  const capture = new CheckConsoleCapture();
+  return captureContext.run(capture, async () => {
+    try {
+      const output = await operation();
+      return Object.freeze({ kind: "returned", messages: capture.snapshot(), output });
+    } catch (error) {
+      return Object.freeze({ kind: "threw", error, messages: capture.snapshot() });
+    }
+  });
+}
+
+class CheckConsoleCapture {
+  readonly #console: Console;
+  readonly #messages: CheckMessage[] = [];
+  #activeCall: ActiveConsoleCall | undefined;
+
+  public constructor() {
+    this.#console = new Console({
+      colorMode: false,
+      ignoreErrors: true,
+      stderr: this.#writer("stderr"),
+      stdout: this.#writer("stdout")
+    });
+  }
+
+  public invoke(method: string, arguments_: readonly unknown[]): void {
+    const activeCall: ActiveConsoleCall = { chunks: [], method };
+    const previousCall = this.#activeCall;
+    this.#activeCall = activeCall;
+    try {
+      const captureMethod: unknown = Reflect.get(this.#console, method);
+      if (typeof captureMethod === "function") {
+        Reflect.apply(captureMethod, this.#console, arguments_);
+      } else {
+        activeCall.chunks.push({
+          stream: streamForMethod(method),
+          text: fallbackConsoleText(method, arguments_)
+        });
+      }
+    } catch {
+      activeCall.chunks.push({
+        stream: "stderr",
+        text: `console.${method} output could not be formatted safely`
+      });
+    } finally {
+      this.#activeCall = previousCall;
+      this.#appendCall(activeCall);
+    }
+  }
+
+  public snapshot(): readonly CheckMessage[] {
+    return this.#messages.length === 0 ? Object.freeze([]) : Object.freeze([...this.#messages]);
+  }
+
+  #appendCall(call: ActiveConsoleCall): void {
+    const chunks = combineAdjacentChunks(call.chunks);
+    for (const chunk of chunks) {
+      this.#messages.push(
+        Object.freeze({
+          code: consoleMessageCode(call.method),
+          level: levelForConsoleCall(call.method, chunk.stream),
+          message: removeTerminalLineEnding(chunk.text)
+        })
+      );
+    }
+  }
+
+  #writer(stream: ConsoleStream): Writable {
+    return new Writable({
+      write: (
+        chunk: unknown,
+        _encoding: BufferEncoding,
+        callback: (error?: Error | null) => void
+      ) => {
+        const activeCall = this.#activeCall;
+        if (activeCall !== undefined) {
+          activeCall.chunks.push({ stream, text: String(chunk) });
+        }
+        callback();
+      }
+    });
+  }
+}
+
+function acquireConsoleRouter(): () => void {
+  if (activeRouterOwnerCount === 0) installConsoleRouter();
+  activeRouterOwnerCount += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    activeRouterOwnerCount -= 1;
+    if (activeRouterOwnerCount === 0) restoreConsoleRouter();
+  };
+}
+
+function installConsoleRouter(): void {
+  const installed: InstalledConsoleMethod[] = [];
+  try {
+    for (const method of consoleMethodNames(HOST_CONSOLE)) {
+      const original: unknown = Reflect.get(HOST_CONSOLE, method);
+      if (typeof original !== "function") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(HOST_CONSOLE, method);
+      const routed = function (this: Console, ...arguments_: unknown[]): unknown {
+        const capture = captureContext.getStore();
+        if (capture !== undefined) {
+          capture.invoke(method, arguments_);
+          return undefined;
+        }
+        return Reflect.apply(original, HOST_CONSOLE, arguments_);
+      };
+      Object.defineProperty(HOST_CONSOLE, method, {
+        configurable: true,
+        enumerable: descriptor?.enumerable ?? false,
+        value: routed,
+        writable: true
+      });
+      installed.push(Object.freeze({ descriptor, method }));
+    }
+    installedMethods = Object.freeze(installed);
+  } catch (error) {
+    restoreInstalledMethods(installed);
+    throw error;
+  }
+}
+
+function restoreConsoleRouter(): void {
+  restoreInstalledMethods(installedMethods);
+  installedMethods = Object.freeze([]);
+}
+
+function restoreInstalledMethods(methods: readonly InstalledConsoleMethod[]): void {
+  for (const { descriptor, method } of [...methods].reverse()) {
+    if (descriptor === undefined) {
+      Reflect.deleteProperty(HOST_CONSOLE, method);
+    } else {
+      Object.defineProperty(HOST_CONSOLE, method, descriptor);
+    }
+  }
+}
+
+function consoleMethodNames(value: Console): readonly string[] {
+  const names = new Set<string>();
+  let current: object | null = value;
+  while (current !== null && current !== Object.prototype) {
+    for (const key of Reflect.ownKeys(current)) {
+      if (typeof key === "string" && key !== "Console" && key !== "constructor") names.add(key);
+    }
+    current = Reflect.getPrototypeOf(current);
+  }
+  return Object.freeze(
+    [...names].filter((name) => typeof Reflect.get(value, name) === "function").sort(compareText)
+  );
+}
+
+function combineAdjacentChunks(
+  chunks: readonly Readonly<{ readonly stream: ConsoleStream; readonly text: string }>[]
+): readonly Readonly<{ readonly stream: ConsoleStream; readonly text: string }>[] {
+  const combined: Array<{ stream: ConsoleStream; text: string }> = [];
+  for (const chunk of chunks) {
+    const previous = combined.at(-1);
+    if (previous?.stream === chunk.stream) {
+      previous.text += chunk.text;
+    } else {
+      combined.push({ stream: chunk.stream, text: chunk.text });
+    }
+  }
+  return combined;
+}
+
+function fallbackConsoleText(method: string, arguments_: readonly unknown[]): string {
+  const formatted = formatWithOptions({ colors: false }, ...arguments_);
+  return formatted.length === 0 ? `console.${method}()` : formatted;
+}
+
+function consoleMessageCode(method: string): string {
+  const normalized = method
+    .replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replaceAll(/[^a-zA-Z0-9-]/g, "-")
+    .toLowerCase();
+  return `console-${normalized}`;
+}
+
+function levelForConsoleCall(method: string, stream: ConsoleStream): CheckMessageLevel {
+  if (method === "warn") return "warning";
+  if (method === "assert" || method === "error" || method === "trace") return "error";
+  return stream === "stderr" ? "error" : "info";
+}
+
+function streamForMethod(method: string): ConsoleStream {
+  return method === "assert" || method === "error" || method === "trace" || method === "warn"
+    ? "stderr"
+    : "stdout";
+}
+
+function removeTerminalLineEnding(text: string): string {
+  if (text.endsWith("\r\n") && text.length > 2) return text.slice(0, -2);
+  if (text.endsWith("\n") && text.length > 1) return text.slice(0, -1);
+  return text;
+}
+
+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/dependencies.ts

@@ -1,4 +1,9 @@
-import type { CheckDependencies, CheckOutcome, DependencyReadResult } from "../../check/check.ts";
+import type {
+  CheckDependencies,
+  CheckOutcome,
+  DependencyObservation,
+  DependencyReadResult
+} from "../../check/check.ts";
 import type { CoreCheckSession } from "../../check-settlement/session.ts";
 import { diagnosticTags, type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
 
@@ -6,23 +11,55 @@ export function createCheckDependencies(
   input: Readonly<{
     readonly checkId: string;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
-    readonly directDependencyIds: readonly string[];
+    readonly directRelationCheckIds: readonly string[];
     readonly session: CoreCheckSession;
   }>
 ): CheckDependencies {
   return Object.freeze({
     get: (dependencyId: string): DependencyReadResult => {
-      const result = readDependency(input.session, input.directDependencyIds, dependencyId);
+      const result = readDirectRelation(input.session, input.directRelationCheckIds, dependencyId);
       input.diagnosticLogger?.observe({
         event: "dependency.read",
         tags: diagnosticTags(`CHECK:${input.checkId}`, "EXECUTION", "DEPENDENCY-READ"),
         details: dependencyReadDetails(dependencyId, result)
       });
       return result;
+    },
+    list: (): readonly DependencyObservation[] => {
+      const observations = listDirectRelationObservations(
+        input.session,
+        input.directRelationCheckIds
+      );
+      input.diagnosticLogger?.observe({
+        event: "dependency.list",
+        tags: diagnosticTags(`CHECK:${input.checkId}`, "EXECUTION", "DEPENDENCY-LIST"),
+        details: directRelationListDetails(observations)
+      });
+      return observations;
     }
   });
 }
 
+function listDirectRelationObservations(
+  session: CoreCheckSession,
+  directRelationCheckIds: readonly string[]
+): readonly DependencyObservation[] {
+  return Object.freeze(
+    directRelationCheckIds.map((checkId) =>
+      Object.freeze({ checkId, outcome: session.readSettledCheckOutcome(checkId) })
+    )
+  );
+}
+
+function directRelationListDetails(
+  observations: readonly DependencyObservation[]
+): Readonly<Record<string, unknown>> {
+  return Object.freeze({
+    dependencyIds: Object.freeze(observations.map(({ checkId }) => checkId)),
+    count: observations.length
+  });
+}
+
 function dependencyReadDetails(
   requestedCheckId: unknown,
   result: DependencyReadResult
@@ -38,12 +75,12 @@ function dependencyReadDetails(
   });
 }
 
-function readDependency(
+function readDirectRelation(
   session: CoreCheckSession,
-  directDependencyIds: readonly string[],
+  directRelationCheckIds: readonly string[],
   checkId: string
 ): DependencyReadResult {
-  if (typeof checkId !== "string" || !directDependencyIds.includes(checkId)) {
+  if (typeof checkId !== "string" || !directRelationCheckIds.includes(checkId)) {
     return dependencyNotDeclared(checkId);
   }
   return dependencyReadResult(checkId, session.readSettledCheckOutcome(checkId));