@zxyycom/vibe-check 0.0.1 → 0.0.3

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

@@ -1,321 +0,0 @@
-import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
-import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
-import { snapshotJsonObject } from "../../check/options-snapshot.ts";
-import {
-  diagnosticTags,
-  summarizeDiagnosticValue,
-  type DiagnosticLogger
-} from "../diagnostic-logging/logger.ts";
-import { parseCheckPreflightResult, type ParsedCheckPreflightResult } from "./preflight-result.ts";
-
-const EMPTY_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
-const INERT_SIGNAL = new AbortController().signal;
-
-export type PreparedCheck = Omit<NormalizedCheck, "options" | "preflight"> &
-  Readonly<{ readonly options: object; readonly preflightMessages: readonly CheckMessage[] }>;
-
-type BlockedCheck = Pick<NormalizedCheck, "definition" | "visibility"> &
-  Readonly<{ readonly preflightMessages: readonly CheckMessage[] }>;
-
-export type ReadyCheckPreflightResolution = Readonly<{
-  readonly kind: "ready";
-  readonly check: PreparedCheck;
-}>;
-
-export type BlockedCheckPreflightResolution = Readonly<{
-  readonly kind: "blocked";
-  readonly check: BlockedCheck;
-  readonly outcome: CheckOutcome;
-}>;
-
-export type CheckPreflightResolution =
-  | ReadyCheckPreflightResolution
-  | BlockedCheckPreflightResolution;
-
-type PreflightResolutionResult =
-  | "skipped"
-  | "prepared"
-  | "continued"
-  | "blocked"
-  | "cancelled-before-callback"
-  | "cancelled-after-callback"
-  | "cancelled-after-throw"
-  | "threw"
-  | "malformed";
-
-type PrepareCheckInput = Readonly<{
-  readonly check: NormalizedCheck;
-  readonly diagnosticLogger: DiagnosticLogger | undefined;
-  readonly signal: AbortSignal | undefined;
-}>;
-
-type PreflightInvocation =
-  | Readonly<{ readonly kind: "returned"; readonly output: unknown }>
-  | Readonly<{ readonly kind: "threw"; readonly error: unknown }>;
-
-/** Completes the sequential invocation-wide barrier before any Check enters the Task graph. */
-export async function prepareChecks(
-  input: Readonly<{
-    readonly checks: readonly NormalizedCheck[];
-    readonly diagnosticLogger?: DiagnosticLogger;
-    readonly signal: AbortSignal | undefined;
-  }>
-): Promise<readonly CheckPreflightResolution[]> {
-  const resolutions: CheckPreflightResolution[] = [];
-  for (const check of input.checks) {
-    resolutions.push(
-      await prepareCheck({
-        check,
-        diagnosticLogger: input.diagnosticLogger,
-        signal: input.signal
-      })
-    );
-  }
-  return Object.freeze(resolutions);
-}
-
-async function prepareCheck(input: PrepareCheckInput): Promise<CheckPreflightResolution> {
-  if (input.signal?.aborted) {
-    return observeBlockedPreflight({
-      check: input.check,
-      diagnosticLogger: input.diagnosticLogger,
-      details: {},
-      result: "cancelled-before-callback",
-      reasonCode: "execution-cancelled"
-    });
-  }
-  if (input.check.preflight === undefined) {
-    return resolveAuthoredOptions(input);
-  }
-  return resolvePreflightInvocation(input, await invokePreflight(input.check, input.signal));
-}
-
-function resolveAuthoredOptions(input: PrepareCheckInput): CheckPreflightResolution {
-  const resolution = readyResolution({
-    authoredCheck: input.check,
-    messages: EMPTY_MESSAGES,
-    preparedOptions: input.check.options
-  });
-  observeReadyOrMalformedResolution(
-    input.diagnosticLogger,
-    input.check.definition.checkId,
-    resolution,
-    "skipped",
-    { source: "authored" }
-  );
-  return resolution;
-}
-
-function resolvePreflightInvocation(
-  input: PrepareCheckInput,
-  invocation: PreflightInvocation
-): CheckPreflightResolution {
-  if (invocation.kind === "threw") {
-    return observeBlockedPreflight({
-      check: input.check,
-      diagnosticLogger: input.diagnosticLogger,
-      details: { error: invocation.error },
-      result: input.signal?.aborted ? "cancelled-after-throw" : "threw",
-      reasonCode: input.signal?.aborted ? "execution-cancelled" : "preflight-threw"
-    });
-  }
-  return resolveReturnedPreflight(input, invocation.output);
-}
-
-function resolveReturnedPreflight(
-  input: PrepareCheckInput,
-  preflightOutput: unknown
-): CheckPreflightResolution {
-  if (input.signal?.aborted) {
-    return observeBlockedPreflight({
-      check: input.check,
-      diagnosticLogger: input.diagnosticLogger,
-      details: { raw: preflightOutput },
-      result: "cancelled-after-callback",
-      reasonCode: "execution-cancelled"
-    });
-  }
-  const preflightResult = parseCheckPreflightResult(preflightOutput);
-  if (preflightResult === undefined) {
-    return observeBlockedPreflight({
-      check: input.check,
-      diagnosticLogger: input.diagnosticLogger,
-      details: { raw: preflightOutput },
-      result: "malformed",
-      reasonCode: "invalid-preflight-result"
-    });
-  }
-  if (preflightResult.status === "failure" && preflightResult.action === "block") {
-    return resolveBlockedPreflightResult(input, preflightResult);
-  }
-  return resolveReadyPreflightResult(input, preflightOutput, preflightResult);
-}
-
-function resolveBlockedPreflightResult(
-  input: PrepareCheckInput,
-  preflightResult: Extract<ParsedCheckPreflightResult, { readonly action: "block" }>
-): CheckPreflightResolution {
-  const resolution = blockedResolution({
-    check: input.check,
-    messages: preflightResult.messages,
-    reasonCode: preflightResult.reason.code
-  });
-  observePreflightResolution(
-    input.diagnosticLogger,
-    input.check.definition.checkId,
-    resolution,
-    "blocked",
-    {
-      ...(preflightResult.messages.length === 0 ? {} : { messages: preflightResult.messages }),
-      reason: preflightResult.reason
-    }
-  );
-  return resolution;
-}
-
-function resolveReadyPreflightResult(
-  input: PrepareCheckInput,
-  preflightOutput: unknown,
-  preflightResult: Exclude<ParsedCheckPreflightResult, { readonly action: "block" }>
-): CheckPreflightResolution {
-  const checkId = input.check.definition.checkId;
-  const result = preflightResult.status === "success" ? "prepared" : "continued";
-  const resolution = readyResolution({
-    authoredCheck: input.check,
-    messages: preflightResult.messages,
-    preparedOptions:
-      preflightResult.status === "success"
-        ? preflightResult.preparedOptions
-        : preflightResult.fallback
-  });
-  observeReadyOrMalformedResolution(input.diagnosticLogger, checkId, resolution, result, {
-    messages: preflightResult.messages,
-    ...(preflightResult.status === "success" ? {} : { reason: preflightResult.reason }),
-    raw: preflightOutput
-  });
-  return resolution;
-}
-
-async function invokePreflight(
-  check: NormalizedCheck,
-  signal: AbortSignal | undefined
-): Promise<PreflightInvocation> {
-  try {
-    return Object.freeze({
-      kind: "returned",
-      output: await check.preflight!(check.options, signal ?? INERT_SIGNAL)
-    });
-  } catch (error) {
-    return Object.freeze({ kind: "threw", error });
-  }
-}
-
-function observeBlockedPreflight(
-  input: Readonly<{
-    readonly check: NormalizedCheck;
-    readonly diagnosticLogger: DiagnosticLogger | undefined;
-    readonly details: Readonly<Record<string, unknown>>;
-    readonly result: PreflightResolutionResult;
-    readonly reasonCode: string;
-  }>
-): BlockedCheckPreflightResolution {
-  const resolution = blockedResolution({
-    check: input.check,
-    messages: EMPTY_MESSAGES,
-    reasonCode: input.reasonCode
-  });
-  observePreflightResolution(
-    input.diagnosticLogger,
-    input.check.definition.checkId,
-    resolution,
-    input.result,
-    input.details
-  );
-  return resolution;
-}
-
-function observeReadyOrMalformedResolution(
-  diagnosticLogger: DiagnosticLogger | undefined,
-  checkId: string,
-  resolution: CheckPreflightResolution,
-  result: "skipped" | "prepared" | "continued",
-  details: Readonly<Record<string, unknown>>
-): void {
-  if (resolution.kind === "blocked") {
-    observePreflightResolution(diagnosticLogger, checkId, resolution, "malformed", {
-      raw: "raw" in details ? details.raw : summarizeDiagnosticValue(details)
-    });
-    return;
-  }
-  const messages = "messages" in details ? details.messages : EMPTY_MESSAGES;
-  observePreflightResolution(diagnosticLogger, checkId, resolution, result, {
-    ...(Array.isArray(messages) && messages.length > 0 ? { messages } : {}),
-    options: summarizeDiagnosticValue(resolution.check.options),
-    ...("reason" in details ? { reason: details.reason } : {}),
-    ...("source" in details ? { source: details.source } : {})
-  });
-}
-
-function observePreflightResolution(
-  diagnosticLogger: DiagnosticLogger | undefined,
-  checkId: string,
-  resolution: CheckPreflightResolution,
-  result: PreflightResolutionResult,
-  details: Readonly<Record<string, unknown>>
-): void {
-  diagnosticLogger?.observe({
-    event: "preflight.resolved",
-    tags: diagnosticTags(`CHECK:${checkId}`, "PREFLIGHT", result.toUpperCase()),
-    details: {
-      ...details,
-      ...(resolution.kind === "blocked" ? { outcome: resolution.outcome } : {})
-    }
-  });
-}
-
-function readyResolution(
-  input: Readonly<{
-    readonly authoredCheck: NormalizedCheck;
-    readonly messages: readonly CheckMessage[];
-    readonly preparedOptions: unknown;
-  }>
-): CheckPreflightResolution {
-  const preparedOptions = snapshotJsonObject(input.preparedOptions);
-  if (preparedOptions === undefined) {
-    return blockedResolution({
-      check: input.authoredCheck,
-      messages: EMPTY_MESSAGES,
-      reasonCode: "invalid-preflight-result"
-    });
-  }
-  const { preflight: _preflight, ...check } = input.authoredCheck;
-  return Object.freeze({
-    kind: "ready",
-    check: Object.freeze({
-      ...check,
-      options: preparedOptions,
-      preflightMessages: input.messages
-    })
-  });
-}
-
-function blockedResolution(
-  input: Readonly<{
-    readonly check: NormalizedCheck;
-    readonly messages: readonly CheckMessage[];
-    readonly reasonCode: string;
-  }>
-): BlockedCheckPreflightResolution {
-  return Object.freeze({
-    kind: "blocked",
-    check: Object.freeze({
-      definition: input.check.definition,
-      preflightMessages: input.messages,
-      visibility: input.check.visibility
-    }),
-    outcome: Object.freeze({
-      status: "unavailable",
-      reason: Object.freeze({ code: input.reasonCode })
-    })
-  });
-}

