@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/project-definition/output-validation.ts

@@ -1,44 +1,44 @@
-import { isAbsolute, relative, resolve, sep } from "node:path";
-
 import type { ProjectOutputs } from "./project-definition.ts";
+import type { ResolvedProgressRenderingOutput } from "./progress-rendering-output.ts";
+import { parseProgressRenderingFields } from "./progress-rendering-output.ts";
 import { snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+import { resolveProgressRenderingOutput } from "./output-defaults.ts";
 
 const OUTPUT_NAMES = ["machinePublication", "progressRendering", "diagnosticLogging"] as const;
-const DIRECTORY_VALIDATION_ROOT = "/vibe-check-validation-root";
 
 export function parseOutputs(value: unknown): ProjectOutputs | undefined {
   const data = exactKeys(value, OUTPUT_NAMES);
   if (data === undefined) return undefined;
   const machinePublication = parseDirectoryOutput(data.machinePublication);
-  const progressRendering = parseSwitchOutput(data.progressRendering);
+  const progressRendering = parseProgressRenderingOutput(data.progressRendering);
   const diagnosticLogging = parseDirectoryOutput(data.diagnosticLogging);
   return machinePublication === undefined ||
     progressRendering === undefined ||
-    diagnosticLogging === undefined ||
-    !isContainedRelativeDirectory(diagnosticLogging.directory)
+    diagnosticLogging === undefined
     ? undefined
     : Object.freeze({ machinePublication, progressRendering, diagnosticLogging });
 }
 
-export function isContainedRelativeDirectory(directory: string): boolean {
-  if (directory.length === 0 || isAbsolute(directory)) return false;
-  const root = resolve(DIRECTORY_VALIDATION_ROOT);
-  const relativeDirectory = relative(root, resolve(root, directory));
-  return relativeDirectory !== ".." && !relativeDirectory.startsWith(`..${sep}`);
+/** Accepts trusted output targets without claiming filesystem containment. */
+export function isOutputDirectory(directory: string): boolean {
+  return directory.length > 0 && !directory.includes("\0");
 }
 
 function parseDirectoryOutput(
   value: unknown
 ): Readonly<{ readonly directory: string; readonly enabled: boolean }> | undefined {
   const data = exactKeys(value, ["directory", "enabled"]);
-  return typeof data?.directory === "string" && typeof data.enabled === "boolean"
+  return typeof data?.directory === "string" &&
+    isOutputDirectory(data.directory) &&
+    typeof data.enabled === "boolean"
     ? Object.freeze({ directory: data.directory, enabled: data.enabled })
     : undefined;
 }
 
-function parseSwitchOutput(value: unknown): Readonly<{ readonly enabled: boolean }> | undefined {
-  const data = exactKeys(value, ["enabled"]);
-  return typeof data?.enabled === "boolean" ? Object.freeze({ enabled: data.enabled }) : undefined;
+function parseProgressRenderingOutput(value: unknown): ResolvedProgressRenderingOutput | undefined {
+  const fields = parseProgressRenderingFields(value);
+  if (!fields.ok || fields.value.enabled === undefined) return undefined;
+  return resolveProgressRenderingOutput(fields.value);
 }
 
 function exactKeys(

package/src/project-definition/progress-rendering-output.ts

@@ -0,0 +1,121 @@
+import { snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+
+/** Progress formatter 只接收当前 selected preview 的默认正文，不接收 Check 或事实对象。 */
+export type ProgressPreviewFormatter = (
+  this: void,
+  context: Readonly<{
+    readonly kind: "record" | "message";
+    readonly text: string;
+    readonly maxCodePoints: number;
+  }>
+) => string;
+
+/** 人读 progress rendering 的作者配置；省略 preview 字段时使用 Product 默认值。 */
+export interface ProgressRenderingOutput {
+  /** `false` 时不构造或写入 progress writer。 */
+  readonly enabled: boolean;
+  /** 每个 settled block 预览的 Record 数量；非负 safe integer，默认 `5`，`0` 只隐藏 detail。 */
+  readonly recordPreviewLimit?: number;
+  /** 每个 settled block 预览的 message 数量；非负 safe integer，默认 `5`，`0` 只隐藏 detail。 */
+  readonly messagePreviewLimit?: number;
+  /** 每条 preview 正文的 Unicode code point 上限；正 safe integer，默认 `240`。 */
+  readonly textPreviewCodePointLimit?: number;
+  /** `null` 或省略保持默认正文；函数返回文本仍由 Product escape 并限制长度。 */
+  readonly formatter?: ProgressPreviewFormatter | null;
+}
+
+/** 已补齐 defaults、可直接交给 progress renderer 的配置。 */
+export interface ResolvedProgressRenderingOutput {
+  readonly enabled: boolean;
+  readonly formatter: ProgressPreviewFormatter | null;
+  readonly messagePreviewLimit: number;
+  readonly recordPreviewLimit: number;
+  readonly textPreviewCodePointLimit: number;
+}
+
+type ProgressRenderingFieldSpec = Readonly<{
+  readonly key: keyof ProgressRenderingOutput;
+  readonly accepts: (value: unknown) => boolean;
+  readonly expected: ProgressRenderingFieldExpectation;
+}>;
+
+/** Closed expectations shared with invocation diagnostics; never contains authored values. */
+export type ProgressRenderingFieldExpectation =
+  | "plain-data-object"
+  | "boolean"
+  | "function-or-null"
+  | "non-negative-safe-integer"
+  | "positive-safe-integer";
+
+type ProgressRenderingFieldsResult = Readonly<
+  | { readonly ok: true; readonly value: Partial<ProgressRenderingOutput> }
+  | {
+      readonly ok: false;
+      readonly key: string | null;
+      readonly reason: "unknown-key" | "invalid-value";
+      readonly expected?: ProgressRenderingFieldExpectation;
+    }
+>;
+
+const PROGRESS_RENDERING_FIELD_SPECS = Object.freeze([
+  { key: "enabled", accepts: isBoolean, expected: "boolean" },
+  { key: "formatter", accepts: isProgressPreviewFormatterOrNull, expected: "function-or-null" },
+  {
+    key: "messagePreviewLimit",
+    accepts: isNonNegativeSafeInteger,
+    expected: "non-negative-safe-integer"
+  },
+  {
+    key: "recordPreviewLimit",
+    accepts: isNonNegativeSafeInteger,
+    expected: "non-negative-safe-integer"
+  },
+  {
+    key: "textPreviewCodePointLimit",
+    accepts: isPositiveSafeInteger,
+    expected: "positive-safe-integer"
+  }
+] satisfies readonly ProgressRenderingFieldSpec[]);
+
+/** Parses the fields shared by Definition output and RunControls override grammar. */
+export function parseProgressRenderingFields(value: unknown): ProgressRenderingFieldsResult {
+  const data = snapshotClosedRecord(value);
+  if (data === undefined) {
+    return { ok: false, key: null, reason: "invalid-value", expected: "plain-data-object" };
+  }
+  const unknownKey = Object.keys(data).find(
+    (key) => !PROGRESS_RENDERING_FIELD_SPECS.some((field) => field.key === key)
+  );
+  if (unknownKey !== undefined) return { ok: false, key: unknownKey, reason: "unknown-key" };
+  for (const { key, accepts, expected } of PROGRESS_RENDERING_FIELD_SPECS) {
+    if (data[key] !== undefined && !accepts(data[key])) {
+      return { ok: false, key, reason: "invalid-value", expected };
+    }
+  }
+  return {
+    ok: true,
+    value: Object.freeze(
+      Object.fromEntries(
+        PROGRESS_RENDERING_FIELD_SPECS.flatMap(({ key }) =>
+          data[key] === undefined ? [] : [[key, data[key]]]
+        )
+      ) as Partial<ProgressRenderingOutput>
+    )
+  };
+}
+
+function isBoolean(value: unknown): boolean {
+  return typeof value === "boolean";
+}
+
+function isNonNegativeSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+function isPositiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+function isProgressPreviewFormatterOrNull(value: unknown): boolean {
+  return value === null || typeof value === "function";
+}

package/src/project-definition/project-definition-validation.ts

@@ -5,9 +5,17 @@ import { parseOutputs } from "./output-validation.ts";
 import {
   type ProjectDefinitionDiagnostic,
   type ProjectDefinitionValidationResult,
+  type AdmissionPolicy,
+  type CustomAdmissionStrategy,
+  type SchedulerMeasurementHook,
   type SchedulerPolicy
 } from "./project-definition.ts";
-import { snapshotClosedArray, snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+import {
+  snapshotClosedArray,
+  snapshotClosedPolicyRecord,
+  snapshotClosedRecord
+} from "../data-boundary/closed-values.ts";
+import { snapshotResourceUnitMapping } from "./resource-unit-mapping.ts";
 
 type DefinitionValidationResult<T> = Readonly<
   | { readonly ok: true; readonly value: T }
@@ -43,7 +51,11 @@ function parseProjectDefinitionFields(
   if (checks === undefined) return invalidDefinition("definition.checks");
   const parsedChecks = parseCheckTreeAuthoring(checks);
   if (parsedChecks === undefined) return invalidDefinition("definition.checks");
-  const tree = resolveParsedCheckTree(parsedChecks, scheduler.maxParallel);
+  const tree = resolveParsedCheckTree(
+    parsedChecks,
+    scheduler.maxParallel,
+    scheduler.resourceCapacities
+  );
   if (tree === undefined) return invalidDefinition("definition.checks");
   const outputs = parseOutputs(data.outputs);
   if (outputs === undefined) return invalidDefinition("definition.outputs");
@@ -88,29 +100,113 @@ function exactRecord(
 }
 
 function parseScheduler(value: unknown): SchedulerPolicy | undefined {
-  const data = exactKeys(value, ["maxParallel"]);
-  return typeof data?.maxParallel === "number" &&
-    Number.isSafeInteger(data.maxParallel) &&
-    data.maxParallel > 0
-    ? Object.freeze({ maxParallel: data.maxParallel })
-    : undefined;
+  const data = snapshotClosedPolicyRecord(value, {
+    optional: ["admissionPolicy", "measurementHooks", "resourceCapacities"],
+    required: ["maxParallel"]
+  });
+  if (data === undefined) return undefined;
+  const admissionPolicy = Object.hasOwn(data, "admissionPolicy")
+    ? parseAdmissionPolicy(data.admissionPolicy)
+    : Object.freeze({ kind: "static" as const });
+  if (admissionPolicy === undefined) return undefined;
+  const measurementHooks = parseMeasurementHooks(data.measurementHooks);
+  if (measurementHooks === undefined) return undefined;
+  const resourceCapacities = snapshotResourceUnitMapping(
+    Object.hasOwn(data, "resourceCapacities") ? data.resourceCapacities : {}
+  );
+  if (resourceCapacities === undefined) return undefined;
+  const maxParallel = positiveSafeInteger(data.maxParallel);
+  if (maxParallel === undefined) return undefined;
+  return Object.freeze({ admissionPolicy, maxParallel, measurementHooks, resourceCapacities });
 }
 
-function exactKeys(
-  value: unknown,
-  keys: readonly string[]
-): Readonly<Record<string, unknown>> | undefined {
+function positiveSafeInteger(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+function parseMeasurementHooks(value: unknown): readonly SchedulerMeasurementHook[] | undefined {
+  if (value === undefined) return Object.freeze([]);
+  if (!Array.isArray(value)) return undefined;
+  const hooks: SchedulerMeasurementHook[] = [];
+  for (const hook of value) {
+    if (!isMeasurementHook(hook)) return undefined;
+    hooks.push(hook);
+  }
+  return Object.freeze(hooks);
+}
+
+function isMeasurementHook(value: unknown): value is SchedulerMeasurementHook {
+  return typeof value === "function";
+}
+
+function parseAdmissionPolicy(value: unknown): AdmissionPolicy | undefined {
   const data = snapshotClosedRecord(value);
-  if (data === undefined) return undefined;
-  return Object.keys(data).length === keys.length && keys.every((key) => Object.hasOwn(data, key))
-    ? data
-    : undefined;
+  if (data === undefined || typeof data.kind !== "string") return undefined;
+  switch (data.kind) {
+    case "static":
+      return parseStaticAdmissionPolicy(data);
+    case "custom":
+      return parseCustomAdmissionPolicy(data);
+  }
+  return undefined;
+}
+
+function parseStaticAdmissionPolicy(
+  policy: Readonly<Record<string, unknown>>
+): Extract<AdmissionPolicy, { readonly kind: "static" }> | undefined {
+  return hasExactKeys(policy, ["kind"]) ? Object.freeze({ kind: "static" }) : undefined;
+}
+
+function parseCustomAdmissionPolicy(
+  policy: Readonly<Record<string, unknown>>
+): Extract<AdmissionPolicy, { readonly kind: "custom" }> | undefined {
+  if (!hasExactKeys(policy, ["kind", "strategy"])) return undefined;
+  const strategy = parseCustomAdmissionStrategy(policy.strategy);
+  return strategy === undefined ? undefined : Object.freeze({ kind: "custom", strategy });
+}
+
+function parseCustomAdmissionStrategy(value: unknown): CustomAdmissionStrategy | undefined {
+  const strategy = snapshotClosedRecord(value);
+  if (strategy === undefined || typeof strategy.kind !== "string") return undefined;
+  if (strategy.kind === "simple") {
+    if (!hasExactKeys(strategy, ["kind", "decide"])) return undefined;
+    if (!isSimpleCustomDecision(strategy.decide)) return undefined;
+    return Object.freeze({ kind: "simple" as const, decide: strategy.decide });
+  }
+  if (strategy.kind === "prepared") {
+    if (!hasExactKeys(strategy, ["kind", "prepare"])) return undefined;
+    if (!isPreparedCustomPreparation(strategy.prepare)) return undefined;
+    return Object.freeze({ kind: "prepared" as const, prepare: strategy.prepare });
+  }
+  return undefined;
+}
+
+function isSimpleCustomDecision(
+  value: unknown
+): value is Extract<CustomAdmissionStrategy, { readonly kind: "simple" }>["decide"] {
+  return typeof value === "function";
+}
+
+function isPreparedCustomPreparation(
+  value: unknown
+): value is Extract<CustomAdmissionStrategy, { readonly kind: "prepared" }>["prepare"] {
+  return typeof value === "function";
+}
+
+function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
+  return (
+    Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key))
+  );
 }
 
 function invalidDefinition(path: string): ProjectDefinitionValidationResult {
   return Object.freeze({
     ok: false,
-    error: Object.freeze({ kind: "invalid-project-definition", path, reason: "invalid-value" })
+    error: Object.freeze({
+      kind: "invalid-project-definition",
+      path,
+      reason: "invalid-value"
+    })
   });
 }
 
@@ -119,5 +215,8 @@ function invalid(
   path: string,
   reason: ProjectDefinitionDiagnostic["reason"]
 ): DefinitionValidationResult<never> {
-  return Object.freeze({ ok: false, error: Object.freeze({ kind, path, reason }) });
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({ kind, path, reason })
+  });
 }