@zxyycom/vibe-check 0.0.1

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

@@ -0,0 +1,137 @@
+import { isNonArrayRecord } from "../../../data-boundary/value-shapes.ts";
+import { errorMessage } from "../../host-environment/error-message.ts";
+import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
+import { normalizeScannerReportedPath } from "../../project-files/reported-path.ts";
+import type { DuplicateCodeFragment, DuplicateCodeLocation } from "../measurement-model.ts";
+import { toScopedJscpdMeasurement } from "./scoped-fragments.ts";
+import type { JscpdScanResult } from "./scanner-contract.ts";
+
+type JscpdFileLocation = Readonly<{
+  readonly end?: unknown;
+  readonly endLoc?: unknown;
+  readonly name?: unknown;
+  readonly start?: unknown;
+  readonly startLoc?: unknown;
+}>;
+
+export function parseJscpdJsonReport(json: string, cwd: string): JscpdScanResult {
+  try {
+    const parsed = JSON.parse(json) as unknown;
+    if (!isNonArrayRecord(parsed)) {
+      throw new Error("jscpd JSON report must be an object");
+    }
+
+    const duplicates = parsed.duplicates;
+    if (!Array.isArray(duplicates)) {
+      throw new Error("jscpd JSON report must include duplicates array");
+    }
+
+    return { ok: true, measurements: parseJscpdMeasurements(duplicates, cwd) };
+  } catch (error: unknown) {
+    return {
+      ok: false,
+      error: `Failed to parse jscpd JSON: ${errorMessage(error)}`,
+      reason: "jscpd-parse-failure"
+    };
+  }
+}
+
+function parseJscpdMeasurements(
+  duplicates: readonly unknown[],
+  cwd: string
+): ExactInputMeasurement<DuplicateCodeFragment>[] {
+  const measurements: ExactInputMeasurement<DuplicateCodeFragment>[] = [];
+
+  for (const [index, duplication] of duplicates.entries()) {
+    if (!isNonArrayRecord(duplication)) {
+      throw new Error(`jscpd duplicate #${index + 1} must be an object`);
+    }
+    const fragment = parseJscpdFragment(duplication, cwd, index + 1);
+    measurements.push(toScopedJscpdMeasurement(fragment));
+  }
+
+  return measurements.sort((a, b) => b.payload.tokenCount - a.payload.tokenCount);
+}
+
+function parseJscpdFragment(
+  duplication: Record<string, unknown>,
+  cwd: string,
+  id: number
+): DuplicateCodeFragment {
+  const lineCount = integerField(duplication, "lines");
+  const tokenCount = integerField(duplication, "tokens");
+  const locations = parseJscpdLocations(duplication, cwd, lineCount);
+
+  return {
+    id,
+    tokenCount,
+    lineCount,
+    locations,
+    codeAreas: []
+  };
+}
+
+function parseJscpdLocations(
+  duplication: Record<string, unknown>,
+  cwd: string,
+  lineCount: number
+): DuplicateCodeLocation[] {
+  return [
+    parseJscpdLocationObject(duplication.firstFile, "firstFile"),
+    parseJscpdLocationObject(duplication.secondFile, "secondFile")
+  ].map((location) => parseJscpdLocation(location, cwd, lineCount));
+}
+
+function parseJscpdLocationObject(value: unknown, name: string): JscpdFileLocation {
+  if (!isNonArrayRecord(value)) {
+    throw new Error(`jscpd duplicate must include ${name} location object`);
+  }
+  return value;
+}
+
+function parseJscpdLocation(
+  location: JscpdFileLocation,
+  cwd: string,
+  lineCount: number
+): DuplicateCodeLocation {
+  const filePath = stringField(location, "name");
+  const startLine =
+    nestedIntegerField(location, "startLoc", "line") ?? integerField(location, "start");
+  const endLine = nestedIntegerField(location, "endLoc", "line") ?? integerField(location, "end");
+
+  return {
+    path: normalizeScannerReportedPath(filePath, cwd),
+    startLine,
+    endLine: endLine || startLine + Math.max(0, lineCount - 1)
+  };
+}
+
+function integerField(record: Record<string, unknown>, name: string): number {
+  const value = record[name];
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    throw new Error(`jscpd field "${name}" must be a safe integer`);
+  }
+  return value;
+}
+
+function nestedIntegerField(
+  record: Record<string, unknown>,
+  parent: string,
+  child: string
+): number | null {
+  const parentValue = record[parent];
+  if (!isNonArrayRecord(parentValue)) return null;
+  const value = parentValue[child];
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    throw new Error(`jscpd field "${parent}.${child}" must be a safe integer`);
+  }
+  return value;
+}
+
+function stringField(record: Record<string, unknown>, name: string): string {
+  const value = record[name];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`jscpd field "${name}" must be a non-empty string`);
+  }
+  return value;
+}

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

