@wispbit/local 1.0.25

package/dist/src/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAG9C,eAAO,MAAM,mBAAmB;;;;;;;;;EAM9B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG5B,CAAA;AAGF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAU9B,CAAA;AAGF,eAAO,MAAM,cAAc;;;;;;;;;;;;IAWzB,CAAA;AAGF,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAwG5C,CAAA;AAGD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAoB9B,CAAA;AAGF,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAgB1C,CAAA;AAGD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAA;AAGF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAgBnB,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBtB,CAAA;AAEX,eAAO,MAAM,aAAa;;;;;;EAIf,CAAA;AAiEX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;GAcpC,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkB/B,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAMxC,CAAA;AAGF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAA;AAEF,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAY5C,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa0B,CAAA;AAE1D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAetB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAA"}

package/dist/src/steps/ExecutionEventEmitter.d.ts

@@ -0,0 +1,156 @@
+import { EventEmitter } from "events";
+import { Language } from "powerlint/languages";
+import { Match } from "powerlint/types";
+export interface ExecutionEvents {
+    "execution:mode": {
+        mode: "check" | "diff";
+        filePath?: string;
+        baseCommit?: string;
+        headCommit?: string;
+    };
+    "rules:start": {
+        totalRules: number;
+    };
+    "rules:progress": {
+        currentRule: number;
+        totalRules: number;
+        ruleId: string;
+        percentage: number;
+        isLlm: boolean;
+    };
+    "rules:complete": {
+        totalRules: number;
+        totalMatches: number;
+        executionTime: number;
+    };
+    "step:start": {
+        ruleId: string;
+        stepName: string;
+        stepType: string;
+        inputs: {
+            filePaths: string[];
+            matches: Match[];
+        };
+    };
+    "step:complete": {
+        ruleId: string;
+        stepName: string;
+        stepType: string;
+        outputs: {
+            filePaths?: string[];
+            matches?: Match[];
+        };
+        executionTime: number;
+    };
+    "test:start": {
+        ruleId: string;
+        testName: string;
+    };
+    "test:matches": {
+        ruleId: string;
+        testName: string;
+        matches: Match[];
+    };
+    "files:discovery:start": {
+        mode: "check" | "diff";
+    };
+    "files:discovery:progress": {
+        message: string;
+        currentCount?: number;
+    };
+    "files:discovery:complete": {
+        totalFiles: number;
+        mode: "check" | "diff";
+        executionTime: number;
+    };
+    "files:filter": {
+        originalCount: number;
+        filteredCount: number;
+        filterType: string;
+    };
+    "indexing:start": {
+        language: Language;
+    };
+    "indexing:progress": {
+        language: Language;
+        message: string;
+        packageName?: string;
+        timeMs?: number;
+    };
+    "indexing:complete": {
+        language: Language;
+        executionTime: number;
+    };
+    "scip:match-lookup:start": {
+        language: Language;
+        match: Match;
+    };
+    "scip:match-lookup:progress": {
+        language: Language;
+        document: any;
+    };
+    "scip:match-lookup:complete": {
+        language: Language;
+        document?: any;
+    };
+    "llm:validation:start": {
+        ruleId: string;
+        matchCount: number;
+        estimatedCost?: string;
+    };
+    "llm:validation:progress": {
+        ruleId: string;
+        tokenCount: number;
+        elapsedTime: number;
+        streamedText?: string;
+    };
+    "llm:validation:complete": {
+        ruleId: string;
+        tokenCount: number;
+        executionTime: number;
+        violationCount: number;
+        fromCache: boolean;
+    };
+}
+export declare class ExecutionEventEmitter extends EventEmitter {
+    private rulesStartTime;
+    private indexingStartTimes;
+    private fileDiscoveryStartTime;
+    constructor();
+    emit<K extends keyof ExecutionEvents>(event: K, data: ExecutionEvents[K]): boolean;
+    on<K extends keyof ExecutionEvents>(event: K, listener: (data: ExecutionEvents[K]) => void): this;
+    once<K extends keyof ExecutionEvents>(event: K, listener: (data: ExecutionEvents[K]) => void): this;
+    off<K extends keyof ExecutionEvents>(event: K, listener: (data: ExecutionEvents[K]) => void): this;
+    setExecutionMode(mode: "check" | "diff", options?: {
+        filePath?: string;
+        baseCommit?: string;
+        headCommit?: string;
+    }): void;
+    startRules(totalRules: number): void;
+    progressRule(currentRule: number, totalRules: number, ruleId: string, isLlm: boolean): void;
+    completeRules(totalRules: number, totalMatches: number): void;
+    startFileDiscovery(mode: "check" | "diff"): void;
+    fileDiscoveryProgress(message: string, currentCount?: number): void;
+    completeFileDiscovery(totalFiles: number, mode: "check" | "diff"): void;
+    fileFilter(originalCount: number, filteredCount: number, filterType: string): void;
+    startScipMatchLookup(language: Language, match: Match): void;
+    scipMatchLookupProgress(language: Language, document: unknown): void;
+    scipMatchLookupComplete(language: Language, document?: unknown): void;
+    startIndexing(language: Language): void;
+    indexingProgress(language: Language, message: string, packageName?: string, timeMs?: number): void;
+    completeIndexing(language: Language): void;
+    startStep(ruleId: string, stepName: string, stepType: string, inputs: {
+        filePaths: string[];
+        matches: Match[];
+    }): void;
+    completeStep(ruleId: string, stepName: string, stepType: string, outputs: {
+        filePaths?: string[];
+        matches?: Match[];
+    }, executionTime?: number): void;
+    startTest(ruleId: string, testName: string): void;
+    testMatches(ruleId: string, testName: string, matches: Match[]): void;
+    startLLMValidation(ruleId: string, matchCount: number, estimatedCost?: string): void;
+    llmValidationProgress(ruleId: string, tokenCount: number, elapsedTime: number, streamedText?: string): void;
+    completeLLMValidation(ruleId: string, tokenCount: number, executionTime: number, violationCount: number, fromCache: boolean): void;
+}
+//# sourceMappingURL=ExecutionEventEmitter.d.ts.map

