@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/package-checks/function-metrics/lizard/parser.ts

@@ -1,179 +0,0 @@
-import type { FunctionMetric } from "../measurement-model.ts";
-import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
-import { errorMessage } from "../../host-environment/error-message.ts";
-import { parseCsvRows } from "./csv.ts";
-import { normalizeScannerReportedPath } from "../../project-files/reported-path.ts";
-
-export type LizardParseResult =
-  | {
-      readonly measurements: readonly ExactInputMeasurement<FunctionMetric>[];
-      readonly ok: true;
-    }
-  | {
-      readonly error: string;
-      readonly ok: false;
-      readonly reason: "invalid-result";
-    };
-
-const LIZARD_COLUMNS = {
-  nloc: 0,
-  ccn: 1,
-  parameterCount: 3,
-  filePath: 6,
-  functionName: 7,
-  startLine: 9,
-  endLine: 10
-} as const;
-
-/**
- * 将 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 function parseLizardCSV(csv: string, cwd: string): LizardParseResult {
-  try {
-    const measurements: ExactInputMeasurement<FunctionMetric>[] = [];
-
-    for (const [index, row] of lizardDataRows(parseCsvRows(csv)).entries()) {
-      const measurement = functionMetricFromLizardRow(row, cwd);
-      if (!measurement) {
-        throw new Error(`invalid Lizard 1.23 CSV row ${index + 1}`);
-      }
-      measurements.push(measurement);
-    }
-
-    measurements.sort((a, b) => compareFunctionMetrics(a.payload, b.payload));
-
-    return { ok: true, measurements };
-  } catch (error: unknown) {
-    return {
-      ok: false,
-      error: `Failed to parse lizard CSV: ${errorMessage(error)}`,
-      reason: "invalid-result"
-    };
-  }
-}
-
-function lizardDataRows(rows: string[][]): string[][] {
-  const header = rows[0] ?? [];
-  return isLizard123Header(header) ? rows.slice(1) : rows;
-}
-
-function functionMetricFromLizardRow(
-  parts: string[],
-  cwd: string
-): ExactInputMeasurement<FunctionMetric> | null {
-  if (parts.length < 11) {
-    return null;
-  }
-
-  const values = parseLizardMetricValues(parts);
-  if (!values) {
-    return null;
-  }
-
-  const filePath = (parts[LIZARD_COLUMNS.filePath] ?? "").trim();
-  if (filePath.length === 0 || values.endLine < values.startLine) {
-    return null;
-  }
-  const sourcePath = normalizeScannerReportedPath(filePath, cwd);
-
-  return {
-    sourcePaths: [sourcePath],
-    payload: {
-      name: parts[LIZARD_COLUMNS.functionName] || "unknown",
-      file: sourcePath,
-      startLine: values.startLine,
-      endLine: values.endLine,
-      lines: values.nloc,
-      parameterCount: values.parameterCount,
-      cyclomaticComplexity: {
-        value: values.ccn,
-        source: "lizard"
-      }
-    }
-  };
-}
-
-interface LizardMetricValues {
-  readonly ccn: number | null;
-  readonly endLine: number;
-  readonly nloc: number;
-  readonly parameterCount: number;
-  readonly startLine: number;
-}
-
-function parseLizardMetricValues(parts: string[]): LizardMetricValues | null {
-  const ccnText = parts[LIZARD_COLUMNS.ccn].trim();
-  const ccn = ccnText === "" ? null : parseInteger(ccnText, 0);
-  const endLine = parseInteger(parts[LIZARD_COLUMNS.endLine], 1);
-  const nloc = parseInteger(parts[LIZARD_COLUMNS.nloc], 0);
-  const parameterCount = parseInteger(parts[LIZARD_COLUMNS.parameterCount], 0);
-  const startLine = parseInteger(parts[LIZARD_COLUMNS.startLine], 1);
-
-  if (
-    (ccnText !== "" && ccn === null) ||
-    endLine === null ||
-    nloc === null ||
-    parameterCount === null ||
-    startLine === null
-  ) {
-    return null;
-  }
-
-  return {
-    ccn,
-    endLine,
-    nloc,
-    parameterCount,
-    startLine
-  };
-}
-
-function compareFunctionMetrics(a: FunctionMetric, b: FunctionMetric): number {
-  for (const comparison of functionMetricComparisons(a, b)) {
-    if (comparison !== 0) return comparison;
-  }
-  return 0;
-}
-
-function functionMetricComparisons(a: FunctionMetric, b: FunctionMetric): readonly number[] {
-  return [
-    compareText(a.file, b.file),
-    a.startLine - b.startLine,
-    a.endLine - b.endLine,
-    compareText(a.name, b.name),
-    a.lines - b.lines,
-    (a.cyclomaticComplexity.value ?? -1) - (b.cyclomaticComplexity.value ?? -1),
-    a.parameterCount - b.parameterCount
-  ];
-}
-
-function compareText(left: string, right: string): number {
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-
-function parseInteger(value: string | undefined, minimum: number): number | null {
-  const text = (value ?? "").trim();
-  if (!/^\d+$/.test(text)) {
-    return null;
-  }
-  const parsed = Number(text);
-  return Number.isSafeInteger(parsed) && parsed >= minimum ? parsed : null;
-}
-
-function isLizard123Header(parts: string[]): boolean {
-  return (
-    parts.length >= 11 &&
-    parts[LIZARD_COLUMNS.nloc] === "NLOC" &&
-    parts[LIZARD_COLUMNS.ccn] === "CCN" &&
-    parts[LIZARD_COLUMNS.parameterCount] === "parameter count" &&
-    parts[LIZARD_COLUMNS.filePath] === "file path" &&
-    parts[LIZARD_COLUMNS.functionName] === "function name" &&
-    parts[LIZARD_COLUMNS.startLine] === "start line" &&
-    parts[LIZARD_COLUMNS.endLine] === "end line"
-  );
-}

package/src/package-checks/function-metrics/lizard/scanner.ts

@@ -1,62 +0,0 @@
-/** 对 approved exact paths 执行 adapter-owned Lizard CSV 协议。 */
-
-import { errorMessage } from "../../host-environment/error-message.ts";
-import { runProcessSync } from "../../host-environment/process/command.ts";
-import type { ResolvedFunctionMetricsScannerOptions } from "../options.ts";
-import { parseLizardCSV, 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 function scanWithLizard({
-  files,
-  cwd,
-  dependency
-}: ScanWithLizardOptions): LizardScanResult {
-  try {
-    if (files.length === 0) return { ok: true, measurements: [] };
-
-    const child = runProcessSync({
-      args: [...files, "--csv"],
-      command: dependency.executable,
-      cwd,
-      timeout: 300_000
-    });
-
-    if (child.signal !== null) {
-      return failedLizardScan(
-        `lizard signal ${child.signal}: ${(child.stderr || child.stdout || "no output").trim()}`
-      );
-    }
-    if (child.error) {
-      return failedLizardScan(`lizard process error: ${child.error.message}`);
-    }
-
-    if (child.status !== 0) {
-      const stderr = (child.stderr || "").trim();
-      const stdout = (child.stdout || "").trim();
-      return failedLizardScan(
-        `lizard ${child.status === null ? "invalid process state" : `exit ${child.status}`}: ${stderr || stdout || "no output"}`
-      );
-    }
-
-    return parseLizardCSV(child.stdout || "", cwd);
-  } catch (error: unknown) {
-    return failedLizardScan(`lizard adapter error: ${errorMessage(error)}`);
-  }
-}
-
-function failedLizardScan(error: string): LizardScanResult {
-  return Object.freeze({ error, ok: false, reason: "execution" });
-}

package/src/package-checks/host-environment/process/command.ts

@@ -1,21 +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 function writeProcessOutput(result: Pick<ProcessResult, "stderr" | "stdout">): void {
-  if (result.stdout) {
-    process.stdout.write(result.stdout);
-  }
-  if (result.stderr) {
-    process.stderr.write(result.stderr);
-  }
-}

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;
-}

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/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;