@@ -0,0 +1,18 @@
+import type { DuplicateCodeFragment } from "../measurement-model.ts";
+import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
+
+export type JscpdScanFailureReason =
+  | "jscpd-execution-error"
+  | "jscpd-report-failure"
+  | "jscpd-parse-failure";
+
+export type JscpdScanResult =
+  | {
+      readonly measurements: readonly ExactInputMeasurement<DuplicateCodeFragment>[];
+      readonly ok: true;
+    }
+  | {
+      readonly error: string;
+      readonly ok: false;
+      readonly reason: JscpdScanFailureReason;
+    };

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

@@ -0,0 +1,257 @@
+/**
+ * jscpd duplicate-code detection wrapper.
+ *
+ * Runs the Check-owned jscpd CLI, writes a temporary config for the
+ * approved exact-scope file list, and normalizes the JSON report behind the
+ * repository-owned DuplicateCodeFragment model.
+ */
+
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { errorMessage } from "../../host-environment/error-message.ts";
+import {
+  runProcess,
+  runProcessSync,
+  type ProcessResult
+} from "../../host-environment/process/command.ts";
+import type { ResolvedDuplicateDetectionScannerOptions } from "../options.ts";
+import { resolveJscpdCommand, type JscpdCommand } from "./command-resolution.ts";
+import { parseJscpdJsonReport } from "./json-report.ts";
+import type { JscpdScanResult } from "./scanner-contract.ts";
+
+export type { JscpdScanResult } from "./scanner-contract.ts";
+export { parseJscpdJsonReport } from "./json-report.ts";
+
+const JSCPD_REPORT_FILE = "jscpd-report.json";
+const JSCPD_PROCESS_MAX_BUFFER = 1024 * 1024 * 64;
+const JSCPD_PROCESS_TIMEOUT_MS = 600_000;
+
+export function parseJscpdVersionOutput(output: string): string | null {
+  const match = output.trim().match(/(?:jscpd|cpd)\s+([^\s]+)/i);
+  return match?.[1] ?? null;
+}
+
+interface ScanWithJscpdOptions {
+  readonly cwd: string;
+  readonly dependency: ResolvedDuplicateDetectionScannerOptions;
+  readonly files: readonly string[];
+  readonly minimumLines: number;
+  readonly minimumTokens: number;
+}
+
+type PreparedJscpdInvocation = Readonly<{
+  readonly argv: readonly string[];
+  readonly configPath: string;
+  readonly outputDir: string;
+  readonly tempDir: string;
+}>;
+
+type PreparedJscpdScan =
+  | Readonly<{
+      readonly cwd: string;
+      readonly dependency: JscpdCommand;
+      readonly invocation: PreparedJscpdInvocation;
+      readonly ok: true;
+    }>
+  | Readonly<{ readonly ok: false; readonly result: JscpdScanResult }>;
+
+export function scanWithJscpd(options: ScanWithJscpdOptions): JscpdScanResult {
+  try {
+    const scan = prepareJscpdScan(options);
+    if (!scan.ok) return scan.result;
+
+    try {
+      const child = runProcessSync({
+        args: scan.invocation.argv,
+        command: scan.dependency.executable,
+        cwd: scan.cwd,
+        encoding: "utf8",
+        windowsHide: true,
+        maxBuffer: JSCPD_PROCESS_MAX_BUFFER,
+        timeout: JSCPD_PROCESS_TIMEOUT_MS
+      });
+
+      return handleJscpdProcessResult({ child, cwd: scan.cwd, invocation: scan.invocation });
+    } finally {
+      cleanupTempDir(scan.invocation.tempDir);
+    }
+  } catch (error: unknown) {
+    return jscpdAdapterError(error);
+  }
+}
+
+export async function scanWithJscpdAsync(options: ScanWithJscpdOptions): Promise<JscpdScanResult> {
+  try {
+    const scan = prepareJscpdScan(options);
+    if (!scan.ok) return scan.result;
+
+    try {
+      const child = await runProcess({
+        args: scan.invocation.argv,
+        command: scan.dependency.executable,
+        cwd: scan.cwd,
+        label: "jscpd",
+        maxBuffer: JSCPD_PROCESS_MAX_BUFFER,
+        timeout: JSCPD_PROCESS_TIMEOUT_MS,
+        windowsHide: true
+      });
+
+      return handleJscpdProcessResult({ child, cwd: scan.cwd, invocation: scan.invocation });
+    } finally {
+      cleanupTempDir(scan.invocation.tempDir);
+    }
+  } catch (error: unknown) {
+    return jscpdAdapterError(error);
+  }
+}
+
+function prepareJscpdScan(options: ScanWithJscpdOptions): PreparedJscpdScan {
+  const { files, cwd, dependency, minimumLines, minimumTokens } = options;
+
+  if (files.length < 2) {
+    return { ok: false, result: { ok: true, measurements: [] } };
+  }
+
+  const resolved = resolveJscpdCommand(dependency.command);
+  if (resolved.kind === "unavailable") {
+    return {
+      ok: false,
+      result: {
+        error: resolved.error,
+        ok: false,
+        reason: "jscpd-execution-error"
+      }
+    };
+  }
+
+  return {
+    ok: true,
+    cwd,
+    dependency: resolved.command,
+    invocation: prepareJscpdInvocation({
+      scanPrefixArguments: resolved.command.scanPrefixArguments,
+      files,
+      minimumLines,
+      minimumTokens
+    })
+  };
+}
+
+function prepareJscpdInvocation({
+  scanPrefixArguments,
+  files,
+  minimumLines,
+  minimumTokens
+}: {
+  readonly scanPrefixArguments: readonly string[];
+  readonly files: readonly string[];
+  readonly minimumLines: number;
+  readonly minimumTokens: number;
+}): PreparedJscpdInvocation {
+  const tempDir = mkdtempSync(join(tmpdir(), "quality-jscpd-"));
+  const outputDir = join(tempDir, "report");
+  const configPath = join(tempDir, ".jscpd.json");
+  const config = {
+    path: files,
+    reporters: ["json"],
+    minTokens: minimumTokens,
+    minLines: minimumLines,
+    absolute: true,
+    silent: true,
+    noTips: true
+  };
+
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  return {
+    tempDir,
+    outputDir,
+    configPath,
+    argv: [...scanPrefixArguments, "--config", configPath, "--output", outputDir]
+  };
+}
+
+function handleJscpdProcessResult({
+  child,
+  cwd,
+  invocation
+}: {
+  readonly child: ProcessResult;
+  readonly cwd: string;
+  readonly invocation: PreparedJscpdInvocation;
+}): JscpdScanResult {
+  if (child.error) {
+    return jscpdProcessError(child.error);
+  }
+
+  if (child.status !== 0) {
+    return jscpdExecutionFailure(
+      child.status,
+      child.signal,
+      trimmedProcessOutput(child.stderr, child.stdout)
+    );
+  }
+
+  return parseJscpdReportFile(join(invocation.outputDir, JSCPD_REPORT_FILE), cwd);
+}
+
+function parseJscpdReportFile(reportPath: string, cwd: string): JscpdScanResult {
+  let json: string;
+  try {
+    json = readFileSync(reportPath, "utf8");
+  } catch (error: unknown) {
+    return {
+      ok: false,
+      error: `jscpd JSON report missing: ${errorMessage(error)}`,
+      reason: "jscpd-report-failure"
+    };
+  }
+
+  if (!json.trim()) {
+    return {
+      ok: false,
+      error: "jscpd JSON report is empty",
+      reason: "jscpd-report-failure"
+    };
+  }
+
+  return parseJscpdJsonReport(json, cwd);
+}
+
+function jscpdProcessError(error: Error): JscpdScanResult {
+  return {
+    ok: false,
+    error: `jscpd process error: ${error.message}`,
+    reason: "jscpd-execution-error"
+  };
+}
+
+function jscpdAdapterError(error: unknown): JscpdScanResult {
+  return {
+    ok: false,
+    error: `jscpd adapter error: ${errorMessage(error)}`,
+    reason: "jscpd-execution-error"
+  };
+}
+
+function jscpdExecutionFailure(
+  status: number | null,
+  signal: NodeJS.Signals | null,
+  output: string
+): JscpdScanResult {
+  const termination = status === null ? `signal ${signal ?? "unknown"}` : `exit ${status}`;
+  return {
+    ok: false,
+    error: `jscpd ${termination}: ${output}`,
+    reason: "jscpd-execution-error"
+  };
+}
+
+function trimmedProcessOutput(stderr: string, stdout: string): string {
+  return stderr.trim() || stdout.trim() || "no output";
+}
+
+function cleanupTempDir(path: string): void {
+  rmSync(path, { recursive: true, force: true });
+}

