@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/invocation.ts

@@ -1,303 +0,0 @@
-import type { CheckProjectContext } from "../check/check.ts";
-import type { CoreSnapshot } from "../check-settlement/facts.ts";
-import {
-  normalizeProjectDefinition,
-  type DefinitionWarning,
-  type NormalizedProjectDefinition,
-  type ProjectDefinition
-} from "../project-definition/project-definition.ts";
-import type { CheckAggregation, RunControls } from "./controls/contract.ts";
-import { prepareTaskGraph } from "./task-scheduler/graph.ts";
-import { aggregateCheckOutcomes, validateCheckAggregationSelection } from "./aggregation.ts";
-import {
-  executeResolvedChecks,
-  type CheckExecutionClock,
-  type ResolvedCheckExecution
-} from "./check-execution/resolved-checks.ts";
-import { planStaticCheckGraph } from "./check-execution/plan.ts";
-import {
-  type ProgressRefreshScheduler,
-  type ProgressRendering,
-  type ProgressWriterFactory
-} from "./progress-rendering/presentation.ts";
-import { completeInvocation, finalizeInvocation, type CoreExecution } from "./completion.ts";
-import { createProjectContext } from "./project-context.ts";
-import {
-  executionCancellation,
-  isCancelled,
-  planning,
-  preExecutionCancellation,
-  type NonConfigurationRunResult,
-  type RunDiagnostic,
-  type RunResult
-} from "./result.ts";
-import {
-  diagnosticTags,
-  type DiagnosticLogger,
-  type DiagnosticLoggerFactory
-} from "./diagnostic-logging/logger.ts";
-import { createInvocation } from "./invocation-creation.ts";
-import type { OutputStatuses } from "./output-status.ts";
-export type Invocation = Readonly<{
-  readonly clock: CheckExecutionClock;
-  readonly controls: RunControls;
-  readonly declarativeFingerprint: string;
-  readonly definition: ProjectDefinition;
-  readonly definitionWarnings: readonly DefinitionWarning[];
-  readonly diagnosticLogger: DiagnosticLogger;
-  readonly outputConfiguration: ProjectDefinition["outputs"];
-  readonly outputs: OutputStatuses;
-  readonly invocationId: string;
-  readonly normalized: NormalizedProjectDefinition;
-  readonly progressRendering: ProgressRendering;
-  readonly projectRoot: string;
-  /** Immutable UTC instant captured for enabled diagnostic or machine output, otherwise `null`. */
-  readonly startedAtUtc: string | null;
-}>;
-export interface RunInvocationDependencies {
-  readonly clock?: CheckExecutionClock;
-  readonly progressRefreshScheduler?: ProgressRefreshScheduler;
-  readonly progressWriterFactory?: ProgressWriterFactory;
-  readonly diagnosticLoggerFactory?: DiagnosticLoggerFactory;
-  /** Test seam for the invocation's machine-readable wall-clock timestamp. */
-  readonly wallClock?: Readonly<{ now(): Date }>;
-}
-export async function executeValidatedRun(
-  definition: ProjectDefinition,
-  controls: RunControls,
-  definitionWarnings: readonly DefinitionWarning[],
-  dependencies: RunInvocationDependencies = {}
-): Promise<RunResult> {
-  const normalized = normalizeProjectDefinition(definition);
-  const aggregation = validateCheckAggregationSelection(
-    controls.checkAggregation,
-    normalized.checks.map((check) => check.definition.checkId)
-  );
-  if (!aggregation.ok)
-    return Object.freeze({
-      kind: "configuration",
-      definitionWarnings: Object.freeze([...definitionWarnings]),
-      diagnostic: aggregation.error
-    });
-
-  const invocation = createInvocation({
-    controls,
-    definition,
-    definitionWarnings,
-    dependencies,
-    normalized
-  });
-  let candidate: NonConfigurationRunResult;
-  try {
-    observeInvocationStarted(invocation, aggregation.value);
-    if (isCancelled(controls)) {
-      candidate = cancelledBeforeExecution(invocation, "pre-work");
-    } else if (!validateTaskGraph(invocation)) {
-      candidate = planningResult(invocation, "task-graph-invalid");
-    } else {
-      candidate = await executePlannedInvocation(invocation, aggregation.value);
-    }
-  } catch {
-    candidate = executionResult(invocation, "task-engine-failed");
-  }
-  return finalizeInvocation(invocation, candidate);
-}
-
-function observeInvocationStarted(
-  invocation: Invocation,
-  aggregation: CheckAggregation | undefined
-): void {
-  invocation.diagnosticLogger.observe({
-    event: "run.started",
-    tags: diagnosticTags("RUN", "STARTED"),
-    details: {
-      aggregation: aggregation ?? null,
-      checkCount: invocation.normalized.checks.length,
-      flags: invocation.controls.flags ?? [],
-      invocationId: invocation.invocationId,
-      outputs: invocation.outputConfiguration,
-      scheduler: invocation.normalized.declarative.scheduler
-    }
-  });
-}
-
-function validateTaskGraph(invocation: Invocation): boolean {
-  try {
-    prepareTaskGraph(
-      planStaticCheckGraph(invocation.normalized.checks),
-      invocation.normalized.declarative.scheduler.maxParallel
-    );
-    invocation.diagnosticLogger.observe({
-      event: "run.planning.succeeded",
-      tags: diagnosticTags("RUN", "PLANNING", "SUCCEEDED"),
-      details: {
-        checkCount: invocation.normalized.checks.length,
-        maxParallel: invocation.normalized.declarative.scheduler.maxParallel
-      }
-    });
-    return true;
-  } catch {
-    invocation.diagnosticLogger.observe({
-      event: "run.planning.failed",
-      tags: diagnosticTags("RUN", "PLANNING", "FAILED"),
-      details: {
-        checkCount: invocation.normalized.checks.length,
-        maxParallel: invocation.normalized.declarative.scheduler.maxParallel
-      }
-    });
-    return false;
-  }
-}
-async function executePlannedInvocation(
-  invocation: Invocation,
-  aggregation: CheckAggregation | undefined
-): Promise<NonConfigurationRunResult> {
-  if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "pre-work");
-  return executePreparedInvocation(
-    invocation,
-    aggregation,
-    createProjectContext({ controls: invocation.controls, root: invocation.projectRoot })
-  );
-}
-async function executePreparedInvocation(
-  invocation: Invocation,
-  aggregation: CheckAggregation | undefined,
-  project: CheckProjectContext
-): Promise<NonConfigurationRunResult> {
-  if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "planning");
-  invocation.progressRendering.prepared(invocation.normalized.checks.length);
-  const executionStartedAt = invocation.clock.now();
-  const executed = await executeChecks(invocation, project, invocation.clock);
-  if (isExecutionRunResult(executed)) return executed;
-  invocation.progressRendering.final({
-    counts: outcomeCounts(executed.snapshot),
-    elapsedMs: elapsedSince(executionStartedAt, invocation.clock),
-    execution: executed.kind
-  });
-  if (executed.kind === "cancelled") {
-    invocation.diagnosticLogger.observe({
-      event: "run.execution.cancelled",
-      tags: diagnosticTags("RUN", "EXECUTION", "CANCELLED"),
-      details: { checkCount: executed.snapshot.checks.length }
-    });
-    return executionCancellation({
-      checkDurations: executed.checkDurations,
-      checkMessages: executed.checkMessages,
-      declarativeFingerprint: invocation.declarativeFingerprint,
-      definitionWarnings: invocation.definitionWarnings,
-      outputs: invocation.outputs.value(),
-      snapshot: executed.snapshot
-    });
-  }
-  const aggregate =
-    aggregation === undefined ? null : aggregateCheckOutcomes(executed.snapshot, aggregation);
-  invocation.diagnosticLogger.observe({
-    event: "run.aggregation.completed",
-    tags: diagnosticTags("RUN", "AGGREGATION", "COMPLETED"),
-    details: { aggregate, selection: aggregation ?? null }
-  });
-  const core: CoreExecution = Object.freeze({
-    aggregate,
-    checkDurations: executed.checkDurations,
-    checkMessages: executed.checkMessages,
-    snapshot: executed.snapshot
-  });
-  return completeInvocation(invocation, core);
-}
-
-function cancelledBeforeExecution(
-  invocation: Invocation,
-  phase: "pre-work" | "planning"
-): NonConfigurationRunResult {
-  invocation.diagnosticLogger.observe({
-    event: "run.cancelled",
-    tags: diagnosticTags("RUN", "CANCELLED"),
-    details: { phase }
-  });
-  return preExecutionCancellation(
-    invocation.declarativeFingerprint,
-    invocation.definitionWarnings,
-    invocation.outputs.value(),
-    phase
-  );
-}
-
-async function executeChecks(
-  invocation: Invocation,
-  project: CheckProjectContext,
-  clock: CheckExecutionClock
-): Promise<ResolvedCheckExecution | NonConfigurationRunResult> {
-  try {
-    return await executeResolvedChecks({
-      checks: invocation.normalized.checks,
-      clock,
-      diagnosticLogger: invocation.diagnosticLogger,
-      maxParallel: invocation.normalized.declarative.scheduler.maxParallel,
-      lifecycle: invocation.progressRendering.lifecycle,
-      project,
-      signal: invocation.controls.signal
-    });
-  } catch {
-    return executionResult(invocation, "task-engine-failed");
-  }
-}
-function outcomeCounts(snapshot: CoreSnapshot): Readonly<{
-  readonly failed: number;
-  readonly notApplicable: number;
-  readonly passed: number;
-  readonly unavailable: number;
-}> {
-  let failed = 0,
-    notApplicable = 0,
-    passed = 0,
-    unavailable = 0;
-  for (const check of snapshot.checks) {
-    switch (check.outcome.status) {
-      case "passed":
-        passed += 1;
-        break;
-      case "failed":
-        failed += 1;
-        break;
-      case "not-applicable":
-        notApplicable += 1;
-        break;
-      case "unavailable":
-        unavailable += 1;
-        break;
-    }
-  }
-  return Object.freeze({ failed, notApplicable, passed, unavailable });
-}
-function elapsedSince(startedAt: number, clock: CheckExecutionClock): number {
-  const elapsed = clock.now() - startedAt;
-  return Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : 0;
-}
-function planningResult(
-  invocation: Invocation,
-  code: Extract<RunDiagnostic["code"], "task-graph-invalid">
-): NonConfigurationRunResult {
-  return planning(
-    invocation.declarativeFingerprint,
-    invocation.definitionWarnings,
-    invocation.outputs.value(),
-    code
-  );
-}
-function executionResult(
-  invocation: Invocation,
-  code: Extract<RunDiagnostic["code"], "publication-model-failed" | "task-engine-failed">
-): NonConfigurationRunResult {
-  return Object.freeze({
-    kind: "execution",
-    declarativeFingerprint: invocation.declarativeFingerprint,
-    definitionWarnings: invocation.definitionWarnings,
-    diagnostic: Object.freeze({ code }),
-    outputs: invocation.outputs.value()
-  });
-}
-function isExecutionRunResult(
-  value: ResolvedCheckExecution | NonConfigurationRunResult
-): value is NonConfigurationRunResult {
-  return "declarativeFingerprint" in value;
-}

