@zxyycom/vibe-check 0.0.1 → 0.0.2

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,11 +5,11 @@
  */
 
 import { errorMessage } from "../../host-environment/error-message.ts";
-import { runProcessSync } from "../../host-environment/process/command.ts";
+import { runProcessSync } from "../../host-environment/process.ts";
 import type { ResolvedFileMetricsScannerOptions } from "../options.ts";
 import { parseSccCSV, type SccScanResult } from "./parser.ts";
 
-const SCC_BY_FILE_ARGUMENTS = Object.freeze(["--by-file", "--format", "csv"]);
+const SCC_BY_FILE_ARGUMENTS = Object.freeze(["--no-config", "--by-file", "--format", "csv"]);
 const SCC_SCAN_TIMEOUT_MS = 300_000;
 
 interface ScanWithSccOptions {

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,39 @@ 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 lineDifference = left[index].line - right[index].line;
+    if (lineDifference !== 0) return lineDifference;
+    const tokenDifference = compareText(left[index].token, right[index].token);
+    if (tokenDifference !== 0) return tokenDifference;
+  }
+  return left.length - right.length;
+}
+
 export function isStableFunctionName(name: string): boolean {
   return name.trim() !== "" && name !== "(anonymous)" && name !== "unknown";
 }