package/dist/src/steps/ExecutionEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionEventEmitter.d.ts","sourceRoot":"","sources":["../../../src/steps/ExecutionEventEmitter.ts"],"names":[],"mappings":"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"}

package/dist/src/steps/FileExecutionContext.d.ts

@@ -0,0 +1,85 @@
+import { Config } from "powerlint/environment/Config";
+import type { Environment } from "powerlint/environment/Environment";
+import { ExecutionEventEmitter } from "powerlint/steps/ExecutionEventEmitter";
+import { Match } from "powerlint/types";
+export type ExecutionMode = "check" | "diff";
+export declare class FileExecutionContext {
+    private environment;
+    private _filePaths;
+    private mode;
+    private eventEmitter;
+    private config;
+    private diffMode?;
+    private constructor();
+    /**
+     * Create and initialize an ExecutionContext
+     */
+    static initialize(config: Config, environment: Environment, mode: ExecutionMode, eventEmitter?: ExecutionEventEmitter, filePath?: string, baseSha?: string): Promise<FileExecutionContext>;
+    get filePaths(): string[];
+    /**
+     * Filter files based on execution mode and return filtered files
+     */
+    filterFiles(filePaths: string[]): string[];
+    /**
+     * Filter matches based on execution mode and return filtered matches
+     */
+    filterMatches(matches: Match[]): Match[];
+    /**
+     * Filter matches to only include those from the given file paths
+     */
+    filterMatchesByFilePaths(matches: Match[], filePaths: string[]): Match[];
+    get executionMode(): ExecutionMode;
+    /**
+     * Discover files based on the execution mode
+     * In 'scan' mode: discovers all files in workspace
+     * In 'diff' mode: gets changed files from git and returns only those
+     *
+     * The filePath parameter can be:
+     * - A specific filename (e.g., "src/file.ts")
+     * - A directory path (e.g., "src/components/")
+     * - A glob pattern (e.g., ".ts")
+     */
+    private discoverFiles;
+    /**
+     * Discover files from a given path which can be a file, directory, or glob pattern
+     */
+    private discoverFilesFromPath;
+    /**
+     * Check if a path contains glob pattern characters
+     */
+    private isGlobPattern;
+    /**
+     * Discover files matching a glob pattern
+     */
+    private discoverFilesFromGlob;
+    /**
+     * Discover all files in a directory
+     */
+    private discoverFilesFromDirectory;
+    /**
+     * Discover all files from directories using glob patterns (scan mode)
+     */
+    private discoverAllFiles;
+    /**
+     * Pattern matching function that uses consistent options
+     */
+    private matchesPattern;
+    /**
+     * Check if a file should be processed
+     */
+    private isFileValid;
+    /**
+     * Check if a specific line range should be processed
+     */
+    private isLineRangeValid;
+    /**
+     * Check if a match should be processed
+     */
+    private isMatchValid;
+    /**
+     * Parse a git patch to determine if a line range intersects with changed lines
+     * Adapted from patchParser.ts logic
+     */
+    private isLineRangeInPatch;
+}
+//# sourceMappingURL=FileExecutionContext.d.ts.map

