@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/package-checks/function-metrics/analyzer/shared/golike.ts

@@ -0,0 +1,143 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/golike.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Go-like function and
+ * nested-block state transitions.
+ */
+
+import { CodeStateMachine } from "./code-reader.ts";
+
+/**
+ * Shared state machine for Go-like readers.
+ *
+ * Function transition methods deliberately remain prototype methods: source
+ * subclasses use `super` and the state machine invokes stored methods with its
+ * owning receiver. This preserves both override dispatch and state identity.
+ */
+/* oxlint-disable typescript/unbound-method */
+export class GoLikeStates extends CodeStateMachine {
+  protected static readonly FUNC_KEYWORD: string = "func";
+  private _type_param_open: string | undefined;
+  private _type_param_close: string | undefined;
+
+  public override _state_global(token: string): void {
+    if (token === this.getFunctionKeyword()) {
+      this.next(this._function_name);
+      this.context.pushNewFunction("");
+    } else if (token === "type") {
+      this.next(this._type_definition);
+    } else if (token === "{") {
+      this.subState(this.cloneState());
+    } else if (token === "}") {
+      this.returnFromState();
+    }
+  }
+
+  protected readonly _type_definition = (_token: string): void => {
+    this.next(this._after_type_name);
+  };
+
+  private readonly _after_type_name = (token: string): void => {
+    if (token === "struct") {
+      this.next(this._struct_definition);
+    } else if (token === "interface") {
+      this.next(this._interface_definition);
+    } else {
+      this.next(this.globalState);
+    }
+  };
+
+  private readonly _struct_definition = (token: string): void => {
+    this.readInsideBracketsThen("{}", token, this.ignoreToken, this.globalState);
+  };
+
+  private readonly _interface_definition = (token: string): void => {
+    this.readInsideBracketsThen("{}", token, this.ignoreToken, this.globalState);
+  };
+
+  /** Source `_function_name` virtual seam used by Kotlin. */
+  protected _function_name(token: string): void {
+    if (token === "`") return;
+    if (token === "(") {
+      const parentFunction = this.context.stackedFunctions.at(-1);
+      if (parentFunction?.name !== "*global*") {
+        this.next(this._function_dec, token);
+      } else {
+        this.next(this._member_function, token);
+      }
+    } else if (token === "{") {
+      this.next(this._expect_function_impl, token);
+    } else {
+      this.context.addToFunctionName(token);
+      this.next(this._expect_function_dec);
+    }
+  }
+
+  private readonly _expect_function_dec = (token: string): void => {
+    if (token === "(") {
+      this.next(this._function_dec, token);
+    } else if (token === "<" || token === "[") {
+      this.next(this._skip_type_parameters, token);
+    } else {
+      this.next(this.globalState);
+    }
+  };
+
+  private readonly _skip_type_parameters = (token: string): void => {
+    if (this.br_count === 0) {
+      this._type_param_open = token;
+      this._type_param_close = token === "<" ? ">" : "]";
+    }
+    let typeParameterDelta = 0;
+    if (token === this._type_param_open) typeParameterDelta = 1;
+    else if (token === this._type_param_close) typeParameterDelta = -1;
+    this.br_count += typeParameterDelta;
+    if (this.br_count === 0) this.next(this._expect_function_dec);
+  };
+
+  private readonly _member_function = (token: string): void => {
+    this.readInsideBracketsThen("()", token, this.addMemberFunctionToken, this._function_name);
+  };
+
+  private readonly addMemberFunctionToken = (token: string): void => {
+    this.context.addToLongFunctionName(token);
+  };
+
+  private readonly _function_dec = (token: string): void => {
+    this.readInsideBracketsThen("()", token, this.addFunctionParameter, this._expect_function_impl);
+  };
+
+  private readonly addFunctionParameter = (token: string): void => {
+    if (!"()".includes(token)) this.context.parameter(token);
+  };
+
+  /** Source `_expect_function_impl` virtual seam used by Scala and Kotlin. */
+  protected _expect_function_impl(token: string): void {
+    if (token === "{" && this.lastToken !== "interface") {
+      this.next(this._function_impl, token);
+    }
+  }
+
+  protected readonly _function_impl = (_token: string): void => {
+    this.subState(this.cloneState(), () => {
+      this.next(this.globalState);
+      this.context.endOfFunction();
+    });
+  };
+
+  private readonly ignoreToken = (_token: string): void => {};
+
+  private getFunctionKeyword(): string {
+    const StateMachine = this.stateMachineConstructor;
+    if (!hasFunctionKeyword(StateMachine)) return GoLikeStates.FUNC_KEYWORD;
+    const keyword = StateMachine.FUNC_KEYWORD;
+    return typeof keyword === "string" ? keyword : GoLikeStates.FUNC_KEYWORD;
+  }
+}
+/* oxlint-enable typescript/unbound-method */
+
+function hasFunctionKeyword(value: object): value is { readonly FUNC_KEYWORD?: unknown } {
+  return "FUNC_KEYWORD" in value;
+}