package/src/project-run/output-status.ts

@@ -1,69 +0,0 @@
-import type { ProjectOutputs } from "../project-definition/project-definition.ts";
-
-export interface RunOutputStatus {
-  readonly enabled: boolean;
-  readonly status: "disabled" | "failed" | "not-run" | "succeeded";
-}
-
-export interface RunDiagnosticLoggingOutputStatus extends RunOutputStatus {
-  /** Project-root-relative target when enabled, otherwise `null`. */
-  readonly file: string | null;
-}
-
-export interface RunOutputStatuses {
-  readonly machinePublication: RunOutputStatus;
-  readonly progressRendering: RunOutputStatus;
-  readonly diagnosticLogging: RunDiagnosticLoggingOutputStatus;
-}
-
-export interface OutputStatuses {
-  readonly failed: (output: keyof RunOutputStatuses) => void;
-  readonly succeeded: (output: keyof RunOutputStatuses) => void;
-  readonly value: () => RunOutputStatuses;
-}
-
-export function createOutputStatuses(
-  configuration: ProjectOutputs,
-  diagnosticLoggingFile: string | null
-): OutputStatuses {
-  const statuses: Record<keyof RunOutputStatuses, RunOutputStatus["status"]> = {
-    machinePublication: initialStatus(configuration.machinePublication.enabled),
-    progressRendering: initialStatus(configuration.progressRendering.enabled),
-    diagnosticLogging: initialStatus(configuration.diagnosticLogging.enabled)
-  };
-  const enabled = (output: keyof RunOutputStatuses): boolean => configuration[output].enabled;
-  return Object.freeze({
-    failed: (output: keyof RunOutputStatuses) => {
-      if (enabled(output)) statuses[output] = "failed";
-    },
-    succeeded: (output: keyof RunOutputStatuses) => {
-      if (enabled(output)) statuses[output] = "succeeded";
-    },
-    value: () =>
-      Object.freeze({
-        machinePublication: Object.freeze({
-          enabled: configuration.machinePublication.enabled,
-          status: statuses.machinePublication
-        }),
-        progressRendering: Object.freeze({
-          enabled: configuration.progressRendering.enabled,
-          status: statuses.progressRendering
-        }),
-        diagnosticLogging: Object.freeze({
-          enabled: configuration.diagnosticLogging.enabled,
-          file: diagnosticLoggingFile,
-          status: statuses.diagnosticLogging
-        })
-      })
-  });
-}
-
-export function failedOutput(statuses: RunOutputStatuses): keyof RunOutputStatuses | undefined {
-  for (const output of ["progressRendering", "machinePublication", "diagnosticLogging"] as const)
-    if (statuses[output].status === "failed") return output;
-  return undefined;
-}
-
-function initialStatus(enabled: boolean): RunOutputStatus["status"] {
-  return enabled ? "not-run" : "disabled";
-}

