@wispbit/local 1.0.25 → 1.0.26

package/dist/index.js

@@ -1,3868 +1,21 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/version.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import latestVersion from "latest-version";
-function getCurrentVersion() {
-  const filename = fileURLToPath(import.meta.url ? import.meta.url : __filename);
-  const __dirname = dirname(filename);
-  const packageJsonPath = join(__dirname, "../package.json");
-  try {
-    const file = readFileSync(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(file);
-    return packageJson.version;
-  } catch {
-    return "0.0.0";
-  }
-}
-async function getLatestVersion() {
-  try {
-    const latestCliVersion = await latestVersion("@wispbit/local");
-    return latestCliVersion;
-  } catch {
-    return getCurrentVersion();
-  }
-}
-var init_version = __esm({
-  "src/version.ts"() {
-    "use strict";
-  }
-});
-
-// src/environment/Config.ts
-var Config;
-var init_Config = __esm({
-  "src/environment/Config.ts"() {
-    "use strict";
-    init_version();
-    Config = class _Config {
-      config;
-      apiKey = null;
-      baseUrl = null;
-      constructor(config) {
-        this.config = {
-          ...config,
-          ignoredGlobs: config.ignoredGlobs || []
-        };
-        this.apiKey = config.apiKey || null;
-        this.baseUrl = config.baseUrl || null;
-      }
-      getIgnoredGlobs() {
-        return this.config.ignoredGlobs || [];
-      }
-      /**
-       * Get the Wispbit API key
-       * @returns The API key or null if not set
-       */
-      getApiKey() {
-        return this.apiKey;
-      }
-      /**
-       * Get the Wispbit API base URL
-       * @returns The base URL
-       */
-      getBaseUrl() {
-        return this.baseUrl;
-      }
-      /**
-       * Get the local PowerLint version
-       * @returns The current PowerLint version
-       */
-      getLocalVersion() {
-        return getCurrentVersion();
-      }
-      /**
-       * Get the schema version
-       * @returns The schema version
-       */
-      getSchemaVersion() {
-        return "v1";
-      }
-      /**
-       * Validate API key with Wispbit API
-       */
-      static async validateApiKey(apiKey, repositoryUrl, baseUrl) {
-        const response = await fetch(`${baseUrl}/plv1/initialize`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`
-          },
-          body: JSON.stringify({
-            repository_url: repositoryUrl,
-            powerlint_version: getCurrentVersion(),
-            schema_version: "v1"
-          })
-        });
-        return response.ok;
-      }
-      /**
-       * Initialize configuration without network validation (for testing)
-       * @param options Optional configuration options
-       * @returns Config instance
-       */
-      static initializeWithoutNetwork(options = {}) {
-        const finalBaseUrl = options.baseUrl || process.env.WISPBIT_API_BASE_URL || "https://api.wispbit.com";
-        const finalApiKey = options.apiKey || process.env.WISPBIT_API_KEY || null;
-        const ignoredGlobs = options.ignoredGlobs || [];
-        return new _Config({
-          ignoredGlobs,
-          apiKey: finalApiKey || void 0,
-          baseUrl: finalBaseUrl
-        });
-      }
-      /**
-       * Initialize configuration by validating API key and repository URL with Wispbit
-       * @param environment Environment instance to get repository URL
-       * @param apiKey Optional API key to use for initialization. If not provided, will use environment variable
-       * @returns Promise<Config | null> - Config if valid, null if API key missing/invalid
-       */
-      static async initialize(environment, {
-        apiKey,
-        baseUrl
-      }) {
-        var _a;
-        const finalBaseUrl = baseUrl || process.env.WISPBIT_API_BASE_URL || "https://api.wispbit.com";
-        const finalApiKey = apiKey || process.env.WISPBIT_API_KEY || null;
-        if (!finalApiKey) {
-          console.log("No API key found");
-          return { failed: true, error: "INVALID_API_KEY" };
-        }
-        const repositoryUrl = await environment.getRepositoryUrl();
-        const isValidApiKey = await _Config.validateApiKey(finalApiKey, repositoryUrl, finalBaseUrl);
-        if (!isValidApiKey) {
-          return { failed: true, error: "INVALID_API_KEY" };
-        }
-        const response = await fetch(`${finalBaseUrl}/plv1/initialize`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${finalApiKey}`
-          },
-          body: JSON.stringify({
-            repository_url: repositoryUrl,
-            powerlint_version: getCurrentVersion(),
-            schema_version: "v1"
-          })
-        });
-        const result = await response.json();
-        if (result.invalid_api_key) {
-          return { failed: true, error: "INVALID_API_KEY" };
-        }
-        if (!result.is_valid_repository) {
-          return { failed: true, error: "INVALID_REPOSITORY" };
-        }
-        const ignoredGlobs = ((_a = result.config) == null ? void 0 : _a.ignored_globs) || [];
-        const config = new _Config({ ignoredGlobs, apiKey: finalApiKey, baseUrl: finalBaseUrl });
-        return config;
-      }
-      /**
-       * Check if PowerLint is configured (has valid API key)
-       */
-      isConfigured() {
-        return this.getApiKey() !== null;
-      }
-    };
-  }
-});
-
-// src/utils/hashString.ts
-import { createHash } from "crypto";
-function hashString(str) {
-  return createHash("sha256").update(str).digest("hex");
-}
-var init_hashString = __esm({
-  "src/utils/hashString.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/git.ts
-import { exec, execSync } from "child_process";
-import { promisify } from "util";
-function findGitRoot() {
-  const stdout = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" });
-  return stdout.trim();
-}
-async function getRepositoryUrl(repoRoot, remoteName = "origin") {
-  var _a;
-  const { stdout } = await execPromise(`git remote show ${remoteName}`, {
-    cwd: repoRoot
-  });
-  const fetchUrlLine = stdout.split("\n").find((line) => line.includes("Fetch URL:"));
-  if (fetchUrlLine) {
-    return ((_a = fetchUrlLine.split("Fetch URL:").pop()) == null ? void 0 : _a.trim()) || null;
-  }
-  return null;
-}
-async function getDefaultBranch(repoRoot, remoteName = "origin") {
-  var _a;
-  const { stdout } = await execPromise(`git remote show ${remoteName}`, {
-    cwd: repoRoot
-  });
-  const headBranchLine = stdout.split("\n").find((line) => line.includes("HEAD branch"));
-  if (headBranchLine) {
-    return ((_a = headBranchLine.split(":").pop()) == null ? void 0 : _a.trim()) || null;
-  }
-  return null;
-}
-async function getChangedFiles(repoRoot, base) {
-  var _a, _b;
-  const { stdout: currentBranchOutput } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    cwd: repoRoot
-  });
-  const currentBranch = currentBranchOutput.trim();
-  const defaultBranch = await getDefaultBranch(repoRoot);
-  const compareTo = base ?? (defaultBranch ? `origin/${defaultBranch}` : "HEAD^");
-  let currentCommit;
-  try {
-    const { stdout: remoteCommitOutput } = await execPromise(
-      `git rev-parse origin/${currentBranch}`,
-      { cwd: repoRoot }
-    );
-    currentCommit = remoteCommitOutput.trim();
-  } catch (error) {
-    const { stdout: currentCommitOutput } = await execPromise("git rev-parse HEAD", {
-      cwd: repoRoot
-    });
-    currentCommit = currentCommitOutput.trim();
-  }
-  let mergeBase;
-  try {
-    const { stdout: mergeBaseOutput } = await execPromise(
-      `git merge-base ${currentBranch} ${compareTo}`,
-      { cwd: repoRoot }
-    );
-    mergeBase = mergeBaseOutput.trim();
-  } catch (error) {
-    mergeBase = "HEAD^";
-  }
-  const { stdout: statusOutput } = await execPromise("git status --porcelain", {
-    cwd: repoRoot
-  });
-  const statusLines = statusOutput.split("\n").filter(Boolean);
-  const fileStatuses = /* @__PURE__ */ new Map();
-  statusLines.forEach((line) => {
-    const statusCode = line.substring(0, 2).trim();
-    const filename = line.substring(3);
-    fileStatuses.set(filename, statusCode);
-  });
-  const { stdout: diffOutput } = await execPromise(`git diff ${mergeBase} --name-only`, {
-    cwd: repoRoot
-  });
-  const allFiles = diffOutput.split("\n").filter(Boolean);
-  const { stdout: deletedFilesOutput } = await execPromise("git ls-files --deleted", {
-    cwd: repoRoot
-  });
-  const deletedFiles = deletedFilesOutput.split("\n").filter(Boolean);
-  allFiles.push(...deletedFiles.filter((file) => !allFiles.includes(file)));
-  const { stdout: untrackedOutput } = await execPromise(
-    "git ls-files --others --exclude-standard",
-    {
-      cwd: repoRoot
-    }
-  );
-  const untrackedFiles = untrackedOutput.split("\n").filter(Boolean);
-  allFiles.push(...untrackedFiles.filter((file) => !allFiles.includes(file)));
-  const nonDeletedFiles = [];
-  const deletedFilesSet = new Set(deletedFiles);
-  const fileIsDeleted = /* @__PURE__ */ new Map();
-  for (const file of allFiles) {
-    const isDeleted = deletedFilesSet.has(file) || ((_a = fileStatuses.get(file)) == null ? void 0 : _a.includes("D")) || ((_b = fileStatuses.get(file)) == null ? void 0 : _b.includes("R"));
-    fileIsDeleted.set(file, Boolean(isDeleted));
-    if (!isDeleted) {
-      nonDeletedFiles.push(file);
-    }
-  }
-  const fileStats = /* @__PURE__ */ new Map();
-  if (nonDeletedFiles.length > 0) {
-    const { stdout: batchNumstatOutput } = await execPromise(
-      `git diff ${mergeBase} --numstat -- ${nonDeletedFiles.map((f) => `'${f.replace(/'/g, "'\\''")}'`).join(" ")}`,
-      { cwd: repoRoot }
-    );
-    const numstatLines = batchNumstatOutput.split("\n").filter(Boolean);
-    numstatLines.forEach((line) => {
-      const parts = line.split("	");
-      if (parts.length >= 3) {
-        const [additionsStr, deletionsStr, filename] = parts;
-        fileStats.set(filename, {
-          additions: parseInt(additionsStr) || 0,
-          deletions: parseInt(deletionsStr) || 0
-        });
-      }
-    });
-  }
-  const fileDiffs = /* @__PURE__ */ new Map();
-  if (nonDeletedFiles.length > 0) {
-    const { stdout: batchDiffOutput } = await execPromise(
-      `git diff ${mergeBase} -- ${nonDeletedFiles.map((f) => `'${f.replace(/'/g, "'\\''")}'`).join(" ")}`,
-      { cwd: repoRoot }
-    );
-    const diffSections = batchDiffOutput.split(/^diff --git /m).filter(Boolean);
-    diffSections.forEach((section) => {
-      const lines = section.split("\n");
-      const firstLine = lines[0];
-      const match = firstLine.match(/a\/(.+?) b\//);
-      if (match) {
-        const filename = match[1];
-        const diffContent = lines.slice(1).filter((line) => {
-          return !(line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ "));
-        }).join("\n");
-        fileDiffs.set(filename, diffContent);
-      }
-    });
-  }
-  const deletedFileContents = /* @__PURE__ */ new Map();
-  const actualDeletedFiles = allFiles.filter((file) => fileIsDeleted.get(file));
-  if (actualDeletedFiles.length > 0) {
-    const deletedFilePromises = actualDeletedFiles.map(async (file) => {
-      const { stdout: lastContent } = await execPromise(
-        `git show '${mergeBase}:${file.replace(/'/g, "'\\''")}'`,
-        {
-          cwd: repoRoot
-        }
-      );
-      return { file, content: lastContent };
-    });
-    const results = await Promise.allSettled(deletedFilePromises);
-    results.forEach((result, index) => {
-      if (result.status === "fulfilled") {
-        deletedFileContents.set(actualDeletedFiles[index], result.value.content);
-      }
-    });
-  }
-  const fileChanges = [];
-  for (const file of allFiles) {
-    const isDeleted = fileIsDeleted.get(file);
-    let additions = 0;
-    let deletions = 0;
-    let diffOutput2 = "";
-    if (isDeleted) {
-      const lastContent = deletedFileContents.get(file);
-      if (lastContent) {
-        deletions = lastContent.split("\n").length;
-        diffOutput2 = lastContent.split("\n").map((line) => `-${line}`).join("\n");
-      }
-    } else {
-      const stats = fileStats.get(file);
-      if (stats) {
-        additions = stats.additions;
-        deletions = stats.deletions;
-      }
-      diffOutput2 = fileDiffs.get(file) || "";
-    }
-    const status = isDeleted ? "removed" : additions > 0 && deletions === 0 ? "added" : "modified";
-    fileChanges.push({
-      filename: file,
-      status,
-      patch: diffOutput2,
-      additions,
-      deletions,
-      sha: hashString(diffOutput2)
-    });
-  }
-  return {
-    files: fileChanges,
-    currentBranch,
-    currentCommit,
-    diffCommit: mergeBase,
-    diffBranch: compareTo
-  };
-}
-var execPromise;
-var init_git = __esm({
-  "src/utils/git.ts"() {
-    "use strict";
-    init_hashString();
-    execPromise = promisify(exec);
-  }
-});
-
-// src/environment/Environment.ts
-var Environment;
-var init_Environment = __esm({
-  "src/environment/Environment.ts"() {
-    "use strict";
-    init_git();
-    Environment = class {
-      workspaceRoot;
-      repositoryUrl;
-      constructor(config) {
-        this.repositoryUrl = (config == null ? void 0 : config.repositoryUrl) || null;
-        this.workspaceRoot = (config == null ? void 0 : config.workspaceRoot) || findGitRoot();
-      }
-      /**
-       * Get the workspace root directory
-       */
-      getWorkspaceRoot() {
-        return this.workspaceRoot;
-      }
-      /**
-       * Get the remote repository URL from Git config
-       * @param remoteName Name of the remote (default: origin)
-       * @returns The remote repository URL or null if not found
-       */
-      async getRepositoryUrl(remoteName = "origin") {
-        if (this.repositoryUrl) {
-          return this.repositoryUrl;
-        }
-        const repositoryUrl = await getRepositoryUrl(this.workspaceRoot, remoteName);
-        if (!repositoryUrl) {
-          throw new Error(
-            "Could not determine repository URL. Make sure you're in a Git repository with a remote origin."
-          );
-        }
-        return repositoryUrl;
-      }
-    };
-  }
-});
-
-// src/environment/Storage.ts
-import * as fs from "fs/promises";
-import os from "os";
-import path from "path";
-import Keyv from "keyv";
-import { KeyvFile } from "keyv-file";
-var Storage;
-var init_Storage = __esm({
-  "src/environment/Storage.ts"() {
-    "use strict";
-    init_hashString();
-    Storage = class {
-      environment;
-      cacheStore;
-      constructor(environment) {
-        this.environment = environment;
-      }
-      /**
-       * Get the base storage directory for powerlint
-       * This replaces the getConfigDirectory functionality
-       */
-      getStorageDirectory() {
-        return path.join(os.homedir(), ".powerlint");
-      }
-      /**
-       * Get the base directory for indexes
-       */
-      getIndexDirectory() {
-        return path.join(
-          this.getStorageDirectory(),
-          "indexes",
-          hashString(this.environment.getWorkspaceRoot())
-        );
-      }
-      /**
-       * Get the base directory for caches
-       */
-      getCacheDirectory() {
-        return path.join(
-          this.getStorageDirectory(),
-          "cache",
-          hashString(this.environment.getWorkspaceRoot())
-        );
-      }
-      /**
-       * Ensure a directory exists, creating it if necessary
-       */
-      async ensureDirectory(dirPath) {
-        await fs.mkdir(dirPath, { recursive: true });
-      }
-      /**
-       * Get the file path for a specific index
-       * Ensures the index directory exists
-       */
-      async getIndexFilePath(language, fileName) {
-        const indexDir = this.getIndexDirectory();
-        await this.ensureDirectory(indexDir);
-        const file = fileName || `${language.toLowerCase()}-index.scip`;
-        return path.join(indexDir, `${language.toLowerCase()}-${file}`);
-      }
-      /**
-       * Check if an index exists for a language
-       */
-      async indexExists(language, fileName) {
-        const indexPath = await this.getIndexFilePath(language, fileName);
-        try {
-          await fs.access(indexPath);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Read an index file for a language
-       */
-      async readIndex(language, fileName) {
-        const indexPath = await this.getIndexFilePath(language, fileName);
-        try {
-          await fs.access(indexPath);
-          return await fs.readFile(indexPath);
-        } catch {
-          return null;
-        }
-      }
-      /**
-       * Save an index file for a language
-       */
-      async saveIndex(language, data, fileName) {
-        const indexPath = await this.getIndexFilePath(language, fileName);
-        await fs.writeFile(indexPath, data);
-      }
-      /**
-       * Get the cache file path
-       */
-      getCacheFilePath() {
-        return path.join(this.getCacheDirectory(), "cache.json");
-      }
-      /**
-       * Purge all storage (cache and indexes)
-       * @returns Object with success status and details about what was purged
-       */
-      async purgeStorage() {
-        let deletedCount = 0;
-        const storagePath = this.getStorageDirectory();
-        try {
-          await fs.access(storagePath);
-          await fs.rm(storagePath, { recursive: true, force: true });
-          deletedCount++;
-        } catch {
-        }
-        return {
-          success: true,
-          deletedCount
-        };
-      }
-      /**
-       * Purge only cache data
-       */
-      async purgeCache() {
-        let deletedCount = 0;
-        const cachePath = this.getCacheDirectory();
-        try {
-          await fs.access(cachePath);
-          await fs.rm(cachePath, { recursive: true, force: true });
-          deletedCount++;
-        } catch {
-        }
-        return {
-          success: true,
-          deletedCount
-        };
-      }
-      /**
-       * Get or initialize the cache store
-       */
-      getCacheStore() {
-        if (!this.cacheStore) {
-          const cacheDir = this.getCacheDirectory();
-          this.cacheStore = new Keyv({
-            store: new KeyvFile({
-              filename: path.join(cacheDir, "cache.json")
-            })
-          });
-        }
-        return this.cacheStore;
-      }
-      /**
-       * Save data to cache
-       */
-      async saveCache(ruleId, cacheKey, data) {
-        const cache = this.getCacheStore();
-        const key = `${ruleId}:${cacheKey}`;
-        await cache.set(key, data);
-      }
-      /**
-       * Read data from cache
-       */
-      async readCache(ruleId, cacheKey) {
-        const cache = this.getCacheStore();
-        const key = `${ruleId}:${cacheKey}`;
-        const data = await cache.get(key);
-        return data || null;
-      }
-      /**
-       * Purge only index data
-       */
-      async purgeIndexes() {
-        let deletedCount = 0;
-        const indexPath = this.getIndexDirectory();
-        try {
-          await fs.access(indexPath);
-          await fs.rm(indexPath, { recursive: true, force: true });
-          deletedCount++;
-        } catch {
-        }
-        return {
-          success: true,
-          deletedCount
-        };
-      }
-    };
-  }
-});
-
-// src/providers/WispbitRuleProvider.ts
-import { z } from "zod";
-var GetRulesSchema, WispbitRuleProvider;
-var init_WispbitRuleProvider = __esm({
-  "src/providers/WispbitRuleProvider.ts"() {
-    "use strict";
-    GetRulesSchema = z.object({
-      repository_url: z.string(),
-      rule_ids: z.array(z.string()).optional(),
-      schema_version: z.string(),
-      powerlint_version: z.string()
-    });
-    WispbitRuleProvider = class {
-      config;
-      environment;
-      constructor(config, environment) {
-        this.config = config;
-        this.environment = environment;
-      }
-      /**
-       * Make a request to the Wispbit API
-       */
-      async makeApiRequest(endpoint, data) {
-        const baseUrl = this.config.getBaseUrl();
-        const apiKey = this.config.getApiKey();
-        const url = `${baseUrl}${endpoint}`;
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`
-          },
-          body: JSON.stringify(data)
-        });
-        if (!response.ok) {
-          throw new Error(`Wispbit API request failed: ${response.status} ${response.statusText}`);
-        }
-        return await response.json();
-      }
-      /**
-       * Get the repository URL for API requests
-       */
-      async getRepositoryUrl() {
-        const repoUrl = await this.environment.getRepositoryUrl();
-        if (!repoUrl) {
-          throw new Error(
-            "Could not determine repository URL. Make sure you're in a Git repository with a remote origin."
-          );
-        }
-        return repoUrl;
-      }
-      /**
-       * Load a specific rule by ID from Wispbit Cloud
-       */
-      async loadRuleById(ruleId) {
-        const rules = await this.fetchRules([ruleId]);
-        if (rules.length === 0) {
-          throw new Error(`Rule with ID '${ruleId}' not found`);
-        }
-        return rules[0];
-      }
-      /**
-       * Load all rules from Wispbit Cloud for the configured repository
-       */
-      async loadAllRules() {
-        return await this.fetchRules();
-      }
-      /**
-       * Fetch rules from Wispbit Cloud API
-       */
-      async fetchRules(ruleIds) {
-        const repositoryUrl = await this.getRepositoryUrl();
-        const requestData = {
-          repository_url: repositoryUrl,
-          rule_ids: ruleIds,
-          schema_version: this.config.getSchemaVersion(),
-          powerlint_version: this.config.getLocalVersion()
-        };
-        GetRulesSchema.parse(requestData);
-        const response = await this.makeApiRequest("/plv1/get-rules", requestData);
-        if (!Array.isArray(response.rules)) {
-          throw new Error("Invalid response format from Wispbit API: expected rules array");
-        }
-        const rules = response.rules;
-        return rules.map((rule) => ({
-          id: rule.id,
-          internalId: rule.internalId,
-          config: {
-            message: rule.message,
-            severity: rule.severity,
-            steps: rule.schema
-          },
-          prompt: rule.prompt,
-          testCases: []
-        }));
-      }
-      /**
-       * Create a new rule in Wispbit Cloud
-       */
-      async createRule(_rule) {
-        await Promise.resolve();
-        throw new Error("Creating rules in Wispbit Cloud is not yet implemented");
-      }
-      /**
-       * Update an existing rule in Wispbit Cloud
-       */
-      async updateRule(_ruleId, _rule) {
-        await Promise.resolve();
-        throw new Error("Updating rules in Wispbit Cloud is not yet implemented");
-      }
-      /**
-       * Delete a rule from Wispbit Cloud
-       */
-      async deleteRule(_ruleId) {
-        await Promise.resolve();
-        throw new Error("Deleting rules from Wispbit Cloud is not yet implemented");
-      }
-    };
-  }
-});
-
-// src/steps/ExecutionEventEmitter.ts
-import { EventEmitter } from "events";
-var ExecutionEventEmitter;
-var init_ExecutionEventEmitter = __esm({
-  "src/steps/ExecutionEventEmitter.ts"() {
-    "use strict";
-    ExecutionEventEmitter = class extends EventEmitter {
-      rulesStartTime = 0;
-      indexingStartTimes = /* @__PURE__ */ new Map();
-      fileDiscoveryStartTime = 0;
-      constructor() {
-        super();
-        this.setMaxListeners(20);
-      }
-      // Type-safe event emission
-      emit(event, data) {
-        return super.emit(event, data);
-      }
-      // Type-safe event listening
-      on(event, listener) {
-        return super.on(event, listener);
-      }
-      once(event, listener) {
-        return super.once(event, listener);
-      }
-      off(event, listener) {
-        return super.off(event, listener);
-      }
-      // Helper method for execution mode
-      setExecutionMode(mode, options) {
-        this.emit("execution:mode", { mode, ...options });
-      }
-      // Helper methods for rule progress
-      startRules(totalRules) {
-        this.rulesStartTime = Date.now();
-        this.emit("rules:start", { totalRules });
-      }
-      progressRule(currentRule, totalRules, ruleId, isLlm) {
-        const percentage = Math.round(currentRule / totalRules * 100);
-        this.emit("rules:progress", { currentRule, totalRules, ruleId, percentage, isLlm });
-      }
-      completeRules(totalRules, totalMatches) {
-        const executionTime = Date.now() - this.rulesStartTime;
-        this.emit("rules:complete", { totalRules, totalMatches, executionTime });
-      }
-      // Helper methods for file discovery
-      startFileDiscovery(mode) {
-        this.fileDiscoveryStartTime = Date.now();
-        this.emit("files:discovery:start", { mode });
-      }
-      fileDiscoveryProgress(message, currentCount) {
-        this.emit("files:discovery:progress", { message, currentCount });
-      }
-      completeFileDiscovery(totalFiles, mode) {
-        const executionTime = Date.now() - this.fileDiscoveryStartTime;
-        this.emit("files:discovery:complete", { totalFiles, mode, executionTime });
-      }
-      fileFilter(originalCount, filteredCount, filterType) {
-        this.emit("files:filter", { originalCount, filteredCount, filterType });
-      }
-      startScipMatchLookup(language, match) {
-        this.emit("scip:match-lookup:start", { language, match });
-      }
-      scipMatchLookupProgress(language, document) {
-        this.emit("scip:match-lookup:progress", { language, document });
-      }
-      scipMatchLookupComplete(language, document) {
-        this.emit("scip:match-lookup:complete", { language, document });
-      }
-      // Helper methods for indexing
-      startIndexing(language) {
-        this.indexingStartTimes.set(language, Date.now());
-        this.emit("indexing:start", { language });
-      }
-      indexingProgress(language, message, packageName, timeMs) {
-        this.emit("indexing:progress", { language, message, packageName, timeMs });
-      }
-      completeIndexing(language) {
-        const startTime = this.indexingStartTimes.get(language) || Date.now();
-        const executionTime = Date.now() - startTime;
-        this.indexingStartTimes.delete(language);
-        this.emit("indexing:complete", { language, executionTime });
-      }
-      // Helper methods for step debugging
-      startStep(ruleId, stepName, stepType, inputs) {
-        this.emit("step:start", { ruleId, stepName, stepType, inputs });
-      }
-      completeStep(ruleId, stepName, stepType, outputs, executionTime = 0) {
-        this.emit("step:complete", { ruleId, stepName, stepType, outputs, executionTime });
-      }
-      // Helper methods for test events
-      startTest(ruleId, testName) {
-        this.emit("test:start", { ruleId, testName });
-      }
-      testMatches(ruleId, testName, matches) {
-        this.emit("test:matches", { ruleId, testName, matches });
-      }
-      // Helper methods for LLM validation events
-      startLLMValidation(ruleId, matchCount, estimatedCost) {
-        this.emit("llm:validation:start", { ruleId, matchCount, estimatedCost });
-      }
-      llmValidationProgress(ruleId, tokenCount, elapsedTime, streamedText) {
-        this.emit("llm:validation:progress", { ruleId, tokenCount, elapsedTime, streamedText });
-      }
-      completeLLMValidation(ruleId, tokenCount, executionTime, violationCount, fromCache) {
-        this.emit("llm:validation:complete", {
-          ruleId,
-          tokenCount,
-          executionTime,
-          violationCount,
-          fromCache
-        });
-      }
-    };
-  }
-});
-
-// src/steps/FileExecutionContext.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { glob } from "glob";
-import { minimatch } from "minimatch";
-var FileExecutionContext;
-var init_FileExecutionContext = __esm({
-  "src/steps/FileExecutionContext.ts"() {
-    "use strict";
-    init_ExecutionEventEmitter();
-    init_git();
-    FileExecutionContext = class _FileExecutionContext {
-      environment;
-      _filePaths = [];
-      mode;
-      eventEmitter;
-      config;
-      diffMode;
-      constructor(config, environment, mode, eventEmitter) {
-        this.environment = environment;
-        this.mode = mode;
-        this.eventEmitter = eventEmitter || new ExecutionEventEmitter();
-        this.config = config;
-      }
-      /**
-       * Create and initialize an ExecutionContext
-       */
-      static async initialize(config, environment, mode, eventEmitter, filePath, baseSha) {
-        const context = new _FileExecutionContext(config, environment, mode, eventEmitter);
-        const initialFiles = await context.discoverFiles(filePath, baseSha);
-        context._filePaths = initialFiles;
-        return context;
-      }
-      // ===== State Management =====
-      get filePaths() {
-        return this._filePaths;
-      }
-      /**
-       * Filter files based on execution mode and return filtered files
-       */
-      filterFiles(filePaths) {
-        const originalCount = filePaths.length;
-        let filteredFiles;
-        if (this.mode === "check") {
-          filteredFiles = filePaths;
-        } else if (!this.diffMode) {
-          filteredFiles = filePaths;
-        } else {
-          filteredFiles = filePaths.filter((filePath) => this.isFileValid({ filePath }));
-        }
-        if (originalCount !== filteredFiles.length) {
-          this.eventEmitter.fileFilter(originalCount, filteredFiles.length, `${this.mode}-mode-files`);
-        }
-        return filteredFiles;
-      }
-      /**
-       * Filter matches based on execution mode and return filtered matches
-       */
-      filterMatches(matches) {
-        const originalCount = matches.length;
-        const filteredMatches = matches.filter((match) => this.isMatchValid({ match }));
-        if (originalCount !== filteredMatches.length) {
-          this.eventEmitter.fileFilter(
-            originalCount,
-            filteredMatches.length,
-            `${this.mode}-mode-matches`
-          );
-        }
-        return filteredMatches;
-      }
-      /**
-       * Filter matches to only include those from the given file paths
-       */
-      filterMatchesByFilePaths(matches, filePaths) {
-        if (matches.length === 0) {
-          return matches;
-        }
-        const filePathSet = new Set(filePaths);
-        return matches.filter((match) => filePathSet.has(match.filePath));
-      }
-      get executionMode() {
-        return this.mode;
-      }
-      // ===== File Discovery =====
-      /**
-       * 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")
-       */
-      async discoverFiles(filePath, baseSha) {
-        this.eventEmitter.startFileDiscovery(this.mode);
-        let discoveredFiles;
-        if (filePath) {
-          discoveredFiles = await this.discoverFilesFromPath(filePath);
-        } else if (this.mode === "diff") {
-          const workspaceRoot = this.environment.getWorkspaceRoot();
-          if (baseSha) {
-            this.eventEmitter.fileDiscoveryProgress(`Getting changed files from ${baseSha}...`);
-          } else {
-            this.eventEmitter.fileDiscoveryProgress("Getting changed files from git...");
-          }
-          const gitChanges = await getChangedFiles(workspaceRoot, baseSha);
-          this.diffMode = {
-            gitChanges,
-            changedFiles: gitChanges.files.map((f) => f.filename),
-            fileChangeMap: new Map(gitChanges.files.map((file) => [file.filename, file]))
-          };
-          this.eventEmitter.fileDiscoveryProgress(
-            `Found ${this.diffMode.changedFiles.length} changed files`
-          );
-          discoveredFiles = this.diffMode.changedFiles.filter((file) => fs2.existsSync(path2.resolve(workspaceRoot, file))).map((file) => file);
-          this.eventEmitter.fileDiscoveryProgress("Applying ignore patterns...");
-          const allIgnorePatterns = this.config.getIgnoredGlobs();
-          if (allIgnorePatterns.length > 0) {
-            const beforeIgnore = discoveredFiles.length;
-            discoveredFiles = discoveredFiles.filter((filePath2) => {
-              const matchesIgnore = allIgnorePatterns.some(
-                (pattern) => this.matchesPattern(filePath2, pattern)
-              );
-              return !matchesIgnore;
-            });
-            if (beforeIgnore !== discoveredFiles.length) {
-              this.eventEmitter.fileDiscoveryProgress(
-                `Filtered out ${beforeIgnore - discoveredFiles.length} ignored files`
-              );
-            }
-          }
-        } else {
-          this.eventEmitter.fileDiscoveryProgress("Scanning workspace for files...");
-          const workspaceRoot = this.environment.getWorkspaceRoot();
-          const allIgnorePatterns = this.config.getIgnoredGlobs();
-          discoveredFiles = await this.discoverAllFiles([workspaceRoot], allIgnorePatterns);
-        }
-        this.eventEmitter.completeFileDiscovery(discoveredFiles.length, this.mode);
-        return discoveredFiles;
-      }
-      /**
-       * Discover files from a given path which can be a file, directory, or glob pattern
-       */
-      async discoverFilesFromPath(filePath) {
-        const workspaceRoot = this.environment.getWorkspaceRoot();
-        const fullPath = path2.resolve(workspaceRoot, filePath);
-        const allIgnorePatterns = this.config.getIgnoredGlobs();
-        if (this.isGlobPattern(filePath)) {
-          this.eventEmitter.fileDiscoveryProgress(
-            `Discovering files matching glob pattern: ${filePath}`
-          );
-          return await this.discoverFilesFromGlob(filePath, allIgnorePatterns);
-        }
-        if (!fs2.existsSync(fullPath)) {
-          throw new Error(`Path not found: ${filePath}`);
-        }
-        const stats = fs2.statSync(fullPath);
-        if (stats.isFile()) {
-          this.eventEmitter.fileDiscoveryProgress(`Checking specific file: ${filePath}`);
-          const matchesIgnore = allIgnorePatterns.some(
-            (pattern) => this.matchesPattern(filePath, pattern)
-          );
-          if (matchesIgnore) {
-            this.eventEmitter.fileDiscoveryProgress(`File ${filePath} is ignored by patterns`);
-            return [];
-          } else {
-            return [filePath];
-          }
-        } else if (stats.isDirectory()) {
-          this.eventEmitter.fileDiscoveryProgress(`Discovering files in directory: ${filePath}`);
-          return await this.discoverFilesFromDirectory(filePath, allIgnorePatterns);
-        } else {
-          throw new Error(`Path is neither a file nor directory: ${filePath}`);
-        }
-      }
-      /**
-       * Check if a path contains glob pattern characters
-       */
-      isGlobPattern(filePath) {
-        return /[*?[\]{}]/.test(filePath);
-      }
-      /**
-       * Discover files matching a glob pattern
-       */
-      async discoverFilesFromGlob(globPattern, ignorePatterns) {
-        const workspaceRoot = this.environment.getWorkspaceRoot();
-        const allIgnorePatterns = ["**/node_modules/**", "**/.git/**", ...ignorePatterns];
-        const matches = await glob(globPattern, {
-          cwd: workspaceRoot,
-          nodir: true,
-          absolute: false,
-          ignore: allIgnorePatterns
-        });
-        this.eventEmitter.fileDiscoveryProgress(`Found ${matches.length} files matching pattern`);
-        return matches;
-      }
-      /**
-       * Discover all files in a directory
-       */
-      async discoverFilesFromDirectory(dirPath, ignorePatterns) {
-        const workspaceRoot = this.environment.getWorkspaceRoot();
-        const globPattern = path2.join(dirPath, "**/*").replace(/\\/g, "/");
-        const allIgnorePatterns = ["**/node_modules/**", "**/.git/**", ...ignorePatterns];
-        const matches = await glob(globPattern, {
-          cwd: workspaceRoot,
-          nodir: true,
-          absolute: false,
-          ignore: allIgnorePatterns
-        });
-        this.eventEmitter.fileDiscoveryProgress(`Found ${matches.length} files in directory`);
-        return matches;
-      }
-      /**
-       * Discover all files from directories using glob patterns (scan mode)
-       */
-      async discoverAllFiles(directories, ignorePatterns) {
-        const allFiles = [];
-        const workspaceRoot = this.environment.getWorkspaceRoot();
-        const allIgnorePatterns = ["**/node_modules/**", "**/.git/**", ...ignorePatterns];
-        for (const dir of directories) {
-          const stats = fs2.statSync(dir);
-          if (!stats.isDirectory()) {
-            const shouldIgnore = ignorePatterns.some((pattern) => this.matchesPattern(dir, pattern));
-            if (!shouldIgnore) {
-              allFiles.push(path2.relative(workspaceRoot, dir));
-            }
-            continue;
-          }
-          const matches = await glob("**/*", {
-            cwd: dir,
-            nodir: true,
-            absolute: false,
-            // Get relative paths from the directory
-            ignore: allIgnorePatterns
-          });
-          const relativePaths = matches.map((match) => {
-            const absolutePath = path2.resolve(dir, match);
-            return path2.relative(workspaceRoot, absolutePath);
-          });
-          allFiles.push(...relativePaths);
-        }
-        return [...new Set(allFiles)];
-      }
-      /**
-       * Pattern matching function that uses consistent options
-       */
-      matchesPattern(filePath, pattern) {
-        return minimatch(filePath, pattern, { dot: true });
-      }
-      /**
-       * Check if a file should be processed
-       */
-      isFileValid(options) {
-        if (this.mode === "check") {
-          return true;
-        }
-        if (!this.diffMode) {
-          return true;
-        }
-        const { filePath } = options;
-        return this.diffMode.changedFiles.some((changedFile) => {
-          return filePath === changedFile || filePath.endsWith(changedFile) || changedFile.endsWith(filePath);
-        });
-      }
-      /**
-       * Check if a specific line range should be processed
-       */
-      isLineRangeValid(options) {
-        if (this.mode === "check") {
-          return true;
-        }
-        if (!this.diffMode) {
-          return true;
-        }
-        const { filePath, startLine, endLine } = options;
-        const fileChange = this.diffMode.fileChangeMap.get(filePath);
-        if (!fileChange) {
-          return false;
-        }
-        if (fileChange.status === "added") {
-          return true;
-        }
-        if (fileChange.status === "removed") {
-          return false;
-        }
-        return this.isLineRangeInPatch({ patch: fileChange.patch, startLine, endLine });
-      }
-      /**
-       * Check if a match should be processed
-       */
-      isMatchValid(options) {
-        if (this.mode === "check") {
-          return true;
-        }
-        if (!this.diffMode) {
-          return true;
-        }
-        const { match } = options;
-        return this.isFileValid({ filePath: match.filePath }) && this.isLineRangeValid({
-          filePath: match.filePath,
-          startLine: match.range.start.line,
-          endLine: match.range.end.line
-        });
-      }
-      // ===== Helper Methods =====
-      /**
-       * Parse a git patch to determine if a line range intersects with changed lines
-       * Adapted from patchParser.ts logic
-       */
-      isLineRangeInPatch(options) {
-        const { patch, startLine, endLine } = options;
-        const lines = patch.split("\n");
-        let currentNewLine = 0;
-        let inHunk = false;
-        for (const line of lines) {
-          const hunkMatch = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/);
-          if (hunkMatch) {
-            currentNewLine = parseInt(hunkMatch[1], 10);
-            inHunk = true;
-            continue;
-          }
-          if (!inHunk) continue;
-          if (line.startsWith("+")) {
-            if (currentNewLine >= startLine && currentNewLine <= endLine) {
-              return true;
-            }
-            currentNewLine++;
-          } else if (line.startsWith("-")) {
-            continue;
-          } else if (!line.startsWith("\\")) {
-            if (currentNewLine >= startLine && currentNewLine <= endLine) {
-              return true;
-            }
-            currentNewLine++;
-          }
-        }
-        return false;
-      }
-    };
-  }
-});
-
-// src/steps/FileFilterStep.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { minimatch as minimatch2 } from "minimatch";
-var FileFilterStep;
-var init_FileFilterStep = __esm({
-  "src/steps/FileFilterStep.ts"() {
-    "use strict";
-    FileFilterStep = class {
-      environment;
-      constructor(environment) {
-        this.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
-       */
-      matchesPattern(path11, pattern) {
-        return minimatch2(path11, pattern, { dot: true });
-      }
-      /**
-       * Evaluate a single file filter condition for a given file path
-       */
-      evaluateCondition(condition, filePath) {
-        const workspaceRoot = this.environment.getWorkspaceRoot();
-        const absoluteFilePath = path3.resolve(workspaceRoot, filePath);
-        if ("fs.siblingExists" in condition) {
-          const { filename } = condition["fs.siblingExists"];
-          const dir = path3.dirname(absoluteFilePath);
-          const siblingPath = path3.join(dir, filename);
-          return fs3.existsSync(siblingPath);
-        }
-        if ("fs.pathMatches" in condition) {
-          const { pattern } = condition["fs.pathMatches"];
-          return this.matchesPattern(filePath, pattern);
-        }
-        if ("fs.ancestorHas" in condition) {
-          const { filename } = condition["fs.ancestorHas"];
-          let currentDir = path3.dirname(absoluteFilePath);
-          const root = path3.parse(currentDir).root;
-          while (currentDir !== root) {
-            const targetPath = path3.join(currentDir, filename);
-            if (fs3.existsSync(targetPath)) {
-              return true;
-            }
-            const parentDir = path3.dirname(currentDir);
-            if (parentDir === currentDir) break;
-            currentDir = parentDir;
-          }
-          return false;
-        }
-        if ("fs.siblingAny" in condition) {
-          const { pattern } = condition["fs.siblingAny"];
-          const dir = path3.dirname(absoluteFilePath);
-          if (!fs3.existsSync(dir)) {
-            return false;
-          }
-          const siblings = fs3.readdirSync(dir);
-          return siblings.some((sibling) => this.matchesPattern(sibling, pattern));
-        }
-        return false;
-      }
-      /**
-       * Evaluate file filter conditions for a given file path
-       */
-      evaluateConditions(conditions, filePath) {
-        const results = [];
-        if (conditions.all) {
-          results.push(conditions.all.every((condition) => this.evaluateCondition(condition, filePath)));
-        }
-        if (conditions.any) {
-          results.push(conditions.any.some((condition) => this.evaluateCondition(condition, filePath)));
-        }
-        if (conditions.not) {
-          results.push(!conditions.not.some((condition) => this.evaluateCondition(condition, filePath)));
-        }
-        return results.length === 0 ? true : results.every((result) => result === true);
-      }
-      /**
-       * Execute file filter on file paths
-       */
-      async execute(filePaths, options) {
-        var _a, _b;
-        const startTime = Date.now();
-        let filteredPaths = filePaths;
-        if ((_a = options.include) == null ? void 0 : _a.length) {
-          filteredPaths = filteredPaths.filter(
-            (filePath) => options.include.some((pattern) => this.matchesPattern(filePath, pattern))
-          );
-        }
-        if ((_b = options.ignore) == null ? void 0 : _b.length) {
-          filteredPaths = filteredPaths.filter((filePath) => {
-            const matchesIgnore = options.ignore.some(
-              (pattern) => this.matchesPattern(filePath, pattern)
-            );
-            return !matchesIgnore;
-          });
-        }
-        if (options.conditions) {
-          filteredPaths = filteredPaths.filter(
-            (filePath) => this.evaluateConditions(options.conditions, filePath)
-          );
-        }
-        const executionTime = Date.now() - startTime;
-        return await Promise.resolve({
-          filteredPaths,
-          executionTime
-        });
-      }
-    };
-  }
-});
-
-// src/languages.ts
-import { existsSync as existsSync3 } from "fs";
-import { createRequire } from "module";
-import path4 from "path";
-import angular from "@ast-grep/lang-angular";
-import bash from "@ast-grep/lang-bash";
-import c from "@ast-grep/lang-c";
-import cpp from "@ast-grep/lang-cpp";
-import csharp from "@ast-grep/lang-csharp";
-import css from "@ast-grep/lang-css";
-import dart from "@ast-grep/lang-dart";
-import elixir from "@ast-grep/lang-elixir";
-import go from "@ast-grep/lang-go";
-import haskell from "@ast-grep/lang-haskell";
-import html from "@ast-grep/lang-html";
-import java from "@ast-grep/lang-java";
-import javascript from "@ast-grep/lang-javascript";
-import json from "@ast-grep/lang-json";
-import kotlin from "@ast-grep/lang-kotlin";
-import lua from "@ast-grep/lang-lua";
-import markdown from "@ast-grep/lang-markdown";
-import php from "@ast-grep/lang-php";
-import python from "@ast-grep/lang-python";
-import ruby from "@ast-grep/lang-ruby";
-import rust from "@ast-grep/lang-rust";
-import scala from "@ast-grep/lang-scala";
-import sql from "@ast-grep/lang-sql";
-import swift from "@ast-grep/lang-swift";
-import toml from "@ast-grep/lang-toml";
-import tsx from "@ast-grep/lang-tsx";
-import typescript from "@ast-grep/lang-typescript";
-import yaml from "@ast-grep/lang-yaml";
-import { registerDynamicLanguage } from "@ast-grep/napi";
-function getGraphQLLibPath() {
-  const graphqlDir = path4.dirname(require2.resolve("tree-sitter-graphql"));
-  const releaseNode = path4.join(graphqlDir, "../../build/Release/tree_sitter_graphql_binding.node");
-  if (existsSync3(releaseNode)) {
-    return releaseNode;
-  }
-  const debugNode = path4.join(graphqlDir, "../../build/Debug/tree_sitter_graphql_binding.node");
-  if (existsSync3(debugNode)) {
-    return debugNode;
-  }
-  const soFile = path4.join(graphqlDir, "parser.so");
-  if (existsSync3(soFile)) {
-    return soFile;
-  }
-  return null;
-}
-function getLanguageFromFilePath(filePath) {
-  const extension = path4.extname(filePath).slice(1);
-  const language = findRegisteredLanguageFromExtension(extension);
-  return language ?? "Unknown" /* Unknown */;
-}
-function findRegisteredLanguageFromExtension(extension) {
-  return Object.keys(REGISTERED_LANGUAGE_EXTENSIONS).find(
-    (language) => REGISTERED_LANGUAGE_EXTENSIONS[language].includes(extension)
-  );
-}
-var require2, graphqlPath, graphql, registeredLanguages, REGISTERED_LANGUAGE_EXTENSIONS;
-var init_languages = __esm({
-  "src/languages.ts"() {
-    "use strict";
-    console.debug = () => {
-    };
-    require2 = createRequire(import.meta.url ? import.meta.url : __filename);
-    graphqlPath = getGraphQLLibPath();
-    graphql = {
-      // node-gyp-build puts the .node file in build/Release/
-      libraryPath: graphqlPath,
-      /** the file extensions of the language. e.g. mojo */
-      extensions: ["graphql"],
-      /** the dylib symbol to load ts-language, default is `tree_sitter_{name}` */
-      languageSymbol: "tree_sitter_graphql",
-      /** the meta variable leading character, default is $ */
-      metaVarChar: "$",
-      /**
-       * An optional char to replace $ in your pattern.
-       * See https://ast-grep.github.io/advanced/custom-language.html#register-language-in-sgconfig-yml
-       */
-      expandoChar: void 0
-    };
-    registeredLanguages = {
-      ["Angular" /* Angular */]: angular,
-      ["Bash" /* Bash */]: bash,
-      ["C" /* C */]: c,
-      ["Cpp" /* Cpp */]: cpp,
-      ["Csharp" /* Csharp */]: csharp,
-      ["Css" /* Css */]: css,
-      ["Dart" /* Dart */]: dart,
-      ["Elixir" /* Elixir */]: elixir,
-      ["Go" /* Go */]: go,
-      ["Haskell" /* Haskell */]: haskell,
-      ["Html" /* Html */]: html,
-      ["Java" /* Java */]: java,
-      ["JavaScript" /* JavaScript */]: javascript,
-      ["Json" /* Json */]: json,
-      ["Kotlin" /* Kotlin */]: kotlin,
-      ["Lua" /* Lua */]: lua,
-      ["Markdown" /* Markdown */]: markdown,
-      ["Php" /* Php */]: php,
-      ["Python" /* Python */]: python,
-      ["Ruby" /* Ruby */]: ruby,
-      ["Rust" /* Rust */]: rust,
-      ["Scala" /* Scala */]: scala,
-      ["Sql" /* Sql */]: sql,
-      ["Swift" /* Swift */]: swift,
-      ["Toml" /* Toml */]: toml,
-      ["Tsx" /* Tsx */]: tsx,
-      ["TypeScript" /* TypeScript */]: typescript,
-      ["Yaml" /* Yaml */]: yaml,
-      ...graphqlPath ? { ["GraphQL" /* GraphQL */]: graphql } : {}
-    };
-    registerDynamicLanguage(registeredLanguages);
-    REGISTERED_LANGUAGE_EXTENSIONS = Object.entries(
-      registeredLanguages
-    ).reduce(
-      (acc, [language, registration]) => {
-        acc[language] = registration.extensions ?? [];
-        return acc;
-      },
-      {}
-    );
-  }
-});
-
-// src/providers/AstGrepAstProvider.ts
-import { readFile as readFile2 } from "fs/promises";
-import path5 from "path";
-import { parse as parse2, parseAsync } from "@ast-grep/napi";
-var AstGrepAstProvider;
-var init_AstGrepAstProvider = __esm({
-  "src/providers/AstGrepAstProvider.ts"() {
-    "use strict";
-    AstGrepAstProvider = class {
-      environment;
-      language;
-      constructor(environment, language) {
-        this.environment = environment;
-        this.language = language;
-      }
-      /**
-       * Find all matches based on ast-grep pattern
-       * @param filePaths File paths to search in (relative to workspace root)
-       * @param schema The ast-grep schema (rule, constraints, etc.)
-       * @returns Array of matches found
-       */
-      async findMatches(filePaths, schema) {
-        if (filePaths.length === 0) {
-          return [];
-        }
-        const { rule, constraints } = schema;
-        const batchSize = this.getBatchSize();
-        const matches = [];
-        for (let i = 0; i < filePaths.length; i += batchSize) {
-          const batch = filePaths.slice(i, i + batchSize);
-          const batchMatches = await this.processBatch(batch, rule, constraints);
-          matches.push(...batchMatches);
-        }
-        return matches;
-      }
-      /**
-       * Get optimal batch size based on available CPU cores and thread pool size
-       */
-      getBatchSize() {
-        const threadPoolSize = parseInt(process.env.UV_THREADPOOL_SIZE || "4", 10);
-        return Math.max(2, Math.floor(threadPoolSize / 2));
-      }
-      /**
-       * Process a batch of files with memory-efficient approach
-       */
-      async processBatch(filePaths, rule, constraints) {
-        const parsePromises = filePaths.map(async (filePath) => {
-          const content = await readFile2(
-            path5.resolve(this.environment.getWorkspaceRoot(), filePath),
-            "utf-8"
-          );
-          const node = await parseAsync(this.language, content);
-          const foundNodes = node.root().findAll({
-            rule,
-            language: this.language,
-            constraints
-          });
-          return foundNodes.map((sgNode) => ({ filePath, sgNode }));
-        });
-        const batchResults = await Promise.all(parsePromises);
-        const sgNodes = batchResults.flat();
-        const matches = [];
-        for (const { filePath, sgNode } of sgNodes) {
-          const range = sgNode.range();
-          matches.push({
-            filePath,
-            text: sgNode.text(),
-            range: {
-              start: {
-                line: range.start.line,
-                column: range.start.column
-              },
-              end: {
-                line: range.end.line,
-                column: range.end.column
-              }
-            },
-            // Try to extract symbol if possible
-            symbol: this.extractSymbol(sgNode),
-            language: this.language
-          });
-        }
-        return matches;
-      }
-      /**
-       * Extract symbol name from ast-grep node if possible
-       */
-      extractSymbol(node) {
-        const kind = node.kind();
-        if (kind === "call_expression") {
-          const functionNode = node.field("function");
-          if (functionNode) {
-            return this.extractSymbol(functionNode);
-          }
-        } else if (kind === "member_expression") {
-          const propertyNode = node.field("property");
-          if (propertyNode) {
-            return propertyNode.text();
-          }
-        } else if (kind === "identifier") {
-          return node.text();
-        }
-        return void 0;
-      }
-      /**
-       * Expand a match to its enclosing function, method, or class definition
-       * @param match The match to expand (typically a small range like a method name)
-       * @returns Expanded match with the full function/method/class body, or null if not found
-       */
-      async expandMatch(match) {
-        const targetNodeKinds = /* @__PURE__ */ new Set([
-          "method_definition",
-          "function_declaration",
-          "function_expression",
-          "arrow_function",
-          "class_declaration",
-          "export_statement",
-          "lexical_declaration"
-          // For const/let function expressions
-        ]);
-        const absolutePath = path5.resolve(this.environment.getWorkspaceRoot(), match.filePath);
-        const content = await readFile2(absolutePath, "utf-8");
-        const root = parse2(this.language, content).root();
-        const nodeAtPosition = this.findNodeAtPosition(
-          root,
-          match.range.start.line,
-          match.range.start.column
-        );
-        if (!nodeAtPosition) {
-          return null;
-        }
-        let current = nodeAtPosition;
-        while (current) {
-          const kindValue = current.kind();
-          const kindStr = typeof kindValue === "string" ? kindValue : String(kindValue);
-          if (targetNodeKinds.has(kindStr)) {
-            const range = current.range();
-            return {
-              filePath: match.filePath,
-              text: current.text(),
-              range: {
-                start: { line: range.start.line, column: range.start.column },
-                end: { line: range.end.line, column: range.end.column }
-              },
-              symbol: match.symbol,
-              language: this.language
-            };
-          }
-          current = current.parent();
-        }
-        return null;
-      }
-      /**
-       * Find the deepest node at a given position
-       */
-      findNodeAtPosition(node, line, column) {
-        const range = node.range();
-        const isAfterStart = line > range.start.line || line === range.start.line && column >= range.start.column;
-        const isBeforeEnd = line < range.end.line || line === range.end.line && column <= range.end.column;
-        if (!isAfterStart || !isBeforeEnd) {
-          return null;
-        }
-        const children = node.children();
-        for (const child of children) {
-          const deeperNode = this.findNodeAtPosition(child, line, column);
-          if (deeperNode) {
-            return deeperNode;
-          }
-        }
-        return node;
-      }
-    };
-  }
-});
-
-// src/utils/readTextAtRange.ts
-import { readFile as readFile3 } from "fs/promises";
-import path6 from "path";
-async function readTextAtRange(workspaceRoot, filePath, range) {
-  const absolutePath = path6.resolve(workspaceRoot, filePath);
-  const content = await readFile3(absolutePath, "utf-8");
-  const lines = content.split("\n");
-  const { start, end } = range;
-  if (start.line === end.line) {
-    const line = lines[start.line] || "";
-    return line.substring(start.column, end.column);
-  }
-  const result = [];
-  for (let i = start.line; i <= end.line && i < lines.length; i++) {
-    const line = lines[i];
-    if (i === start.line) {
-      result.push(line.substring(start.column));
-    } else if (i === end.line) {
-      result.push(line.substring(0, end.column));
-    } else {
-      result.push(line);
-    }
-  }
-  return result.join("\n");
-}
-var init_readTextAtRange = __esm({
-  "src/utils/readTextAtRange.ts"() {
-    "use strict";
-  }
-});
-
-// src/providers/ScipIntelligenceProvider.ts
-import { spawn } from "child_process";
-import fs4 from "fs/promises";
-import { createRequire as createRequire2 } from "module";
-import os2 from "os";
-import path7 from "path";
-function processScipProgressData(data, buffer, eventEmitter, language, rootPath) {
-  const text = data.toString();
-  buffer += text;
-  const lines = buffer.split("\n");
-  const newBuffer = lines.pop() || "";
-  let latestPackageLine = null;
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-    const packageMatch = trimmedLine.match(PACKAGE_REGEX);
-    if (packageMatch) {
-      latestPackageLine = trimmedLine;
-    }
-  }
-  for (const line of lines) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine) continue;
-    const packageMatch = trimmedLine.match(PACKAGE_REGEX);
-    if (packageMatch) {
-      if (trimmedLine === latestPackageLine) {
-        const [, packagePath, timeMs] = packageMatch;
-        const relativePackagePath = path7.relative(rootPath, packagePath);
-        eventEmitter.indexingProgress(
-          language,
-          `Indexed ${relativePackagePath}`,
-          relativePackagePath,
-          parseInt(timeMs, 10)
-        );
-      }
-    } else {
-      eventEmitter.indexingProgress(language, trimmedLine);
-    }
-  }
-  return newBuffer;
-}
-var require3, scip, PACKAGE_REGEX, ScipIntelligenceProvider;
-var init_ScipIntelligenceProvider = __esm({
-  "src/providers/ScipIntelligenceProvider.ts"() {
-    "use strict";
-    init_Storage();
-    init_languages();
-    init_ExecutionEventEmitter();
-    init_readTextAtRange();
-    require3 = createRequire2(import.meta.url ? import.meta.url : __filename);
-    ({ scip } = require3("@sourcegraph/scip-root/bindings/typescript/scip.js"));
-    PACKAGE_REGEX = /^\+ (.+?) \((\d+)ms\)$/;
-    ScipIntelligenceProvider = class {
-      environment;
-      storage;
-      language;
-      scipIndex = null;
-      indexingPromise = null;
-      eventEmitter;
-      constructor(environment, language, eventEmitter) {
-        this.environment = environment;
-        this.storage = new Storage(environment);
-        this.language = language;
-        this.eventEmitter = eventEmitter || new ExecutionEventEmitter();
-      }
-      /**
-       * Get the SCIP CLI command for the given language
-       */
-      getScipCommand() {
-        switch (this.language) {
-          case "TypeScript" /* TypeScript */:
-          case "JavaScript" /* JavaScript */:
-          case "Tsx" /* Tsx */:
-            return "scip-typescript";
-          case "Python" /* Python */:
-            return "scip-python";
-          default:
-            throw new Error(`SCIP is not supported for language: ${this.language}`);
-        }
-      }
-      /**
-       * Ensure the index is ready, starting indexing if needed
-       */
-      async ensureIndexReady() {
-        if (this.scipIndex !== null) {
-          return;
-        }
-        if (this.indexingPromise !== null) {
-          return this.indexingPromise;
-        }
-        this.indexingPromise = this.startIndexing();
-        await this.indexingPromise;
-      }
-      /**
-       * Start the indexing process
-       */
-      async startIndexing() {
-        if (await this.storage.indexExists(this.language, `index.scip`)) {
-          await this.loadIndex();
-          return;
-        }
-        const finalIndexPath = await this.storage.getIndexFilePath(this.language, `index.scip`);
-        const tempIndexPath = path7.join(os2.tmpdir(), `scip-index-${this.language}-${Date.now()}.tmp`);
-        this.eventEmitter.startIndexing(this.language);
-        const scipCommand = this.getScipCommand();
-        const child = spawn(scipCommand, ["index", "--output", tempIndexPath], {
-          cwd: this.environment.getWorkspaceRoot(),
-          stdio: ["ignore", "pipe", "pipe"],
-          env: process.env
-        });
-        let progressBuffer = "";
-        child.stdout.on("data", (data) => {
-          progressBuffer = processScipProgressData(
-            data,
-            progressBuffer,
-            this.eventEmitter,
-            this.language,
-            this.environment.getWorkspaceRoot()
-          );
-        });
-        let stderr = "";
-        child.stderr.on("data", (data) => {
-          stderr += data.toString();
-          process.stderr.write(data);
-        });
-        await new Promise((resolve3, reject) => {
-          child.on("close", async (code) => {
-            if (code === 0) {
-              await fs4.rename(tempIndexPath, finalIndexPath);
-              resolve3();
-            } else {
-              await fs4.unlink(tempIndexPath).catch(() => {
-              });
-              reject(new Error(`${scipCommand} index exited with code ${code}, stderr: ${stderr}`));
-            }
-          });
-          child.on("error", async (err) => {
-            await fs4.unlink(tempIndexPath).catch(() => {
-            });
-            reject(err);
-          });
-        });
-        if (stderr) {
-          console.error("SCIP indexing stderr:", stderr);
-        }
-        this.eventEmitter.completeIndexing(this.language);
-        await this.loadIndex();
-      }
-      /**
-       * Find all definitions for a given match
-       * Automatically filters out external symbols
-       */
-      async findDefinitions(match) {
-        await this.ensureIndexReady();
-        if (!this.scipIndex) throw new Error("SCIP index not ready");
-        this.eventEmitter.startScipMatchLookup(this.language, match);
-        const definitions = [];
-        const documents = this.scipIndex.documents;
-        for (const document of documents) {
-          if (document.relative_path !== match.filePath) continue;
-          this.eventEmitter.scipMatchLookupProgress(this.language, document);
-          const scipOcc = this.findBestOverlappingOccurrence(document.occurrences, match);
-          if (scipOcc) {
-            if (this.isExternalSymbol(scipOcc.symbol)) {
-              continue;
-            }
-            this.eventEmitter.scipMatchLookupProgress(this.language, scipOcc);
-            const def = await this.findDefinitionForSymbol(scipOcc.symbol, documents);
-            if (def) {
-              definitions.push(def);
-            }
-          }
-        }
-        return definitions;
-      }
-      /**
-       * Find all references for a given match
-       * Automatically filters out external symbols
-       */
-      async findReferences(match) {
-        await this.ensureIndexReady();
-        if (!this.scipIndex) {
-          return [];
-        }
-        const references = [];
-        const documents = this.scipIndex.documents;
-        for (const document of documents) {
-          if (document.relative_path !== match.filePath) continue;
-          const scipOcc = this.findBestOverlappingOccurrence(document.occurrences, match);
-          if (scipOcc) {
-            if (this.isExternalSymbol(scipOcc.symbol)) {
-              break;
-            }
-            const refs = await this.findReferencesForSymbol(scipOcc.symbol, documents);
-            references.push(...refs);
-            break;
-          }
-        }
-        return references;
-      }
-      /**
-       * Check if a symbol is from an external library (internal use)
-       */
-      isExternalSymbol(symbol) {
-        return symbol.includes("node_modules") || symbol.startsWith("npm/");
-      }
-      /**
-       * Find the best SCIP occurrence that overlaps with the given match
-       * Uses heuristics to pick the most relevant occurrence when multiple overlap
-       */
-      findBestOverlappingOccurrence(occurrences, match) {
-        const candidates = [];
-        for (const scipOcc of occurrences) {
-          const range = scipOcc.range;
-          if (!range || range.length < 3) continue;
-          if (!this.rangesOverlap(range, match)) continue;
-          let score = 0;
-          if (!this.rangeFullyInside(range, match)) continue;
-          const startCol = range.length === 3 ? range[1] : range[1];
-          score += startCol * 1e3;
-          if (scipOcc.symbol_roles !== scip.SymbolRole.Definition) {
-            score += 100;
-          }
-          if (match.symbol) {
-            const { className, methodName } = this.extractSymbolNames(scipOcc.symbol);
-            if (methodName === match.symbol || className === match.symbol) {
-              score += 1e4;
-            }
-          }
-          candidates.push({ occurrence: scipOcc, score });
-        }
-        if (candidates.length === 0) return null;
-        candidates.sort((a, b) => b.score - a.score);
-        return candidates[0].occurrence;
-      }
-      /**
-       * Check if two ranges overlap
-       */
-      rangesOverlap(scipRange, match) {
-        if (scipRange.length === 3) {
-          const [line, startCol, endCol] = scipRange;
-          if (match.range.start.line === match.range.end.line) {
-            return line === match.range.start.line && !(endCol <= match.range.start.column || startCol >= match.range.end.column);
-          } else {
-            if (line < match.range.start.line || line > match.range.end.line) return false;
-            if (line === match.range.start.line && endCol <= match.range.start.column) return false;
-            if (line === match.range.end.line && startCol >= match.range.end.column) return false;
-            return true;
-          }
-        } else if (scipRange.length === 4) {
-          const [startLine, _startCol, endLine, _endCol] = scipRange;
-          if (endLine < match.range.start.line || startLine > match.range.end.line) return false;
-          return true;
-        }
-        return false;
-      }
-      /**
-       * Check if SCIP range is fully inside the match span
-       */
-      rangeFullyInside(scipRange, match) {
-        if (scipRange.length === 3) {
-          const [line, startCol, endCol] = scipRange;
-          if (line < match.range.start.line || line > match.range.end.line) return false;
-          if (line === match.range.start.line && startCol < match.range.start.column) return false;
-          if (line === match.range.end.line && endCol > match.range.end.column) return false;
-          return true;
-        } else if (scipRange.length === 4) {
-          const [startLine, startCol, endLine, endCol] = scipRange;
-          if (startLine < match.range.start.line) return false;
-          if (endLine > match.range.end.line) return false;
-          if (startLine === match.range.start.line && startCol < match.range.start.column) return false;
-          if (endLine === match.range.end.line && endCol > match.range.end.column) return false;
-          return true;
-        }
-        return false;
-      }
-      /**
-       * Extract class and method names from SCIP symbol
-       * e.g., "scip-typescript npm @wispbit/server 1.0.0 src/services/`OrganizationService`#updateViolationCounts()."
-       * returns { className: "OrganizationService", methodName: "updateViolationCounts" }
-       *
-       * For standalone functions without a class:
-       * e.g., "scip-typescript npm @wispbit/server 1.0.0 src/utils/helper()."
-       * returns { className: null, methodName: "helper" }
-       */
-      extractSymbolNames(symbol) {
-        const classMethodMatch = symbol.match(/`([^`]+)`#([^#./`(]+)(?:\(\))?[.`]*$/);
-        if (classMethodMatch) {
-          return {
-            className: classMethodMatch[1],
-            methodName: classMethodMatch[2]
-          };
-        }
-        const methodMatch = symbol.match(/([^#./`(]+)(?:\(\))?[.`]*$/);
-        if (methodMatch) {
-          return {
-            className: null,
-            methodName: methodMatch[1]
-          };
-        }
-        return { className: null, methodName: null };
-      }
-      /**
-       * Find definition for a symbol across all documents
-       */
-      async findDefinitionForSymbol(symbol, documents) {
-        for (const document of documents) {
-          for (const occ of document.occurrences) {
-            if (occ.symbol === symbol && occ.symbol_roles === scip.SymbolRole.Definition) {
-              const range = occ.range ?? [];
-              const startLine = range[0] ?? 0;
-              const startColumn = range[1] ?? 0;
-              const endLine = range.length === 4 ? range[2] : startLine;
-              const endColumn = range.length === 4 ? range[3] : range[2] ?? startColumn;
-              const text = await readTextAtRange(
-                this.environment.getWorkspaceRoot(),
-                document.relative_path,
-                {
-                  start: { line: startLine, column: startColumn },
-                  end: { line: endLine, column: endColumn }
-                }
-              );
-              return {
-                language: this.language,
-                filePath: document.relative_path,
-                range: {
-                  start: { line: startLine, column: startColumn },
-                  end: { line: endLine, column: endColumn }
-                },
-                symbol,
-                text
-              };
-            }
-          }
-        }
-        return null;
-      }
-      /**
-       * Find all references for a symbol across all documents
-       */
-      async findReferencesForSymbol(symbol, documents) {
-        const references = [];
-        for (const document of documents) {
-          for (const occ of document.occurrences) {
-            if (occ.symbol === symbol && occ.symbol_roles !== scip.SymbolRole.Definition) {
-              const range = occ.range ?? [];
-              const startLine = range[0] ?? 0;
-              const startColumn = range[1] ?? 0;
-              const endLine = range.length === 4 ? range[2] : startLine;
-              const endColumn = range.length === 4 ? range[3] : range[2] ?? startColumn;
-              const text = await readTextAtRange(
-                this.environment.getWorkspaceRoot(),
-                document.relative_path,
-                {
-                  start: { line: startLine, column: startColumn },
-                  end: { line: endLine, column: endColumn }
-                }
-              );
-              references.push({
-                language: this.language,
-                filePath: document.relative_path,
-                range: {
-                  start: { line: startLine, column: startColumn },
-                  end: { line: endLine, column: endColumn }
-                },
-                symbol,
-                text
-              });
-            }
-          }
-        }
-        return references;
-      }
-      /**
-       * Load SCIP index from the configured path
-       */
-      async loadIndex() {
-        const buffer = await this.storage.readIndex(this.language, `index.scip`);
-        if (!buffer) {
-          throw new Error(`Index not found for language: ${this.language}`);
-        }
-        this.scipIndex = this.parseIndex(new Uint8Array(buffer));
-      }
-      /**
-       * Parse a SCIP index from bytes
-       */
-      parseIndex(buffer) {
-        return scip.Index.deserialize(buffer);
-      }
-    };
-  }
-});
-
-// src/providers/LanguageBackend.ts
-var LanguageBackendNotSupportedError, LanguageBackend;
-var init_LanguageBackend = __esm({
-  "src/providers/LanguageBackend.ts"() {
-    "use strict";
-    init_AstGrepAstProvider();
-    init_ScipIntelligenceProvider();
-    LanguageBackendNotSupportedError = class extends Error {
-      constructor(methodName, reason) {
-        super(`${methodName} is not supported: ${reason}`);
-        this.name = "LanguageBackendNotSupportedError";
-      }
-    };
-    LanguageBackend = class {
-      astProvider;
-      intelligenceProvider;
-      language;
-      constructor(environment, language, eventEmitter) {
-        this.language = language;
-        this.astProvider = new AstGrepAstProvider(environment, language);
-        this.intelligenceProvider = new ScipIntelligenceProvider(environment, language, eventEmitter);
-      }
-      /**
-       * Find all matches based on the AST provider
-       */
-      async findMatches(filePaths, schema) {
-        if (!this.astProvider) {
-          throw new LanguageBackendNotSupportedError(
-            "findMatches",
-            "no AST provider configured for this language"
-          );
-        }
-        return await this.astProvider.findMatches(filePaths, schema);
-      }
-      /**
-       * Find all definitions for a given match
-       */
-      async findDefinitions(match) {
-        if (!this.intelligenceProvider) {
-          throw new LanguageBackendNotSupportedError(
-            "findDefinitions",
-            "no intelligence provider configured for this language"
-          );
-        }
-        return await this.intelligenceProvider.findDefinitions(match);
-      }
-      /**
-       * Find all references for a given match
-       */
-      async findReferences(match) {
-        if (!this.intelligenceProvider) {
-          throw new LanguageBackendNotSupportedError(
-            "findReferences",
-            "no intelligence provider configured for this language"
-          );
-        }
-        return await this.intelligenceProvider.findReferences(match);
-      }
-      /**
-       * Expand a match to its enclosing function, method, or class definition
-       * Useful for expanding a definition point (e.g., method name) to the full body
-       */
-      async expandMatch(match) {
-        if (!this.astProvider) {
-          throw new LanguageBackendNotSupportedError(
-            "expandMatch",
-            "no AST provider configured for this language"
-          );
-        }
-        return await this.astProvider.expandMatch(match);
-      }
-    };
-  }
-});
-
-// src/steps/FindMatchesStep.ts
-import path8 from "path";
-var FindMatchesStep;
-var init_FindMatchesStep = __esm({
-  "src/steps/FindMatchesStep.ts"() {
-    "use strict";
-    init_languages();
-    init_LanguageBackend();
-    FindMatchesStep = class {
-      environment;
-      eventEmitter;
-      constructor(environment, eventEmitter) {
-        this.environment = environment;
-        this.eventEmitter = eventEmitter;
-      }
-      /**
-       * 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
-       */
-      async execute(schema, language, context) {
-        const startTime = Date.now();
-        const languageFilteredPaths = context.filePaths.filter((filePath) => {
-          const fileLanguage = getLanguageFromFilePath(filePath);
-          return fileLanguage === language;
-        });
-        const backend = new LanguageBackend(this.environment, language, this.eventEmitter);
-        const allMatches = await backend.findMatches(languageFilteredPaths, schema);
-        const matchesWithLanguage = allMatches.map((match) => {
-          if (path8.isAbsolute(match.filePath)) {
-            throw new Error(
-              `Match provider returned absolute path: ${match.filePath}. All file paths must be relative to workspace root.`
-            );
-          }
-          return {
-            ...match,
-            language
-          };
-        });
-        let filteredMatches = context.previousMatches && context.previousMatches.length > 0 ? this.filterMatchesByRanges(matchesWithLanguage, context.previousMatches, language) : matchesWithLanguage;
-        filteredMatches = this.deduplicateMatches(filteredMatches);
-        const executionTime = Date.now() - startTime;
-        return {
-          matches: filteredMatches,
-          totalMatches: filteredMatches.length,
-          executionTime
-        };
-      }
-      /**
-       * 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
-       */
-      filterMatchesByRanges(matches, previousMatches, _language) {
-        const result = [];
-        for (const match of matches) {
-          const containingMatch = previousMatches.find(
-            (prevMatch) => this.isMatchInRange(match, prevMatch)
-          );
-          if (!containingMatch) {
-            continue;
-          }
-          const source = [
-            ...containingMatch.source || [],
-            {
-              filePath: containingMatch.filePath,
-              text: containingMatch.text,
-              range: containingMatch.range,
-              symbol: containingMatch.symbol,
-              language: containingMatch.language
-            }
-          ];
-          result.push({
-            ...match,
-            source
-          });
-        }
-        return result;
-      }
-      /**
-       * Check if a match falls within the range of another match
-       * Both matches must be in the same file
-       */
-      isMatchInRange(match, rangeMatch) {
-        if (match.filePath !== rangeMatch.filePath) {
-          return false;
-        }
-        const matchStart = match.range.start;
-        const matchEnd = match.range.end;
-        const rangeStart = rangeMatch.range.start;
-        const rangeEnd = rangeMatch.range.end;
-        const startInRange = matchStart.line > rangeStart.line || matchStart.line === rangeStart.line && matchStart.column >= rangeStart.column;
-        const endInRange = matchEnd.line < rangeEnd.line || matchEnd.line === rangeEnd.line && matchEnd.column <= rangeEnd.column;
-        return startInRange && endInRange;
-      }
-      /**
-       * Remove duplicate matches by keeping only the largest overlapping match.
-       * If multiple matches overlap (one is contained within another), keep only the largest one.
-       */
-      deduplicateMatches(matches) {
-        if (matches.length <= 1) {
-          return matches;
-        }
-        const result = [];
-        for (const match of matches) {
-          const isContainedByAnother = matches.some((otherMatch) => {
-            if (match === otherMatch) return false;
-            return this.isMatchInRange(match, otherMatch);
-          });
-          if (!isContainedByAnother) {
-            result.push(match);
-          }
-        }
-        return result;
-      }
-    };
-  }
-});
-
-// src/steps/GotoDefinitionStep.ts
-import path9 from "path";
-import { minimatch as minimatch3 } from "minimatch";
-var GotoDefinitionStep;
-var init_GotoDefinitionStep = __esm({
-  "src/steps/GotoDefinitionStep.ts"() {
-    "use strict";
-    init_LanguageBackend();
-    init_ExecutionEventEmitter();
-    GotoDefinitionStep = class {
-      maxDepth = 1;
-      environment;
-      eventEmitter;
-      constructor(environment, eventEmitter) {
-        this.environment = environment;
-        this.eventEmitter = eventEmitter || new ExecutionEventEmitter();
-      }
-      /**
-       * Execute goto-definition on matches
-       */
-      async execute(matches, language, options = {}) {
-        const startTime = Date.now();
-        const backend = new LanguageBackend(this.environment, language, this.eventEmitter);
-        const definitions = await this.followDefinitions(
-          matches,
-          backend,
-          this.maxDepth,
-          options.where,
-          language
-        );
-        const executionTime = Date.now() - startTime;
-        const flattenedDefinitions = definitions.map((def) => {
-          const { depth: _depth, sourceMatch, ...match } = def;
-          const source = sourceMatch ? [
-            {
-              filePath: sourceMatch.filePath,
-              text: sourceMatch.text,
-              range: sourceMatch.range,
-              symbol: sourceMatch.symbol,
-              language: sourceMatch.language
-            },
-            ...sourceMatch.source || []
-          ] : [];
-          return {
-            ...match,
-            source
-          };
-        });
-        return {
-          definitions: flattenedDefinitions,
-          totalDefinitions: flattenedDefinitions.length,
-          executionTime
-        };
-      }
-      /**
-       * Follow definitions up to maxDepth
-       */
-      async followDefinitions(matches, backend, maxDepth, filter, language) {
-        const definitions = [];
-        const visited = /* @__PURE__ */ new Set();
-        for (const match of matches) {
-          await this.followDefinitionsRecursive(
-            match,
-            backend,
-            0,
-            maxDepth,
-            filter,
-            definitions,
-            visited,
-            match,
-            language
-          );
-        }
-        return definitions;
-      }
-      /**
-       * Recursively follow definitions
-       */
-      async followDefinitionsRecursive(match, backend, currentDepth, maxDepth, filter, definitions, visited, sourceMatch, language) {
-        if (currentDepth >= maxDepth) {
-          return;
-        }
-        const key = `${match.filePath}:${match.range.start.line}:${match.range.start.column}:${match.symbol ?? ""}`;
-        if (visited.has(key)) {
-          return;
-        }
-        visited.add(key);
-        const backendDefinitions = await backend.findDefinitions(match);
-        for (const backendDef of backendDefinitions) {
-          const expandedDef = await backend.expandMatch(backendDef) ?? backendDef;
-          const defResult = {
-            ...expandedDef,
-            language,
-            depth: currentDepth,
-            sourceMatch: sourceMatch || match
-          };
-          if (filter && !this.matchesDefinitionFilter(defResult, filter)) {
-            continue;
-          }
-          definitions.push(defResult);
-          if (currentDepth + 1 < maxDepth) {
-            await this.followDefinitionsRecursive(
-              backendDef,
-              backend,
-              currentDepth + 1,
-              maxDepth,
-              filter,
-              definitions,
-              visited,
-              sourceMatch || match,
-              language
-            );
-          }
-        }
-      }
-      /**
-       * Check if a definition matches a filter
-       */
-      matchesDefinitionFilter(def, filter) {
-        var _a, _b, _c;
-        if (filter.all) {
-          return filter.all.every((f) => this.matchesDefinitionFilter(def, f));
-        }
-        if (filter.any) {
-          return filter.any.some((f) => this.matchesDefinitionFilter(def, f));
-        }
-        if (filter.not) {
-          return !this.matchesDefinitionFilter(def, filter.not);
-        }
-        if (filter.file) {
-          if (!this.matchesFileSpec(def.filePath, filter.file)) {
-            return false;
-          }
-        }
-        if ((_a = filter.method) == null ? void 0 : _a.name) {
-          const symbol = def.symbol;
-          if (!symbol || !this.matchesNameSpec(symbol, filter.method.name)) {
-            return false;
-          }
-        }
-        if ((_b = filter.function) == null ? void 0 : _b.name) {
-          const symbol = def.symbol;
-          if (!symbol || !this.matchesNameSpec(symbol, filter.function.name)) {
-            return false;
-          }
-        }
-        if ((_c = filter.class) == null ? void 0 : _c.name) {
-        }
-        return true;
-      }
-      /**
-       * Check if a name matches a name specification
-       */
-      matchesNameSpec(name, spec) {
-        if (spec.equals) {
-          return name === spec.equals;
-        }
-        if (spec.anyOf) {
-          return spec.anyOf.includes(name);
-        }
-        if (spec.regex) {
-          const regex = new RegExp(spec.regex);
-          return regex.test(name);
-        }
-        return true;
-      }
-      /**
-       * Check if a file path matches a file specification
-       */
-      matchesFileSpec(filePath, spec) {
-        const relativePath = path9.relative(this.environment.getWorkspaceRoot(), filePath);
-        if (spec.path) {
-          return relativePath === spec.path;
-        }
-        if (spec.glob) {
-          return minimatch3(relativePath, spec.glob);
-        }
-        if (spec.regex) {
-          const regex = new RegExp(spec.regex);
-          return regex.test(relativePath);
-        }
-        return true;
-      }
-    };
-  }
-});
-
-// src/providers/WispbitViolationValidationProvider.ts
-var WispbitViolationValidationProvider;
-var init_WispbitViolationValidationProvider = __esm({
-  "src/providers/WispbitViolationValidationProvider.ts"() {
-    "use strict";
-    init_hashString();
-    WispbitViolationValidationProvider = class {
-      config;
-      constructor(config) {
-        this.config = config;
-      }
-      async validateViolations(params) {
-        var _a;
-        const matchesWithIds = params.matches.map((match) => ({
-          match,
-          matchId: this.generateMatchId(match)
-        }));
-        const baseUrl = this.config.getBaseUrl();
-        const apiKey = this.config.getApiKey();
-        const response = await fetch(`${baseUrl}/plv1/validate-violation`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`
-          },
-          body: JSON.stringify({
-            rule: params.rule,
-            matches: matchesWithIds.map(({ match, matchId }) => ({
-              matchId,
-              filePath: match.filePath,
-              range: match.range,
-              text: match.text,
-              language: match.language,
-              symbol: match.symbol,
-              source: match.source
-            })),
-            powerlint_version: this.config.getLocalVersion(),
-            schema_version: this.config.getSchemaVersion()
-          })
-        });
-        if (!response.ok) {
-          const errorText = await response.text();
-          throw new Error(
-            `Wispbit validation failed: ${response.status} ${response.statusText} - ${errorText}`
-          );
-        }
-        const result = await response.json();
-        const results = [];
-        for (const { matchId } of matchesWithIds) {
-          const validationResult = (_a = result.results) == null ? void 0 : _a.find((r) => r.matchId === matchId);
-          results.push({
-            matchId,
-            isViolation: Boolean(validationResult == null ? void 0 : validationResult.isViolation),
-            reason: String((validationResult == null ? void 0 : validationResult.reason) || "No violation detected"),
-            confidence: typeof (validationResult == null ? void 0 : validationResult.confidence) === "number" ? validationResult.confidence : 1
-          });
-        }
-        return results;
-      }
-      /**
-       * Generate a unique ID for a single match
-       */
-      generateMatchId(match) {
-        const matchData = {
-          filePath: match.filePath,
-          startLine: match.range.start.line,
-          startColumn: match.range.start.column || 0,
-          endLine: match.range.end.line,
-          endColumn: match.range.end.column || 0,
-          text: match.text
-        };
-        return hashString(JSON.stringify(matchData)).substring(0, 16);
-      }
-    };
-  }
-});
-
-// src/steps/LLMStep.ts
-var LLMStep;
-var init_LLMStep = __esm({
-  "src/steps/LLMStep.ts"() {
-    "use strict";
-    init_Storage();
-    init_WispbitViolationValidationProvider();
-    init_ExecutionEventEmitter();
-    init_hashString();
-    LLMStep = class {
-      environment;
-      eventEmitter;
-      config;
-      storage;
-      constructor(config, environment, eventEmitter) {
-        this.environment = environment;
-        this.eventEmitter = eventEmitter || new ExecutionEventEmitter();
-        this.config = config;
-        this.storage = new Storage(environment);
-      }
-      /**
-       * Generate a unique ID for a single match
-       * Hash is based on filePath + range + text
-       */
-      generateMatchId(match) {
-        const matchData = {
-          filePath: match.filePath,
-          startLine: match.range.start.line,
-          startColumn: match.range.start.column || 0,
-          endLine: match.range.end.line,
-          endColumn: match.range.end.column || 0,
-          text: match.text
-        };
-        return hashString(JSON.stringify(matchData)).substring(0, 16);
-      }
-      /**
-       * Generate a hash for a prompt string
-       */
-      hashPrompt(prompt) {
-        return hashString(prompt);
-      }
-      /**
-       * Generate a cache key for a single match LLM validation
-       */
-      generateMatchCacheKey(matchId, promptHash) {
-        return `match_${matchId}_prompt_${promptHash}.json`;
-      }
-      /**
-       * 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
-       */
-      async executeLLMValidation(rule, uncachedMatches) {
-        const llmStartTime = Date.now();
-        const promptHash = this.hashPrompt(rule.prompt);
-        const validationProvider = new WispbitViolationValidationProvider(this.config);
-        const validationParams = {
-          rule,
-          matches: uncachedMatches
-        };
-        this.eventEmitter.startLLMValidation(rule.id, uncachedMatches.length);
-        const validationResults = await validationProvider.validateViolations(validationParams);
-        const newViolationMatches = [];
-        for (const result of validationResults) {
-          const originalMatch = uncachedMatches.find(
-            (match) => this.generateMatchId(match) === result.matchId
-          );
-          if (originalMatch && result.isViolation) {
-            newViolationMatches.push({
-              ...originalMatch,
-              metadata: {
-                fromCache: false,
-                llmValidation: {
-                  isViolation: true,
-                  confidence: result.confidence,
-                  reason: result.reason
-                }
-              }
-            });
-          }
-          const cacheKey = this.generateMatchCacheKey(result.matchId, promptHash);
-          const decision = {
-            matchId: result.matchId,
-            isViolation: result.isViolation,
-            confidence: result.confidence,
-            reason: result.reason
-          };
-          await this.storage.saveCache(rule.id, cacheKey, decision);
-        }
-        this.eventEmitter.completeLLMValidation(
-          rule.id,
-          0,
-          // Token usage is handled internally by the validation providers
-          Date.now() - llmStartTime,
-          newViolationMatches.length,
-          false
-        );
-        return {
-          matches: newViolationMatches,
-          executionTime: Date.now() - llmStartTime
-        };
-      }
-      /**
-       * 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
-       */
-      async execute(rule, previousMatches) {
-        const startTime = Date.now();
-        const promptHash = this.hashPrompt(rule.prompt);
-        const cachedMatches = [];
-        const uncachedMatches = [];
-        for (const match of previousMatches) {
-          const matchId = this.generateMatchId(match);
-          const cacheKey = this.generateMatchCacheKey(matchId, promptHash);
-          const cachedDecision = await this.storage.readCache(rule.id, cacheKey);
-          if (cachedDecision) {
-            if (cachedDecision.isViolation) {
-              cachedMatches.push({
-                ...match,
-                metadata: {
-                  fromCache: true,
-                  llmValidation: {
-                    isViolation: cachedDecision.isViolation,
-                    confidence: cachedDecision.confidence,
-                    reason: cachedDecision.reason
-                  }
-                }
-              });
-            }
-          } else {
-            uncachedMatches.push(match);
-          }
-        }
-        let newViolationMatches = [];
-        if (uncachedMatches.length > 0) {
-          const llmResult = await this.executeLLMValidation(rule, uncachedMatches);
-          newViolationMatches = llmResult.matches;
-        }
-        if (uncachedMatches.length === 0) {
-          this.eventEmitter.completeLLMValidation(
-            rule.id,
-            0,
-            // No tokens for cached result
-            Date.now() - startTime,
-            cachedMatches.length,
-            true
-            // fromCache = true
-          );
-        }
-        const allMatches = [...cachedMatches, ...newViolationMatches];
-        return {
-          matches: allMatches,
-          executionTime: Date.now() - startTime
-        };
-      }
-    };
-  }
-});
-
-// src/steps/RuleExecutor.ts
-var RuleExecutor;
-var init_RuleExecutor = __esm({
-  "src/steps/RuleExecutor.ts"() {
-    "use strict";
-    init_ExecutionEventEmitter();
-    init_FileExecutionContext();
-    init_FileFilterStep();
-    init_FindMatchesStep();
-    init_GotoDefinitionStep();
-    init_LLMStep();
-    RuleExecutor = class {
-      fileFilterStep;
-      findMatchesStep;
-      gotoDefinitionStep;
-      llmStep;
-      environment;
-      executionContext;
-      currentMode;
-      eventEmitter;
-      config;
-      constructor(config, environment, eventEmitter) {
-        this.environment = environment;
-        this.eventEmitter = eventEmitter || new ExecutionEventEmitter();
-        this.config = config;
-        this.fileFilterStep = new FileFilterStep(this.environment);
-        this.findMatchesStep = new FindMatchesStep(this.environment, this.eventEmitter);
-        this.gotoDefinitionStep = new GotoDefinitionStep(this.environment, this.eventEmitter);
-        this.llmStep = new LLMStep(this.config, this.environment, this.eventEmitter);
-      }
-      /**
-       * Execute a single step
-       */
-      async executeStep(rule, stepName, stepConfig, filePaths, matches, options) {
-        const stepType = stepConfig.type;
-        if (stepType === "ast-grep") {
-          const { type: _type, language, ...schema } = stepConfig;
-          const stepResult = await this.findMatchesStep.execute(schema, language, {
-            filePaths,
-            previousMatches: matches
-          });
-          return {
-            matches: stepResult.matches
-          };
-        }
-        if (stepType === "step-group") {
-          let allMatches = [];
-          for (let i = 0; i < stepConfig.steps.length; i++) {
-            const subStep = stepConfig.steps[i];
-            const subStepName = `${stepName}[${i}]`;
-            const subResult = await this.executeStep(
-              rule,
-              subStepName,
-              subStep,
-              filePaths,
-              matches,
-              options
-            );
-            if (subResult.matches) {
-              allMatches = allMatches.concat(subResult.matches);
-            }
-          }
-          return {
-            matches: allMatches
-          };
-        }
-        if (stepType === "file-filter") {
-          const stepResult = await this.fileFilterStep.execute(filePaths, {
-            include: stepConfig.include,
-            ignore: stepConfig.ignore,
-            conditions: stepConfig.conditions
-          });
-          return {
-            filePaths: stepResult.filteredPaths
-          };
-        }
-        if (stepType === "goto-definition") {
-          if (matches.length === 0) {
-            return {
-              matches: []
-            };
-          }
-          const { language } = stepConfig;
-          const matchesForLanguage = matches.filter((m) => m.language === language);
-          if (matchesForLanguage.length === 0) {
-            return {
-              matches: []
-            };
-          }
-          const stepResult = await this.gotoDefinitionStep.execute(matchesForLanguage, language, {
-            where: stepConfig.where
-          });
-          const definitionFilePaths = [...new Set(stepResult.definitions.map((d) => d.filePath))];
-          return {
-            filePaths: definitionFilePaths,
-            matches: stepResult.definitions
-          };
-        }
-        if (stepType === "llm") {
-          if (matches.length === 0) {
-            return {
-              matches: []
-            };
-          }
-          const llmResult = await this.llmStep.execute(rule, matches);
-          return {
-            matches: llmResult.matches
-          };
-        }
-        throw new Error(`Unknown step type: ${stepType}`);
-      }
-      /**
-       * Execute all steps in multiple rule configurations
-       */
-      async execute(rules, options) {
-        if (this.currentMode && this.currentMode !== options.mode) {
-          throw new Error(`Execution mode mismatch: expected ${this.currentMode}, got ${options.mode}`);
-        }
-        if (!this.executionContext || this.currentMode !== options.mode) {
-          this.executionContext = await FileExecutionContext.initialize(
-            this.config,
-            this.environment,
-            options.mode,
-            this.eventEmitter,
-            options.filePath,
-            options.baseSha
-          );
-          this.currentMode = options.mode;
-        }
-        this.eventEmitter.startRules(rules.length);
-        const results = [];
-        for (let i = 0; i < rules.length; i++) {
-          const rule = rules[i];
-          const ruleId = rule.id;
-          let isLlm = false;
-          for (const stepWithId of rule.config.steps) {
-            if (stepWithId.step.type === "llm") {
-              isLlm = true;
-              break;
-            }
-          }
-          this.eventEmitter.progressRule(i + 1, rules.length, ruleId, isLlm);
-          const ruleConfig = rule.config;
-          let currentFilePaths = [...this.executionContext.filePaths];
-          let currentMatches = [];
-          for (const stepWithId of ruleConfig.steps) {
-            const stepName = stepWithId.id;
-            const stepConfig = stepWithId.step;
-            this.eventEmitter.startStep(ruleId, stepName, stepConfig.type, {
-              filePaths: currentFilePaths,
-              matches: currentMatches
-            });
-            const stepStartTime = Date.now();
-            const result = await this.executeStep(
-              rule,
-              stepName,
-              stepConfig,
-              currentFilePaths,
-              currentMatches,
-              options
-            );
-            const stepExecutionTime = Date.now() - stepStartTime;
-            this.eventEmitter.emit("step:complete", {
-              ruleId,
-              stepName,
-              stepType: stepConfig.type,
-              outputs: result,
-              executionTime: stepExecutionTime
-            });
-            if (result.filePaths !== void 0) {
-              currentFilePaths = this.executionContext.filterFiles(result.filePaths);
-              currentMatches = this.executionContext.filterMatchesByFilePaths(
-                currentMatches,
-                currentFilePaths
-              );
-            }
-            if (result.matches !== void 0) {
-              currentMatches = this.executionContext.filterMatches(result.matches);
-            }
-            if (currentFilePaths.length === 0) {
-              break;
-            }
-          }
-          const sortedMatches = currentMatches.sort((a, b) => a.filePath.localeCompare(b.filePath));
-          results.push({
-            ruleId,
-            matches: sortedMatches
-          });
-        }
-        const totalMatches = results.reduce((sum, result) => sum + result.matches.length, 0);
-        this.eventEmitter.completeRules(rules.length, totalMatches);
-        return results;
-      }
-    };
-  }
-});
-
-// src/types.ts
-var InvalidRuleFormatError;
-var init_types = __esm({
-  "src/types.ts"() {
-    "use strict";
-    InvalidRuleFormatError = class extends Error {
-      constructor(ruleId, message, validationErrors) {
-        super(`Invalid rule format in '${ruleId}': ${message}`);
-        this.validationErrors = validationErrors;
-        this.name = "InvalidRuleFormatError";
-      }
-    };
-  }
-});
-
-// src/utils/formatters.ts
-import { stripVTControlCharacters } from "node:util";
-import chalk from "chalk";
-import ora from "ora";
-function formatClickableRuleId(ruleId, internalId) {
-  if (internalId) {
-    return chalk.underline.dim(
-      `\x1B]8;;https://app.wispbit.com/rules/${internalId}\x1B\\${ruleId}\x1B]8;;\x1B\\`
-    );
-  }
-  return chalk.dim(ruleId);
-}
-function pluralize(word, count) {
-  return count === 1 ? word : `${word}s`;
-}
-function textTable(rows, opts = {}) {
-  const hsep = "  ";
-  const align = opts.align || [];
-  const stringLength = opts.stringLength || ((str) => stripVTControlCharacters(str).length);
-  const sizes = rows.reduce((acc, row) => {
-    row.forEach((c2, ix) => {
-      const n = stringLength(c2);
-      if (!acc[ix] || n > acc[ix]) {
-        acc[ix] = n;
-      }
-    });
-    return acc;
-  }, []);
-  return rows.map(
-    (row) => row.map((c2, ix) => {
-      const n = sizes[ix] - stringLength(c2) || 0;
-      const s = Array(Math.max(n + 1, 1)).join(" ");
-      if (align[ix] === "r") {
-        return s + c2;
-      }
-      return c2 + s;
-    }).join(hsep).trimEnd()
-  ).join("\n");
-}
-function printSummary(results, summary) {
-  let output = "\n";
-  let violationCount = 0;
-  let suggestionCount = 0;
-  const ruleResults = /* @__PURE__ */ new Map();
-  results.forEach((result) => {
-    if (result.matches.length === 0) {
-      return;
-    }
-    const ruleId = result.ruleId || "unknown";
-    if (!ruleResults.has(ruleId)) {
-      ruleResults.set(ruleId, {
-        message: result.message,
-        severity: result.severity,
-        internalId: result.internalId,
-        matches: [],
-        hasLlmValidation: false
-      });
-    }
-    const ruleData = ruleResults.get(ruleId);
-    result.matches.forEach((match) => {
-      var _a;
-      ruleData.matches.push({
-        filePath: match.filePath,
-        line: match.range.start.line + 1,
-        column: match.range.start.column + 1,
-        endLine: match.range.end.line !== match.range.start.line ? match.range.end.line + 1 : void 0,
-        text: match.text
-      });
-      if ((_a = match.metadata) == null ? void 0 : _a.llmValidation) {
-        ruleData.hasLlmValidation = true;
-      }
-      if (result.severity === "violation") {
-        violationCount++;
-      } else {
-        suggestionCount++;
-      }
-    });
-  });
-  ruleResults.forEach((ruleData, ruleId) => {
-    if (ruleData.matches.length === 0 && ruleData.severity !== "skipped") {
-      return;
-    }
-    let messageType;
-    if (ruleData.severity === "violation") {
-      messageType = chalk.hex(VIOLATION_COLOR)(" violation".padStart(9));
-    } else if (ruleData.severity === "suggestion") {
-      messageType = chalk.hex(SUGGESTION_COLOR)("suggestion".padEnd(7));
-    } else {
-      messageType = chalk.hex(SKIPPED_COLOR)("   skipped".padEnd(9));
-    }
-    const llmIndicator = ruleData.hasLlmValidation ? `${chalk.hex(SKIPPED_COLOR)("(llm)")} ` : "";
-    const clickableRuleId = formatClickableRuleId(ruleId, ruleData.internalId);
-    const ruleHeader = `${messageType} ${chalk.dim("\u2502")} ${llmIndicator}${ruleData.message.replace(/([^ ])\.$/u, "$1")} ${chalk.dim("(")}${clickableRuleId}${chalk.dim(")")}`;
-    output += `${ruleHeader}
-`;
-    output += `${chalk.dim("\u2500".repeat(80))}
-`;
-    if (ruleData.severity === "skipped") {
-      output += `
-`;
-    } else {
-      const sortedMatches = ruleData.matches.sort((a, b) => a.filePath.localeCompare(b.filePath));
-      const shouldShowCodeSnippets = sortedMatches.length < 10 && sortedMatches.some((match) => match.text && match.text.split("\n").length <= 10);
-      if (shouldShowCodeSnippets) {
-        sortedMatches.forEach((match, index) => {
-          output += `  ${match.filePath}
-`;
-          if (match.text && match.text.split("\n").length <= 10) {
-            const lines = match.text.split("\n");
-            lines.forEach((line, lineIndex) => {
-              const lineNumber = match.line + lineIndex;
-              const lineNumberBox = chalk.bgHex(LINE_NUMBER_BG_COLOR).hex(LINE_NUMBER_TEXT_COLOR)(
-                ` ${String(lineNumber)} `
-              );
-              output += `  ${lineNumberBox} ${chalk.dim(line)}
-`;
-            });
-          }
-          if (index < sortedMatches.length - 1) {
-            output += `
-`;
-          }
-        });
-      } else {
-        sortedMatches.forEach((match) => {
-          const lineRange = match.endLine ? `(${match.line}:${match.endLine})` : `(${match.line})`;
-          output += `  ${match.filePath} ${chalk.dim(lineRange)}
-`;
-        });
-      }
-      output += `
-
-`;
-    }
-  });
-  const total = violationCount + suggestionCount;
-  if (total === 0) {
-    console.log(`
-no results`);
-  }
-  const violationText = violationCount > 0 ? `${chalk.dim("violations".padStart(12))} ${chalk.hex(VIOLATION_COLOR)("\u25A0")} ${chalk.hex(VIOLATION_COLOR).bold(violationCount)}` : `${chalk.dim("violations".padStart(12))} ${chalk.dim(violationCount)}`;
-  const suggestionText = suggestionCount > 0 ? `${chalk.dim("suggestions".padStart(12))} ${chalk.hex(SUGGESTION_COLOR)("\u25CF")} ${chalk.hex(SUGGESTION_COLOR).bold(suggestionCount)}` : `${chalk.dim("suggestions".padStart(12))} ${chalk.dim(suggestionCount)}`;
-  const filesText = summary.totalFiles ? `${summary.totalFiles} ${pluralize("file", summary.totalFiles)}` : "0 files";
-  const rulesText = `${summary.totalRules} ${pluralize("rule", summary.totalRules)}`;
-  const timeText = summary.executionTime ? `${Math.round(summary.executionTime)}ms` : "";
-  const detailsText = [filesText, rulesText, timeText].filter(Boolean).join(", ");
-  output += `${violationText}
-`;
-  output += `${suggestionText}
-`;
-  output += `${chalk.dim("summary".padStart(12))} ${detailsText}
-`;
-  console.log(total > 0 ? chalk.reset(output) : output);
-  if (violationCount > 0) {
-    process.exit(1);
-  }
-}
-function printRulesList(rules) {
-  if (rules.length === 0) {
-    console.log(chalk.yellow("No rules found."));
-    console.log(chalk.dim("Go to https://app.wispbit.com/rules to create a rule."));
-    return;
-  }
-  const tableData = [];
-  tableData.push([
-    "",
-    `${"id".padEnd(12)} ${chalk.dim("\u2502")} ${"severity".padEnd(12)} ${chalk.dim("\u2502")} message`
-  ]);
-  tableData.push([
-    "",
-    `${chalk.dim("\u2500".repeat(12))} ${chalk.dim("\u253C")} ${chalk.dim("\u2500".repeat(12))} ${chalk.dim("\u253C")} ${chalk.dim("\u2500".repeat(80))}`
-  ]);
-  for (const rule of rules) {
-    const severityColor = rule.config.severity === "violation" ? chalk.hex(VIOLATION_COLOR) : chalk.hex(SUGGESTION_COLOR);
-    const severityText = severityColor(rule.config.severity);
-    const ruleId = formatClickableRuleId(rule.id, rule.internalId);
-    const idPadding = Math.max(0, 12 - rule.id.length);
-    const severityPadding = Math.max(0, 12 - rule.config.severity.length);
-    tableData.push([
-      "",
-      `${ruleId}${" ".repeat(idPadding)} ${chalk.dim("\u2502")} ${severityText}${" ".repeat(severityPadding)} ${chalk.dim("\u2502")} ${rule.config.message}`
-    ]);
-  }
-  const table = textTable(tableData, {
-    align: ["", "l"],
-    stringLength(str) {
-      return stripVTControlCharacters(str).length;
-    }
-  });
-  console.log("\n" + table);
-  console.log(chalk.dim(`
-Use 'wispbit check --rule <rule-id>' to run a specific rule.`));
-}
-function outputJSON(results, format = "pretty") {
-  const matches = [];
-  for (const result of results) {
-    for (const match of result.matches) {
-      const jsonMatch = {
-        filePath: match.filePath,
-        range: match.range,
-        language: match.language,
-        text: match.text,
-        symbol: match.symbol,
-        source: match.source,
-        ruleId: result.ruleId,
-        internalId: result.internalId,
-        severity: result.severity,
-        message: result.message
-      };
-      matches.push(jsonMatch);
-    }
-  }
-  if (format === "stream") {
-    for (const match of matches) {
-      console.log(JSON.stringify(match));
-    }
-  } else if (format === "compact") {
-    console.log(JSON.stringify(matches));
-  } else {
-    console.log(JSON.stringify(matches, null, 2));
-  }
-}
-function setupTerminalReporter(eventEmitter, debugMode = false) {
-  let spinner = null;
-  let indexingStartTime = null;
-  let executionMode = null;
-  eventEmitter.on("execution:mode", (data) => {
-    executionMode = data;
-  });
-  eventEmitter.on("rules:start", (_data) => {
-    spinner = ora({
-      spinner: {
-        interval: 120,
-        frames: loadingFrames
-      },
-      color: false
-    }).start();
-    const handleInterrupt = () => {
-      if (spinner) {
-        spinner.stop();
-      }
-      process.exit(130);
-    };
-    process.on("SIGINT", handleInterrupt);
-    process.on("SIGTERM", handleInterrupt);
-  });
-  eventEmitter.on("rules:progress", (data) => {
-    if (spinner) {
-      let modeText = "";
-      if (executionMode) {
-        if (executionMode.mode === "check") {
-          modeText = executionMode.filePath ? ` (${executionMode.filePath})` : " (ALL FILES)";
-        } else if (executionMode.mode === "diff") {
-          modeText = ` (${executionMode.baseCommit} \u2192 ${executionMode.headCommit})`;
-        }
-      }
-      spinner.text = `${data.isLlm ? chalk.hex(SKIPPED_COLOR)("(llm) ") : ""}${data.ruleId}${modeText}`;
-    }
-  });
-  eventEmitter.on("rules:complete", () => {
-    if (spinner) {
-      spinner.stop();
-      spinner = null;
-    }
-  });
-  eventEmitter.on("files:discovery:start", (data) => {
-    if (debugMode) {
-      console.log(`
-${chalk.blue("Discovering files")} in ${chalk.bold(data.mode)} mode...`);
-    }
-  });
-  eventEmitter.on("files:discovery:progress", (data) => {
-    if (debugMode) {
-      console.log(`   ${data.message}`);
-    }
-  });
-  eventEmitter.on("files:discovery:complete", (data) => {
-    if (debugMode) {
-      console.log(
-        chalk.green("File discovery complete:"),
-        `${data.totalFiles} files found (${data.executionTime}ms)`
-      );
-    }
-  });
-  eventEmitter.on("files:filter", (data) => {
-    if (debugMode && data.originalCount !== data.filteredCount) {
-      console.log(
-        chalk.yellow("Filtered:"),
-        `${data.originalCount} \u2192 ${data.filteredCount} ${data.filterType}`
-      );
-    }
-  });
-  eventEmitter.on("indexing:start", (_data) => {
-    indexingStartTime = Date.now();
-  });
-  eventEmitter.on("indexing:progress", (data) => {
-    if (spinner) {
-      spinner.color = "yellow";
-    }
-    if (indexingStartTime && Date.now() - indexingStartTime > 1e3) {
-      if (spinner) {
-        spinner.text = `Indexing ${data.language}...`;
-      }
-    }
-    if (spinner) {
-      if (data.packageName && data.timeMs) {
-        spinner.text = `Indexing ${data.language}: ${data.packageName}`;
-      } else if (data.message !== "Indexing files...") {
-        spinner.text = `Indexing ${data.language}: ${data.message}`;
-      }
-    }
-    if (debugMode) {
-      if (data.packageName && data.timeMs) {
-        console.log(`   + ${data.packageName} (${data.timeMs}ms)`);
-      } else if (data.message === "Indexing files...") {
-        process.stdout.write(".");
-      } else if (data.message !== "Indexing files...") {
-        console.log(`   ${data.message}`);
-      }
-    }
-  });
-  eventEmitter.on("indexing:complete", (data) => {
-    indexingStartTime = null;
-    if (spinner) {
-      spinner.color = "blue";
-    }
-    if (debugMode) {
-      process.stdout.write("\n");
-      console.log(
-        chalk.green("Indexing complete for"),
-        `${data.language} (${data.executionTime}ms)`
-      );
-    }
-  });
-  if (debugMode) {
-    eventEmitter.on("scip:match-lookup:start", (data) => {
-      console.log(
-        chalk.cyan(
-          `
-\u{1F50D} [${data.language}] Starting SCIP match lookup for: ${JSON.stringify(data.match)}`
-        )
-      );
-    });
-    eventEmitter.on("scip:match-lookup:progress", (data) => {
-      console.log(`${JSON.stringify(data.document)}`);
-    });
-    eventEmitter.on("scip:match-lookup:complete", (data) => {
-      console.log(chalk.green(`SCIP match lookup complete for: ${data.language}`));
-    });
-    eventEmitter.on("step:start", (data) => {
-      console.log(
-        chalk.cyan(`
-\u{1F527} [${data.ruleId}] Starting step: ${data.stepName} (${data.stepType})`)
-      );
-      console.log(`   Input files: ${data.inputs.filePaths.length}`);
-      console.log(`   Input matches: ${data.inputs.matches.length}`);
-      if (data.inputs.matches.length > 0) {
-        console.log(`   Match details:`);
-        data.inputs.matches.forEach((match, idx) => {
-          var _a;
-          console.log(`     Match ${idx + 1}:`);
-          console.log(`       File: ${match.filePath}`);
-          console.log(
-            `       Range: ${match.range.start.line}:${match.range.start.column} \u2192 ${match.range.end.line}:${match.range.end.column}`
-          );
-          if (match.symbol) {
-            console.log(`       Symbol: ${match.symbol}`);
-          }
-          if (match.source && match.source.length > 0) {
-            console.log(`       Source chain: ${match.source.length} step(s)`);
-            match.source.forEach((src, srcIdx) => {
-              const range = `${src.range.start.line}:${src.range.start.column} \u2192 ${src.range.end.line}:${src.range.end.column}`;
-              console.log(
-                `         ${srcIdx + 1}. ${src.filePath} [${src.symbol || "N/A"}] @ ${range}`
-              );
-            });
-          }
-          console.log(`       Text preview: ${(_a = match.text) == null ? void 0 : _a.substring(0, 120)}...`);
-        });
-      }
-    });
-    eventEmitter.on("step:complete", (data) => {
-      console.log(
-        chalk.cyan(
-          `\u2705 [${data.ruleId}] Completed step: ${data.stepName} (${data.stepType}) (${data.executionTime}ms)`
-        )
-      );
-      if (data.outputs.filePaths !== void 0) {
-        console.log(`   Output files: ${data.outputs.filePaths.length}`);
-      }
-      if (data.outputs.matches !== void 0) {
-        console.log(`   Output matches: ${data.outputs.matches.length}`);
-        if (data.outputs.matches.length > 0) {
-          console.log(`   Output match details:`);
-          data.outputs.matches.forEach((match, idx) => {
-            var _a;
-            console.log(`     Match ${idx + 1}:`);
-            console.log(`       File: ${match.filePath}`);
-            console.log(
-              `       Range: ${match.range.start.line}:${match.range.start.column} \u2192 ${match.range.end.line}:${match.range.end.column}`
-            );
-            if (match.symbol) {
-              console.log(`       Symbol: ${match.symbol}`);
-            }
-            if (match.source && match.source.length > 0) {
-              console.log(`       Source chain: ${match.source.length} step(s)`);
-              match.source.forEach((src, srcIdx) => {
-                const range = `${src.range.start.line}:${src.range.start.column} \u2192 ${src.range.end.line}:${src.range.end.column}`;
-                console.log(
-                  `         ${srcIdx + 1}. ${src.filePath} [${src.symbol || "N/A"}] @ ${range}`
-                );
-              });
-            }
-            console.log(`       Text preview: ${(_a = match.text) == null ? void 0 : _a.substring(0, 120)}...`);
-          });
-        }
-      }
-    });
-    eventEmitter.on("test:start", (data) => {
-      console.log(chalk.magenta(`
-\u{1F9EA} [${data.ruleId}] Running test: "${data.testName}"`));
-    });
-    eventEmitter.on("test:matches", (data) => {
-      console.log(chalk.magenta(`   Found ${data.matches.length} match(es):`));
-      data.matches.forEach((match, idx) => {
-        var _a;
-        console.log(`   Match ${idx + 1}:`);
-        console.log(`     File: ${match.filePath}`);
-        console.log(
-          `     Range: ${match.range.start.line}:${match.range.start.column} \u2192 ${match.range.end.line}:${match.range.end.column}`
-        );
-        if (match.symbol) {
-          console.log(`     Symbol: ${match.symbol}`);
-        }
-        if (match.source && match.source.length > 0) {
-          console.log(`     Source chain: ${match.source.length} step(s)`);
-          match.source.forEach((src, srcIdx) => {
-            const range = `${src.range.start.line}:${src.range.start.column} \u2192 ${src.range.end.line}:${src.range.end.column}`;
-            console.log(`       ${srcIdx + 1}. ${src.filePath} [${src.symbol || "N/A"}] @ ${range}`);
-          });
-        }
-        console.log(`     Text preview: ${(_a = match.text) == null ? void 0 : _a.substring(0, 120)}...`);
-      });
-    });
-  }
-  return () => {
-    if (spinner) {
-      spinner.stop();
-      spinner = null;
-    }
-  };
-}
-var VIOLATION_COLOR, SUGGESTION_COLOR, SKIPPED_COLOR, BRAND_COLOR, LINE_NUMBER_BG_COLOR, LINE_NUMBER_TEXT_COLOR, loadingFrames;
-var init_formatters = __esm({
-  "src/utils/formatters.ts"() {
-    "use strict";
-    VIOLATION_COLOR = "#ff6b35";
-    SUGGESTION_COLOR = "#4a90e2";
-    SKIPPED_COLOR = "#9b59b6";
-    BRAND_COLOR = "#fbbf24";
-    LINE_NUMBER_BG_COLOR = "#f8f8f8";
-    LINE_NUMBER_TEXT_COLOR = "#888888";
-    loadingFrames = [
-      chalk.hex(BRAND_COLOR)("~(oo)~"),
-      chalk.hex(BRAND_COLOR)("~(oO)~"),
-      chalk.hex(BRAND_COLOR)("~(Oo)~"),
-      chalk.hex(BRAND_COLOR)("~(OO)~"),
-      chalk.hex(BRAND_COLOR)("~(\u25CFo)~"),
-      chalk.hex(BRAND_COLOR)("~(o\u25CF)~"),
-      chalk.hex(BRAND_COLOR)("~(\u25C9o)~"),
-      chalk.hex(BRAND_COLOR)("~(o\u25C9)~"),
-      chalk.hex(BRAND_COLOR)("\\(oo)/"),
-      chalk.hex(BRAND_COLOR)("\\(oO)/"),
-      chalk.hex(BRAND_COLOR)("\\(Oo)/"),
-      chalk.hex(BRAND_COLOR)("\\(OO)/"),
-      chalk.hex(BRAND_COLOR)("~(Oo)~"),
-      chalk.hex(BRAND_COLOR)("~(oO)~"),
-      chalk.hex(BRAND_COLOR)("~(\u25CEo)~"),
-      chalk.hex(BRAND_COLOR)("~(o\u25CE)~"),
-      chalk.hex(BRAND_COLOR)("~(oo)~"),
-      chalk.hex(BRAND_COLOR)("~(OO)~"),
-      chalk.hex(BRAND_COLOR)("~(Oo)~"),
-      chalk.hex(BRAND_COLOR)("\\(oo)/"),
-      chalk.hex(BRAND_COLOR)("\\(oO)/"),
-      chalk.hex(BRAND_COLOR)("\\(Oo)/"),
-      chalk.hex(BRAND_COLOR)("\\(OO)/")
-    ];
-  }
-});
-
-// src/utils/asciiFrames.ts
-import chalk2 from "chalk";
-var BRAND_COLOR2, VIOLATION_COLOR2, SUGGESTION_COLOR2, SKIPPED_COLOR2, WISPBIT_FRAMES;
-var init_asciiFrames = __esm({
-  "src/utils/asciiFrames.ts"() {
-    "use strict";
-    BRAND_COLOR2 = "#fbbf24";
-    VIOLATION_COLOR2 = "#ff6b35";
-    SUGGESTION_COLOR2 = "#4a90e2";
-    SKIPPED_COLOR2 = "#9b59b6";
-    WISPBIT_FRAMES = [
-      // Frame 1 - Normal position
-      `
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("     \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D   \u255A\u2550\u255D   ")}
-`,
-      // Frame 2 - Wave starts from left
-      `
-${chalk2.hex(SUGGESTION_COLOR2)("    \u2588\u2588\u2557    ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
-${chalk2.hex(SUGGESTION_COLOR2)("    \u2588\u2588\u2551    ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
-${chalk2.hex(SUGGESTION_COLOR2)("    \u2588\u2588\u2551 \u2588\u2557 ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(SUGGESTION_COLOR2)("    \u2588\u2588\u2551\u2588\u2588\u2588\u2557")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(SUGGESTION_COLOR2)("    \u255A\u2588\u2588\u2588\u2554\u2588\u2588")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(SUGGESTION_COLOR2)("     \u255A\u2550\u2550\u255D\u255A\u2550")}${chalk2.hex(BRAND_COLOR2)("\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D   \u255A\u2550\u255D   ")}
-`,
-      // Frame 3 - Wave in middle
-      `
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557")}${chalk2.hex(SKIPPED_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551")}${chalk2.hex(SKIPPED_COLOR2)("\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551")}${chalk2.hex(SKIPPED_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551")}${chalk2.hex(SKIPPED_COLOR2)("\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551")}${chalk2.hex(SKIPPED_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     ")}${chalk2.hex(BRAND_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("     \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D")}${chalk2.hex(SKIPPED_COLOR2)("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     ")}${chalk2.hex(BRAND_COLOR2)("\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D   \u255A\u2550\u255D   ")}
-`,
-      // Frame 4 - Wave towards right
-      `
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 ")}${chalk2.hex(VIOLATION_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557")}${chalk2.hex(VIOLATION_COLOR2)("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D")}${chalk2.hex(VIOLATION_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D ")}${chalk2.hex(VIOLATION_COLOR2)("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     ")}${chalk2.hex(VIOLATION_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("     \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     ")}${chalk2.hex(VIOLATION_COLOR2)("\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D   \u255A\u2550\u255D   ")}
-`,
-      // Frame 5 - Wave at end
-      `
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557")}${chalk2.hex(SUGGESTION_COLOR2)("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551")}${chalk2.hex(SUGGESTION_COLOR2)("\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551")}${chalk2.hex(SUGGESTION_COLOR2)("   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551")}${chalk2.hex(SUGGESTION_COLOR2)("   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("    \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551")}${chalk2.hex(SUGGESTION_COLOR2)("   \u2588\u2588\u2551   ")}
-${chalk2.hex(BRAND_COLOR2)("     \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D")}${chalk2.hex(SUGGESTION_COLOR2)("   \u255A\u2550\u255D   ")}
-`
-    ];
-  }
-});
-
-// src/utils/startupScreen.ts
-import readline from "readline";
-import chalk3 from "chalk";
-import ora2 from "ora";
-function clearScreen() {
-  process.stdout.write("\x1B[2J\x1B[H");
-}
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-async function showAnimatedFrames(durationMs = 3e3) {
-  const spinner = ora2({
-    text: "",
-    spinner: {
-      interval: 100,
-      // ms per frame
-      frames: WISPBIT_FRAMES
-    }
-  }).start();
-  await sleep(durationMs);
-  spinner.stop();
-}
-async function promptForInput(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return await new Promise((resolve3) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve3(answer.trim());
-    });
-  });
-}
-async function showStartupScreen() {
-  clearScreen();
-  await showAnimatedFrames(1500);
-  console.log(WISPBIT_FRAMES[0]);
-  console.log(chalk3.hex(VIOLATION_COLOR)("\n  Welcome to wispbit"));
-  console.log(chalk3("  The linter for AI\n"));
-  console.log(chalk3.dim("  To use wispbit, you need an API key."));
-  console.log(chalk3.dim("  You can get one at: https://app.wispbit.com/api-keys\n"));
-  const apiKey = await promptForInput(
-    chalk3.bold.hex(SUGGESTION_COLOR)("  Enter your Wispbit API key (or press Enter to exit): ")
-  );
-  if (!apiKey) {
-    console.log(chalk3.dim("\n  Setup cancelled."));
-    return null;
-  }
-  return apiKey;
-}
-var init_startupScreen = __esm({
-  "src/utils/startupScreen.ts"() {
-    "use strict";
-    init_asciiFrames();
-    init_formatters();
-  }
-});
-
-// src/cli.ts
-var cli_exports = {};
-__export(cli_exports, {
-  checkForUpdates: () => checkForUpdates
-});
-import * as fs5 from "fs/promises";
-import * as os3 from "os";
-import * as path10 from "path";
-import Big from "big.js";
-import chalk4 from "chalk";
-import dotenv from "dotenv";
-import meow from "meow";
-import semver from "semver";
-function getConfigFilePath() {
-  return path10.join(os3.homedir(), ".powerlint", "config.json");
-}
-async function saveApiKey(apiKey) {
-  const configPath = getConfigFilePath();
-  const configDir = path10.dirname(configPath);
-  await fs5.mkdir(configDir, { recursive: true });
-  let existingConfig = {};
-  try {
-    const configContent = await fs5.readFile(configPath, "utf-8");
-    existingConfig = JSON.parse(configContent);
-  } catch {
-  }
-  const newConfig = {
-    ...existingConfig,
-    apiKey
-  };
-  await fs5.writeFile(configPath, JSON.stringify(newConfig, null, 2));
-}
-async function loadApiKey() {
-  const configPath = getConfigFilePath();
-  try {
-    const configContent = await fs5.readFile(configPath, "utf-8");
-    const config = JSON.parse(configContent);
-    return config.apiKey || null;
-  } catch {
-    return null;
-  }
-}
-async function ensureConfigured() {
-  const environment = new Environment();
-  let apiKey = process.env.WISPBIT_API_KEY || null;
-  if (!apiKey) {
-    apiKey = await loadApiKey();
-  }
-  let config = await Config.initialize(environment, { apiKey: apiKey || void 0 });
-  if ("failed" in config) {
-    if (config.error === "INVALID_API_KEY") {
-      const newApiKey = await showStartupScreen();
-      if (!newApiKey) {
-        process.exit(0);
-      }
-      const repositoryUrl = await environment.getRepositoryUrl();
-      if (!repositoryUrl) {
-        console.log(chalk4.red("Repository URL not found. Make sure you're in a git repository."));
-        process.exit(1);
-      }
-      console.log(chalk4.dim("Validating API key..."));
-      await saveApiKey(newApiKey);
-      config = await Config.initialize(environment, { apiKey: newApiKey });
-      if ("failed" in config) {
-        console.log(chalk4.red("Invalid API key. Please check your API key and try again."));
-        process.exit(1);
-      } else {
-        console.log(chalk4.green("Setup complete! powerlint has been configured."));
-        return config;
-      }
-    } else if (config.error === "INVALID_REPOSITORY") {
-      const repositoryUrl = await environment.getRepositoryUrl();
-      console.log(
-        chalk4.red(
-          `No repository in wispbit found for url: ${repositoryUrl}. If your git remote URL was recently modified, use "git remote set-url origin <new-url>" to update the remote URL.`
-        )
-      );
-      process.exit(1);
-    }
-  }
-  return config;
-}
-async function checkForUpdates() {
-  const currentVersion = getCurrentVersion();
-  const latestCliVersion = await getLatestVersion();
-  if (semver.gt(latestCliVersion, currentVersion)) {
-    console.log(
-      chalk4.bgHex("#b2f5ea").black.bold(` NEW VERSION AVAILABLE: ${latestCliVersion} (current: ${currentVersion}) `)
-    );
-    console.log(
-      chalk4.bgHex("#b2f5ea").black.bold(` Run 'pnpm install -g @wispbit/cli' to update 
-`)
-    );
-  }
-}
-async function executeCommand(options) {
-  const environment = new Environment();
-  const config = await ensureConfigured();
-  const { ruleId, json: json2, mode, filePath } = options;
-  let jsonOutput = false;
-  let jsonFormat = "pretty";
-  if (json2) {
-    jsonOutput = true;
-    if (json2 === "stream") {
-      jsonFormat = "stream";
-    } else if (json2 === "compact") {
-      jsonFormat = "compact";
-    } else {
-      jsonFormat = "pretty";
-    }
-  } else {
-    await checkForUpdates();
-  }
-  let rules;
-  try {
-    const ruleProvider = new WispbitRuleProvider(config, environment);
-    if (ruleId) {
-      const rule = await ruleProvider.loadRuleById(ruleId);
-      rules = [rule];
-    } else {
-      rules = await ruleProvider.loadAllRules();
-    }
-  } catch (error) {
-    if (error instanceof InvalidRuleFormatError) {
-      console.error(chalk4.red("Rule Validation Error:"), error.message);
-      if (error.validationErrors && error.validationErrors.length > 0) {
-        console.error(chalk4.red("Validation errors:"));
-        error.validationErrors.forEach((err) => {
-          console.error(chalk4.red("  \u2022"), err);
-        });
-      }
-      process.exit(1);
-    }
-    throw error;
-  }
-  if (!json2) {
-    if (mode === "check") {
-      const modeBox = chalk4.bgHex("#eab308").black(" CHECK ");
-      const targetInfo = chalk4.dim(` (${filePath || "all files"})`);
-      console.log(`${modeBox}${targetInfo}`);
-    } else {
-      const baseCommit = cli.flags.base || "origin/main";
-      const headCommit = cli.flags.head || "HEAD";
-      const modeBox = chalk4.bgHex("#4a90e2").black(" DIFF ");
-      const branchInfo = chalk4.dim(` (${headCommit}..${baseCommit})`);
-      console.log(`${modeBox}${branchInfo}`);
-    }
-  }
-  const eventEmitter = new ExecutionEventEmitter();
-  if (mode === "check") {
-    eventEmitter.setExecutionMode("check", { filePath });
-  } else {
-    const baseCommit = cli.flags.base || "origin/main";
-    const headCommit = cli.flags.head || "current branch";
-    eventEmitter.setExecutionMode("diff", { baseCommit, headCommit });
-  }
-  const cleanupTerminalReporter = !options.json ? setupTerminalReporter(eventEmitter, options.debug || false) : void 0;
-  const executionStartTime = Date.now();
-  const ruleExecutor = new RuleExecutor(config, environment, eventEmitter);
-  let totalFiles = 0;
-  eventEmitter.on("files:discovery:complete", (data) => {
-    totalFiles = data.totalFiles;
-  });
-  const ruleResults = await ruleExecutor.execute(rules, {
-    mode,
-    filePath,
-    baseSha: cli.flags.base
-  });
-  const results = [];
-  for (const ruleResult of ruleResults) {
-    const rule = rules.find((r) => r.id === ruleResult.ruleId);
-    if (rule) {
-      let llmCost;
-      let llmTokens;
-      const result = {
-        ruleId: ruleResult.ruleId,
-        internalId: rule.internalId,
-        message: rule.config.message,
-        severity: rule.config.severity,
-        matches: ruleResult.matches,
-        llmCost,
-        llmTokens
-      };
-      results.push(result);
-    }
-  }
-  cleanupTerminalReporter == null ? void 0 : cleanupTerminalReporter();
-  if (jsonOutput) {
-    outputJSON(results, jsonFormat);
-  } else {
-    const violationResults = results.filter((r) => r.severity === "violation");
-    const suggestionResults = results.filter((r) => r.severity === "suggestion");
-    const violationCount = violationResults.reduce((sum, r) => sum + r.matches.length, 0);
-    const suggestionCount = suggestionResults.reduce((sum, r) => sum + r.matches.length, 0);
-    const totalMatches = violationCount + suggestionCount;
-    const totalLLMCost = results.filter((r) => r.llmCost).reduce((sum, r) => sum.plus(new Big(r.llmCost || 0)), new Big(0));
-    const totalLLMTokens = results.filter((r) => r.llmTokens).reduce((sum, r) => sum + (r.llmTokens || 0), 0);
-    let executionModeInfo;
-    if (mode === "check") {
-      executionModeInfo = { mode: "check", filePath };
-    } else {
-      const baseCommit = cli.flags.base || "origin/main";
-      const headCommit = cli.flags.head || "current branch";
-      executionModeInfo = { mode: "diff", baseCommit, headCommit };
-    }
-    const executionTime = Date.now() - executionStartTime;
-    printSummary(results, {
-      totalRules: rules.length,
-      violationCount,
-      suggestionCount,
-      totalMatches,
-      totalLLMCost: totalLLMCost.toString(),
-      totalLLMTokens,
-      executionMode: executionModeInfo,
-      executionTime,
-      totalFiles
-    });
-  }
-  return results;
-}
-async function listRules() {
-  const config = await ensureConfigured();
-  const environment = new Environment();
-  const ruleProvider = new WispbitRuleProvider(config, environment);
-  const rules = await ruleProvider.loadAllRules();
-  printRulesList(rules);
-}
-async function main() {
-  const command = cli.input[0];
-  const subcommand = cli.input[1];
-  switch (command) {
-    case "check": {
-      const filePath = cli.input[1];
-      await executeCommand({
-        ruleId: cli.flags.rule,
-        json: cli.flags.json,
-        debug: cli.flags.debug,
-        mode: "check",
-        filePath
-      });
-      break;
-    }
-    case "diff": {
-      await executeCommand({
-        ruleId: cli.flags.rule,
-        json: cli.flags.json,
-        debug: cli.flags.debug,
-        mode: "diff"
-      });
-      break;
-    }
-    case "list": {
-      await listRules();
-      break;
-    }
-    case "cache": {
-      if (subcommand === "purge") {
-        const environment = new Environment();
-        const storage = new Storage(environment);
-        const result = await storage.purgeCache();
-        console.log(
-          `
-${chalk4.green("Cache purged successfully.")} Removed ${result.deletedCount} item(s).`
-        );
-      } else {
-        console.error(chalk4.red("Unknown cache subcommand:"), subcommand);
-        cli.showHelp();
-        process.exit(1);
-      }
-      break;
-    }
-    default: {
-      if (!command) {
-        await executeCommand({
-          ruleId: cli.flags.rule,
-          json: cli.flags.json,
-          debug: cli.flags.debug,
-          mode: "diff"
-        });
-      } else {
-        console.error(chalk4.red("Unknown command:"), command);
-        cli.showHelp();
-        process.exit(1);
-      }
-      break;
-    }
-  }
-}
-var cli;
-var init_cli = __esm({
-  "src/cli.ts"() {
-    "use strict";
-    init_Config();
-    init_Environment();
-    init_Storage();
-    init_WispbitRuleProvider();
-    init_ExecutionEventEmitter();
-    init_RuleExecutor();
-    init_types();
-    init_formatters();
-    init_startupScreen();
-    init_version();
-    dotenv.config();
-    cli = meow(
-      `
-wispbit - the linter for AI
-https://wispbit.com/
-
-Usage:
-  $ wispbit [diff-options] (run diff by default)
-  $ wispbit check [file-path/directory] [check-options]
-  $ wispbit diff [diff-options]
-  $ wispbit list
-  $ wispbit cache purge
-
-Commands:
-  check [file-path/directory]                  Run linting rules against a specific file/folder or entire codebase
-  diff                               Run linting rules only on changed files in the current PR
-  list                               List all available rules with their ID, message, and severity
-  cache purge                        Purge the cache directory (indexes, caching, etc.)
-
-Options for check:
-  --rule <ruleId>                    Optional rule ID to run specific rule
-  --json [format]                    Output in JSON format (pretty, stream, compact)
-  -d, --debug                        Enable debug output
-
-Options for diff:
-  --rule <ruleId>                    Optional rule ID to run specific rule
-  --json [format]                    Output in JSON format (pretty, stream, compact)
-  --base <commit>                    Base commit/branch/SHA to compare against (defaults to origin/main)
-  --head <commit>                    Head commit/branch/SHA to compare against (defaults to current branch)
-  -d, --debug                        Enable debug output
-
-
-Global options:
-  -v, --version                      Show version number
-  -h, --help                         Show help
-`,
-      {
-        importMeta: import.meta,
-        flags: {
-          // Scan/diff options
-          rule: {
-            type: "string"
-          },
-          json: {
-            type: "string"
-          },
-          base: {
-            type: "string"
-          },
-          head: {
-            type: "string"
-          },
-          // Debug option
-          debug: {
-            type: "boolean",
-            shortFlag: "d",
-            default: false
-          },
-          // Global options
-          version: {
-            type: "boolean",
-            shortFlag: "v"
-          },
-          help: {
-            type: "boolean",
-            shortFlag: "h"
-          }
-        },
-        version: getCurrentVersion()
-      }
-    );
-    main();
-  }
-});
-
-// src/index.ts
 process.emitWarning = () => {
 };
 process.removeAllListeners("warning");
 console.debug = () => {
 };
-var originalEmit = process.emit;
+const originalEmit = process.emit;
 process.emit = function(event, ...args) {
-  if (event === "warning" && (args[0] && args[0].name === "ExperimentalWarning" || args[0] && args[0].code === "DEP0040")) {
-    return false;
+  if (event === "warning" && args[0]) {
+    const warning = args[0];
+    if (warning.name === "ExperimentalWarning") {
+      return false;
+    }
+    if (warning.code === "DEP0040") {
+      return false;
+    }
   }
   return originalEmit.apply(process, [event, ...args]);
 };
-Promise.resolve().then(() => (init_cli(), cli_exports)).catch(console.error);
+import("./cli.js").catch(console.error);
 //# sourceMappingURL=index.js.map