package/src/package-checks/function-metrics/analyzer/shared/js-style-regex.ts

@@ -0,0 +1,80 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/js_style_regex_expression.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to a TypeScript tokenizer wrapper while preserving the
+ * upstream eager regex-token combination order.
+ */
+
+import type { TokenFactory } from "./code-reader.ts";
+
+/** A static reader tokenizer shape accepted by the JavaScript regex wrapper. */
+export type TokenGenerator = (
+  sourceCode: string,
+  addition?: string,
+  tokenFactory?: TokenFactory
+) => Generator<string>;
+
+/**
+ * Wrap a tokenizer with Lizard's JavaScript-style regular-expression joining.
+ * The final index advance intentionally mirrors the upstream implementation.
+ */
+export function js_style_regex_expression(generator: TokenGenerator): TokenGenerator {
+  return function* generateTokensWithRegex(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    const regexPattern = /\/(\S*?[^\s\\]\/)+?(igm)*/u;
+    const tokens = Array.from(generator(sourceCode, addition, tokenFactory));
+    const result: string[] = [];
+    let index = 0;
+
+    while (index < tokens.length) {
+      const token = tokens[index];
+      if (token === "/") {
+        const previousToken = tokens[index - 1]?.trim();
+        const isRegex =
+          index === 0 ||
+          (previousToken !== undefined &&
+            previousToken.length > 0 &&
+            "=,({[?:!&|;".includes(previousToken.at(-1) ?? ""));
+        if (isRegex) {
+          const regexTokens = [token];
+          index += 1;
+          while (index < tokens.length) {
+            const nextToken = tokens[index];
+            if (nextToken === undefined || nextToken.endsWith("/")) break;
+            regexTokens.push(nextToken);
+            index += 1;
+          }
+          if (index < tokens.length) {
+            const closingToken = tokens[index];
+            if (closingToken === undefined) break;
+            regexTokens.push(closingToken);
+            index += 1;
+            const flags = tokens[index];
+            if (flags !== undefined && /^[igm]+$/u.test(flags)) {
+              regexTokens.push(flags);
+              index += 1;
+            }
+          }
+          const combined = regexTokens.join("");
+          if (regexPattern.exec(combined)?.index === 0) {
+            result.push(combined);
+          } else {
+            result.push(...regexTokens);
+          }
+        } else {
+          result.push(token);
+        }
+      } else if (token !== undefined) {
+        result.push(token);
+      }
+      index += 1;
+    }
+
+    yield* result;
+  };
+}

package/src/package-checks/function-metrics/analyzer/shared/rubylike.ts

