@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -0,0 +1,311 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py processor order, FileAnalyzer, map_files_to_analyzer,
+ * analyze_files, and extension lifecycle hooks.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0
+ * Modified: in-memory execution pipeline isolated from state and reporting.
+ */
+
+import {
+  invokeExtensionCall,
+  invokeExtensionCrossFileProcessOutcome,
+  invokeExtensionSetArgs
+} from "./extensions/protocol.ts";
+import type { ExtensionArgumentRegistrar } from "./extensions/protocol.ts";
+import type {
+  AnalyzerProcessor,
+  AnalyzerReader,
+  ReaderConstructor,
+  TokenProcessor,
+  TokenStream
+} from "./contracts.ts";
+import { FileInfoBuilder } from "./analysis-context.ts";
+import type { FileInformation } from "./analysis-model.ts";
+import { isPythonWhitespace, splitPythonLines } from "./shared/code-reader.ts";
+
+/** Python str.strip(), as used by the source comment-directive processor. */
+function stripPythonWhitespace(value: string): string {
+  const characters = Array.from(value);
+  let firstCharacter = 0;
+  while (
+    firstCharacter < characters.length &&
+    isPythonWhitespace(characters[firstCharacter] ?? "")
+  ) {
+    firstCharacter += 1;
+  }
+
+  let lastCharacter = characters.length;
+  while (
+    lastCharacter > firstCharacter &&
+    isPythonWhitespace(characters[lastCharacter - 1] ?? "")
+  ) {
+    lastCharacter -= 1;
+  }
+  return characters.slice(firstCharacter, lastCharacter).join("");
+}
+
+export function preprocessing(tokens: TokenStream, reader: AnalyzerReader): TokenStream {
+  return reader.preprocess?.(tokens) ?? withoutWhitespace(tokens);
+}
+
+/** Upstream comment directive and generated-code handling. */
+export function* commentCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+  for (const token of tokens) {
+    const comment = reader.getCommentFromToken(token);
+    if (comment === undefined) {
+      yield token;
+      continue;
+    }
+
+    for (const _line of splitPythonLines(comment).slice(1)) {
+      yield "\n";
+    }
+
+    const strippedComment = stripPythonWhitespace(comment);
+    if (strippedComment.startsWith("#lizard forgive global")) {
+      reader.context.forgiveGlobal = true;
+    } else if (strippedComment.startsWith("#lizard forgives(")) {
+      const metricMatch = /#lizard forgives?\(([^)]*)\)/u.exec(strippedComment);
+      if (metricMatch?.[1]) {
+        for (const metric of metricMatch[1].split(",")) {
+          const trimmedMetric = stripPythonWhitespace(metric);
+          if (trimmedMetric) reader.context.currentFunction.forgivenMetrics.add(trimmedMetric);
+        }
+      }
+    } else if (strippedComment.startsWith("#lizard forgive")) {
+      reader.context.forgive = true;
+    }
+
+    if (comment.includes("GENERATED CODE")) return;
+  }
+}
+
+/** Upstream non-comment source-line counting. */
+export function* lineCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+  const { context } = reader;
+  context.currentLine = 1;
+  let newline = 1;
+
+  for (const token of tokens) {
+    if (token === "\n") {
+      context.currentLine += 1;
+      newline = 1;
+      continue;
+    }
+
+    const embeddedNewlineCount = token.split("\n").length - 1;
+    context.currentLine += embeddedNewlineCount;
+    context.addNloc(embeddedNewlineCount + newline);
+    newline = 0;
+    yield token;
+  }
+}
+
+/** Upstream file and current-function token counting. */
+export function* tokenCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+  const { context } = reader;
+  for (const token of tokens) {
+    context.fileinfo.tokenCount += 1;
+    context.currentFunction.tokenCount += 1;
+    yield token;
+  }
+}
+
+/** Upstream cyclomatic-condition counting. */
+export function* conditionCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+  for (const token of tokens) {
+    if (reader.conditions.has(token)) reader.context.addCondition();
+    yield token;
+  }
+}
+
+/** The ordered default processor list from lizard.py:get_extensions. */
+export const DEFAULT_TOKEN_PROCESSORS: readonly TokenProcessor[] = Object.freeze([
+  preprocessing,
+  commentCounter,
+  lineCounter,
+  tokenCounter,
+  conditionCounter
+]);
+
+/**
+ * Drives the in-memory half of upstream FileAnalyzer.  Reader registry and
+ * filesystem decoding stay at the product integration boundary, so callers
+ * supply the concrete reader explicitly.
+ */
+export class FileAnalyzer {
+  public readonly processors: readonly AnalyzerProcessor[];
+
+  public constructor(processors: readonly AnalyzerProcessor[] = DEFAULT_TOKEN_PROCESSORS) {
+    this.processors = processors;
+  }
+
+  public analyzeSourceCode<Reader extends AnalyzerReader>(
+    filename: string,
+    sourceCode: string,
+    Reader: ReaderConstructor<Reader>
+  ): FileInformation {
+    const context = new FileInfoBuilder(filename);
+    const reader = new Reader(context);
+    let tokens = Reader.generateTokens(sourceCode);
+
+    try {
+      for (const processor of this.processors) tokens = applyProcessor(processor, tokens, reader);
+      for (const _token of reader.__call__(tokens, reader)) {
+        // The reader drives its state machine while the in-memory pipeline drains.
+      }
+    } catch (error: unknown) {
+      if (!isRecursionLimit(error)) throw error;
+    }
+
+    return context.fileinfo;
+  }
+
+  /** Source `analyze_source_code` spelling retained for translated extension/core callers. */
+  public analyze_source_code<Reader extends AnalyzerReader>(
+    filename: string,
+    sourceCode: string,
+    Reader: ReaderConstructor<Reader>
+  ): FileInformation {
+    return this.analyzeSourceCode(filename, sourceCode, Reader);
+  }
+}
+
+/** The source-aligned default analyzer has only the five core processors. */
+export const DEFAULT_FILE_ANALYZER = new FileAnalyzer(DEFAULT_TOKEN_PROCESSORS);
+
+/**
+ * One already-admitted source unit at the in-memory boundary. File discovery,
+ * decoding and reader selection stay outside this source-aligned core.
+ */
+export interface InMemoryAnalyzerFile {
+  readonly filename: string;
+  readonly sourceCode: string;
+  readonly reader: ReaderConstructor;
+}
+
+/**
+ * Source-aligned `map_files_to_analyzer` after the explicitly excluded file
+ * opening/multiprocessing entry surface has supplied in-memory source units.
+ */
+export function mapFilesToAnalyzer(
+  files: Iterable<InMemoryAnalyzerFile>,
+  analyzer: FileAnalyzer,
+  workingThreads: number
+): Iterable<FileInformation> {
+  // The Product owns Worker scheduling. Retain the source argument/lifecycle
+  // without creating a second analyzer-level concurrency framework.
+  void workingThreads;
+  return mapInMemoryFiles(files, analyzer);
+}
+
+/** Source `map_files_to_analyzer` spelling for the retained in-memory lifecycle. */
+export function map_files_to_analyzer(
+  files: Iterable<InMemoryAnalyzerFile>,
+  analyzer: FileAnalyzer,
+  workingThreads: number
+): Iterable<FileInformation> {
+  return mapFilesToAnalyzer(files, analyzer, workingThreads);
+}
+
+/**
+ * Source-aligned `analyze_files` lifecycle. `exts` intentionally uses Python
+ * truthiness: an omitted or empty list receives the five default processors.
+ */
+export function analyzeFiles(
+  files: Iterable<InMemoryAnalyzerFile>,
+  threads = 1,
+  exts?: readonly AnalyzerProcessor[]
+): Iterable<FileInformation> | undefined {
+  const extensions = exts !== undefined && exts.length > 0 ? exts : [...DEFAULT_TOKEN_PROCESSORS];
+  const fileAnalyzer = new FileAnalyzer(extensions);
+  let result: Iterable<FileInformation> | undefined = mapFilesToAnalyzer(
+    files,
+    fileAnalyzer,
+    threads
+  );
+  for (const extension of extensions) {
+    const outcome = invokeExtensionCrossFileProcessOutcome(extension, result);
+    if (outcome.hookPresent) result = outcome.result;
+  }
+  return result;
+}
+
+/** Source `analyze_files` spelling for translated internal callers. */
+export function analyze_files(
+  files: Iterable<InMemoryAnalyzerFile>,
+  threads = 1,
+  exts?: readonly AnalyzerProcessor[]
+): Iterable<FileInformation> | undefined {
+  return analyzeFiles(files, threads, exts);
+}
+
+/**
+ * Apply source registration-order cross-file passes. A present hook replaces
+ * the stream even when it returns undefined; only an absent hook is skipped.
+ */
+export function applyCrossFileProcessors(
+  fileInfos: Iterable<FileInformation>,
+  processors: readonly AnalyzerProcessor[]
+): Iterable<FileInformation> | undefined {
+  let processedFileInfos: Iterable<FileInformation> | undefined = fileInfos;
+  for (const processor of processors) {
+    const outcome = invokeExtensionCrossFileProcessOutcome(processor, processedFileInfos);
+    if (outcome.hookPresent) processedFileInfos = outcome.result;
+  }
+  return processedFileInfos;
+}
+
+/** Forward the internal parser seam to extensions in source registration order. */
+export function registerExtensionArguments(
+  processors: readonly AnalyzerProcessor[],
+  parser: ExtensionArgumentRegistrar
+): void {
+  for (const processor of processors) {
+    invokeExtensionSetArgs(processor, parser);
+  }
+}
+
+export function analyzeSourceCode<Reader extends AnalyzerReader>(
+  filename: string,
+  sourceCode: string,
+  Reader: ReaderConstructor<Reader>,
+  processors: readonly AnalyzerProcessor[] = DEFAULT_TOKEN_PROCESSORS
+): FileInformation {
+  if (processors === DEFAULT_TOKEN_PROCESSORS) {
+    return DEFAULT_FILE_ANALYZER.analyzeSourceCode(filename, sourceCode, Reader);
+  }
+  return new FileAnalyzer(processors).analyzeSourceCode(filename, sourceCode, Reader);
+}
+
+function* mapInMemoryFiles(
+  files: Iterable<InMemoryAnalyzerFile>,
+  analyzer: FileAnalyzer
+): Generator<FileInformation> {
+  for (const file of files) {
+    yield analyzer.analyze_source_code(file.filename, file.sourceCode, file.reader);
+  }
+}
+function applyProcessor(
+  processor: AnalyzerProcessor,
+  tokens: TokenStream,
+  reader: AnalyzerReader
+): TokenStream {
+  return typeof processor === "function"
+    ? processor(tokens, reader)
+    : invokeExtensionCall(processor, tokens, reader);
+}
+
+function isRecursionLimit(error: unknown): boolean {
+  return (
+    error instanceof RangeError &&
+    (error.message.includes("call stack") || error.message.toLowerCase().includes("recursion"))
+  );
+}
+
+function* withoutWhitespace(tokens: TokenStream): Generator<string> {
+  for (const token of tokens) {
+    if (!isPythonWhitespace(token) || token === "\n") yield token;
+  }
+}

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