package/dist/src/steps/FileExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/steps/FileExecutionContext.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAGvC,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,CAAA;AAE5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC,CAIhB;IAED,OAAO;IAYP;;OAEG;WACU,UAAU,CACrB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,YAAY,CAAC,EAAE,qBAAqB,EACpC,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,oBAAoB,CAAC;IAYhC,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED;;OAEG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAoB1C;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE;IAiBxC;;OAEG;IACH,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE;IASxE,IAAI,aAAa,IAAI,aAAa,CAEjC;IAID;;;;;;;;;OASG;YACW,aAAa;IAwE3B;;OAEG;YACW,qBAAqB;IA4CnC;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;YACW,qBAAqB;IAoBnC;;OAEG;YACW,0BAA0B;IAuBxC;;OAEG;YACW,gBAAgB;IA2C9B;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CA0C3B"}

package/dist/src/steps/FileFilterStep.d.ts

@@ -0,0 +1,35 @@
+import type { Environment } from "powerlint/environment/Environment";
+import { FileFilterConditions } from "powerlint/types";
+export interface FileFilterResult {
+    filteredPaths: string[];
+    executionTime: number;
+}
+export interface FileFilterOptions {
+    include?: string[];
+    ignore?: string[];
+    conditions?: FileFilterConditions;
+}
+export declare class FileFilterStep {
+    private environment;
+    constructor(environment: Environment);
+    /**
+     * Centralized pattern matching function that uses consistent options
+     * @param path - The path to test
+     * @param pattern - The glob pattern to match against
+     * @returns true if the path matches the pattern
+     */
+    private matchesPattern;
+    /**
+     * Evaluate a single file filter condition for a given file path
+     */
+    private evaluateCondition;
+    /**
+     * Evaluate file filter conditions for a given file path
+     */
+    private evaluateConditions;
+    /**
+     * Execute file filter on file paths
+     */
+    execute(filePaths: string[], options: FileFilterOptions): Promise<FileFilterResult>;
+}
+//# sourceMappingURL=FileFilterStep.d.ts.map

package/dist/src/steps/FileFilterStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileFilterStep.d.ts","sourceRoot":"","sources":["../../../src/steps/FileFilterStep.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,EAAuB,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAE3E,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,oBAAoB,CAAA;CAClC;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,WAAW,CAAa;gBAEpB,WAAW,EAAE,WAAW;IAIpC;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsB1B;;OAEG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAoC1F"}

package/dist/src/steps/FileFilterStep.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FileFilterStep.test.d.ts.map

package/dist/src/steps/FileFilterStep.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileFilterStep.test.d.ts","sourceRoot":"","sources":["../../../src/steps/FileFilterStep.test.ts"],"names":[],"mappings":""}

package/dist/src/steps/FindMatchesStep.d.ts