package/types/package-checks/file-metrics/scc/csv.d.ts

@@ -1 +0,0 @@
-export declare function parseCsvRows(csv: string): string[][];

package/types/package-checks/function-metrics/lizard/availability.d.ts

@@ -1,11 +0,0 @@
-import type { ResolvedFunctionMetricsScannerOptions } from "../options.ts";
-type LizardAvailability = Readonly<{
-    readonly available: true;
-    readonly version: string;
-} | {
-    readonly available: false;
-    readonly error: string;
-    readonly reason: "contract-error" | "execution-error" | "tool-unavailable";
-}>;
-export declare function checkLizard(rootDir: string, dependency: ResolvedFunctionMetricsScannerOptions): Promise<LizardAvailability>;
-export {};

package/types/package-checks/function-metrics/lizard/csv.d.ts

@@ -1 +0,0 @@
-export declare function parseCsvRows(csv: string): string[][];

package/types/package-checks/function-metrics/lizard/parser.d.ts

@@ -1,17 +0,0 @@
-import type { FunctionMetric } from "../measurement-model.ts";
-import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
-export type LizardParseResult = {
-    readonly measurements: readonly ExactInputMeasurement<FunctionMetric>[];
-    readonly ok: true;
-} | {
-    readonly error: string;
-    readonly ok: false;
-    readonly reason: "invalid-result";
-};
-/**
- * 将 Lizard CSV 输出解析为 FunctionMetric 数组。
- *
- * Lizard 1.23 CSV 列（--csv）：
- * NLOC,CCN,token count,parameter count,length,location,file path,function name,long name,start line,end line
- */
-export declare function parseLizardCSV(csv: string, cwd: string): LizardParseResult;