@@ -0,0 +1,142 @@
+/**
+ * Check-private Lizard-domain entry for suffix capability and supplied-source
+ * analysis. Product input admission, I/O, cancellation, and metric mapping
+ * remain outside the source-aligned port.
+ */
+
+import { analyzeSourceCode } from "./pipeline.ts";
+import { getExtensions } from "./extensions/registry.ts";
+import { get_reader_for, languages, type RegisteredReader } from "./reader-registry.ts";
+
+/** A supplied in-memory source accepted by the Lizard-domain façade. */
+export interface LizardSourceInput {
+  readonly filename: string;
+  readonly sourceCode: string;
+}
+
+/** The Lizard function fields needed by the private Product adapter. */
+export interface LizardFunctionInfo {
+  readonly complex_tags: readonly LizardComplexityTag[];
+  readonly cyclomatic_complexity: number;
+  readonly end_line: number;
+  readonly filename: string;
+  readonly name: string;
+  readonly nloc: number;
+  readonly parameter_count: number;
+  readonly max_nesting_depth: number;
+  readonly start_line: number;
+}
+
+/** One source-ordered `[token, line]` contributor from lizardcomplextags.py. */
+export type LizardComplexityTag = readonly [token: string, line: number];
+
+/** In-memory Lizard analysis for one supplied source file. */
+export interface LizardSourceAnalysis {
+  readonly function_list: readonly LizardFunctionInfo[];
+}
+
+const readerByAsciiSuffix = new Map<string, RegisteredReader>();
+const extensionByCanonicalSuffix = new Map<string, string>();
+for (const reader of languages()) {
+  for (const extension of reader.ext) {
+    const canonicalSuffix = extension.toLowerCase();
+    if (!readerByAsciiSuffix.has(canonicalSuffix)) {
+      readerByAsciiSuffix.set(canonicalSuffix, reader);
+    }
+    extensionByCanonicalSuffix.set(canonicalSuffix, extension);
+  }
+}
+
+/** Source-order, first-wins resolver index; its contents remain private to this host seam. */
+const LIZARD_READER_BY_ASCII_SUFFIX: ReadonlyMap<string, RegisteredReader> = readerByAsciiSuffix;
+
+/** The source-order suffix set, deduplicated by the registry's case-insensitive matching. */
+const LIZARD_SOURCE_EXTENSIONS = Object.freeze([...extensionByCanonicalSuffix.values()]);
+const SELECTED_EXTENSION_PROCESSORS = Object.freeze(getExtensions(["complextags", "nd"]));
+
+/** Returns the fixed source-order suffix capability of the translated Lizard readers. */
+export function lizardSourceExtensions(): readonly string[] {
+  return LIZARD_SOURCE_EXTENSIONS;
+}
+
+/** Whether the translated Lizard registry can analyze this supplied filename. */
+export function isLizardSourceSupported(filename: string): boolean {
+  return resolveLizardReader(filename) !== undefined;
+}
+
+/**
+ * Analyzes one caller-supplied source with the matching translated reader.
+ * Unsupported suffixes remain outside the Lizard analysis result instead of
+ * being coerced into an empty analysis.
+ */
+export function analyzeLizardSource(input: LizardSourceInput): LizardSourceAnalysis | undefined {
+  const reader = resolveLizardReader(input.filename);
+  if (reader === undefined) return undefined;
+
+  const fileInformation = analyzeSourceCode(
+    input.filename,
+    input.sourceCode,
+    reader,
+    SELECTED_EXTENSION_PROCESSORS
+  );
+  return Object.freeze({
+    function_list: Object.freeze(
+      fileInformation.function_list.map((functionInfo) =>
+        Object.freeze({
+          complex_tags: Object.freeze(
+            (functionInfo.complex_tags ?? []).map(([token, line]) =>
+              Object.freeze([token, line] as LizardComplexityTag)
+            )
+          ),
+          cyclomatic_complexity: functionInfo.cyclomatic_complexity,
+          end_line: functionInfo.end_line,
+          filename: functionInfo.filename,
+          name: functionInfo.name,
+          nloc: functionInfo.nloc,
+          parameter_count: functionInfo.parameter_count,
+          max_nesting_depth: functionInfo.max_nesting_depth,
+          start_line: functionInfo.start_line
+        })
+      )
+    )
+  });
+}
+
+/**
+ * Keep source-order regex lookup for every filename shape outside the small,
+ * proven ASCII suffix grammar. The fast index is a façade-only host seam, not
+ * a second reader registry or a Product-facing reader capability.
+ */
+function resolveLizardReader(filename: string): RegisteredReader | undefined {
+  const suffix = asciiAlphanumericFinalSuffix(filename);
+  return suffix === undefined
+    ? get_reader_for(filename)
+    : LIZARD_READER_BY_ASCII_SUFFIX.get(suffix);
+}
+
+/**
+ * Accept only full ASCII filenames without JavaScript line terminators and
+ * with an ASCII-alphanumeric final suffix. Everything else keeps the source
+ * registry's `/iu` semantics through the fallback above.
+ */
+function asciiAlphanumericFinalSuffix(filename: string): string | undefined {
+  let finalDot = -1;
+  for (let index = 0; index < filename.length; index += 1) {
+    const character = filename.charCodeAt(index);
+    if (character > 0x7f || character === 0x0a || character === 0x0d) return undefined;
+    if (character === 0x2e) finalDot = index;
+  }
+
+  if (finalDot === -1 || finalDot === filename.length - 1) return undefined;
+
+  let suffix = "";
+  for (let index = finalDot + 1; index < filename.length; index += 1) {
+    const character = filename.charCodeAt(index);
+    const isAsciiDigit = character >= 0x30 && character <= 0x39;
+    const isAsciiLowercase = character >= 0x61 && character <= 0x7a;
+    const isAsciiUppercase = character >= 0x41 && character <= 0x5a;
+    if (!isAsciiDigit && !isAsciiLowercase && !isAsciiUppercase) return undefined;
+    suffix += String.fromCharCode(isAsciiUppercase ? character + 0x20 : character);
+  }
+  return suffix;
+}

