@zxyycom/vibe-check 0.0.1 → 0.0.2

package/types/package-checks/file-metrics/scc/parser.d.ts

@@ -1,7 +1,7 @@
 import type { ExactInputMeasurement } from "../../project-files/exact-input-measurement.ts";
 import type { FileMetric } from "../measurement-model.ts";
-export declare const SCC_VERSION = "3.7.0";
-export declare const SCC_VERSION_OUTPUT = "scc version 3.7.0";
+export declare const SCC_VERSION = "4.0.0";
+export declare const SCC_VERSION_OUTPUT = "scc version 4.0.0";
 export declare const SCC_BY_FILE_CSV_HEADER = "Language,Provider,Filename,Lines,Code,Comments,Blanks,Complexity,Bytes,ULOC";
 export type SccScanResult = {
     readonly measurements: readonly ExactInputMeasurement<FileMetric>[];
@@ -14,12 +14,12 @@ export type SccScanResult = {
 /**
  * 解析 scc CSV 输出。
  *
- * scc 3.7.0 `--by-file --format csv` 列：
+ * scc 4.0.0 `--no-config --by-file --format csv` 列：
  * Language,Provider,Filename,Lines,Code,Comments,Blanks,Complexity,Bytes,ULOC
  *
  * - Lines 包含所有行（code + comments + blanks）
  * - Code 是文件级代码行数，用于 code-line finding
  * - Complexity 是 scc complexitychecks token 命中数，用于 low-decision-token allowance，不是函数级 CC
- * - ULOC (Usable Lines of Code) 由 3.7.0 输出，但首期不进入稳定 metrics
+ * - ULOC (Usable Lines of Code) 由 4.0.0 输出，但首期不进入稳定 metrics
  */
 export declare function parseSccCSV(csv: string, cwd: string): SccScanResult;

package/types/package-checks/function-metrics/analysis.d.ts

@@ -6,5 +6,5 @@ export interface FunctionMetricInstance {
 export interface FunctionMetricAnalysis {
     readonly instances: readonly FunctionMetricInstance[];
 }
-export declare function analyzeFunctionMetrics(metrics: readonly FunctionMetric[]): FunctionMetricAnalysis | undefined;
+export declare function analyzeFunctionMetrics(metrics: readonly unknown[]): FunctionMetricAnalysis | undefined;
 export declare function isStableFunctionName(name: string): boolean;

package/types/package-checks/function-metrics/analyzer/analysis-context.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py nesting stack and FileInfoBuilder lifecycle;
+ * lizard_ext/lizardnd.py typed FileInfoBuilder lifecycle seam.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0 AND MIT
+ * Modified: mutable analysis context isolated from result models and pipeline.
+ */
+import { FunctionInfo, FileInformation, Nesting } from "./analysis-model.ts";
+export interface NestingStackLike {
+    withNamespace(name: string): string;
+    addBareNesting(): void;
+    addNamespace(token: string): void;
+    startNewFunctionNesting(functionInfo: FunctionInfo): void;
+    popNesting(): Nesting | undefined;
+    readonly currentNestingLevel: number;
+    readonly lastFunction: FunctionInfo | undefined;
+}
+/**
+ * The source spelling exposed by Python's FileInfoBuilder.__getattr__.
+ *
+ * A translated extension may only implement the methods it decorates, as
+ * lizardduplicate's NestingStackWithUnifiedTokens does. The adapter below
+ * supplies all remaining names from its wrapped stack just like __getattr__.
+ */
+export interface SourceNestingStackLike {
+    nesting_stack: Nesting[];
+    pending_function: FunctionInfo | undefined;
+    with_namespace(name: string): string;
+    add_bare_nesting(): void;
+    add_namespace(token: string): void;
+    start_new_function_nesting(functionInfo: FunctionInfo): void;
+    pop_nesting(): Nesting | undefined;
+    readonly current_nesting_level: number;
+    readonly last_function: FunctionInfo | undefined;
+}
+/** The complete spelling bridge passed to source-aligned nesting decorators. */
+export interface NestingStackAdapter extends NestingStackLike, SourceNestingStackLike {
+}
+/** A source-aligned nesting-stack decorator constructor. */
+export interface NestingStackDecorator<Decorated extends object = NestingStackLike> {
+    new (decorated: NestingStackAdapter): Decorated;
+}
+/** The nesting stack that readers use to qualify and complete functions. */
+export declare class NestingStack implements NestingStackAdapter {
+    private nestingStack;
+    private pendingFunction;
+    /** Source-name aliases retain the mutable stack storage for decorators. */
+    get nesting_stack(): Nesting[];
+    set nesting_stack(value: Nesting[]);
+    get pending_function(): FunctionInfo | undefined;
+    set pending_function(value: FunctionInfo | undefined);
+    withNamespace(name: string): string;
+    with_namespace(name: string): string;
+    addBareNesting(): void;
+    add_bare_nesting(): void;
+    addNamespace(token: string): void;
+    add_namespace(token: string): void;
+    startNewFunctionNesting(functionInfo: FunctionInfo): void;
+    start_new_function_nesting(functionInfo: FunctionInfo): void;
+    popNesting(): Nesting | undefined;
+    pop_nesting(): Nesting | undefined;
+    get currentNestingLevel(): number;
+    get current_nesting_level(): number;
+    get lastFunction(): FunctionInfo | undefined;
+    get last_function(): FunctionInfo | undefined;
+    private createNesting;
+}
+/**
+ * The reader context used to build one file and its function list.  It keeps
+ * the mutable state that upstream readers intentionally share across stages.
+ */
+export declare class FileInfoBuilder {
+    fileinfo: FileInformation;
+    currentLine: number;
+    forgive: boolean;
+    forgiveGlobal: boolean;
+    newline: boolean;
+    globalPseudoFunction: FunctionInfo;
+    currentFunction: FunctionInfo;
+    stackedFunctions: FunctionInfo[];
+    private nestingStack;
+    private readonly decoratedStackFallbacks;
+    constructor(filename: string);
+    /**
+     * These aliases preserve the source extension/context protocol while keeping
+     * a single mutable storage location for each analyzer value.
+     */
+    get current_line(): number;
+    set current_line(value: number);
+    get forgive_global(): boolean;
+    set forgive_global(value: boolean);
+    get global_pseudo_function(): FunctionInfo;
+    set global_pseudo_function(value: FunctionInfo);
+    get current_function(): FunctionInfo;
+    set current_function(value: FunctionInfo);
+    get stacked_functions(): FunctionInfo[];
+    set stacked_functions(value: FunctionInfo[]);
+    get _nesting_stack(): object;
+    set _nesting_stack(value: object);
+    withNamespace(name: string): string;
+    with_namespace(name: string): string;
+    addBareNesting(): void;
+    add_bare_nesting(): void;
+    addNamespace(token: string): void;
+    add_namespace(token: string): void;
+    startNewFunctionNesting(functionInfo: FunctionInfo): void;
+    start_new_function_nesting(functionInfo: FunctionInfo): void;
+    get currentNestingLevel(): number;
+    get current_nesting_level(): number;
+    get lastFunction(): FunctionInfo | undefined;
+    get last_function(): FunctionInfo | undefined;
+    /** Equivalent to Python's decorate_nesting_stack extension seam. */
+    decorateNestingStack<Decorated extends object>(decorateClass: NestingStackDecorator<Decorated>): Decorated;
+    decorate_nesting_stack<Decorated extends object>(decorateClass: NestingStackDecorator<Decorated>): Decorated;
+    popNesting(): void;
+    pop_nesting(): void;
+    private finishPoppedNesting;
+    addNloc(count: number): void;
+    add_nloc(count: number): void;
+    tryNewFunction(name: string): void;
+    try_new_function(name: string): void;
+    confirmNewFunction(): void;
+    confirm_new_function(): void;
+    restartNewFunction(name: string): void;
+    restart_new_function(name: string): void;
+    pushNewFunction(name: string): void;
+    push_new_function(name: string): void;
+    addCondition(increment?: number): void;
+    add_condition(increment?: number): void;
+    /** Source lizardnd.py's monkey-patched FileInfoBuilder method surface. */
+    addNdCondition(increment?: number): number;
+    add_nd_condition(increment?: number): number;
+    resetNdComplexity(): void;
+    reset_nd_complexity(): void;
+    addHiddenBracketCondition(increment?: number): void;
+    add_hidden_bracket_condition(increment?: number): void;
+    getHiddenBracket(): number;
+    get_hidden_bracket(): number;
+    loopBracketStatus(): void;
+    loop_bracket_status(): void;
+    getLoopStatus(): boolean;
+    get_loop_status(): boolean;
+    setInCondition(inCondition: boolean): void;
+    set_in_condition(inCondition: boolean): void;
+    getInCondition(): boolean;
+    get_in_condition(): boolean;
+    incrementConditionDepth(): void;
+    increment_condition_depth(): void;
+    decrementConditionDepth(): void;
+    decrement_condition_depth(): void;
+    getConditionDepth(): number;
+    get_condition_depth(): number;
+    resetConditionTracking(): void;
+    reset_condition_tracking(): void;
+    setLogicalOperatorAdded(added: boolean): void;
+    set_logical_operator_added(added: boolean): void;
+    getLogicalOperatorAdded(): boolean;
+    get_logical_operator_added(): boolean;
+    setPrevWasElse(value: boolean): void;
+    set_prev_was_else(value: boolean): void;
+    getPrevWasElse(): boolean;
+    get_prev_was_else(): boolean;
+    clearPrevWasElse(): void;
+    clear_prev_was_else(): void;
+    addToLongFunctionName(appended: string): void;
+    add_to_long_function_name(appended: string): void;
+    addToFunctionName(appended: string): void;
+    add_to_function_name(appended: string): void;
+    parameter(token: string): void;
+    endOfFunction(): void;
+    end_of_function(): void;
+    private get nestingStackAdapter();
+}

package/types/package-checks/function-metrics/analyzer/analysis-model.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py FunctionInfo and FileInformation; lizard_ext/lizardcomplextags.py
+ * and lizard_ext/lizardnd.py FunctionInfo lifecycle seams.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0 AND MIT
+ * Modified: mutable analysis result state isolated from execution and reporting.
+ */
+export declare class AttributeError extends Error {
+    constructor(targetName: string, attributeName: string);
+}
+/** One lexical nesting level. */
+export declare class Nesting {
+    get nameInSpace(): string;
+    get name_in_space(): string;
+}
+export declare const BARE_NESTING: Nesting;
+/** A named namespace/class scope in a function name. */
+export declare class Namespace extends Nesting {
+    readonly name: string;
+    constructor(name: string);
+    get nameInSpace(): string;
+}
+/** Lizard's mutable per-function metrics model. */
+export declare class FunctionInfo extends Nesting {
+    name: string;
+    filename: string;
+    startLine: number;
+    cyclomaticComplexity: number;
+    nloc: number;
+    tokenCount: number;
+    longName: string;
+    endLine: number;
+    fullParameters: string[];
+    topNestingLevel: number;
+    fanIn: number;
+    fanOut: number;
+    generalFanOut: number;
+    maxNestingDepth: number;
+    /** Source lizardcomplextags.py storage; absent until its processor observes a token. */
+    complexTags: [string, number][] | undefined;
+    /** Source lizardnd.py's per-function mutable processor state. */
+    nestingDepth: number;
+    hiddenBracket: number;
+    bracketLoop: boolean;
+    inCondition: boolean;
+    conditionDepth: number;
+    logicalOperatorAdded: boolean;
+    prevWasElse: boolean;
+    forgivenMetrics: Set<string>;
+    constructor(name: string, filename: string, startLine?: number, ccn?: number);
+    /**
+     * Source-name aliases share the camel-case storage above.  They are an
+     * analyzer-internal translation seam for extension bodies, not a Product API.
+     */
+    get cyclomatic_complexity(): number;
+    set cyclomatic_complexity(value: number);
+    get token_count(): number;
+    set token_count(value: number);
+    get long_name(): string;
+    set long_name(value: string);
+    get start_line(): number;
+    set start_line(value: number);
+    get end_line(): number;
+    set end_line(value: number);
+    get full_parameters(): string[];
+    set full_parameters(value: string[]);
+    get top_nesting_level(): number;
+    set top_nesting_level(value: number);
+    get fan_in(): number;
+    set fan_in(value: number);
+    get fan_out(): number;
+    set fan_out(value: number);
+    get general_fan_out(): number;
+    set general_fan_out(value: number);
+    get max_nesting_depth(): number;
+    set max_nesting_depth(value: number);
+    get complex_tags(): [string, number][] | undefined;
+    set complex_tags(value: [string, number][] | undefined);
+    get nesting_depth(): number;
+    set nesting_depth(value: number);
+    get hidden_bracket(): number;
+    set hidden_bracket(value: number);
+    get bracket_loop(): boolean;
+    set bracket_loop(value: boolean);
+    get in_condition(): boolean;
+    set in_condition(value: boolean);
+    get condition_depth(): number;
+    set condition_depth(value: number);
+    get logical_operator_added(): boolean;
+    set logical_operator_added(value: boolean);
+    get prev_was_else(): boolean;
+    set prev_was_else(value: boolean);
+    get forgiven_metrics(): Set<string>;
+    set forgiven_metrics(value: Set<string>);
+    get nameInSpace(): string;
+    get unqualifiedName(): string;
+    get unqualified_name(): string;
+    get location(): string;
+    get parameterCount(): number;
+    get parameter_count(): number;
+    get parameters(): string[];
+    get length(): number;
+    addToFunctionName(appended: string): void;
+    add_to_function_name(appended: string): void;
+    addToLongName(appended: string): void;
+    add_to_long_name(appended: string): void;
+    addParameter(token: string): void;
+    add_parameter(token: string): void;
+}
+/** Lizard's mutable aggregate for a single source file. */
+export declare class FileInformation {
+    filename: string;
+    nloc: number;
+    functionList: FunctionInfo[];
+    tokenCount: number;
+    constructor(filename: string, nloc: number, functionList?: FunctionInfo[]);
+    /** Source-name aliases share the camel-case storage for internal extensions. */
+    get function_list(): FunctionInfo[];
+    set function_list(value: FunctionInfo[]);
+    get token_count(): number;
+    set token_count(value: number);
+    get averageNloc(): number;
+    get average_nloc(): number;
+    get averageTokenCount(): number;
+    get average_token_count(): number;
+    get averageCyclomaticComplexity(): number;
+    get average_cyclomatic_complexity(): number;
+    get ccn(): number;
+    get CCN(): number;
+    get nestingDepth(): number;
+    get ND(): number;
+    functionsAverage(attribute: string): number;
+    functions_average(attribute: string): number;
+}

package/types/package-checks/function-metrics/analyzer/contracts.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Analyzer-internal TypeScript contracts for reader and token-processor composition.
+ * This type-only host seam is erased at runtime: it neither copies nor implements
+ * translated Lizard behavior and is intentionally outside translated-source provenance.
+ */
+import type { FileInfoBuilder } from "./analysis-context.ts";
+import type { LizardExtension } from "./extensions/protocol.ts";
+export type TokenStream = Iterable<string>;
+/** The minimum reader contract used by the in-memory Lizard pipeline. */
+export interface AnalyzerReader {
+    readonly conditions: ReadonlySet<string>;
+    readonly controlFlowKeywords: ReadonlySet<string>;
+    readonly logicalOperators: ReadonlySet<string>;
+    readonly caseKeywords: ReadonlySet<string>;
+    readonly ternaryOperators: ReadonlySet<string>;
+    readonly control_flow_keywords: ReadonlySet<string>;
+    readonly logical_operators: ReadonlySet<string>;
+    readonly case_keywords: ReadonlySet<string>;
+    readonly ternary_operators: ReadonlySet<string>;
+    readonly ext: readonly string[];
+    readonly languages: unknown;
+    readonly languageNames: readonly string[];
+    /** Source `language_names` alias used by translated internal extensions. */
+    readonly language_names: readonly string[];
+    readonly extraSubclasses: ReadonlySet<unknown>;
+    readonly extra_subclasses: ReadonlySet<unknown>;
+    readonly parallelStates: readonly unknown[];
+    readonly parallel_states: readonly unknown[];
+    readonly context: FileInfoBuilder;
+    /** Optional source reader attributes consumed by lizardnd.py. */
+    readonly loops?: readonly string[] | ReadonlySet<string>;
+    readonly bracket?: string;
+    readonly loop_indicator?: string;
+    readonly indent_indicator?: string;
+    __call__(tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+    getCommentFromToken(token: string): string | undefined;
+    process(tokens: TokenStream): TokenStream;
+    preprocess?(tokens: TokenStream): TokenStream;
+}
+/** A concrete reader supplies its tokenizer and receives a per-file context. */
+export interface ReaderConstructor<Reader extends AnalyzerReader = AnalyzerReader> {
+    new (context: FileInfoBuilder): Reader;
+    generateTokens(sourceCode: string): TokenStream;
+}
+/** One source-aligned stage between tokenization and reader state processing. */
+export type TokenProcessor = (tokens: TokenStream, reader: AnalyzerReader) => TokenStream;
+/** A core processor or one internal Lizard extension processor. */
+export type AnalyzerProcessor = TokenProcessor | LizardExtension;

package/types/package-checks/function-metrics/analyzer/extensions/lizardcomplextags.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/lizardcomplextags.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: mechanically translated to the Check-private TypeScript port.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { LizardExtension as LizardExtensionProtocol } from "./protocol.ts";
+/** Records every source reader condition token with its current source line. */
+export declare class LizardExtension implements LizardExtensionProtocol {
+    __call__(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/extensions/lizardnd.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/lizardnd.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the Check-private TypeScript port. Python's
+ * import-time FileInfoBuilder/FunctionInfo monkey patches are represented by
+ * typed private members on those host classes in analysis-context.ts and analysis-model.ts.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { ExtensionArgumentRegistrar, LizardExtension as LizardExtensionProtocol } from "./protocol.ts";
+export declare const DEFAULT_ND_THRESHOLD = 7;
+/** Source lizardnd.py processor and its FUNCTION_INFO/set_args lifecycle. */
+export declare class LizardExtension implements LizardExtensionProtocol {
+    static readonly FUNCTION_INFO: {
+        max_nesting_depth: {
+            caption: string;
+            average_caption: string;
+        };
+    };
+    static set_args(parser: ExtensionArgumentRegistrar): void;
+    __call__(tokens: TokenStream, reader: AnalyzerReader, lDepth?: number): Generator<string>;
+}
+/** Source lizardnd.py's FileInfoBuilder patch target, supplied by analysis-context.ts. */
+export type NDFileInfoAddition = Pick<FileInfoBuilder, "add_nd_condition" | "reset_nd_complexity" | "add_hidden_bracket_condition" | "get_hidden_bracket" | "loop_bracket_status" | "get_loop_status" | "set_in_condition" | "get_in_condition" | "increment_condition_depth" | "decrement_condition_depth" | "get_condition_depth" | "reset_condition_tracking" | "set_logical_operator_added" | "get_logical_operator_added" | "set_prev_was_else" | "get_prev_was_else" | "clear_prev_was_else">;
+/** Source check_loop_brackets; TypeScript returns no value like Python. */
+export declare function check_loop_brackets(context: FileInfoBuilder, lDepth: number, hiddenBrackets: number): void;

package/types/package-checks/function-metrics/analyzer/extensions/protocol.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard_ext/extension_base.py and lizard_ext/lizard*.py extension
+ * contracts.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the analyzer-internal extension protocol; this is
+ * not exported through the product API as a plugin surface.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInformation } from "../analysis-model.ts";
+/** Metadata an extension contributes to FunctionInfo/report schemas. */
+export interface FunctionInfoDefinition {
+    readonly caption?: string;
+    readonly average_caption?: string;
+}
+/** The source-aligned FUNCTION_INFO mapping owned by one extension. */
+export type FunctionInfoDefinitions = Readonly<Record<string, FunctionInfoDefinition>>;
+/** Python `argparse.add_argument` keyword options used by translated bodies. */
+export interface ExtensionArgumentKeywordOptions {
+    readonly default?: number;
+    readonly dest?: string;
+    readonly help?: string;
+    /** The source `type=int` conversion contract. */
+    readonly type?: "int";
+}
+/** The minimal internal parser seam consumed by source set_args hooks. */
+export interface ExtensionArgumentRegistrar {
+    add_argument(...arguments_: readonly (string | ExtensionArgumentKeywordOptions)[]): void;
+}
+/** A source-aligned extension token processor. */
+export type ExtensionCall = (tokens: TokenStream, reader: AnalyzerReader) => TokenStream;
+/** A source-aligned extension cross-file processor. */
+export type ExtensionCrossFileProcess = {
+    bivarianceHack(fileInfos: Iterable<FileInformation> | undefined): Iterable<FileInformation> | undefined;
+}["bivarianceHack"];
+/** Preserve the distinction between an absent hook and a present hook returning undefined. */
+export type ExtensionCrossFileProcessOutcome = {
+    readonly hookPresent: false;
+} | {
+    readonly hookPresent: true;
+    readonly result: Iterable<FileInformation> | undefined;
+};
+/** A source-aligned extension result printer. */
+export type ExtensionPrintResult = () => void;
+/** A source-aligned extension argument registrar. */
+export type ExtensionSetArgs = (parser: ExtensionArgumentRegistrar) => void;
+/**
+ * The internal protocol shared by translated Lizard extension bodies.  Hooks
+ * are optional here because Python permits class-level static hooks that are
+ * resolved from an instantiated extension.
+ */
+export interface LizardExtension {
+    __call__?: ExtensionCall;
+    readonly ordering_index?: number;
+    readonly FUNCTION_INFO?: FunctionInfoDefinitions;
+    readonly silent_all_others?: boolean;
+    cross_file_process?: ExtensionCrossFileProcess;
+    print_result?: ExtensionPrintResult;
+    set_args?: ExtensionSetArgs;
+}
+/** Python resolves extension class attributes and static methods through instances. */
+export interface LizardExtensionClassMetadata {
+    readonly ordering_index?: number;
+    readonly FUNCTION_INFO?: FunctionInfoDefinitions;
+    readonly silent_all_others?: boolean;
+}
+/** A directly registered class is an opaque descriptor, not a constructor to invoke at load time. */
+export type LizardExtensionConstructor = LizardExtensionClassMetadata & {
+    readonly prototype: LizardExtension;
+};
+/** One non-string value retained verbatim by source-aligned registration. */
+export type RegisteredLizardExtension = LizardExtension | LizardExtensionConstructor;
+/** Any processor object on which upstream performs hasattr-style lifecycle lookup. */
+export type LizardExtensionDescriptor = object;
+/** Accepted internal extension registration inputs. */
+export type ExtensionInput = string | RegisteredLizardExtension;
+/** Ordinary hook names resolved through Python's instance attribute lookup. */
+export type ExtensionHookName = "cross_file_process" | "print_result" | "set_args";
+/** Resolve metadata with the same descriptor precedence used by extension hooks. */
+export declare function extensionMetadata(extension: LizardExtensionDescriptor): LizardExtensionClassMetadata;
+/** Resolve a cross-file hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "cross_file_process"): ExtensionCrossFileProcess | undefined;
+/** Resolve a result hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "print_result"): ExtensionPrintResult | undefined;
+/** Resolve an argument hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "set_args"): ExtensionSetArgs | undefined;
+/** Resolve Python's special __call__ lookup from the extension type, ignoring its own dictionary. */
+export declare function resolveExtensionCall(extension: LizardExtensionDescriptor): ExtensionCall | undefined;
+/** Invoke a token hook and reject an extension that supplies neither source hook form. */
+export declare function invokeExtensionCall(extension: LizardExtensionDescriptor, tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+/** Invoke an optional cross-file hook with source instance/static resolution. */
+export declare function invokeExtensionCrossFileProcess(extension: LizardExtensionDescriptor, fileInfos: Iterable<FileInformation> | undefined): Iterable<FileInformation> | undefined;
+/** Invoke a cross-file hook without collapsing a present undefined result into absence. */
+export declare function invokeExtensionCrossFileProcessOutcome(extension: LizardExtensionDescriptor, fileInfos: Iterable<FileInformation> | undefined): ExtensionCrossFileProcessOutcome;
+/** Invoke an optional result hook with source instance/static resolution. */
+export declare function invokeExtensionPrintResult(extension: LizardExtensionDescriptor): void;
+/** Invoke an optional argument hook with source instance/static resolution. */
+export declare function invokeExtensionSetArgs(extension: LizardExtensionDescriptor, parser: ExtensionArgumentRegistrar): void;

package/types/package-checks/function-metrics/analyzer/extensions/registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py:get_extensions and lizard_ext/lizard*.py module names.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0 AND MIT
+ * Modified: translated to an analyzer-internal registration table. Deferred
+ * bodies fail explicitly rather than pretending to process source.
+ */
+import type { AnalyzerProcessor } from "../contracts.ts";
+import type { ExtensionInput, RegisteredLizardExtension } from "./protocol.ts";
+export type ExtensionBodyStatus = "deferred-extension-body" | "translated";
+/** One known upstream extension module whose body has not yet been translated. */
+export interface ExtensionRegistration {
+    readonly name: string;
+    readonly sourcePath: string;
+    readonly status: ExtensionBodyStatus;
+}
+/** Explicitly fail named loads until their source body is translated. */
+export declare class DeferredExtensionBodyError extends Error {
+    readonly extensionName: string;
+    readonly sourcePath: string;
+    constructor(registration: ExtensionRegistration);
+}
+/** All 19 upstream Lizard extension bodies in the current translation scope. */
+export declare const EXTENSION_REGISTRATIONS: readonly ExtensionRegistration[];
+/**
+ * Source-aligned get_extensions semantics: start with the five default
+ * processors, then resolve and insert each supplied extension by ordering_index.
+ */
+export declare function getExtensions(extensionInputs?: readonly ExtensionInput[]): AnalyzerProcessor[];
+/** Source `get_extensions` spelling for translated analyzer-internal callers. */
+export declare function get_extensions(extensionNames?: readonly ExtensionInput[]): AnalyzerProcessor[];
+/** Resolve an object/class directly, or report a known named body as deferred. */
+export declare function loadExtension(extensionInput: ExtensionInput): RegisteredLizardExtension;

package/types/package-checks/function-metrics/analyzer/pipeline.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 type { ExtensionArgumentRegistrar } from "./extensions/protocol.ts";
+import type { AnalyzerProcessor, AnalyzerReader, ReaderConstructor, TokenProcessor, TokenStream } from "./contracts.ts";
+import type { FileInformation } from "./analysis-model.ts";
+export declare function preprocessing(tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+/** Upstream comment directive and generated-code handling. */
+export declare function commentCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream non-comment source-line counting. */
+export declare function lineCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream file and current-function token counting. */
+export declare function tokenCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream cyclomatic-condition counting. */
+export declare function conditionCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** The ordered default processor list from lizard.py:get_extensions. */
+export declare const DEFAULT_TOKEN_PROCESSORS: readonly TokenProcessor[];
+/**
+ * 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 declare class FileAnalyzer {
+    readonly processors: readonly AnalyzerProcessor[];
+    constructor(processors?: readonly AnalyzerProcessor[]);
+    analyzeSourceCode<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>): FileInformation;
+    /** Source `analyze_source_code` spelling retained for translated extension/core callers. */
+    analyze_source_code<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>): FileInformation;
+}
+/** The source-aligned default analyzer has only the five core processors. */
+export declare const DEFAULT_FILE_ANALYZER: FileAnalyzer;
+/**
+ * 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 declare function mapFilesToAnalyzer(files: Iterable<InMemoryAnalyzerFile>, analyzer: FileAnalyzer, workingThreads: number): Iterable<FileInformation>;
+/** Source `map_files_to_analyzer` spelling for the retained in-memory lifecycle. */
+export declare function map_files_to_analyzer(files: Iterable<InMemoryAnalyzerFile>, analyzer: FileAnalyzer, workingThreads: number): Iterable<FileInformation>;
+/**
+ * Source-aligned `analyze_files` lifecycle. `exts` intentionally uses Python
+ * truthiness: an omitted or empty list receives the five default processors.
+ */
+export declare function analyzeFiles(files: Iterable<InMemoryAnalyzerFile>, threads?: number, exts?: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/** Source `analyze_files` spelling for translated internal callers. */
+export declare function analyze_files(files: Iterable<InMemoryAnalyzerFile>, threads?: number, exts?: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/**
+ * 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 declare function applyCrossFileProcessors(fileInfos: Iterable<FileInformation>, processors: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/** Forward the internal parser seam to extensions in source registration order. */
+export declare function registerExtensionArguments(processors: readonly AnalyzerProcessor[], parser: ExtensionArgumentRegistrar): void;
+export declare function analyzeSourceCode<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>, processors?: readonly AnalyzerProcessor[]): FileInformation;