package/src/project-run/invocation-creation.ts

@@ -1,160 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { relative, resolve } from "node:path";
-
-import {
-  createDeclarativeFingerprint,
-  type DefinitionWarning,
-  type NormalizedProjectDefinition,
-  type ProjectDefinition
-} from "../project-definition/project-definition.ts";
-import type { RunControls } from "./controls/contract.ts";
-import {
-  createDiagnosticLogger,
-  type DiagnosticLogger,
-  type DiagnosticLoggerFactory,
-  type DiagnosticObservation
-} from "./diagnostic-logging/logger.ts";
-import type { Invocation, RunInvocationDependencies } from "./invocation.ts";
-import { createOutputStatuses } from "./output-status.ts";
-import { effectiveOutputs } from "./output-configuration.ts";
-import { createProgressRendering } from "./progress-rendering/presentation.ts";
-
-const SYSTEM_MONOTONIC_CLOCK: Invocation["clock"] = Object.freeze({
-  now: () => performance.now()
-});
-
-export interface InvocationCreationInput {
-  readonly controls: RunControls;
-  readonly definition: ProjectDefinition;
-  readonly definitionWarnings: readonly DefinitionWarning[];
-  readonly dependencies: RunInvocationDependencies;
-  readonly normalized: NormalizedProjectDefinition;
-}
-
-/** Creates immutable invocation-owned output state before any planning or execution work. */
-export function createInvocation(input: InvocationCreationInput): Invocation {
-  const outputConfiguration = effectiveOutputs(input.definition, input.controls);
-  const clock = input.dependencies.clock ?? SYSTEM_MONOTONIC_CLOCK;
-  const projectRoot = resolve(input.controls.projectRoot ?? process.cwd());
-  const startedAtUtc = captureOutputCreationTimestamp(outputConfiguration, input.dependencies);
-  const identity = createInvocationIdentity();
-  const diagnosticLoggingFile = resolveDiagnosticLoggingFile({
-    identity,
-    outputConfiguration,
-    projectRoot,
-    startedAtUtc
-  });
-  const outputs = createOutputStatuses(outputConfiguration, diagnosticLoggingFile);
-  const diagnosticLogger = createDiagnosticLoggerSafely(
-    input.dependencies.diagnosticLoggerFactory ?? createDiagnosticLogger,
-    {
-      clock,
-      enabled: outputConfiguration.diagnosticLogging.enabled,
-      file: diagnosticLoggingFile === null ? null : resolve(projectRoot, diagnosticLoggingFile)
-    }
-  );
-
-  return Object.freeze({
-    clock,
-    controls: input.controls,
-    declarativeFingerprint: createDeclarativeFingerprint(input.normalized.declarative),
-    definition: input.definition,
-    definitionWarnings: Object.freeze([...input.definitionWarnings]),
-    diagnosticLogger,
-    outputConfiguration,
-    outputs,
-    invocationId: identity.id,
-    normalized: input.normalized,
-    progressRendering: createProgressRendering(outputConfiguration.progressRendering, outputs, {
-      clock,
-      refreshScheduler: input.dependencies.progressRefreshScheduler,
-      writerFactory: input.dependencies.progressWriterFactory
-    }),
-    projectRoot,
-    startedAtUtc
-  });
-}
-
-function captureOutputCreationTimestamp(
-  outputConfiguration: ProjectDefinition["outputs"],
-  dependencies: RunInvocationDependencies
-): string | null {
-  if (
-    !outputConfiguration.diagnosticLogging.enabled &&
-    !outputConfiguration.machinePublication.enabled
-  )
-    return null;
-  return (dependencies.wallClock?.now() ?? new Date()).toISOString();
-}
-
-function createInvocationIdentity(): Readonly<{ readonly id: string; readonly uuid: string }> {
-  const uuid = randomUUID();
-  return Object.freeze({ id: `invocation/v1:${uuid}`, uuid });
-}
-
-function resolveDiagnosticLoggingFile(
-  input: Readonly<{
-    readonly identity: Readonly<{ readonly uuid: string }>;
-    readonly outputConfiguration: ProjectDefinition["outputs"];
-    readonly projectRoot: string;
-    readonly startedAtUtc: string | null;
-  }>
-): string | null {
-  if (!input.outputConfiguration.diagnosticLogging.enabled) return null;
-  return relative(
-    input.projectRoot,
-    resolve(
-      input.projectRoot,
-      input.outputConfiguration.diagnosticLogging.directory,
-      diagnosticLogFileName(requireStartedAtUtc(input.startedAtUtc), input.identity.uuid)
-    )
-  );
-}
-
-function createDiagnosticLoggerSafely(
-  factory: DiagnosticLoggerFactory,
-  input: Parameters<DiagnosticLoggerFactory>[0]
-): DiagnosticLogger {
-  let delegate: DiagnosticLogger;
-  try {
-    delegate = factory(input);
-  } catch {
-    return failedDiagnosticLogger();
-  }
-  let failed = false;
-  return Object.freeze({
-    close: () => {
-      try {
-        const status = delegate.close();
-        return failed ? "failed" : status;
-      } catch {
-        return "failed";
-      }
-    },
-    observe: (observation: DiagnosticObservation) => {
-      if (failed) return;
-      try {
-        delegate.observe(observation);
-      } catch {
-        failed = true;
-      }
-    }
-  });
-}
-
-function failedDiagnosticLogger(): DiagnosticLogger {
-  return Object.freeze({
-    close: () => "failed" as const,
-    observe: () => undefined
-  });
-}
-
-function diagnosticLogFileName(startedAtUtc: string, invocationUuid: string): string {
-  const compactUtc = startedAtUtc.replaceAll("-", "").replaceAll(":", "");
-  return `run-${compactUtc}-${invocationUuid}.log`;
-}
-
-function requireStartedAtUtc(startedAtUtc: string | null): string {
-  if (startedAtUtc === null) throw new Error("Enabled output requires an invocation timestamp");
-  return startedAtUtc;
-}