package/src/package-checks/function-metrics/analyzer/reader-registry.ts

@@ -0,0 +1,84 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/__init__.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to an analyzer-internal ordered reader registry. Product
+ * admission and fallback policy remain outside this module.
+ */
+
+import type { ReaderConstructor } from "./contracts.ts";
+import { CSharpReader } from "./readers/csharp.ts";
+import { ErlangReader } from "./readers/erlang.ts";
+import { FortranReader } from "./readers/fortran.ts";
+import { GDScriptReader } from "./readers/gdscript.ts";
+import { GoReader } from "./readers/go.ts";
+import { JavaReader } from "./readers/java.ts";
+import { JavaScriptReader } from "./readers/javascript.ts";
+import { KotlinReader } from "./readers/kotlin.ts";
+import { LuaReader } from "./readers/lua.ts";
+import { ObjCReader } from "./readers/objc.ts";
+import { PerlReader } from "./readers/perl.ts";
+import { PHPReader } from "./readers/php.ts";
+import { PLSQLReader } from "./readers/plsql.ts";
+import { PythonReader } from "./readers/python.ts";
+import { RReader } from "./readers/r.ts";
+import { RubyReader } from "./readers/ruby.ts";
+import { RustReader } from "./readers/rust.ts";
+import { ScalaReader } from "./readers/scala.ts";
+import { SolidityReader } from "./readers/solidity.ts";
+import { StReader } from "./readers/st.ts";
+import { SwiftReader } from "./readers/swift.ts";
+import { TSXReader } from "./readers/tsx.ts";
+import { TTCNReader } from "./readers/ttcn.ts";
+import { TypeScriptReader } from "./readers/typescript.ts";
+import { VueReader } from "./readers/vue.ts";
+import { ZigReader } from "./readers/zig.ts";
+import { CLikeReader } from "./shared/clike.ts";
+
+/** A translated Lizard reader constructor with its source suffix matcher. */
+export interface RegisteredReader extends ReaderConstructor {
+  readonly ext: readonly string[];
+  matchFilename(filename: string): boolean;
+}
+
+/** Source-order equivalent of lizard_languages.languages(). */
+export function languages(): readonly RegisteredReader[] {
+  return [
+    CLikeReader,
+    JavaReader,
+    CSharpReader,
+    JavaScriptReader,
+    PythonReader,
+    ObjCReader,
+    TTCNReader,
+    RubyReader,
+    PHPReader,
+    SwiftReader,
+    ScalaReader,
+    GDScriptReader,
+    GoReader,
+    LuaReader,
+    RustReader,
+    TypeScriptReader,
+    FortranReader,
+    KotlinReader,
+    SolidityReader,
+    ErlangReader,
+    ZigReader,
+    TSXReader,
+    VueReader,
+    PerlReader,
+    StReader,
+    RReader,
+    PLSQLReader
+  ];
+}
+
+/** Source-order suffix lookup. Unknown suffixes deliberately remain unsupported here. */
+export function get_reader_for(filename: string): RegisteredReader | undefined {
+  for (const reader of languages()) {
+    if (reader.matchFilename(filename)) return reader;
+  }
+  return undefined;
+}