@@ -0,0 +1,161 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/rubylike.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript with source-aligned nested-state and
+ * callback sequencing for Ruby-like readers.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader, CodeStateMachine } from "./code-reader.ts";
+import { ScriptLanguageMixIn } from "./script-language.ts";
+
+/** The embedded-document substate from the upstream module. */
+export function state_embedded_doc(token: string): boolean {
+  return token === "=end";
+}
+
+/** Shared function/block state machine for Ruby-like languages. */
+export class RubylikeStateMachine extends CodeStateMachine {
+  protected static readonly FUNC_KEYWORD: string = "def";
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+  }
+
+  public override _state_global(token: string): void {
+    if (token === "end" || token === "}") {
+      this.returnFromState();
+    } else if (token === this.getFunctionKeyword()) {
+      this.next(this._def);
+    } else if (token === "it") {
+      this.next(this._it);
+    } else if (
+      ["begin", "do", "class", "module", "{", "${"].includes(token) &&
+      this.lastToken !== "."
+    ) {
+      this.subState(this.cloneState());
+    } else if (["while", "for"].includes(token)) {
+      if (this.is_newline()) this.next(this._for_while);
+    } else if (["if", "unless"].includes(token)) {
+      if (this.is_newline()) {
+        this.subState(this.cloneState());
+      } else {
+        this.next(this._if);
+      }
+    } else if (token === "=begin") {
+      this.subState(state_embedded_doc);
+    }
+  }
+
+  public is_newline(): boolean {
+    return this.context.newline || this.lastToken === ";";
+  }
+
+  private getFunctionKeyword(): string {
+    const StateMachine = this.stateMachineConstructor;
+    if (!hasFunctionKeyword(StateMachine)) return RubylikeStateMachine.FUNC_KEYWORD;
+    const keyword = StateMachine.FUNC_KEYWORD;
+    return typeof keyword === "string" ? keyword : RubylikeStateMachine.FUNC_KEYWORD;
+  }
+
+  /** Source `_def` seam used by Lua's `_anonymous_def` transition. */
+  protected readonly _def = (token: string): void => {
+    if (token === "(") {
+      this.context.pushNewFunction("(anonymous)");
+      this.next(this._def_parameters);
+      return;
+    }
+    this.context.pushNewFunction(token);
+    this.next(this._def_continue);
+  };
+
+  private readonly _it = (token: string): void => {
+    if (token === "do" || token === "{") {
+      this.context.pushNewFunction(this.lastToken ?? "");
+      this.next(this._def_continue);
+    }
+  };
+
+  /** Source `_def_continue` seam used by Lua _defs. */
+  protected readonly _def_continue = (token: string): void => {
+    const finishDefinition = (): void => {
+      this.context.endOfFunction();
+      this.next(this.globalState);
+    };
+
+    if (token === ".") {
+      this.context.addToFunctionName(token);
+      this.next(this._def_class_method);
+    } else if (token === "(") {
+      this.next(this._def_parameters);
+    } else {
+      this.subState(this.cloneState(), finishDefinition, token);
+    }
+  };
+
+  /** Source `_def_class_method` seam used by Lua _defs. */
+  protected readonly _def_class_method = (token: string): void => {
+    this.context.addToFunctionName(token);
+    this.next(this._def_continue);
+  };
+
+  /** Source `_def_parameters` seam used by Lua's `_anonymous_def` transition. */
+  protected readonly _def_parameters = (token: string): void => {
+    if (token === ")") {
+      this.next(this._def_continue);
+    } else {
+      this.context.parameter(token);
+      return;
+    }
+    this.context.addToLongFunctionName(` ${token}`);
+  };
+
+  private readonly _if = (token: string): void => {
+    if (this.is_newline()) {
+      this.next(this.globalState, token);
+    } else if (token === "then") {
+      this.next(this.globalState);
+      this.subState(this.cloneState());
+    }
+  };
+
+  private readonly _for_while = (token: string): void => {
+    if (this.is_newline() || token === "do") {
+      this.next(this.globalState);
+      if (token !== "end") this.subState(this.cloneState());
+    }
+  };
+}
+
+/** Shared reader configuration for Ruby-like languages. */
+export class RubylikeReader extends CodeReader {
+  public static override controlFlowKeywords: ReadonlySet<string> = new Set([
+    "if",
+    "elsif",
+    "elseif",
+    "until",
+    "for",
+    "while",
+    "rescue",
+    "ensure",
+    "when"
+  ]);
+  public static override logicalOperators: ReadonlySet<string> = new Set(["and", "or", "||", "&&"]);
+  public static override caseKeywords: ReadonlySet<string> = new Set();
+  public static override ternaryOperators: ReadonlySet<string> = new Set(["?"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new RubylikeStateMachine(context)];
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return ScriptLanguageMixIn.get_comment_from_token(token);
+  }
+}
+
+function hasFunctionKeyword(value: object): value is { readonly FUNC_KEYWORD?: unknown } {
+  return "FUNC_KEYWORD" in value;
+}

