@wispbit/local 1.0.25

package/dist/cli.js

@@ -0,0 +1,3668 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+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";
+
+// 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();
+  }
+}
+
+// src/environment/Config.ts
+var 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/git.ts
+import { exec, execSync } from "child_process";
+import { promisify } from "util";
+
+// src/utils/hashString.ts
+import { createHash } from "crypto";
+function hashString(str) {
+  return createHash("sha256").update(str).digest("hex");
+}
+
+// src/utils/git.ts
+var execPromise = promisify(exec);
+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
+  };
+}
+
+// src/environment/Environment.ts
+var 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 = 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 = z.object({
+  repository_url: z.string(),
+  rule_ids: z.array(z.string()).optional(),
+  schema_version: z.string(),
+  powerlint_version: z.string()
+});
+var 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 = 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 = 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 = 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/steps/FindMatchesStep.ts
+import path8 from "path";
+
+// 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";
+console.debug = () => {
+};
+var require2 = createRequire(import.meta.url ? import.meta.url : __filename);
+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;
+}
+var graphqlPath = getGraphQLLibPath();
+var 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
+};
+var 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);
+var REGISTERED_LANGUAGE_EXTENSIONS = Object.entries(
+  registeredLanguages
+).reduce(
+  (acc, [language, registration]) => {
+    acc[language] = registration.extensions ?? [];
+    return acc;
+  },
+  {}
+);
+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)
+  );
+}
+
+// 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 = 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/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";
+
+// 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");
+}
+
+// src/providers/ScipIntelligenceProvider.ts
+var require3 = createRequire2(import.meta.url ? import.meta.url : __filename);
+var { scip } = require3("@sourcegraph/scip-root/bindings/typescript/scip.js");
+var PACKAGE_REGEX = /^\+ (.+?) \((\d+)ms\)$/;
+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 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 = class extends Error {
+  constructor(methodName, reason) {
+    super(`${methodName} is not supported: ${reason}`);
+    this.name = "LanguageBackendNotSupportedError";
+  }
+};
+var 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
+var 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 = 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 = 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 = 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 = 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 = 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";
+var VIOLATION_COLOR = "#ff6b35";
+var SUGGESTION_COLOR = "#4a90e2";
+var SKIPPED_COLOR = "#9b59b6";
+var BRAND_COLOR = "#fbbf24";
+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);
+}
+var LINE_NUMBER_BG_COLOR = "#f8f8f8";
+var LINE_NUMBER_TEXT_COLOR = "#888888";
+var 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)/")
+];
+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;
+    }
+  };
+}
+
+// src/utils/startupScreen.ts
+import readline from "readline";
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/utils/asciiFrames.ts
+import chalk2 from "chalk";
+var BRAND_COLOR2 = "#fbbf24";
+var VIOLATION_COLOR2 = "#ff6b35";
+var SUGGESTION_COLOR2 = "#4a90e2";
+var SKIPPED_COLOR2 = "#9b59b6";
+var 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
+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;
+}
+
+// src/cli.ts
+dotenv.config();
+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 
+`)
+    );
+  }
+}
+var 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()
+  }
+);
+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;
+    }
+  }
+}
+main();
+export {
+  checkForUpdates
+};
+//# sourceMappingURL=cli.js.map