package/src/package-checks/function-metrics/analyzer/readers/csharp.ts

@@ -0,0 +1,110 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/csharp.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the source CLikeStates
+ * overrides for class declarations and expression-bodied members.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeNestingStackStates, CLikeReader, CLikeStates } from "../shared/clike.ts";
+import type { TokenFactory } from "../shared/code-reader.ts";
+
+/** C# reader with source-derived condition categories and parallel states. */
+export class CSharpReader extends CLikeReader {
+  public static override ext: readonly string[] = ["cs"];
+  public static override languageNames: readonly string[] = ["csharp"];
+  public static override controlFlowKeywords = new Set(["if", "for", "while", "catch"]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set(["case"]);
+  public static override ternaryOperators = new Set(["?", "??"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new CSharpStates(context), new CLikeNestingStackStates(context)];
+  }
+
+  public static override generateTokens(
+    sourceCode: string,
+    _addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CLikeReader.generateTokens(sourceCode, String.raw`|(?:\?\?)`, tokenFactory);
+  }
+}
+
+/** Direct translation of lizard_languages.csharp.CSharpStates. */
+class CSharpStates extends CLikeStates {
+  private in_primary_constructor = false;
+  private class_name: string | undefined;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+  }
+
+  public override statemachine_clone(): CSharpStates {
+    return new CSharpStates(this.context);
+  }
+
+  public override try_new_function(name: string): void {
+    if (this.in_primary_constructor) return;
+    super.try_new_function(name);
+    if (this.class_name !== undefined && this.context.currentFunction !== undefined) {
+      this.context.currentFunction.name = `${this.class_name}::${name}`;
+    }
+  }
+
+  protected override _state_dec_to_imp(token: string): void {
+    if (token === "=>") {
+      this.context.confirmNewFunction();
+      this.next(this._state_expression_body);
+      return;
+    }
+    super._state_dec_to_imp(token);
+  }
+
+  private readonly _state_expression_body = (token: string): void => {
+    if (token === ";") {
+      this.context.endOfFunction();
+      this.next(this.globalState);
+    }
+  };
+
+  public override _state_global(token: string): void {
+    if (["class", "struct", "record"].includes(token)) {
+      this.class_name = undefined;
+      this.next(this._state_class_declaration);
+      return;
+    }
+    super._state_global(token);
+  }
+
+  private readonly _state_class_declaration = (token: string): void => {
+    if (token === "(") {
+      this.in_primary_constructor = true;
+      this.next(this._state_primary_constructor);
+    } else if (token === "{") {
+      this.next(this.globalState);
+    } else if (isAlphabetic(token) && this.class_name === undefined) {
+      this.class_name = token;
+    }
+  };
+
+  private readonly _state_primary_constructor = (token: string): void => {
+    this.readInsideBracketsThen(
+      "()",
+      token,
+      this.finishPrimaryConstructor,
+      this._state_class_declaration
+    );
+  };
+
+  private readonly finishPrimaryConstructor = (_token: string): void => {
+    this.in_primary_constructor = false;
+  };
+}
+
+function isAlphabetic(token: string): boolean {
+  return /^\p{L}/u.test(token);
+}