@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/progress-rendering/renderer-lifecycle.ts

@@ -4,16 +4,20 @@ import type {
   ProgressRenderer,
   ProgressWriter
 } from "./renderer.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
 import {
+  formatFlagConditionNotMatchedBlock,
   formatFinalSummary,
   formatRunningRow,
   formatSettledBlock,
+  isFlagConditionNotMatchedFeedback,
   shouldPresentSettledFeedback
 } from "./renderer-formatting.ts";
 
 interface RunningCheck {
   readonly checkId: string;
   readonly displayName: string;
+  readonly omitQuietPassedRow: boolean;
   readonly startedAtMs: number;
   elapsedMs: number | null;
 }
@@ -25,14 +29,23 @@ export class ProgressRendererController implements ProgressRenderer {
   private readonly clock: ProgressClock;
   private readonly writer: ProgressWriter;
   private completedCount = 0;
+  private readonly flagConditionNotMatchedDisplayNames: string[] = [];
+  private quietPassOmissionConfiguredCount = 0;
+  private quietPassOmittedCount = 0;
   private preparedTotal: number | undefined;
   private renderedRunningRows = 0;
   private readonly running: RunningCheck[] = [];
   private readonly usesColor: boolean;
+  private readonly progressRendering: ResolvedProgressRenderingOutput;
 
-  constructor(writer: ProgressWriter, clock: ProgressClock) {
+  constructor(
+    writer: ProgressWriter,
+    clock: ProgressClock,
+    progressRendering: ResolvedProgressRenderingOutput
+  ) {
     this.writer = writer;
     this.clock = clock;
+    this.progressRendering = progressRendering;
     this.refreshesRunningRegion = writer.isTTY && writer.term?.toLowerCase() !== "dumb";
     this.usesColor = this.refreshesRunningRegion && writer.color;
   }
@@ -48,7 +61,10 @@ export class ProgressRendererController implements ProgressRenderer {
   render(feedback: ProgressFeedback): void {
     switch (feedback.kind) {
       case "prepared":
-        this.prepare(feedback.totalChecks);
+        this.prepare(feedback.totalChecks, feedback.quietPassOmissionConfiguredCount);
+        return;
+      case "flag-control-completed":
+        this.completeFlagControl();
         return;
       case "started":
         this.start(feedback);
@@ -61,10 +77,15 @@ export class ProgressRendererController implements ProgressRenderer {
     }
   }
 
-  private prepare(totalChecks: number): void {
+  private prepare(totalChecks: number, quietPassOmissionConfiguredCount: number): void {
     if (this.preparedTotal !== undefined) throw new Error("Progress feedback was prepared twice");
     this.preparedTotal = totalChecks;
-    this.writer.write(`Vibe Check\ntotal ${totalChecks} checks\n\nChecks:\n`);
+    this.quietPassOmissionConfiguredCount = quietPassOmissionConfiguredCount;
+    const configuredSuffix =
+      quietPassOmissionConfiguredCount === 0
+        ? ""
+        : ` · ${quietPassOmissionConfiguredCount} configured for quiet-pass omission`;
+    this.writer.write(`Vibe Check\ntotal ${totalChecks} checks${configuredSuffix}\n\nChecks:\n`);
   }
 
   private start(feedback: Extract<ProgressFeedback, { readonly kind: "started" }>): void {
@@ -74,6 +95,7 @@ export class ProgressRendererController implements ProgressRenderer {
     this.running.push({
       checkId: feedback.checkId,
       displayName: feedback.displayName,
+      omitQuietPassedRow: feedback.omitQuietPassedRow,
       elapsedMs: null,
       startedAtMs: this.clock.now()
     });
@@ -85,18 +107,24 @@ export class ProgressRendererController implements ProgressRenderer {
     if (this.refreshesRunningRegion) this.eraseRunningRegion();
     this.completedCount += 1;
     this.removeRunningCheck(feedback.checkId);
-    if (shouldPresentSettledFeedback(feedback)) {
+    if (isFlagConditionNotMatchedFeedback(feedback)) {
+      this.flagConditionNotMatchedDisplayNames.push(feedback.displayName);
+    } else if (shouldPresentSettledFeedback(feedback)) {
       this.writer.write(
         formatSettledBlock({
-          completionOrdinal: this.completedCount,
+          completionOrdinal: feedback.omitQuietPassedRow ? undefined : this.completedCount,
           displayName: feedback.displayName,
           durationMs: feedback.durationMs,
           messages: feedback.messages,
           outcome: feedback.outcome,
+          records: feedback.records,
           totalChecks,
-          usesColor: this.usesColor
+          usesColor: this.usesColor,
+          progressRendering: this.progressRendering
         })
       );
+    } else {
+      this.quietPassOmittedCount += 1;
     }
     if (this.refreshesRunningRegion) this.redrawRunningRegion();
   }
@@ -106,7 +134,31 @@ export class ProgressRendererController implements ProgressRenderer {
     if (this.running.length > 0) {
       throw new Error("Progress feedback finalized while Checks are still running");
     }
-    this.writer.write(formatFinalSummary(feedback));
+    this.flushFlagConditionNotMatchedChecks();
+    this.writer.write(
+      formatFinalSummary({
+        ...feedback,
+        quietPassOmissionConfiguredCount: this.quietPassOmissionConfiguredCount,
+        quietPassOmittedCount: this.quietPassOmittedCount
+      })
+    );
+  }
+
+  private completeFlagControl(): void {
+    this.requirePrepared();
+    this.flushFlagConditionNotMatchedChecks();
+  }
+
+  private flushFlagConditionNotMatchedChecks(): void {
+    const firstDisplayName = this.flagConditionNotMatchedDisplayNames[0];
+    if (firstDisplayName === undefined) return;
+    this.writer.write(
+      formatFlagConditionNotMatchedBlock([
+        firstDisplayName,
+        ...this.flagConditionNotMatchedDisplayNames.slice(1)
+      ])
+    );
+    this.flagConditionNotMatchedDisplayNames.length = 0;
   }
 
   private eraseRunningRegion(): void {
@@ -121,9 +173,9 @@ export class ProgressRendererController implements ProgressRenderer {
     for (const [index, check] of this.running.entries()) {
       this.writer.write(
         formatRunningRow({
-          displayIndex: this.completedCount + index + 1,
           displayName: check.displayName,
           elapsedMs: check.elapsedMs,
+          displayIndex: check.omitQuietPassedRow ? undefined : this.completedCount + index + 1,
           totalChecks
         })
       );

package/src/project-run/progress-rendering/renderer.ts

@@ -1,22 +1,31 @@
-import type { CheckMessage, CheckOutcome, CheckVisibility } from "../../check/check.ts";
+import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
+import type { CoreRecord } from "../../check-settlement/facts.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
+import { resolveProgressRenderingOutput } from "../../project-definition/output-defaults.ts";
 import { ProgressRendererController } from "./renderer-lifecycle.ts";
 
 export interface ProgressWriter {
   readonly color: boolean;
   readonly isTTY: boolean;
   readonly term: string | undefined;
+  close?(): void;
   write(content: string): void;
 }
 
 export type ProgressFeedback = Readonly<
   | {
       readonly kind: "prepared";
+      readonly quietPassOmissionConfiguredCount: number;
       readonly totalChecks: number;
     }
+  | {
+      readonly kind: "flag-control-completed";
+    }
   | {
       readonly kind: "started";
       readonly checkId: string;
       readonly displayName: string;
+      readonly omitQuietPassedRow: boolean;
     }
   | {
       readonly kind: "settled";
@@ -24,8 +33,9 @@ export type ProgressFeedback = Readonly<
       readonly displayName: string;
       readonly outcome: CheckOutcome;
       readonly durationMs: number | null;
-      readonly visibility: CheckVisibility;
+      readonly omitQuietPassedRow: boolean;
       readonly messages: readonly CheckMessage[];
+      readonly records: readonly CoreRecord[];
     }
   | {
       readonly kind: "final";
@@ -57,12 +67,19 @@ const SYSTEM_PROGRESS_CLOCK: ProgressClock = Object.freeze({ now: () => performa
 /** Product-private lifecycle presentation with one owner for feedback and its writer. */
 export function createProgressRenderer(
   writer: ProgressWriter,
-  clock: ProgressClock = SYSTEM_PROGRESS_CLOCK
+  clock: ProgressClock = SYSTEM_PROGRESS_CLOCK,
+  progressRendering: ResolvedProgressRenderingOutput = resolveProgressRenderingOutput({
+    enabled: true
+  })
 ): ProgressRenderer {
-  const controller = new ProgressRendererController(writer, clock);
+  const controller = new ProgressRendererController(writer, clock, progressRendering);
   return Object.freeze({
     refreshesRunningRegion: controller.refreshesRunningRegion,
-    refresh: (): void => controller.refresh(),
-    render: (feedback: ProgressFeedback): void => controller.render(feedback)
+    refresh: (): void => {
+      controller.refresh();
+    },
+    render: (feedback: ProgressFeedback): void => {
+      controller.render(feedback);
+    }
   });
 }

package/src/project-run/project-context.ts

@@ -1,11 +1,16 @@
-import type { CheckProjectContext } from "../check/check.ts";
-import type { RunControls } from "./controls/contract.ts";
+import type { CheckProjectContext, ProjectChanges } from "../check/check.ts";
+import type { ResolvedInvocationPaths } from "./invocation/paths.ts";
 /** Materializes only invocation-wide callback input; Check-local options own domain configuration. */
 export function createProjectContext(
-  input: Readonly<{ readonly controls: RunControls; readonly root: string }>
+  input: Readonly<{
+    readonly changes?: ProjectChanges;
+    readonly flags: readonly string[];
+    readonly paths: ResolvedInvocationPaths;
+  }>
 ): CheckProjectContext {
   return Object.freeze({
-    flags: Object.freeze([...(input.controls.flags ?? [])]),
-    root: input.root
+    ...(input.changes === undefined ? {} : { changes: input.changes }),
+    flags: input.flags,
+    root: input.paths.projectRoot
   });
 }

package/src/project-run/result.ts

@@ -6,79 +6,123 @@ import type { RunControlDiagnostic } from "./controls/validation-result.ts";
 import type { CheckAggregate, RunControls } from "./controls/contract.ts";
 import type { CheckMessageLevel } from "../check/check.ts";
 import type { CoreSnapshot } from "../check-settlement/facts.ts";
-import type { RunOutputStatuses } from "./output-status.ts";
+import type { RunOutputStatuses } from "./outputs/status.ts";
+
+/** Product 不能形成正常 Run 结果时的稳定 invocation diagnostic。 */
 export type RunDiagnostic = Readonly<{
-  readonly code: "task-graph-invalid" | "task-engine-failed" | "publication-model-failed";
+  /** 失败的 Run-owned execution 或 planning boundary；它不是任何 Check 的 terminal status。 */
+  readonly code:
+    | "admission-policy-failed"
+    | "admission-strategy-preparation-failed"
+    | "task-graph-invalid"
+    | "task-engine-failed"
+    | "publication-model-failed";
 }>;
+
+/** 一项 executable Check 的最终 duration readback。 */
 export type CheckDuration = Readonly<{
+  /** 与 snapshot 中 Check facts 相同的 stable Check identity。 */
   readonly checkId: string;
+  /** 已测量的 execution duration；未进入 execution 的 Check 为 `null`，不是零时长。 */
   readonly durationMs: number | null;
 }>;
+
+/** Run 在 Check terminal lifecycle 中接受的人读 message。 */
 export interface CheckRunMessage {
+  /** 产生 message 的 stable Check identity。 */
   readonly checkId: string;
+  /** author message 或已捕获 console output 的 presentation severity。 */
   readonly level: CheckMessageLevel;
+  /** owning Check 或 Product capture 使用的稳定 message code。 */
   readonly code: string;
+  /** 人读正文；不能代替 snapshot 中的 terminal outcome。 */
   readonly message: string;
 }
+
+/** 只有已形成 terminal Check facts 的 Run branch 才具备的完整结果 readback。 */
 export interface RunResultFacts {
-  readonly aggregate: CheckAggregate | null;
+  /** 有完整 terminal Check facts 时，由有效 Check 列表形成的 invocation-level conclusion。 */
+  readonly aggregate: CheckAggregate;
+  /** 按 canonical Check order 的 duration facts；未执行 Check 仍以 `null` 保留。 */
   readonly checkDurations: readonly CheckDuration[];
+  /** 已接受的 author 与 console-capture messages，不决定 Check outcome。 */
   readonly checkMessages: readonly CheckRunMessage[];
+  /** 已结算的完整 Check 与 supplemental Record facts。 */
   readonly snapshot: CoreSnapshot;
 }
 /** 一次 Project Run 的可判别结果；output failure 保留已结算 facts。 */
 export type RunResult = Readonly<
   | {
+      /** Definition、RunControls 或 aggregation selection 无效；没有执行任何 Check author callback。 */
       readonly kind: "configuration";
+      /** Definition normalization 时仍可报告、但不单独阻止本 branch 的 warning。 */
       readonly definitionWarnings: readonly DefinitionWarning[];
+      /** 指向被拒绝 Definition 或 RunControls value 的 closed diagnostic。 */
       readonly diagnostic: ProjectDefinitionDiagnostic | RunControlDiagnostic;
     }
   | {
+      /** 配置有效，但 static Check graph 不能进入 execution planning。 */
       readonly kind: "planning";
+      /** normalized declarative Definition 的 matching signal；不包含 RunControls 或 outcome。 */
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
+      /** 这次 planning 失败的 Product diagnostic。 */
       readonly diagnostic: RunDiagnostic;
+      /** 配置有效后各 terminal output participant 的独立状态。 */
       readonly outputs: RunOutputStatuses;
     }
   | {
+      /** invocation 在 Check work 开始前或 planning 中响应 caller cancellation。 */
       readonly kind: "cancelled";
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
       readonly outputs: RunOutputStatuses;
+      /** 取消发生在尚未形成 terminal Check facts 的阶段。 */
       readonly phase: "pre-work" | "planning";
     }
   | {
+      /** invocation 在至少可能已开始 Check work 的 execution 阶段响应 caller cancellation。 */
       readonly kind: "cancelled";
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
       readonly outputs: RunOutputStatuses;
+      /** 此 branch 总在 terminal Check facts 形成后的 execution cancellation 返回。 */
       readonly phase: "execution";
+      /** 按 canonical Check order 的 duration facts；未执行 Check 为 `null`。 */
       readonly checkDurations: readonly CheckDuration[];
+      /** cancellation 前已接受的 author 与 console-capture messages。 */
       readonly checkMessages: readonly CheckRunMessage[];
+      /** cancellation 时已结算的完整 Check 与 supplemental Record facts。 */
       readonly snapshot: CoreSnapshot;
     }
   | ({
+      /** 所有 Check 已完成 terminal settlement；不表示每项 Check 都 `passed`。 */
       readonly kind: "completed";
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
       readonly outputs: RunOutputStatuses;
     } & RunResultFacts)
   | {
+      /** Product execution/settlement infrastructure 失败；不把它误表示为 Check `failed`。 */
       readonly kind: "execution";
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
+      /** 停止正常 execution 的 Product diagnostic；本 branch 不提供 partial snapshot。 */
       readonly diagnostic: RunDiagnostic;
       readonly outputs: RunOutputStatuses;
     }
   | ({
+      /** Check facts 已完整结算，但至少一个 terminal output participant 失败。 */
       readonly kind: "output";
       readonly declarativeFingerprint: string;
       readonly definitionWarnings: readonly DefinitionWarning[];
+      /** 失败的 machine、progress、diagnostic 或 scheduler-measurement output 类别。 */
       readonly diagnostic: Readonly<{
         readonly code:
           | "machine-publication-failed"
           | "progress-rendering-failed"
-          | "diagnostic-logging-failed";
+          | "diagnostic-logging-failed"
+          | "scheduler-terminal-effects-failed";
       }>;
       readonly outputs: RunOutputStatuses;
     } & RunResultFacts)
@@ -115,6 +159,8 @@ function outputDiagnosticCode(
       return "progress-rendering-failed";
     case "diagnosticLogging":
       return "diagnostic-logging-failed";
+    case "terminalEffects":
+      return "scheduler-terminal-effects-failed";
   }
 }
 

package/src/project-run/run.ts

@@ -2,22 +2,23 @@ import type { ProjectDefinition } from "../project-definition/project-definition
 import type { RunControls } from "./controls/contract.ts";
 import { validateProjectDefinition } from "../project-definition/project-definition-validation.ts";
 import { validateRunControls } from "./controls/validation.ts";
-import { executeValidatedRun } from "./invocation.ts";
+import { executeValidatedRun } from "./invocation/run.ts";
 import type { RunResult } from "./result.ts";
 
-export type { RunOutputStatus, RunOutputStatuses } from "./output-status.ts";
+export type { RunOutputStatus, RunOutputStatuses } from "./outputs/status.ts";
 export type { RunDiagnostic, RunResult } from "./result.ts";
 
 /**
- * 在调用方的 Bun runtime 中执行一个由项目拥有的 Project Definition。
+ * 在调用方的 Node runtime 中执行一个由项目拥有的 Project Definition。
  *
  * @param definition - Project Definition input；{@link defineConfig} 补齐 defaults，run 在 invocation 前验证。
  * @param controls - 本次 invocation context 与 outputs 使用的闭合控制值。
  * @returns ordinary configuration、planning、execution、cancellation 与 output failures 通过 `RunResult`
  * 返回；调用方先按 `kind` narrow。
- * @remarks Definition validation 关闭 authoring grammar；可选 Check preflight 组成 invocation execution barrier，
- * 并在 execution callback、dependency resolver 或 scanner 前完成。`output` branch 同时提供完整 final
- * snapshot 与 output failure diagnostic。
+ * @remarks Definition validation 关闭 authoring grammar；可选 Check preparation 在其 Task 通过直接 relation
+ * readiness 后被 Scheduler admission 时运行，并先于该 Check 自己的 execution callback。它受该 Task 的
+ * mutex、capacity、priority 与 cancellation 约束，而不是 invocation-wide barrier。`output` branch 同时提供
+ * 完整 final snapshot 与 output failure diagnostic。
  */
 export async function run(
   definition: ProjectDefinition,

package/src/project-run/task-scheduler/admission-core/compiled-graph-lookup.ts

@@ -0,0 +1,71 @@
+/** Required accessors for compiler-owned dense slot indexes. */
+
+import type { PlannedTask } from "../graph.ts";
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+
+export function requiredTaskForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): PlannedTask {
+  const task = compiled.graph.tasks[taskSlot];
+  if (task === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return task;
+}
+
+export function requiredTaskMutexSlotsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["taskMutexSlots"][number] {
+  const slots = compiled.taskMutexSlots[taskSlot];
+  if (slots === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return slots;
+}
+
+export function requiredTaskResourceClaimsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["taskResourceClaims"][number] {
+  const claims = compiled.taskResourceClaims[taskSlot];
+  if (claims === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return claims;
+}
+
+export function requiredReverseDependenciesForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseDependencies"][number] {
+  const dependencies = compiled.relationIndexes.reverseDependencies[taskSlot];
+  if (dependencies === undefined)
+    throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return dependencies;
+}
+
+export function requiredReverseObservationsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseObservations"][number] {
+  const observations = compiled.relationIndexes.reverseObservations[taskSlot];
+  if (observations === undefined)
+    throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return observations;
+}
+
+export function requiredReverseMutexOccurrencesForCompiled(
+  compiled: CompiledAdmissionGraph,
+  mutexSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseMutexOccurrences"][number] {
+  const occurrences = compiled.relationIndexes.reverseMutexOccurrences[mutexSlot];
+  if (occurrences === undefined) {
+    throw new Error(`admission core mutex slot is unknown: ${mutexSlot}`);
+  }
+  return occurrences;
+}
+
+export function requiredScopeTerminalSlotsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["scopeSlotsByTerminalTaskSlot"][number] {
+  const scopeSlots = compiled.scopeSlotsByTerminalTaskSlot[taskSlot];
+  if (scopeSlots === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return scopeSlots;
+}