@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/package-checks/duplicate-detection/execution.ts

@@ -1,18 +1,36 @@
 import { resolve } from "node:path";
 
 import type { CheckExecutionContext, CheckResult } from "../../check/check.ts";
+import {
+  reconcileFindingWaivers,
+  type FindingWaiverReconciliation
+} from "../../finding-waivers/reconciliation.ts";
 import { collectProjectFileSets, requireProjectFileSet } from "../project-files/collection.ts";
 import { fingerprintProjectFiles } from "../project-files/file-fingerprint.ts";
 import { settleFindings } from "../code-quality-findings/policy.ts";
+import {
+  reportFindingWaiverAudits,
+  reportReconciledCodeQualityFindingRecords
+} from "../code-quality-findings/finding-waiver-evidence.ts";
+import { appendCheckMessages } from "../../check/finding-presentation.ts";
+import { duplicateFindingMessages, duplicateWaiverMessages } from "./finding-messages.ts";
 import { getGitSha } from "./project-revision.ts";
 import { measureDuplicateDetection, type DuplicateMeasurementResult } from "./measurement.ts";
 import type {
   DuplicateDetectionAreaInput,
   DuplicateDetectionExactInputSet
 } from "./measurement-model.ts";
-import type { ResolvedDuplicateDetectionOptions } from "./options.ts";
+import type {
+  DuplicateDetectionFindingWaiver,
+  ResolvedDuplicateDetectionOptions
+} from "./options.ts";
 import { validResolvedDuplicateDetectionOptions } from "./options-validation.ts";
