@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/package-checks/file-metrics/scc/batch-planner.ts

@@ -0,0 +1,56 @@
+const TERMINAL_NUL_CODE_UNITS = 1;
+
+/** SCC adapter 的私有 Windows argv 传输上限；不属于 scanner options。 */
+export const SCC_BATCH_COMMAND_LINE_CEILING = 28_000;
+
+export type SccBatchPlan =
+  | { readonly batches: readonly (readonly string[])[]; readonly ok: true }
+  | { readonly error: string; readonly ok: false };
+
+/**
+ * 返回 Windows command-line serialization 的保守 UTF-16 code-unit 上界。
+ *
+ * 每个 argument 都按最多双倍转义并保留一对引号，arguments 之间保留一个分隔符，
+ * 最后保留 CreateProcessW 所需的终止 NUL。
+ */
+export function estimateSccCommandLineCodeUnits(argumentsToEstimate: readonly string[]): number {
+  return argumentsToEstimate.reduce(
+    (total, argument, index) => total + (index === 0 ? 0 : 1) + 2 * argument.length + 2,
+    TERMINAL_NUL_CODE_UNITS
+  );
+}
+
+/** 将已批准的 exact paths 按固定 SCC protocol 稳定地切为可传输 batches。 */
+export function planSccBatches(
+  executable: string,
+  fixedArguments: readonly string[],
+  includePaths: readonly string[],
+  ceiling = SCC_BATCH_COMMAND_LINE_CEILING
+): SccBatchPlan {
+  const batches: string[][] = [];
+  let currentBatch: string[] = [];
+
+  for (const includePath of includePaths) {
+    const singlePathArguments = [executable, ...fixedArguments, includePath];
+    if (estimateSccCommandLineCodeUnits(singlePathArguments) > ceiling) {
+      return {
+        ok: false,
+        error: `scc exact path cannot fit command-line ceiling ${ceiling}: ${JSON.stringify(includePath)}`
+      };
+    }
+
+    const candidateBatch = [...currentBatch, includePath];
+    if (
+      currentBatch.length > 0 &&
+      estimateSccCommandLineCodeUnits([executable, ...fixedArguments, ...candidateBatch]) > ceiling
+    ) {
+      batches.push(currentBatch);
+      currentBatch = [includePath];
+      continue;
+    }
+    currentBatch = candidateBatch;
+  }
+
+  if (currentBatch.length > 0) batches.push(currentBatch);
+  return { ok: true, batches };
+}

package/src/package-checks/file-metrics/scc/logical-scan-resources.ts

@@ -0,0 +1,59 @@
+import { DEFAULT_PROCESS_MAX_BUFFER_BYTES } from "../../host-environment/process.ts";
+
+export const SCC_LOGICAL_SCAN_TIMEOUT_MS = 300_000;
+const NANOSECONDS_PER_MILLISECOND = 1_000_000n;
+
+export interface SccLogicalScanResources {
+  readonly deadlineNanoseconds: bigint;
+  stderrRemainingBytes: number;
+  stdoutRemainingBytes: number;
+}
+
+/** 为一次 logical SCC scan 建立共享 deadline 与 stdout/stderr 预算。 */
+export function beginSccLogicalScanResources(
+  startedNanoseconds: bigint,
+  timeoutMilliseconds = SCC_LOGICAL_SCAN_TIMEOUT_MS,
+  outputBudgetBytes = DEFAULT_PROCESS_MAX_BUFFER_BYTES
+): SccLogicalScanResources {
+  return {
+    deadlineNanoseconds:
+      startedNanoseconds + BigInt(timeoutMilliseconds) * NANOSECONDS_PER_MILLISECOND,
+    stderrRemainingBytes: outputBudgetBytes,
+    stdoutRemainingBytes: outputBudgetBytes
+  };
+}
+
+/** 计算下一个 batch 可使用的完整毫秒数；deadline 到期时不再启动 process。 */
+export function remainingSccBatchTimeoutMs(
+  resources: SccLogicalScanResources,
+  nowNanoseconds: bigint
+): number | null {
+  const remainingNanoseconds = resources.deadlineNanoseconds - nowNanoseconds;
+  const remainingMilliseconds = Number(remainingNanoseconds / NANOSECONDS_PER_MILLISECOND);
+  return remainingMilliseconds > 0 ? remainingMilliseconds : null;
+}
+
+/** 以两个 stream 中较小的余量限制本次 process 的 maxBuffer。 */
+export function remainingSccBatchMaxBuffer(resources: SccLogicalScanResources): number | null {
+  const remainingBytes = Math.min(resources.stdoutRemainingBytes, resources.stderrRemainingBytes);
+  return remainingBytes > 0 ? remainingBytes : null;
+}
+
+/** 记录一次 process 的 UTF-8 output；任一 stream 超出完整 logical-scan 预算即失败。 */
+export function consumeSccProcessOutput(
+  resources: SccLogicalScanResources,
+  stdout: string,
+  stderr: string
+): boolean {
+  const stdoutBytes = Buffer.byteLength(stdout, "utf8");
+  const stderrBytes = Buffer.byteLength(stderr, "utf8");
+  if (
+    stdoutBytes > resources.stdoutRemainingBytes ||
+    stderrBytes > resources.stderrRemainingBytes
+  ) {
+    return false;
+  }
+  resources.stdoutRemainingBytes -= stdoutBytes;
+  resources.stderrRemainingBytes -= stderrBytes;
+  return true;
+}