package/src/package-checks/duplicate-detection/jscpd/scoped-fragments.ts

@@ -0,0 +1,17 @@
+import type { DuplicateCodeFragment } from "../measurement-model.ts";
+import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
+
+export function toScopedJscpdMeasurement(
+  fragment: DuplicateCodeFragment
+): ExactInputMeasurement<DuplicateCodeFragment> {
+  return {
+    payload: fragment,
+    sourcePaths: fragment.locations.map((location) => location.path)
+  };
+}
+
+export function toScopedJscpdMeasurements(
+  fragments: readonly DuplicateCodeFragment[]
+): ExactInputMeasurement<DuplicateCodeFragment>[] {
+  return fragments.map(toScopedJscpdMeasurement);
+}

package/src/package-checks/duplicate-detection/measurement-model.ts

@@ -0,0 +1,44 @@
+import type {
+  ResolvedDuplicateDetectionOptions,
+  ResolvedDuplicateDetectionScannerOptions
+} from "./options.ts";
+
+export interface DuplicateCodeLocation {
+  readonly endLine: number;
+  readonly path: string;
+  readonly startLine: number;
+}
+
+export interface DuplicateCodeFragment {
+  readonly codeAreas: readonly string[];
+  readonly id: number;
+  readonly lineCount: number;
+  readonly locations: readonly DuplicateCodeLocation[];
+  readonly tokenCount: number;
+}
+
+export interface DuplicateDetectionAreaInput {
+  readonly approvedExactPaths: readonly string[];
+  readonly codeArea: string;
+  readonly minimumLines: number;
+  readonly minimumTokens: number;
+}
+
+export interface DuplicateDetectionExactInputSet {
+  readonly approvedExactPaths: readonly string[];
+  readonly areas: readonly DuplicateDetectionAreaInput[];
+  readonly cacheRootDir: string;
+  readonly commitSha: string;
+  readonly inputFingerprint: Readonly<{
+    readonly fileCount: number;
+    readonly fileList: readonly string[];
+    readonly fingerprint: string;
+  }>;
+  readonly rootDir: string;
+}
+
+export interface DuplicateMeasurementInput {
+  readonly cache: ResolvedDuplicateDetectionOptions["cache"];
+  readonly dependency: ResolvedDuplicateDetectionScannerOptions;
+  readonly exactInput: DuplicateDetectionExactInputSet;
+}

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