@@ -0,0 +1,41 @@
+import type { Environment } from "powerlint/environment/Environment";
+import type { Language } from "powerlint/languages";
+import { ExecutionEventEmitter } from "powerlint/steps/ExecutionEventEmitter";
+import { Match } from "powerlint/types";
+export interface FindMatchesResult {
+    matches: Match[];
+    totalMatches: number;
+    executionTime: number;
+}
+export declare class FindMatchesStep {
+    private environment;
+    private eventEmitter?;
+    constructor(environment: Environment, eventEmitter?: ExecutionEventEmitter);
+    /**
+     * Execute pattern matching on files
+     * @param schema - The matching schema (rule, constraints, etc.) - provider-specific
+     * @param language - The language to use for pattern matching
+     * @param context - Context containing filePaths and optional previousMatches to filter against
+     */
+    execute(schema: Record<string, any>, language: Language, context: {
+        filePaths: string[];
+        previousMatches?: Match[];
+    }): Promise<FindMatchesResult>;
+    /**
+     * Filter matches to only include those within the ranges of previous matches
+     * A match is included if it falls within any of the previous match ranges
+     * The source is propagated from the previous match
+     */
+    private filterMatchesByRanges;
+    /**
+     * Check if a match falls within the range of another match
+     * Both matches must be in the same file
+     */
+    private isMatchInRange;
+    /**
+     * Remove duplicate matches by keeping only the largest overlapping match.
+     * If multiple matches overlap (one is contained within another), keep only the largest one.
+     */
+    private deduplicateMatches;
+}
+//# sourceMappingURL=FindMatchesStep.d.ts.map

package/dist/src/steps/FindMatchesStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindMatchesStep.d.ts","sourceRoot":"","sources":["../../../src/steps/FindMatchesStep.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAGnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEvC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,YAAY,CAAC,CAAuB;gBAEhC,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,qBAAqB;IAK1E;;;;;OAKG;IACG,OAAO,CACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,eAAe,CAAC,EAAE,KAAK,EAAE,CAAA;KAAE,GAC1D,OAAO,CAAC,iBAAiB,CAAC;IA8C7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAwBtB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CAuB3B"}

package/dist/src/steps/FindMatchesStep.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FindMatchesStep.test.d.ts.map

package/dist/src/steps/FindMatchesStep.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FindMatchesStep.test.d.ts","sourceRoot":"","sources":["../../../src/steps/FindMatchesStep.test.ts"],"names":[],"mappings":""}

package/dist/src/steps/GotoDefinitionStep.d.ts

@@ -0,0 +1,86 @@
+import type { Environment } from "powerlint/environment/Environment";
+import type { Language } from "powerlint/languages";
+import { ExecutionEventEmitter } from "powerlint/steps/ExecutionEventEmitter";
+import { Match } from "powerlint/types";
+/** Exact or regex name matching */
+interface NameSpec {
+    equals?: string;
+    anyOf?: string[];
+    regex?: string;
+}
+/** File matcher (path OR glob OR regex) */
+interface FileMatch {
+    path?: string;
+    glob?: string;
+    regex?: string;
+}
+/** Method filter */
+interface MethodSelector {
+    file?: FileMatch;
+    name: NameSpec;
+}
+/** Class filter */
+interface ClassSelector {
+    file?: FileMatch;
+    name: NameSpec;
+    method?: MethodSelector;
+}
+/** Top-level function filter */
+interface FunctionSelector {
+    file?: FileMatch;
+    name: NameSpec;
+}
+/** Definition-side predicates (post-hop) */
+interface DefinitionPredicate {
+    file?: FileMatch;
+    class?: ClassSelector;
+    method?: MethodSelector;
+    function?: FunctionSelector;
+}
+/** Boolean combinators for definition filters */
+interface DefinitionFilter extends Partial<DefinitionPredicate> {
+    all?: DefinitionFilter[];
+    any?: DefinitionFilter[];
+    not?: DefinitionFilter;
+}
+export interface GotoDefinitionResult {
+    definitions: Match[];
+    totalDefinitions: number;
+    executionTime: number;
+}
+export interface GotoDefinitionOptions {
+    /** Filter for which definitions to include (default: all non-external) */
+    where?: DefinitionFilter;
+}
+export declare class GotoDefinitionStep {
+    private readonly maxDepth;
+    private environment;
+    private eventEmitter?;
+    constructor(environment: Environment, eventEmitter?: ExecutionEventEmitter);
+    /**
+     * Execute goto-definition on matches
+     */
+    execute(matches: Match[], language: Language, options?: GotoDefinitionOptions): Promise<GotoDefinitionResult>;
+    /**
+     * Follow definitions up to maxDepth
+     */
+    private followDefinitions;
+    /**
+     * Recursively follow definitions
+     */
+    private followDefinitionsRecursive;
+    /**
+     * Check if a definition matches a filter
+     */
+    private matchesDefinitionFilter;
+    /**
+     * Check if a name matches a name specification
+     */
+    private matchesNameSpec;
+    /**
+     * Check if a file path matches a file specification
+     */
+    private matchesFileSpec;
+}
+export {};
+//# sourceMappingURL=GotoDefinitionStep.d.ts.map