package/types/package-checks/function-metrics/lizard/scanner.d.ts

@@ -1,15 +0,0 @@
-/** 对 approved exact paths 执行 adapter-owned Lizard CSV 协议。 */
-import type { ResolvedFunctionMetricsScannerOptions } from "../options.ts";
-import { type LizardParseResult } from "./parser.ts";
-export type LizardScanResult = LizardParseResult | Readonly<{
-    error: string;
-    ok: false;
-    reason: "execution";
-}>;
-interface ScanWithLizardOptions {
-    readonly cwd: string;
-    readonly dependency: ResolvedFunctionMetricsScannerOptions;
-    readonly files: readonly string[];
-}
-export declare function scanWithLizard({ files, cwd, dependency }: ScanWithLizardOptions): LizardScanResult;
-export {};

package/types/package-checks/host-environment/process/command.d.ts

@@ -1,7 +0,0 @@
-import type { ProcessResult } from "./contract.ts";
-export { processFailure, processFailureFromResult, processFailed } from "./failure.ts";
-export { PLAIN_TEXT_PROCESS_ENV, plainTextProcessEnv } from "./env.ts";
-export { runProcess, runProcessSync } from "./runner.ts";
-export { DEFAULT_PROCESS_MAX_BUFFER_BYTES } from "./contract.ts";
-export type { ProcessFailure, ProcessResult, RunProcessOptions, RunProcessSyncOptions } from "./contract.ts";
-export declare function writeProcessOutput(result: Pick<ProcessResult, "stderr" | "stdout">): void;

package/types/package-checks/project-files/config-glob.d.ts

@@ -1,5 +0,0 @@
-/**
- * Product config glob 的唯一 matcher boundary。
- * Candidate 使用 slash form；dot path 只由显式 glob 决定，不附加隐式忽略规则。
- */
-export declare function matchesAnyConfigGlob(candidatePath: string, configGlobs: readonly string[]): boolean;