@@ -0,0 +1,223 @@
+import { acceptExactInputMeasurements } from "../project-files/exact-input-measurement.ts";
+import { applyDuplicateAreaPolicy } from "./area-policy.ts";
+import {
+  loadScanCacheEntry,
+  writeScanCacheEntry,
+  type DuplicateCodeCacheIdentity
+} from "./cache/store.ts";
+import { createDuplicateScanCacheIdentity } from "./cache/identity.ts";
+import { checkJscpd } from "./jscpd/availability.ts";
+import { scanWithJscpdAsync } from "./jscpd/scanner.ts";
+import { toScopedJscpdMeasurements } from "./jscpd/scoped-fragments.ts";
+import type {
+  DuplicateCodeFragment,
+  DuplicateDetectionAreaInput,
+  DuplicateDetectionExactInputSet,
+  DuplicateMeasurementInput
+} from "./measurement-model.ts";
+import type { ResolvedDuplicateDetectionScannerOptions } from "./options.ts";
+import { isValidDuplicateFragment } from "./records.ts";
+
+export type DuplicateMeasurementResult = Readonly<
+  | { fragments: readonly DuplicateCodeFragment[]; kind: "complete" }
+  | { kind: "execution-failed" }
+  | { kind: "invalid-result" }
+  | { kind: "cache-write-failed" }
+  | { kind: "unavailable" }
+>;
+
+type RawMeasurementResult = Readonly<
+  | { fragments: readonly DuplicateCodeFragment[]; kind: "complete" }
+  | { kind: "execution-failed" }
+  | { kind: "invalid-result" }
+  | { kind: "cache-write-failed" }
+>;
+
+interface RawScopeMeasurementInput {
+  readonly cache: DuplicateMeasurementInput["cache"];
+  readonly dependency: ResolvedDuplicateDetectionScannerOptions;
+  readonly exactInput: DuplicateDetectionExactInputSet;
+  readonly minimumLines: number;
+  readonly minimumTokens: number;
+  readonly toolVersion: string;
+}
+
+export async function measureDuplicateDetection(
+  options: DuplicateMeasurementInput
+): Promise<DuplicateMeasurementResult> {
+  const { dependency, exactInput } = options;
+  if (!validMeasurementInput(exactInput)) {
+    return Object.freeze({ kind: "invalid-result" });
+  }
+  const availability = await checkJscpd(exactInput.rootDir, dependency);
+  if (!availability.available) {
+    return Object.freeze({ kind: "unavailable" });
+  }
+
+  const minimumLines = Math.min(...exactInput.areas.map((area) => area.minimumLines));
+  const minimumTokens = Math.min(...exactInput.areas.map((area) => area.minimumTokens));
+  const rawMeasurement = await measureRawScope({
+    cache: options.cache,
+    dependency,
+    exactInput,
+    minimumLines,
+    minimumTokens,
+    toolVersion: availability.version
+  });
+  if (rawMeasurement.kind !== "complete") return rawMeasurement;
+
+  const fragments = applyDuplicateAreaPolicy(rawMeasurement.fragments, exactInput.areas);
+  return fragments === undefined
+    ? Object.freeze({ kind: "invalid-result" })
+    : Object.freeze({ fragments, kind: "complete" });
+}
+
+function validMeasurementInput(exactInput: DuplicateDetectionExactInputSet): boolean {
+  const approvedExactPaths = exactInput.approvedExactPaths;
+  if (!hasValidScopeIdentity(exactInput) || !hasValidApprovedPaths(exactInput)) return false;
+
+  const approvedPathSet = new Set(approvedExactPaths);
+  const coveredPathSet = new Set<string>();
+  const codeAreaSet = new Set<string>();
+  for (const area of exactInput.areas) {
+    if (!isValidAreaInput(area) || codeAreaSet.has(area.codeArea)) return false;
+    codeAreaSet.add(area.codeArea);
+    for (const path of area.approvedExactPaths) {
+      if (!approvedPathSet.has(path)) return false;
+      coveredPathSet.add(path);
+    }
+  }
+  return coveredPathSet.size === approvedPathSet.size;
+}
+
+function hasValidScopeIdentity(exactInput: DuplicateDetectionExactInputSet): boolean {
+  return (
+    exactInput.approvedExactPaths.length >= 2 &&
+    nonEmptyString(exactInput.rootDir) &&
+    nonEmptyString(exactInput.cacheRootDir) &&
+    nonEmptyString(exactInput.commitSha)
+  );
+}
+
+function hasValidApprovedPaths(exactInput: DuplicateDetectionExactInputSet): boolean {
+  const paths = exactInput.approvedExactPaths;
+  return (
+    paths.every(nonEmptyString) &&
+    sameStrings(paths, uniqueSorted(paths)) &&
+    validFingerprintForPaths(exactInput.inputFingerprint, paths)
+  );
+}
+
+function isValidAreaInput(area: DuplicateDetectionAreaInput): boolean {
+  return (
+    nonEmptyString(area.codeArea) &&
+    positiveSafeInteger(area.minimumLines) &&
+    positiveSafeInteger(area.minimumTokens) &&
+    area.approvedExactPaths.length > 0 &&
+    area.approvedExactPaths.every(nonEmptyString) &&
+    sameStrings(area.approvedExactPaths, uniqueSorted(area.approvedExactPaths))
+  );
+}
+
+function validFingerprintForPaths(
+  fingerprint: DuplicateDetectionExactInputSet["inputFingerprint"],
+  approvedExactPaths: readonly string[]
+): boolean {
+  const expectedFileList = approvedExactPaths.slice(0, 200);
+  return (
+    fingerprint.fileCount === approvedExactPaths.length &&
+    sameStrings(fingerprint.fileList, expectedFileList) &&
+    nonEmptyString(fingerprint.fingerprint)
+  );
+}
+
+async function measureRawScope(input: RawScopeMeasurementInput): Promise<RawMeasurementResult> {
+  const identity = createDuplicateScanCacheIdentity(input);
+  const exactPaths = input.exactInput.approvedExactPaths;
+  if (input.cache.enabled) {
+    const cachedFragments = loadValidCachedFragments(
+      input.exactInput.cacheRootDir,
+      identity,
+      exactPaths
+    );
+    if (cachedFragments !== null) {
+      return Object.freeze({ fragments: cachedFragments, kind: "complete" });
+    }
+  }
+  return scanAndCacheScope(input, identity, exactPaths);
+}
+
+function loadValidCachedFragments(
+  cacheRootDir: string,
+  identity: DuplicateCodeCacheIdentity,
+  exactPaths: readonly string[]
+): readonly DuplicateCodeFragment[] | null {
+  const cached = loadScanCacheEntry({ rootDir: cacheRootDir, identity });
+  if (!cached.hit) return null;
+  const accepted = acceptExactInputMeasurements(
+    toScopedJscpdMeasurements(cached.metrics),
+    exactPaths
+  );
+  return accepted.ok && accepted.payloads.every(isValidDuplicateFragment)
+    ? Object.freeze(accepted.payloads)
+    : null;
+}
+
+async function scanAndCacheScope(
+  input: RawScopeMeasurementInput,
+  identity: DuplicateCodeCacheIdentity,
+  exactPaths: readonly string[]
+): Promise<RawMeasurementResult> {
+  const result = await scanWithJscpdAsync({
+    cwd: input.exactInput.rootDir,
+    dependency: input.dependency,
+    files: exactPaths,
+    minimumLines: input.minimumLines,
+    minimumTokens: input.minimumTokens
+  });
+  if (!result.ok) {
+    return Object.freeze({
+      kind: result.reason === "jscpd-execution-error" ? "execution-failed" : "invalid-result"
+    });
+  }
+
+  const accepted = acceptExactInputMeasurements(result.measurements, exactPaths);
+  if (!accepted.ok || !accepted.payloads.every(isValidDuplicateFragment)) {
+    return Object.freeze({ kind: "invalid-result" });
+  }
+  const fragments = Object.freeze(accepted.payloads);
+  if (input.cache.enabled) {
+    try {
+      writeScanCacheEntry({
+        rootDir: input.exactInput.cacheRootDir,
+        identity,
+        metrics: [...fragments]
+      });
+    } catch {
+      return Object.freeze({ kind: "cache-write-failed" });
+    }
+  }
+  return Object.freeze({ fragments, kind: "complete" });
+}
+
+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;
+}
+
+function uniqueSorted(values: readonly string[]): string[] {
+  return [...new Set(values)].sort(compareText);
+}
+
+function sameStrings(left: readonly string[], right: readonly string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}