package/src/package-checks/file-metrics/scc/parser.ts

@@ -2,9 +2,9 @@ import type { ExactInputMeasurement } from "../../project-files/exact-input-meas
 import { errorMessage } from "../../host-environment/error-message.ts";
 import { normalizeScannerReportedPath } from "../../project-files/reported-path.ts";
 import type { FileMetric } from "../measurement-model.ts";
-import { parseCsvRows } from "./csv.ts";
+import { parseCsvRows } from "../../host-environment/csv.ts";
 
-export const SCC_VERSION = "3.7.0";
+export const SCC_VERSION = "4.0.0";
 export const SCC_VERSION_OUTPUT = `scc version ${SCC_VERSION}`;
 export const SCC_BY_FILE_CSV_HEADER =
   "Language,Provider,Filename,Lines,Code,Comments,Blanks,Complexity,Bytes,ULOC";
@@ -49,13 +49,13 @@ interface SccRawRow {
 /**
  * 解析 scc CSV 输出。
  *
- * scc 3.7.0 `--by-file --format csv` 列：
+ * scc 4.0.0 `--no-config --by-file --format csv` 列：
  * Language,Provider,Filename,Lines,Code,Comments,Blanks,Complexity,Bytes,ULOC
  *
  * - Lines 包含所有行（code + comments + blanks）
  * - Code 是文件级代码行数，用于 code-line finding
  * - Complexity 是 scc complexitychecks token 命中数，用于 low-decision-token allowance，不是函数级 CC
- * - ULOC (Usable Lines of Code) 由 3.7.0 输出，但首期不进入稳定 metrics
+ * - ULOC (Usable Lines of Code) 由 4.0.0 输出，但首期不进入稳定 metrics
  */
 export function parseSccCSV(csv: string, cwd: string): SccScanResult {
   try {

package/src/package-checks/file-metrics/scc/scanner.ts

@@ -5,12 +5,23 @@
  */
 
 import { errorMessage } from "../../host-environment/error-message.ts";
-import { runProcessSync } from "../../host-environment/process/command.ts";
+import { runProcessSync, type ProcessResult } from "../../host-environment/process.ts";
+import { acceptExactInputMeasurements } from "../../project-files/exact-input-measurement.ts";
+import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
+import type { FileMetric } from "../measurement-model.ts";
 import type { ResolvedFileMetricsScannerOptions } from "../options.ts";
+import { planSccBatches } from "./batch-planner.ts";
+import {
+  beginSccLogicalScanResources,
+  consumeSccProcessOutput,
+  remainingSccBatchMaxBuffer,
+  remainingSccBatchTimeoutMs,
+  type SccLogicalScanResources
+} from "./logical-scan-resources.ts";
 import { parseSccCSV, type SccScanResult } from "./parser.ts";
 
-const SCC_BY_FILE_ARGUMENTS = Object.freeze(["--by-file", "--format", "csv"]);
-const SCC_SCAN_TIMEOUT_MS = 300_000;
+const SCC_BY_FILE_ARGUMENTS = Object.freeze(["--no-config", "--by-file", "--format", "csv"]);
+type SccMeasurement = ExactInputMeasurement<FileMetric>;
 
 interface ScanWithSccOptions {
   readonly cwd: string;
@@ -22,38 +33,19 @@ export function scanWithScc({ cwd, includePaths, scanner }: ScanWithSccOptions):
   try {
     if (includePaths.length === 0) return { ok: true, measurements: [] };
 
-    const scanArguments = buildSccArgs(includePaths);
+    const batchPlan = planSccBatches(scanner.executable, SCC_BY_FILE_ARGUMENTS, includePaths);
+    if (!batchPlan.ok) return { ok: false, error: batchPlan.error, reason: "execution" };
 
-    const commandResult = runProcessSync({
-      args: scanArguments,
-      command: scanner.executable,
-      cwd,
-      timeout: SCC_SCAN_TIMEOUT_MS
-    });
+    const logicalScanResources = beginSccLogicalScanResources(process.hrtime.bigint());
+    const measurements: SccMeasurement[] = [];
 
-    if (commandResult.error) {
-      return {
-        ok: false,
-        error: `scc process error: ${commandResult.error.message}`,
-        reason: "execution"
-      };
-    }
-
-    if (commandResult.status !== 0) {
-      const stderr = (commandResult.stderr || "").trim();
-      const stdout = (commandResult.stdout || "").trim();
-      const termination =
-        commandResult.status === null
-          ? `signal ${commandResult.signal ?? "unknown"}`
-          : `exit ${commandResult.status}`;
-      return {
-        ok: false,
-        error: `scc ${termination}: ${stderr || stdout || "no output"}`,
-        reason: "execution"
-      };
+    for (const batch of batchPlan.batches) {
+      const batchResult = scanSccBatch({ batch, cwd, logicalScanResources, scanner });
+      if (!batchResult.ok) return batchResult;
+      measurements.push(...batchResult.measurements);
     }
 
-    return parseSccCSV(commandResult.stdout || "", cwd);
+    return mergeSccBatchMeasurements(measurements);
   } catch (error: unknown) {
     return {
       ok: false,
@@ -63,6 +55,116 @@ export function scanWithScc({ cwd, includePaths, scanner }: ScanWithSccOptions):
   }
 }
 
-function buildSccArgs(includePaths: readonly string[]): string[] {
-  return [...SCC_BY_FILE_ARGUMENTS, ...includePaths];
+function scanSccBatch({
+  batch,
+  cwd,
+  logicalScanResources,
+  scanner
+}: {
+  readonly batch: readonly string[];
+  readonly cwd: string;
+  readonly logicalScanResources: SccLogicalScanResources;
+  readonly scanner: ResolvedFileMetricsScannerOptions;
+}): SccScanResult {
+  const remainingTimeoutMs = remainingSccBatchTimeoutMs(
+    logicalScanResources,
+    process.hrtime.bigint()
+  );
+  if (remainingTimeoutMs === null) return expiredSccDeadline();
+  const remainingMaxBufferBytes = remainingSccBatchMaxBuffer(logicalScanResources);
+  if (remainingMaxBufferBytes === null) return exhaustedSccOutputBudget();
+
+  const commandResult = runProcessSync({
+    args: [...SCC_BY_FILE_ARGUMENTS, ...batch],
+    command: scanner.executable,
+    cwd,
+    maxBuffer: remainingMaxBufferBytes,
+    timeout: remainingTimeoutMs
+  });
+  const processFailure = sccBatchProcessFailure(commandResult, logicalScanResources);
+  if (processFailure !== null) return processFailure;
+  return parseAcceptedSccBatch(commandResult.stdout, cwd, batch);
+}
+
+function expiredSccDeadline(): SccScanResult {
+  return {
+    ok: false,
+    error: "scc logical scan exceeded its shared timeout before the next batch",
+    reason: "execution"
+  };
+}
+
+function exhaustedSccOutputBudget(): SccScanResult {
+  return {
+    ok: false,
+    error: "scc logical scan exhausted its cumulative output budget before the next batch",
+    reason: "execution"
+  };
+}
+
+function sccBatchProcessFailure(
+  commandResult: ProcessResult,
+  logicalScanResources: SccLogicalScanResources
+): SccScanResult | null {
+  if (!consumeSccProcessOutput(logicalScanResources, commandResult.stdout, commandResult.stderr)) {
+    return {
+      ok: false,
+      error: "scc logical scan exceeded its cumulative stdout or stderr output budget",
+      reason: "execution"
+    };
+  }
+  if (commandResult.error) {
+    return {
+      ok: false,
+      error: `scc process error: ${commandResult.error.message}`,
+      reason: "execution"
+    };
+  }
+  if (commandResult.status === 0) return null;
+
+  const output = commandResult.stderr.trim() || commandResult.stdout.trim() || "no output";
+  const termination =
+    commandResult.status === null
+      ? `signal ${commandResult.signal ?? "unknown"}`
+      : `exit ${commandResult.status}`;
+  return { ok: false, error: `scc ${termination}: ${output}`, reason: "execution" };
+}
+
+function parseAcceptedSccBatch(
+  stdout: string,
+  cwd: string,
+  batch: readonly string[]
+): SccScanResult {
+  const parsed = parseSccCSV(stdout, cwd);
+  if (!parsed.ok) return parsed;
+  const acceptedMeasurements = acceptExactInputMeasurements(parsed.measurements, batch);
+  return acceptedMeasurements.ok
+    ? parsed
+    : { ok: false, error: acceptedMeasurements.error, reason: "invalid-result" };
+}
+
+function mergeSccBatchMeasurements(measurements: readonly SccMeasurement[]): SccScanResult {
+  const measuredPaths = new Set<string>();
+  for (const measurement of measurements) {
+    if (measuredPaths.has(measurement.payload.path)) {
+      return {
+        ok: false,
+        error: `scc returned duplicate measurement path ${JSON.stringify(measurement.payload.path)}`,
+        reason: "invalid-result"
+      };
+    }
+    measuredPaths.add(measurement.payload.path);
+  }
+  return {
+    ok: true,
+    measurements: [...measurements].sort((left, right) =>
+      compareText(left.payload.path, right.payload.path)
+    )
+  };
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
 }

package/src/package-checks/function-metrics/analysis.ts

@@ -11,7 +11,7 @@ export interface FunctionMetricAnalysis {
 }
 
 export function analyzeFunctionMetrics(
-  metrics: readonly FunctionMetric[]
+  metrics: readonly unknown[]
 ): FunctionMetricAnalysis | undefined {
   const metricsByIdentity = groupValidMetrics(metrics);
   if (metricsByIdentity === undefined) {
@@ -26,9 +26,7 @@ export function analyzeFunctionMetrics(
   return Object.freeze({ instances: Object.freeze(instances) });
 }
 
-function groupValidMetrics(
-  metrics: readonly FunctionMetric[]
-): Map<string, FunctionMetric[]> | undefined {
+function groupValidMetrics(metrics: readonly unknown[]): Map<string, FunctionMetric[]> | undefined {
   const groups = new Map<string, FunctionMetric[]>();
   for (const metric of metrics) {
     if (!isValidFunctionMetric(metric)) {
@@ -54,7 +52,8 @@ function createFunctionInstances(sortedGroup: readonly FunctionMetric[]): Functi
   );
 }
 
-function isValidFunctionMetric(metric: FunctionMetric): boolean {
+function isValidFunctionMetric(metric: unknown): metric is FunctionMetric {
+  if (!isRecord(metric)) return false;
   return (
     typeof metric.file === "string" &&
     metric.file.length > 0 &&
@@ -65,28 +64,59 @@ function isValidFunctionMetric(metric: FunctionMetric): boolean {
   );
 }
 
-function hasValidFunctionLocation(metric: FunctionMetric): boolean {
+function hasValidFunctionLocation(metric: Readonly<Record<string, unknown>>): boolean {
   return (
-    Number.isSafeInteger(metric.startLine) &&
-    metric.startLine >= 1 &&
-    Number.isSafeInteger(metric.endLine) &&
+    isPositiveSafeInteger(metric.startLine) &&
+    isPositiveSafeInteger(metric.endLine) &&
     metric.endLine >= metric.startLine
   );
 }
 
-function hasValidFunctionMeasurements(metric: FunctionMetric): boolean {
-  const complexity = metric.cyclomaticComplexity.value;
+function hasValidFunctionMeasurements(metric: Readonly<Record<string, unknown>>): boolean {
   return (
-    Number.isSafeInteger(metric.lines) &&
-    metric.lines >= 0 &&
-    Number.isSafeInteger(metric.parameterCount) &&
-    metric.parameterCount >= 0 &&
-    (complexity === null || isValidComplexity(complexity))
+    isValidNonNegativeInteger(metric.lines) &&
+    isValidNonNegativeInteger(metric.parameterCount) &&
+    validCyclomaticComplexity(metric.cyclomaticComplexity) &&
+    validNestingDepth(metric.nestingDepth) &&
+    validComplexityContributors(metric.complexityContributors)
   );
 }
 
-function isValidComplexity(complexity: number): boolean {
-  return Number.isSafeInteger(complexity) && complexity >= 0;
+function validCyclomaticComplexity(value: unknown): boolean {
+  if (!isRecord(value) || value.source !== "typescript-analyzer") return false;
+  return value.value === null || isValidNonNegativeInteger(value.value);
+}
+
+function validNestingDepth(value: unknown): boolean {
+  return (
+    isRecord(value) &&
+    value.source === "typescript-analyzer" &&
+    isValidNonNegativeInteger(value.value)
+  );
+}
+
+function validComplexityContributors(value: unknown): boolean {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (contributor) =>
+        isRecord(contributor) &&
+        typeof contributor.token === "string" &&
+        isPositiveSafeInteger(contributor.line)
+    )
+  );
+}
+
+function isValidNonNegativeInteger(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 >= 1;
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === "object" && value !== null;
 }
 
 function functionSubject(metric: Pick<FunctionMetric, "file" | "name">): string {
@@ -119,14 +149,44 @@ function functionIdentityKey(metric: Pick<FunctionMetric, "file" | "name">): str
 
 function compareFunctionInstances(left: FunctionMetric, right: FunctionMetric): number {
   return (
-    left.startLine - right.startLine ||
-    left.endLine - right.endLine ||
+    compareFunctionLocation(left, right) ||
+    compareFunctionMeasurements(left, right) ||
+    compareComplexityContributors(left.complexityContributors, right.complexityContributors) ||
+    left.parameterCount - right.parameterCount
+  );
+}
+
+function compareFunctionLocation(left: FunctionMetric, right: FunctionMetric): number {
+  return left.startLine - right.startLine || left.endLine - right.endLine;
+}
+
+function compareFunctionMeasurements(left: FunctionMetric, right: FunctionMetric): number {
+  return (
     left.lines - right.lines ||
     (left.cyclomaticComplexity.value ?? -1) - (right.cyclomaticComplexity.value ?? -1) ||
-    left.parameterCount - right.parameterCount
+    left.nestingDepth.value - right.nestingDepth.value
   );
 }
 
+function compareComplexityContributors(
+  left: FunctionMetric["complexityContributors"],
+  right: FunctionMetric["complexityContributors"]
+): number {
+  const commonLength = Math.min(left.length, right.length);
+  for (let index = 0; index < commonLength; index += 1) {
+    const leftContributor = left[index];
+    const rightContributor = right[index];
+    if (leftContributor === undefined || rightContributor === undefined) {
+      throw new Error(`Complexity contributor index is out of range: ${index}`);
+    }
+    const lineDifference = leftContributor.line - rightContributor.line;
+    if (lineDifference !== 0) return lineDifference;
+    const tokenDifference = compareText(leftContributor.token, rightContributor.token);
+    if (tokenDifference !== 0) return tokenDifference;
+  }
+  return left.length - right.length;
+}
+
 export function isStableFunctionName(name: string): boolean {
   return name.trim() !== "" && name !== "(anonymous)" && name !== "unknown";
 }