-import { buildDuplicateRecordCandidates } from "./records.ts";
+import {
+  buildDuplicateRecordCandidates,
+  duplicateDetectionFindingIdentity,
+  duplicateDetectionWaiverAuditRecord,
+  type DuplicateRecordCandidate
+} from "./records.ts";
 import type { DuplicateDetectionFinalData } from "./final-data.ts";
 
 export const DUPLICATE_DETECTION_CHECK_DEFINITION = {
@@ -43,7 +61,7 @@ export async function executeDuplicateDetection(
     return unavailable("source-unavailable");
   }
   if (exactInput.approvedExactPaths.length < 2) {
-    return Object.freeze({ status: "not-applicable", reason: { code: "no-eligible-input" } });
+    return noEligibleDuplicateInputResult(context);
   }
   const measurement = await measureDuplicateDetection({
     cache: context.options.cache,
@@ -56,11 +74,52 @@ export async function executeDuplicateDetection(
     context.options.codeAreas
   );
   if (candidates === undefined) return unavailable("external-result-invalid");
-  for (const candidate of candidates) {
-    context.records.report({ id: candidate.id }, candidate.data);
-  }
-  return settleFindings(
-    candidates.map((candidate) => ({ actionable: true, blocking: candidate.data.blocking }))
+  const reconciliation = reconcileDuplicateFindingWaivers(
+    candidates,
+    context.options.findingWaivers
+  );
+  reportReconciledCodeQualityFindingRecords(context, reconciliation);
+  reportFindingWaiverAudits(context, reconciliation, duplicateDetectionWaiverAuditRecord);
+  return settleDuplicateFindings(reconciliation);
+}
+
+function noEligibleDuplicateInputResult(
+  context: CheckExecutionContext<ResolvedDuplicateDetectionOptions>
+): CheckResult<DuplicateDetectionFinalData> {
+  const reconciliation = reconcileDuplicateFindingWaivers([], context.options.findingWaivers);
+  reportFindingWaiverAudits(context, reconciliation, duplicateDetectionWaiverAuditRecord);
+  return appendCheckMessages(
+    Object.freeze({ status: "not-applicable", reason: { code: "no-eligible-input" } }),
+    duplicateWaiverMessages(reconciliation)
+  );
+}
+
+function reconcileDuplicateFindingWaivers(
+  candidates: readonly DuplicateRecordCandidate[],
+  waivers: readonly DuplicateDetectionFindingWaiver[]
+): FindingWaiverReconciliation<DuplicateRecordCandidate> {
+  return reconcileFindingWaivers({
+    findings: candidates,
+    identify: duplicateDetectionFindingIdentity,
+    waivers
+  });
+}
+
+function settleDuplicateFindings(
+  reconciliation: FindingWaiverReconciliation<DuplicateRecordCandidate>
+): CheckResult<DuplicateDetectionFinalData> {
+  const settlement = settleFindings(
+    reconciliation.findings.map((finding) => ({
+      actionable: finding.disposition !== "waived",
+      blocking: finding.finding.data.blocking
+    }))
+  );
+  const actionableCandidates = reconciliation.findings
+    .filter(({ disposition }) => disposition !== "waived")
+    .map(({ finding }) => finding);
+  return appendCheckMessages(
+    appendCheckMessages(settlement, duplicateFindingMessages(actionableCandidates)),
+    duplicateWaiverMessages(reconciliation)
   );
 }
 
@@ -88,7 +147,6 @@ function collectAreaInputs(
   rootDir: string,
   codeAreas: ResolvedDuplicateDetectionOptions["codeAreas"]
 ): readonly DuplicateDetectionAreaInput[] {
-  const areas: DuplicateDetectionAreaInput[] = [];
   const orderedPolicies = Object.entries(codeAreas).sort(([left], [right]) =>
     compareText(left, right)
   );
@@ -96,19 +154,21 @@ function collectAreaInputs(
     rootDir,
     Object.fromEntries(orderedPolicies.map(([areaId, policy]) => [areaId, policy.files]))
   );
-  for (const [codeArea, policy] of orderedPolicies) {
-    const approvedExactPaths = requireProjectFileSet(filesByArea, codeArea);
-    if (approvedExactPaths.length === 0) continue;
-    areas.push(
-      Object.freeze({
-        approvedExactPaths: Object.freeze(approvedExactPaths),
-        codeArea,
-        minimumLines: policy.minimumLines,
-        minimumTokens: policy.minimumTokens
-      })
-    );
-  }
-  return Object.freeze(areas);
+  return Object.freeze(
+    orderedPolicies.flatMap(([codeArea, policy]) => {
+      const approvedExactPaths = requireProjectFileSet(filesByArea, codeArea);
+      return approvedExactPaths.length === 0
+        ? []
+        : [
+            Object.freeze({
+              approvedExactPaths: Object.freeze(approvedExactPaths),
+              codeArea,
+              minimumLines: policy.minimumLines,
+              minimumTokens: policy.minimumTokens
+            })
+          ];
+    })
+  );
 }
 
 function uniqueSorted(values: readonly string[]): string[] {

package/src/package-checks/duplicate-detection/finding-messages.ts

@@ -0,0 +1,75 @@
+import type { CheckMessage } from "../../check/check.ts";
+import { presentCheckFindings } from "../../check/finding-presentation.ts";
+import type {
+  FindingWaiverAudit,
+  FindingWaiverReconciliation
+} from "../../finding-waivers/reconciliation.ts";
+import type { DuplicateDetectionFindingLocation } from "./options.ts";
+import { duplicateDetectionWaiverIdentity, type DuplicateRecordCandidate } from "./records.ts";
+
+const PRESENTED_FINDING_LIMIT = 10;
+
+/** Projects duplicate Records into bounded, project-relative terminal summaries. */
+export function duplicateFindingMessages(
+  candidates: readonly DuplicateRecordCandidate[]
+): readonly CheckMessage[] {
+  return presentCheckFindings({
+    findings: candidates,
+    limit: PRESENTED_FINDING_LIMIT,
+    message: ({ data }) =>
+      Object.freeze({
+        code: "finding-detail",
+        level: data.blocking ? ("error" as const) : ("warning" as const),
+        message: `Duplicate fragment contains ${data.tokenCount} tokens across ${data.lineCount} lines at ${duplicateLocationSummary(data.locations)}.`
+      }),
+    omittedMessage: ({ omittedCount, omittedFindings }) =>
+      Object.freeze({
+        code: "findings-omitted",
+        level: omittedFindings.some(({ data }) => data.blocking)
+          ? ("error" as const)
+          : ("warning" as const),
+        message: `${omittedCount} additional duplicate finding(s) were not shown; inspect this Check's Records for the complete set.`
+      })
+  });
+}
+
+/** 将每项 duplicate-detection waiver audit 投影为可行动的 terminal message。 */
+export function duplicateWaiverMessages(
+  reconciliation: FindingWaiverReconciliation<DuplicateRecordCandidate>
+): readonly CheckMessage[] {
+  return Object.freeze(reconciliation.waiverAudits.map(duplicateWaiverMessage));
+}
+
+function duplicateWaiverMessage(audit: FindingWaiverAudit): CheckMessage {
+  const identity = duplicateDetectionWaiverIdentity(audit.waiver);
+  const subject = duplicateLocationSummary(identity.locations);
+  switch (audit.status) {
+    case "applied":
+      return Object.freeze({
+        code: "finding-waived",
+        level: "info",
+        message: `Duplicate finding at ${subject} was waived: ${audit.waiver.reason}`
+      });
+    case "unused":
+      return Object.freeze({
+        code: "unused-finding-waiver",
+        level: "warning",
+        message: `Configured duplicate-detection finding waiver at ${subject} matched no finding; remove it or update its identity. Reason: ${audit.waiver.reason}`
+      });
+    case "overmatched":
+      return Object.freeze({
+        code: "overmatched-finding-waiver",
+        level: "warning",
+        message: `Configured duplicate-detection finding waiver at ${subject} matched ${audit.matchCount} findings and was not applied; narrow its identity. Reason: ${audit.waiver.reason}`
+      });
+  }
+}
+
+function duplicateLocationSummary(locations: readonly DuplicateDetectionFindingLocation[]): string {
+  const presented = locations
+    .slice(0, 2)
+    .map(({ endLine, path, startLine }) => `${path}:${startLine}-${endLine}`)
+    .join(", ");
+  const omitted = locations.length - 2;
+  return omitted > 0 ? `${presented}, and ${omitted} more location(s)` : presented;
+}

package/src/package-checks/duplicate-detection/finding-waiver-identity.ts

@@ -0,0 +1,68 @@
+import {
+  snapshotClosedArray,
+  snapshotClosedPolicyRecord
+} from "../../data-boundary/closed-values.ts";
+import { isPositiveSafeInteger } from "../../data-boundary/value-shapes.ts";
+import { isNormalizedProjectRelativePath } from "../host-environment/path.ts";
+import type {
+  DuplicateDetectionFindingIdentity,
+  DuplicateDetectionFindingLocation
+} from "./options.ts";
+
+export function resolveDuplicateDetectionFindingIdentity(
+  value: unknown
+): DuplicateDetectionFindingIdentity | undefined {
+  const identity = snapshotClosedPolicyRecord(value, { required: ["locations", "metric"] });
+  if (identity === undefined || identity.metric !== "duplicate-tokens") return undefined;
+  const candidates = snapshotClosedArray(identity.locations);
+  if (candidates === undefined || candidates.length < 2) return undefined;
+  const locations: DuplicateDetectionFindingLocation[] = [];
+  for (const candidate of candidates) {
+    const resolved = resolveDuplicateFindingLocation(candidate);
+    if (resolved === undefined) return undefined;
+    const previous = locations.at(-1);
+    if (previous !== undefined && compareDuplicateFindingLocations(previous, resolved) >= 0) {
+      return undefined;
+    }
+    locations.push(resolved);
+  }
+  return Object.freeze({ locations: Object.freeze(locations), metric: "duplicate-tokens" });
+}
+
+function resolveDuplicateFindingLocation(
+  value: unknown
+): DuplicateDetectionFindingLocation | undefined {
+  const location = snapshotClosedPolicyRecord(value, {
+    required: ["endLine", "path", "startLine"]
+  });
+  if (
+    location === undefined ||
+    !isNormalizedProjectRelativePath(location.path) ||
+    !isPositiveSafeInteger(location.startLine) ||
+    !isPositiveSafeInteger(location.endLine) ||
+    location.endLine < location.startLine
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    endLine: location.endLine,
+    path: location.path,
+    startLine: location.startLine
+  });
+}
+
+export function compareDuplicateFindingLocations(
+  left: DuplicateDetectionFindingLocation,
+  right: DuplicateDetectionFindingLocation
+): number {
+  const pathOrder = compareText(left.path, right.path);
+  if (pathOrder !== 0) return pathOrder;
+  const startLineOrder = left.startLine - right.startLine;
+  return startLineOrder === 0 ? left.endLine - right.endLine : startLineOrder;
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

package/src/package-checks/duplicate-detection/jscpd/availability.ts

@@ -1,4 +1,4 @@
-import { runProcess } from "../../host-environment/process/command.ts";
+import { runProcess } from "../../host-environment/process.ts";
 import type { ResolvedDuplicateDetectionScannerOptions } from "../options.ts";
 import { isMissingExplicitCommand } from "./command-path.ts";
 import { isPackageJscpdCommand, resolveJscpdCommand } from "./command-resolution.ts";

package/src/package-checks/duplicate-detection/jscpd/command-resolution.ts

@@ -20,7 +20,7 @@ export type ResolvedJscpdCommand =
 
 /**
  * package-provided scanner 的可移植 marker。真实 executable 只由私有 jscpd adapter 解析，避免公共
- * Definition 与 fingerprint 保存 consumer-specific Bun 或 package path。
+ * Definition 与 fingerprint 保存 consumer-specific runtime 或 package path。
  */
 export const DEFAULT_JSCPD_COMMAND: DuplicateDetectionScannerCommand = Object.freeze({
   kind: "package"

package/src/package-checks/duplicate-detection/jscpd/json-report.ts

@@ -60,7 +60,12 @@ function parseJscpdFragment(
 ): DuplicateCodeFragment {
   const lineCount = integerField(duplication, "lines");
   const tokenCount = integerField(duplication, "tokens");
-  const locations = parseJscpdLocations(duplication, cwd, lineCount);
+  const locations = parseJscpdLocations(
+    duplication,
+    cwd,
+    lineCount,
+    optionalStringField(duplication, "format")
+  );
 
   return {
     id,
@@ -74,12 +79,13 @@ function parseJscpdFragment(
 function parseJscpdLocations(
   duplication: Record<string, unknown>,
   cwd: string,
-  lineCount: number
+  lineCount: number,
+  format: string | null
 ): DuplicateCodeLocation[] {
   return [
     parseJscpdLocationObject(duplication.firstFile, "firstFile"),
     parseJscpdLocationObject(duplication.secondFile, "secondFile")
-  ].map((location) => parseJscpdLocation(location, cwd, lineCount));
+  ].map((location) => parseJscpdLocation(location, cwd, lineCount, format));
 }
 
 function parseJscpdLocationObject(value: unknown, name: string): JscpdFileLocation {
@@ -92,7 +98,8 @@ function parseJscpdLocationObject(value: unknown, name: string): JscpdFileLocati
 function parseJscpdLocation(
   location: JscpdFileLocation,
   cwd: string,
-  lineCount: number
+  lineCount: number,
+  format: string | null
 ): DuplicateCodeLocation {
   const filePath = stringField(location, "name");
   const startLine =
@@ -100,12 +107,24 @@ function parseJscpdLocation(
   const endLine = nestedIntegerField(location, "endLoc", "line") ?? integerField(location, "end");
 
   return {
-    path: normalizeScannerReportedPath(filePath, cwd),
+    path: normalizeScannerReportedPath(stripJscpdFormatSuffix(filePath, format), cwd),
     startLine,
     endLine: endLine || startLine + Math.max(0, lineCount - 1)
   };
 }
 
+function stripJscpdFormatSuffix(filePath: string, format: string | null): string {
+  const suffix = format === null ? null : `:${format}`;
+  return suffix !== null && filePath.endsWith(suffix)
+    ? filePath.slice(0, -suffix.length)
+    : filePath;
+}
+
+function optionalStringField(record: Record<string, unknown>, name: string): string | null {
+  const value = record[name];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
 function integerField(record: Record<string, unknown>, name: string): number {
   const value = record[name];
   if (typeof value !== "number" || !Number.isSafeInteger(value)) {

package/src/package-checks/duplicate-detection/jscpd/scanner.ts

@@ -8,14 +8,10 @@
 
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 
 import { errorMessage } from "../../host-environment/error-message.ts";
-import {
-  runProcess,
-  runProcessSync,
-  type ProcessResult
-} from "../../host-environment/process/command.ts";
+import { runProcess, runProcessSync, type ProcessResult } from "../../host-environment/process.ts";
 import type { ResolvedDuplicateDetectionScannerOptions } from "../options.ts";
 import { resolveJscpdCommand, type JscpdCommand } from "./command-resolution.ts";
 import { parseJscpdJsonReport } from "./json-report.ts";
@@ -131,6 +127,7 @@ function prepareJscpdScan(options: ScanWithJscpdOptions): PreparedJscpdScan {
     cwd,
     dependency: resolved.command,
     invocation: prepareJscpdInvocation({
+      cwd,
       scanPrefixArguments: resolved.command.scanPrefixArguments,
       files,
       minimumLines,
@@ -140,11 +137,13 @@ function prepareJscpdScan(options: ScanWithJscpdOptions): PreparedJscpdScan {
 }
 
 function prepareJscpdInvocation({
+  cwd,
   scanPrefixArguments,
   files,
   minimumLines,
   minimumTokens
 }: {
+  readonly cwd: string;
   readonly scanPrefixArguments: readonly string[];
   readonly files: readonly string[];
   readonly minimumLines: number;
@@ -154,7 +153,7 @@ function prepareJscpdInvocation({
   const outputDir = join(tempDir, "report");
   const configPath = join(tempDir, ".jscpd.json");
   const config = {
-    path: files,
+    path: files.map((path) => resolve(cwd, path)),
     reporters: ["json"],
     minTokens: minimumTokens,
     minLines: minimumLines,

package/src/package-checks/duplicate-detection/options-resolution.ts

@@ -1,17 +1,21 @@
 import {
-  hasRequiredAndOptionalRecordKeys,
+  snapshotClosedPolicyRecord,
   snapshotClosedRecord
 } from "../../data-boundary/closed-values.ts";
+import { isNonEmptyString, isPositiveSafeInteger } from "../../data-boundary/value-shapes.ts";
 import {
   resolveProjectFileSelection,
   snapshotDefaultProjectFileSelection
 } from "../project-files/configuration.ts";
 import {
   DEFAULT_FINDING_POLICY,
+  resolveCodeAreaPolicyMap,
   resolveFindingPolicy,
   type FindingPolicy
 } from "../code-quality-findings/policy.ts";
+import { resolveFindingWaiverAuthoring } from "../code-quality-findings/finding-waiver-authoring.ts";
 import { DEFAULT_JSCPD_COMMAND } from "./jscpd/command-resolution.ts";
+import { resolveDuplicateDetectionFindingIdentity } from "./finding-waiver-identity.ts";
 import type {
   DuplicateDetectionScannerCommand,
   ResolvedDuplicateDetectionCodeAreaOptions,
@@ -24,17 +28,12 @@ const DEFAULT_CACHE_DIRECTORY = ".cache/vibe-check";
 const DEFAULT_MINIMUM_LINES = 4;
 const DEFAULT_MINIMUM_TOKENS = 100;
 
-interface PolicyRecordKeys {
-  readonly optional?: readonly string[];
-  readonly required?: readonly string[];
-}
-
 /** 校验 constructor input，并将所有可省略 policy 物化为完整、冻结的 Check options。 */
 export function resolveDuplicateDetectionOptions(
   value: unknown
 ): ResolvedDuplicateDetectionOptions | undefined {
-  const input = snapshotPolicyRecord(value, {
-    optional: ["cache", "codeAreas", "findingPolicy", "scanner"]
+  const input = snapshotClosedPolicyRecord(value, {
+    optional: ["cache", "codeAreas", "findingPolicy", "findingWaivers", "scanner"]
   });
   if (input === undefined) return undefined;
 
@@ -42,10 +41,20 @@ export function resolveDuplicateDetectionOptions(
   const findingPolicy = resolveFindingPolicy(input.findingPolicy, DEFAULT_FINDING_POLICY);
   if (findingPolicy === undefined) return undefined;
   const codeAreas = resolveCodeAreas(input.codeAreas, findingPolicy);
+  const findingWaivers = resolveFindingWaiverAuthoring(
+    input.findingWaivers,
+    resolveDuplicateDetectionFindingIdentity
+  );
   const scanner = resolveScanner(input.scanner);
-  if (cache === undefined || codeAreas === undefined || scanner === undefined) return undefined;
+  if (
+    cache === undefined ||
+    codeAreas === undefined ||
+    findingWaivers === undefined ||
+    scanner === undefined
+  )
+    return undefined;
 
-  const options = Object.freeze({ cache, codeAreas, scanner });
+  const options = Object.freeze({ cache, codeAreas, findingWaivers, scanner });
   return validResolvedDuplicateDetectionOptions(options) ? options : undefined;
 }
 
@@ -53,11 +62,11 @@ function resolveCache(value: unknown): ResolvedDuplicateDetectionOptions["cache"
   if (value === undefined) {
     return Object.freeze({ directory: DEFAULT_CACHE_DIRECTORY, enabled: true });
   }
-  const cache = snapshotPolicyRecord(value, { optional: ["directory", "enabled"] });
+  const cache = snapshotClosedPolicyRecord(value, { optional: ["directory", "enabled"] });
   if (cache === undefined) return undefined;
   const directory = cache.directory ?? DEFAULT_CACHE_DIRECTORY;
   const enabled = cache.enabled ?? true;
-  if (!nonEmptyString(directory) || typeof enabled !== "boolean") return undefined;
+  if (!isNonEmptyString(directory) || typeof enabled !== "boolean") return undefined;
   return Object.freeze({ directory, enabled });
 }
 
@@ -65,20 +74,11 @@ function resolveCodeAreas(
   value: unknown,
   defaultFindingPolicy: FindingPolicy
 ): ResolvedDuplicateDetectionOptions["codeAreas"] | undefined {
-  if (value === undefined) {
-    return Object.freeze({ project: defaultCodeArea(defaultFindingPolicy) });
-  }
-  const areas = snapshotClosedRecord(value);
-  if (areas === undefined || Object.keys(areas).length === 0) return undefined;
-
-  const resolvedEntries: Array<readonly [string, ResolvedDuplicateDetectionCodeAreaOptions]> = [];
-  for (const [areaId, candidate] of Object.entries(areas)) {
-    if (!nonEmptyString(areaId)) return undefined;
-    const area = resolveCodeArea(candidate, defaultFindingPolicy);
-    if (area === undefined) return undefined;
-    resolvedEntries.push([areaId, area]);
-  }
-  return Object.freeze(Object.fromEntries(resolvedEntries));
+  return resolveCodeAreaPolicyMap(
+    value,
+    () => defaultCodeArea(defaultFindingPolicy),
+    (candidate) => resolveCodeArea(candidate, defaultFindingPolicy)
+  );
 }
 
 function defaultCodeArea(findingPolicy: FindingPolicy): ResolvedDuplicateDetectionCodeAreaOptions {
@@ -94,7 +94,7 @@ function resolveCodeArea(
   value: unknown,
   defaultFindingPolicy: FindingPolicy
 ): ResolvedDuplicateDetectionCodeAreaOptions | undefined {
-  const area = snapshotPolicyRecord(value, {
+  const area = snapshotClosedPolicyRecord(value, {
     optional: ["findingPolicy", "minimumLines", "minimumTokens"],
     required: ["files"]
   });
@@ -106,8 +106,8 @@ function resolveCodeArea(
   if (
     files === undefined ||
     findingPolicy === undefined ||
-    !positiveSafeInteger(minimumLines) ||
-    !positiveSafeInteger(minimumTokens)
+    !isPositiveSafeInteger(minimumLines) ||
+    !isPositiveSafeInteger(minimumTokens)
   ) {
     return undefined;
   }
@@ -116,7 +116,7 @@ function resolveCodeArea(
 
 function resolveScanner(value: unknown): ResolvedDuplicateDetectionScannerOptions | undefined {
   if (value === undefined) return Object.freeze({ command: DEFAULT_JSCPD_COMMAND });
-  const scanner = snapshotPolicyRecord(value, { optional: ["command"] });
+  const scanner = snapshotClosedPolicyRecord(value, { optional: ["command"] });
   if (scanner === undefined) return undefined;
   const command = resolveScannerCommand(scanner.command);
   return command === undefined ? undefined : Object.freeze({ command });
@@ -129,34 +129,9 @@ function resolveScannerCommand(value: unknown): DuplicateDetectionScannerCommand
     return Object.keys(command).length === 1 ? DEFAULT_JSCPD_COMMAND : undefined;
   }
   if (command?.kind !== "custom") return undefined;
-  const custom = snapshotPolicyRecord(command, { required: ["executable", "kind"] });
-  if (custom === undefined || custom.kind !== "custom" || !nonEmptyString(custom.executable)) {
+  const custom = snapshotClosedPolicyRecord(command, { required: ["executable", "kind"] });
+  if (custom === undefined || custom.kind !== "custom" || !isNonEmptyString(custom.executable)) {
     return undefined;
   }
   return Object.freeze({ executable: custom.executable, kind: "custom" });
 }
-
-function snapshotPolicyRecord(
-  value: unknown,
-  keys: PolicyRecordKeys
-): Readonly<Record<string, unknown>> | undefined {
-  const record = snapshotClosedRecord(value);
-  if (
-    record === undefined ||
-    !hasRequiredAndOptionalRecordKeys(record, {
-      optional: keys.optional ?? [],
-      required: keys.required ?? []
-    })
-  ) {
-    return undefined;
-  }
-  return record;
-}
-
-function positiveSafeInteger(value: unknown): value is number {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-
-function nonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0;
-}