package/types/project-run/check-execution/preflight.d.ts

@@ -1,27 +0,0 @@
-import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
-import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
-import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
-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;
-/** Completes the sequential invocation-wide barrier before any Check enters the Task graph. */
-export declare function prepareChecks(input: Readonly<{
-    readonly checks: readonly NormalizedCheck[];
-    readonly diagnosticLogger?: DiagnosticLogger;
-    readonly signal: AbortSignal | undefined;
-}>): Promise<readonly CheckPreflightResolution[]>;
-export {};

package/types/project-run/invocation.d.ts

@@ -1,34 +0,0 @@
-import { type DefinitionWarning, type NormalizedProjectDefinition, type ProjectDefinition } from "../project-definition/project-definition.ts";
-import type { RunControls } from "./controls/contract.ts";
-import { type CheckExecutionClock } from "./check-execution/resolved-checks.ts";
-import { type ProgressRefreshScheduler, type ProgressRendering, type ProgressWriterFactory } from "./progress-rendering/presentation.ts";
-import { type RunResult } from "./result.ts";
-import { type DiagnosticLogger, type DiagnosticLoggerFactory } from "./diagnostic-logging/logger.ts";
-import type { OutputStatuses } from "./output-status.ts";
-export type Invocation = Readonly<{
-    readonly clock: CheckExecutionClock;
-    readonly controls: RunControls;
-    readonly declarativeFingerprint: string;
-    readonly definition: ProjectDefinition;
-    readonly definitionWarnings: readonly DefinitionWarning[];
-    readonly diagnosticLogger: DiagnosticLogger;
-    readonly outputConfiguration: ProjectDefinition["outputs"];
-    readonly outputs: OutputStatuses;
-    readonly invocationId: string;
-    readonly normalized: NormalizedProjectDefinition;
-    readonly progressRendering: ProgressRendering;
-    readonly projectRoot: string;
-    /** Immutable UTC instant captured for enabled diagnostic or machine output, otherwise `null`. */
-    readonly startedAtUtc: string | null;
-}>;
-export interface RunInvocationDependencies {
-    readonly clock?: CheckExecutionClock;
-    readonly progressRefreshScheduler?: ProgressRefreshScheduler;
-    readonly progressWriterFactory?: ProgressWriterFactory;
-    readonly diagnosticLoggerFactory?: DiagnosticLoggerFactory;
-    /** Test seam for the invocation's machine-readable wall-clock timestamp. */
-    readonly wallClock?: Readonly<{
-        now(): Date;
-    }>;
-}
-export declare function executeValidatedRun(definition: ProjectDefinition, controls: RunControls, definitionWarnings: readonly DefinitionWarning[], dependencies?: RunInvocationDependencies): Promise<RunResult>;

package/types/project-run/output-configuration.d.ts

@@ -1,3 +0,0 @@
-import type { ProjectDefinition, ProjectOutputs } from "../project-definition/project-definition.ts";
-import type { RunControls } from "./controls/contract.ts";
-export declare function effectiveOutputs(definition: ProjectDefinition, controls: RunControls): ProjectOutputs;

package/types/project-run/output-status.d.ts

@@ -1,21 +0,0 @@
-import type { ProjectOutputs } from "../project-definition/project-definition.ts";
-export interface RunOutputStatus {
-    readonly enabled: boolean;
-    readonly status: "disabled" | "failed" | "not-run" | "succeeded";
-}
-export interface RunDiagnosticLoggingOutputStatus extends RunOutputStatus {
-    /** Project-root-relative target when enabled, otherwise `null`. */
-    readonly file: string | null;
-}
-export interface RunOutputStatuses {
-    readonly machinePublication: RunOutputStatus;
-    readonly progressRendering: RunOutputStatus;
-    readonly diagnosticLogging: RunDiagnosticLoggingOutputStatus;
-}
-export interface OutputStatuses {
-    readonly failed: (output: keyof RunOutputStatuses) => void;
-    readonly succeeded: (output: keyof RunOutputStatuses) => void;
-    readonly value: () => RunOutputStatuses;
-}
-export declare function createOutputStatuses(configuration: ProjectOutputs, diagnosticLoggingFile: string | null): OutputStatuses;
-export declare function failedOutput(statuses: RunOutputStatuses): keyof RunOutputStatuses | undefined;