package/dist/src/steps/GotoDefinitionStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GotoDefinitionStep.d.ts","sourceRoot":"","sources":["../../../src/steps/GotoDefinitionStep.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEvC,mCAAmC;AACnC,UAAU,QAAQ;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,2CAA2C;AAC3C,UAAU,SAAS;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,oBAAoB;AACpB,UAAU,cAAc;IACtB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,QAAQ,CAAA;CACf;AAED,mBAAmB;AACnB,UAAU,aAAa;IACrB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,CAAC,EAAE,cAAc,CAAA;CACxB;AAED,gCAAgC;AAChC,UAAU,gBAAgB;IACxB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,QAAQ,CAAA;CACf;AAED,4CAA4C;AAC5C,UAAU,mBAAmB;IAC3B,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CAC5B;AAED,iDAAiD;AACjD,UAAU,gBAAiB,SAAQ,OAAO,CAAC,mBAAmB,CAAC;IAC7D,GAAG,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACxB,GAAG,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACxB,GAAG,CAAC,EAAE,gBAAgB,CAAA;CACvB;AAQD,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,KAAK,EAAE,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,gBAAgB,CAAA;CACzB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;IACrC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,YAAY,CAAC,CAAuB;gBAEhC,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,qBAAqB;IAK1E;;OAEG;IACG,OAAO,CACX,OAAO,EAAE,KAAK,EAAE,EAChB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,oBAAoB,CAAC;IAgDhC;;OAEG;YACW,iBAAiB;IA2B/B;;OAEG;YACW,0BAA0B;IA6DxC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAyC/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAcvB;;OAEG;IACH,OAAO,CAAC,eAAe;CAexB"}

package/dist/src/steps/LLMStep.d.ts

@@ -0,0 +1,50 @@
+import { Config } from "powerlint/environment/Config";
+import type { Environment } from "powerlint/environment/Environment";
+import { ExecutionEventEmitter } from "powerlint/steps/ExecutionEventEmitter";
+import type { Match } from "powerlint/types";
+import { Rule } from "powerlint/types";
+export interface LLMStepResult {
+    matches: Match[];
+    executionTime: number;
+}
+export type LLMStepExecutionResult = LLMStepResult;
+export interface LLMMatchDecision {
+    matchId: string;
+    isViolation: boolean;
+    confidence: number;
+    reason: string;
+}
+export declare class LLMStep {
+    private environment;
+    private eventEmitter;
+    private config;
+    private storage;
+    constructor(config: Config, environment: Environment, eventEmitter?: ExecutionEventEmitter);
+    /**
+     * Generate a unique ID for a single match
+     * Hash is based on filePath + range + text
+     */
+    private generateMatchId;
+    /**
+     * Generate a hash for a prompt string
+     */
+    private hashPrompt;
+    /**
+     * Generate a cache key for a single match LLM validation
+     */
+    private generateMatchCacheKey;
+    /**
+     * Execute the actual LLM validation for uncached matches
+     * @param config - LLM step configuration (contains provider and model)
+     * @param uncachedMatches - Matches that need LLM evaluation
+     * @param promptContent - The loaded prompt content
+     */
+    private executeLLMValidation;
+    /**
+     * Execute the LLM step - always runs LLM validation immediately
+     * @param config - LLM step configuration
+     * @param previousMatches - Matches from previous steps to be judged by LLM
+     */
+    execute(rule: Rule, previousMatches: Match[]): Promise<LLMStepExecutionResult>;
+}
+//# sourceMappingURL=LLMStep.d.ts.map