package/src/package-checks/function-metrics/analyzer/shared/script-language.ts

@@ -0,0 +1,50 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/script_language.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the source mixin's
+ * static comment and tokenizer members.
+ */
+
+import { CodeReader, type TokenFactory } from "./code-reader.ts";
+
+/** Common comment extraction and tokenization used by script-language readers. */
+export class ScriptLanguageMixIn {
+  public static get_comment_from_token(token: string): string | undefined {
+    if (!token.startsWith("#")) return undefined;
+
+    const stripped = token.replace(/^#+/u, "").trim();
+    if (
+      stripped.startsWith("lizard forgive global") ||
+      stripped.startsWith("#lizard forgive global")
+    ) {
+      return "#lizard forgive global";
+    }
+    if (stripped.startsWith("lizard forgive") || stripped.startsWith("#lizard forgive")) {
+      return "#lizard forgive";
+    }
+    return stripped;
+  }
+
+  public static generate_common_tokens(
+    sourceCode: string,
+    addition: string,
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CodeReader.generateTokens(sourceCode, String.raw`|#[^\n]*${addition}`, tokenFactory);
+  }
+
+  /** TS-facing call sites share the source methods' implementations. */
+  public static getCommentFromToken(token: string): string | undefined {
+    return this.get_comment_from_token(token);
+  }
+
+  public static generateCommonTokens(
+    sourceCode: string,
+    addition: string,
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return this.generate_common_tokens(sourceCode, addition, tokenFactory);
+  }
+}

package/src/package-checks/function-metrics/analyzer-adapter.ts

@@ -0,0 +1,84 @@
+import {
+  analyzeLizardSource,
+  isLizardSourceSupported,
+  lizardSourceExtensions,
+  type LizardFunctionInfo
+} from "./analyzer/port-facade.ts";
+import type { FunctionMetric } from "./measurement-model.ts";
+
+/** One parent-admitted source passed through the Product adapter to the Lizard port. */
+export interface FunctionMetricsAnalyzerSource {
+  readonly path: string;
+  readonly source: string;
+}
+
+/** The complete in-memory source batch that one Worker asks the adapter to analyze. */
+export interface FunctionMetricsAnalyzerInput {
+  readonly files: readonly FunctionMetricsAnalyzerSource[];
+}
+
+/** Product-facing result of a complete adapter analysis; failures never carry a prefix. */
+export type FunctionMetricsAnalyzerResult =
+  | Readonly<{ readonly kind: "analysis-failed" }>
+  | Readonly<{ readonly kind: "complete"; readonly metrics: readonly FunctionMetric[] }>;
+
+/** The translated port's fixed suffix capability, presented for functionMetrics selection. */
+export const FUNCTION_METRICS_SUPPORTED_FILE_EXTENSIONS = Object.freeze([
+  ...lizardSourceExtensions()
+]);
+
+/** Whether a Product-selected path is supported by the translated Lizard port. */
+export function isFunctionMetricsAnalyzerSourceSupported(filePath: string): boolean {
+  return isLizardSourceSupported(filePath);
+}
+
+/**
+ * Maps complete Lizard-domain analyses into the Product's function metrics.
+ * An unsupported source or analyzer exception discards every collected metric.
+ */
+export function analyzeFunctionMetricsSources(
+  input: FunctionMetricsAnalyzerInput
+): FunctionMetricsAnalyzerResult {
+  try {
+    const metrics: FunctionMetric[] = [];
+    for (const sourceFile of input.files) {
+      const analysis = analyzeLizardSource({
+        filename: sourceFile.path,
+        sourceCode: sourceFile.source
+      });
+      if (analysis === undefined) return analysisFailed();
+      for (const functionInfo of analysis.function_list) {
+        metrics.push(toFunctionMetric(sourceFile.path, functionInfo));
+      }
+    }
+    return Object.freeze({ kind: "complete", metrics: Object.freeze(metrics) });
+  } catch {
+    return analysisFailed();
+  }
+}
+
+function analysisFailed(): FunctionMetricsAnalyzerResult {
+  return Object.freeze({ kind: "analysis-failed" });
+}
+
+function toFunctionMetric(filePath: string, functionInfo: LizardFunctionInfo): FunctionMetric {
+  return Object.freeze({
+    complexityContributors: Object.freeze(
+      functionInfo.complex_tags.map(([token, line]) => Object.freeze({ line, token }))
+    ),
+    cyclomaticComplexity: Object.freeze({
+      source: "typescript-analyzer" as const,
+      value: functionInfo.cyclomatic_complexity
+    }),
+    endLine: functionInfo.end_line,
+    file: filePath,
+    lines: functionInfo.nloc,
+    name: functionInfo.name,
+    nestingDepth: Object.freeze({
+      source: "typescript-analyzer" as const,
+      value: functionInfo.max_nesting_depth
+    }),
+    parameterCount: functionInfo.parameter_count,
+    startLine: functionInfo.start_line
+  });
+}

package/src/package-checks/function-metrics/analyzer-worker-contract.ts

@@ -0,0 +1,10 @@
+import type {
+  FunctionMetricsAnalyzerInput,
+  FunctionMetricsAnalyzerResult
+} from "./analyzer-adapter.ts";
+
+/** Exact, already-admitted source texts passed from one functionMetrics Check to its Worker. */
+export type FunctionMetricsAnalysisWorkerRequest = FunctionMetricsAnalyzerInput;
+
+/** The one-shot Worker response; errors never carry partial measurements. */
+export type FunctionMetricsAnalysisWorkerResponse = FunctionMetricsAnalyzerResult;

package/src/package-checks/function-metrics/analyzer-worker-port.ts

@@ -0,0 +1,164 @@
+import { Worker } from "node:worker_threads";
+
+import type {
+  FunctionMetricsAnalysisWorkerRequest,
+  FunctionMetricsAnalysisWorkerResponse
+} from "./analyzer-worker-contract.ts";
+import type { FunctionMetric } from "./measurement-model.ts";
+
+type FunctionMetricsWorkerAnalysisResult = Readonly<
+  | { kind: "analysis-failed" }
+  | { kind: "cancelled" }
+  | { kind: "complete"; metrics: readonly FunctionMetric[] }
+>;
+
+export interface FunctionMetricsWorkerPort {
+  readonly postMessage: (value: unknown) => void;
+  readonly subscribe: (
+    listeners: Readonly<{
+      readonly error: () => void;
+      readonly exit: (code: number) => void;
+      readonly message: (value: unknown) => void;
+    }>
+  ) => () => void;
+  readonly terminate: () => void;
+}
+
+/** Creates the private Node Worker transport for one admitted analyzer batch. */
+export function createNodeFunctionMetricsWorker(): FunctionMetricsWorkerPort {
+  const worker = new Worker(new URL("./analyzer-worker.ts", import.meta.url));
+  return Object.freeze({
+    postMessage: (value: unknown): void => {
+      worker.postMessage(value);
+    },
+    subscribe: (listeners: Parameters<FunctionMetricsWorkerPort["subscribe"]>[0]): (() => void) => {
+      worker.once("message", listeners.message);
+      worker.once("error", listeners.error);
+      worker.once("exit", listeners.exit);
+      return (): void => {
+        worker.off("message", listeners.message);
+        worker.off("error", listeners.error);
+        worker.off("exit", listeners.exit);
+      };
+    },
+    terminate: (): void => {
+      void worker.terminate().catch(() => undefined);
+    }
+  });
+}
+
+/** Runs one admitted batch through a Worker and settles its transport exactly once. */
+export async function analyzeAdmittedSources(
+  request: FunctionMetricsAnalysisWorkerRequest,
+  approvedExactPaths: readonly string[],
+  signal: AbortSignal,
+  createWorker: () => FunctionMetricsWorkerPort
+): Promise<FunctionMetricsWorkerAnalysisResult> {
+  let worker: FunctionMetricsWorkerPort;
+  try {
+    worker = createWorker();
+  } catch {
+    return Object.freeze({ kind: "analysis-failed" });
+  }
+  return new Promise((resolveResult) => {
+    let settled = false;
+    let unsubscribe = (): void => {};
+    const finish = (result: FunctionMetricsWorkerAnalysisResult): void => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", cancelled);
+      unsubscribe();
+      worker.terminate();
+      resolveResult(result);
+    };
+    const cancelled = (): void => {
+      finish(Object.freeze({ kind: "cancelled" }));
+    };
+    unsubscribe = worker.subscribe({
+      error: () => {
+        finish(Object.freeze({ kind: "analysis-failed" }));
+      },
+      exit: () => {
+        finish(Object.freeze({ kind: "analysis-failed" }));
+      },
+      message: (value: unknown): void => {
+        if (signal.aborted) {
+          cancelled();
+          return;
+        }
+        finish(parseWorkerResponse(value, approvedExactPaths));
+      }
+    });
+    signal.addEventListener("abort", cancelled, { once: true });
+    if (signal.aborted) {
+      cancelled();
+      return;
+    }
+    try {
+      worker.postMessage(request);
+    } catch {
+      finish(Object.freeze({ kind: "analysis-failed" }));
+    }
+  });
+}
+
+function parseWorkerResponse(
+  value: unknown,
+  approvedExactPaths: readonly string[]
+): FunctionMetricsWorkerAnalysisResult {
+  if (!isWorkerResponse(value)) return Object.freeze({ kind: "analysis-failed" });
+  if (value.kind === "analysis-failed") return value;
+  const approvedPaths = new Set(approvedExactPaths);
+  return value.metrics.every((metric) => approvedPaths.has(metric.file))
+    ? Object.freeze({ kind: "complete", metrics: value.metrics })
+    : Object.freeze({ kind: "analysis-failed" });
+}
+
+function isWorkerResponse(value: unknown): value is FunctionMetricsAnalysisWorkerResponse {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "kind" in value &&
+    (value.kind === "analysis-failed" ||
+      (value.kind === "complete" &&
+        "metrics" in value &&
+        Array.isArray(value.metrics) &&
+        value.metrics.every(isFunctionMetric)))
+  );
+}
+
+function isFunctionMetric(value: unknown): value is FunctionMetric {
+  return (
+    isRecord(value) &&
+    hasFunctionMetricIdentity(value) &&
+    hasFunctionMetricMeasurements(value) &&
+    isTypeScriptAnalyzerCyclomaticComplexity(value.cyclomaticComplexity)
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function hasFunctionMetricIdentity(metric: Record<string, unknown>): boolean {
+  return typeof metric.file === "string" && typeof metric.name === "string";
+}
+
+function hasFunctionMetricMeasurements(metric: Record<string, unknown>): boolean {
+  return (
+    Number.isSafeInteger(metric.startLine) &&
+    Number.isSafeInteger(metric.endLine) &&
+    Number.isSafeInteger(metric.lines) &&
+    Number.isSafeInteger(metric.parameterCount)
+  );
+}
+
+function isTypeScriptAnalyzerCyclomaticComplexity(value: unknown): boolean {
+  return (
+    isRecord(value) && value.source === "typescript-analyzer" && isNullableSafeInteger(value.value)
+  );
+}
+
+function isNullableSafeInteger(value: unknown): boolean {
+  return value === null || (typeof value === "number" && Number.isSafeInteger(value));
+}