package/dist/src/steps/LLMStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LLMStep.d.ts","sourceRoot":"","sources":["../../../src/steps/LLMStep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAIpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAGtC,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAA;AAElD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,OAAO;IAClB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAS;gBACZ,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,qBAAqB;IAO1F;;;OAGG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;OAKG;YACW,oBAAoB;IAkElC;;;;OAIG;IACG,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAkErF"}

package/dist/src/steps/RuleExecutor.d.ts

@@ -0,0 +1,35 @@
+import { Config } from "powerlint/environment/Config";
+import { Environment } from "powerlint/environment/Environment";
+import { ExecutionEventEmitter } from "powerlint/steps/ExecutionEventEmitter";
+import { ExecutionMode } from "powerlint/steps/FileExecutionContext";
+import { Match, Rule } from "powerlint/types";
+export interface RuleExecutionResult {
+    ruleId: string;
+    matches: Match[];
+}
+export interface RuleExecutionOptions {
+    mode: ExecutionMode;
+    filePath?: string;
+    baseSha?: string;
+}
+export declare class RuleExecutor {
+    private fileFilterStep;
+    private findMatchesStep;
+    private gotoDefinitionStep;
+    private llmStep;
+    private environment;
+    private executionContext?;
+    private currentMode?;
+    private eventEmitter;
+    private config;
+    constructor(config: Config, environment: Environment, eventEmitter?: ExecutionEventEmitter);
+    /**
+     * Execute a single step
+     */
+    private executeStep;
+    /**
+     * Execute all steps in multiple rule configurations
+     */
+    execute(rules: Rule[], options: RuleExecutionOptions): Promise<RuleExecutionResult[]>;
+}
+//# sourceMappingURL=RuleExecutor.d.ts.map

package/dist/src/steps/RuleExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleExecutor.d.ts","sourceRoot":"","sources":["../../../src/steps/RuleExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAC7E,OAAO,EAAwB,aAAa,EAAE,MAAM,sCAAsC,CAAA;AAK1F,OAAO,EAAY,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEvD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,KAAK,EAAE,CAAA;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,aAAa,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,gBAAgB,CAAC,CAAsB;IAC/C,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,qBAAqB;IAU1F;;OAEG;YACW,WAAW;IAmHzB;;OAEG;IACG,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;CAiH5F"}

package/dist/src/steps/RuleExecutor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RuleExecutor.test.d.ts.map

package/dist/src/steps/RuleExecutor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleExecutor.test.d.ts","sourceRoot":"","sources":["../../../src/steps/RuleExecutor.test.ts"],"names":[],"mappings":""}

package/dist/src/test/TestExecutor.d.ts

@@ -0,0 +1,33 @@
+import { Config } from "powerlint/environment/Config";
+import { Match } from "powerlint/types";
+import { type Rule, type RuleTestCase } from "powerlint/types";
+export interface TestExecutorOptions {
+    rules: Rule[];
+}
+export interface TestCaseExecutionResult {
+    testCase: RuleTestCase;
+    matches: Match[];
+    executionTime: number;
+    error?: string;
+}
+export interface RuleExecutionResult {
+    rule: Rule;
+    results: TestCaseExecutionResult[];
+}
+export interface TestExecutorResult {
+    ruleResults: RuleExecutionResult[];
+}
+export declare class TestExecutor {
+    private eventEmitter;
+    private config;
+    constructor(config: Config);
+    /**
+     * Run a single test case for a rule and return the matches
+     */
+    private runTestCase;
+    /**
+     * Execute tests for the given rules
+     */
+    execute(options: TestExecutorOptions): Promise<TestExecutorResult>;
+}
+//# sourceMappingURL=TestExecutor.d.ts.map

package/dist/src/test/TestExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestExecutor.d.ts","sourceRoot":"","sources":["../../../src/test/TestExecutor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AAIrD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,IAAI,EAAE,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,YAAY,CAAA;IACtB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,uBAAuB,EAAE,CAAA;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,mBAAmB,EAAE,CAAA;CACnC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,EAAE,MAAM;IAK1B;;OAEG;YACW,WAAW;IAkCzB;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAqCzE"}

package/dist/src/test/rules.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rules.test.d.ts.map

package/dist/src/test/rules.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.test.d.ts","sourceRoot":"","sources":["../../../src/test/rules.test.ts"],"names":[],"mappings":""}