@wispbit/local 1.0.26 → 1.0.28

package/dist/cli.js

@@ -10,6 +10,340 @@ import dotenv from "dotenv";
 import meow from "meow";
 import semver from "semver";
 
+// src/api/WispbitApiClient.ts
+import pRetry from "p-retry";
+import { z as z2 } from "zod";
+
+// src/validationSchemas.ts
+import { z } from "zod";
+
+// src/languages.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path 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 Language = /* @__PURE__ */ ((Language2) => {
+  Language2["Angular"] = "Angular";
+  Language2["Bash"] = "Bash";
+  Language2["C"] = "C";
+  Language2["Cpp"] = "Cpp";
+  Language2["Csharp"] = "Csharp";
+  Language2["Css"] = "Css";
+  Language2["Dart"] = "Dart";
+  Language2["Elixir"] = "Elixir";
+  Language2["Go"] = "Go";
+  Language2["Haskell"] = "Haskell";
+  Language2["Html"] = "Html";
+  Language2["Java"] = "Java";
+  Language2["JavaScript"] = "JavaScript";
+  Language2["Json"] = "Json";
+  Language2["Kotlin"] = "Kotlin";
+  Language2["Lua"] = "Lua";
+  Language2["Markdown"] = "Markdown";
+  Language2["Php"] = "Php";
+  Language2["Python"] = "Python";
+  Language2["Ruby"] = "Ruby";
+  Language2["Rust"] = "Rust";
+  Language2["Scala"] = "Scala";
+  Language2["Sql"] = "Sql";
+  Language2["Swift"] = "Swift";
+  Language2["Toml"] = "Toml";
+  Language2["Tsx"] = "Tsx";
+  Language2["TypeScript"] = "TypeScript";
+  Language2["Yaml"] = "Yaml";
+  Language2["GraphQL"] = "GraphQL";
+  Language2["Unknown"] = "Unknown";
+  return Language2;
+})(Language || {});
+var require2 = createRequire(import.meta.url ? import.meta.url : __filename);
+function getGraphQLLibPath() {
+  const graphqlDir = path.dirname(require2.resolve("tree-sitter-graphql"));
+  const releaseNode = path.join(graphqlDir, "../../build/Release/tree_sitter_graphql_binding.node");
+  if (existsSync(releaseNode)) {
+    return releaseNode;
+  }
+  const debugNode = path.join(graphqlDir, "../../build/Debug/tree_sitter_graphql_binding.node");
+  if (existsSync(debugNode)) {
+    return debugNode;
+  }
+  const soFile = path.join(graphqlDir, "parser.so");
+  if (existsSync(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 = path.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/validationSchemas.ts
+var MatchRangeSchema = z.object({
+  start: z.object({
+    line: z.number().describe("0-based line number"),
+    column: z.number().describe("0-based column number")
+  }),
+  end: z.object({
+    line: z.number().describe("0-based line number"),
+    column: z.number().describe("0-based column number")
+  })
+});
+var MatchSourceSchema = z.lazy(
+  () => z.object({
+    filePath: z.string().describe("File path where this source match occurred"),
+    text: z.string().optional().describe("The matched text at this source step"),
+    range: MatchRangeSchema.describe("Position range of this source match"),
+    symbol: z.string().optional().describe("Optional symbol name if applicable"),
+    language: z.nativeEnum(Language).describe(
+      "The language this source match was found in (e.g., Language.TypeScript, Language.Python)"
+    )
+  })
+);
+var MatchMetadataSchema = z.object({
+  fromCache: z.boolean().optional().describe("Whether this match was retrieved from cache"),
+  llmValidation: z.object({
+    isViolation: z.boolean().describe("Whether the LLM determined this is a violation"),
+    confidence: z.number().min(0).max(1).describe("Confidence score (0-1) of the validation"),
+    reason: z.string().describe("Explanation of the validation decision")
+  }).optional().describe("LLM validation metadata if applicable")
+}).optional().describe("Metadata about the match and its processing");
+var MatchSchema = z.object({
+  filePath: z.string().describe("File path where the match was found"),
+  text: z.string().optional().describe("The matched text/code snippet"),
+  range: MatchRangeSchema.describe("Position range of the match"),
+  symbol: z.string().optional().describe("Optional symbol name if applicable"),
+  language: z.nativeEnum(Language).describe("The language this match was found in (e.g., Language.TypeScript, Language.Python)"),
+  source: z.array(MatchSourceSchema).optional().describe(
+    "Chain of sources that led to this match. First entry is the original source, last entry is the immediate parent."
+  ),
+  metadata: MatchMetadataSchema
+});
+var ValidateViolationResponseSchema = z.object({
+  validMatches: z.array(MatchSchema).describe("Matches that are valid violations"),
+  skippedMatches: z.array(MatchSchema).describe("Matches that are not violations")
+});
+
+// src/api/WispbitApiClient.ts
+var InitializeRequestSchema = z2.object({
+  repository_url: z2.string(),
+  powerlint_version: z2.string(),
+  schema_version: z2.string()
+});
+var InitializeResponseSchema = z2.object({
+  configured: z2.boolean(),
+  invalid_api_key: z2.boolean().optional(),
+  is_valid_repository: z2.boolean().optional(),
+  config: z2.object({
+    ignored_globs: z2.array(z2.string())
+  }).optional()
+});
+var GetRulesRequestSchema = z2.object({
+  repository_url: z2.string(),
+  rule_ids: z2.array(z2.string()).optional(),
+  schema_version: z2.string(),
+  powerlint_version: z2.string()
+});
+var GetRulesResponseSchema = z2.object({
+  rules: z2.array(
+    z2.object({
+      id: z2.string(),
+      internalId: z2.string(),
+      internalVersionId: z2.string(),
+      message: z2.string(),
+      prompt: z2.string(),
+      severity: z2.enum(["suggestion", "violation"]),
+      schema: z2.any()
+    })
+  )
+});
+var ValidateViolationRequestSchema = z2.object({
+  rule: z2.object({
+    internalId: z2.string(),
+    internalVersionId: z2.string(),
+    contents: z2.string()
+  }),
+  matches: z2.array(z2.any()),
+  powerlint_version: z2.string(),
+  schema_version: z2.string()
+});
+var WispbitApiClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.apiKey = config.apiKey;
+  }
+  /**
+   * Make a request to the Wispbit API with retry logic
+   */
+  async request(endpoint, data, responseSchema) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await pRetry(
+      async () => {
+        const res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(data)
+        });
+        if (!res.ok) {
+          const errorText = await res.text();
+          throw new Error(
+            `Wispbit API request failed: ${res.status} ${res.statusText} - ${errorText}`
+          );
+        }
+        return res;
+      },
+      {
+        retries: 3,
+        minTimeout: 1e3,
+        maxTimeout: 5e3,
+        onFailedAttempt: (error) => {
+          console.warn(
+            `API request to ${endpoint} failed (attempt ${error.attemptNumber}/4): ${error.message}`
+          );
+        }
+      }
+    );
+    const json2 = await response.json();
+    if (responseSchema) {
+      return responseSchema.parse(json2);
+    }
+    return json2;
+  }
+  /**
+   * Initialize PowerLint configuration with Wispbit
+   */
+  async initialize(request) {
+    const validatedRequest = InitializeRequestSchema.parse(request);
+    return await this.request("/plv1/initialize", validatedRequest, InitializeResponseSchema);
+  }
+  /**
+   * Get rules from Wispbit Cloud
+   */
+  async getRules(request) {
+    const validatedRequest = GetRulesRequestSchema.parse(request);
+    return await this.request("/plv1/get-rules", validatedRequest, GetRulesResponseSchema);
+  }
+  /**
+   * Validate violations with Wispbit
+   */
+  async validateViolation(request) {
+    const validatedRequest = ValidateViolationRequestSchema.parse(request);
+    return await this.request(
+      "/plv1/validate-violation",
+      validatedRequest,
+      ValidateViolationResponseSchema
+    );
+  }
+  /**
+   * Validate violations with Wispbit (internal endpoint for testing)
+   */
+  async validateViolationInternal(request) {
+    const validatedRequest = ValidateViolationRequestSchema.parse(request);
+    return await this.request(
+      "/plv1/internal/validate-violation",
+      validatedRequest,
+      ValidateViolationResponseSchema
+    );
+  }
+};
+
 // src/version.ts
 import { readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -41,13 +375,22 @@ var Config = class _Config {
   config;
   apiKey = null;
   baseUrl = null;
-  constructor(config) {
+  apiClient = null;
+  useInternalEndpoint = false;
+  constructor(config, options) {
     this.config = {
       ...config,
       ignoredGlobs: config.ignoredGlobs || []
     };
     this.apiKey = config.apiKey || null;
     this.baseUrl = config.baseUrl || null;
+    this.useInternalEndpoint = (options == null ? void 0 : options.useInternalEndpoint) ?? false;
+    if (this.apiKey && this.baseUrl) {
+      this.apiClient = new WispbitApiClient({
+        baseUrl: this.baseUrl,
+        apiKey: this.apiKey
+      });
+    }
   }
   getIgnoredGlobs() {
     return this.config.ignoredGlobs || [];
@@ -66,6 +409,16 @@ var Config = class _Config {
   getBaseUrl() {
     return this.baseUrl;
   }
+  /**
+   * Get the Wispbit API client
+   * @returns The API client instance
+   */
+  getApiClient() {
+    if (!this.apiClient) {
+      throw new Error("API client not initialized. Config must have both apiKey and baseUrl.");
+    }
+    return this.apiClient;
+  }
   /**
    * Get the local PowerLint version
    * @returns The current PowerLint version
@@ -80,24 +433,6 @@ var Config = class _Config {
   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
@@ -107,11 +442,16 @@ var Config = class _Config {
     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
-    });
+    return new _Config(
+      {
+        ignoredGlobs,
+        apiKey: finalApiKey || void 0,
+        baseUrl: finalBaseUrl
+      },
+      {
+        useInternalEndpoint: true
+      }
+    );
   }
   /**
    * Initialize configuration by validating API key and repository URL with Wispbit
@@ -131,23 +471,15 @@ var Config = class _Config {
       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 tempClient = new WispbitApiClient({
+      baseUrl: finalBaseUrl,
+      apiKey: finalApiKey
+    });
+    const result = await tempClient.initialize({
+      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" };
     }
@@ -164,11 +496,17 @@ var Config = class _Config {
   isConfigured() {
     return this.getApiKey() !== null;
   }
+  /**
+   * Check if the internal validation endpoint should be used
+   */
+  shouldUseInternalEndpoint() {
+    return this.useInternalEndpoint;
+  }
 };
 
 // src/utils/git.ts
 import { exec, execSync } from "child_process";
-import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { promisify } from "util";
 
 // src/utils/hashString.ts
@@ -225,7 +563,7 @@ async function tryGetUpstream(repoRoot) {
 function tryGetGraphiteParent(repoRoot, branch) {
   const metadataPath = `.git/refs/branch-metadata/${branch}`;
   const fullPath = `${repoRoot}/${metadataPath}`;
-  if (!existsSync(fullPath)) {
+  if (!existsSync2(fullPath)) {
     return void 0;
   }
   const content = readFileSync2(fullPath, "utf-8");
@@ -714,7 +1052,7 @@ var Environment = class {
 // src/environment/Storage.ts
 import * as fs from "fs/promises";
 import os from "os";
-import path from "path";
+import path2 from "path";
 import Keyv from "keyv";
 import { KeyvFile } from "keyv-file";
 var Storage = class {
@@ -728,13 +1066,13 @@ var Storage = class {
    * This replaces the getConfigDirectory functionality
    */
   getStorageDirectory() {
-    return path.join(os.homedir(), ".powerlint");
+    return path2.join(os.homedir(), ".powerlint");
   }
   /**
    * Get the base directory for indexes
    */
   getIndexDirectory() {
-    return path.join(
+    return path2.join(
       this.getStorageDirectory(),
       "indexes",
       hashString(this.environment.getWorkspaceRoot())
@@ -744,7 +1082,7 @@ var Storage = class {
    * Get the base directory for caches
    */
   getCacheDirectory() {
-    return path.join(
+    return path2.join(
       this.getStorageDirectory(),
       "cache",
       hashString(this.environment.getWorkspaceRoot())
@@ -764,7 +1102,7 @@ var Storage = class {
     const indexDir = this.getIndexDirectory();
     await this.ensureDirectory(indexDir);
     const file = fileName || `${language.toLowerCase()}-index.scip`;
-    return path.join(indexDir, `${language.toLowerCase()}-${file}`);
+    return path2.join(indexDir, `${language.toLowerCase()}-${file}`);
   }
   /**
    * Check if an index exists for a language
@@ -801,7 +1139,7 @@ var Storage = class {
    * Get the cache file path
    */
   getCacheFilePath() {
-    return path.join(this.getCacheDirectory(), "cache.json");
+    return path2.join(this.getCacheDirectory(), "cache.json");
   }
   /**
    * Purge all storage (cache and indexes)
@@ -846,7 +1184,7 @@ var Storage = class {
       const cacheDir = this.getCacheDirectory();
       this.cacheStore = new Keyv({
         store: new KeyvFile({
-          filename: path.join(cacheDir, "cache.json")
+          filename: path2.join(cacheDir, "cache.json")
         })
       });
     }
@@ -889,13 +1227,6 @@ var Storage = class {
 };
 
 // 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;
@@ -903,26 +1234,6 @@ var WispbitRuleProvider = class {
     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
    */
@@ -956,19 +1267,14 @@ var WispbitRuleProvider = class {
    */
   async fetchRules(ruleIds) {
     const repositoryUrl = await this.getRepositoryUrl();
-    const requestData = {
+    const apiClient = this.config.getApiClient();
+    const response = await apiClient.getRules({
       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) => ({
+    });
+    return response.rules.map((rule) => ({
       id: rule.id,
       internalId: rule.internalId,
       config: {
@@ -980,27 +1286,6 @@ var WispbitRuleProvider = class {
       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
@@ -1083,11 +1368,18 @@ var ExecutionEventEmitter = class extends EventEmitter {
     this.emit("indexing:complete", { language, executionTime });
   }
   // Helper methods for step debugging
-  startStep(ruleId, stepName, stepType, inputs) {
-    this.emit("step:start", { ruleId, stepName, stepType, inputs });
+  startStep(ruleId, stepName, stepType, inputs, parentStepName) {
+    this.emit("step:start", { ruleId, stepName, stepType, inputs, parentStepName });
   }
-  completeStep(ruleId, stepName, stepType, outputs, executionTime = 0) {
-    this.emit("step:complete", { ruleId, stepName, stepType, outputs, executionTime });
+  completeStep(ruleId, stepName, stepType, outputs, executionTime = 0, parentStepName) {
+    this.emit("step:complete", {
+      ruleId,
+      stepName,
+      stepType,
+      outputs,
+      executionTime,
+      parentStepName
+    });
   }
   // Helper methods for test events
   startTest(ruleId, testName) {
@@ -1096,6 +1388,9 @@ var ExecutionEventEmitter = class extends EventEmitter {
   testMatches(ruleId, testName, matches) {
     this.emit("test:matches", { ruleId, testName, matches });
   }
+  completeTest(ruleId, testName, matches, stepExecutions) {
+    this.emit("test:complete", { ruleId, testName, matches, stepExecutions });
+  }
   // Helper methods for LLM validation events
   startLLMValidation(ruleId, matchCount, estimatedCost) {
     this.emit("llm:validation:start", { ruleId, matchCount, estimatedCost });
@@ -1116,9 +1411,18 @@ var ExecutionEventEmitter = class extends EventEmitter {
 
 // src/steps/FileExecutionContext.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 import { glob } from "glob";
+
+// src/utils/patternMatching.ts
 import ignore from "ignore";
+function matchesAnyPattern(filePath, patterns) {
+  if (patterns.length === 0) return false;
+  const ig = ignore().add(patterns);
+  return ig.ignores(filePath);
+}
+
+// src/steps/FileExecutionContext.ts
 var FileExecutionContext = class _FileExecutionContext {
   environment;
   _filePaths = [];
@@ -1253,14 +1557,14 @@ var FileExecutionContext = class _FileExecutionContext {
     } else if (this.mode === "diff") {
       const workspaceRoot = this.environment.getWorkspaceRoot();
       discoveredFiles = this.diffMode.changedFiles.filter(
-        (file) => fs2.existsSync(path2.resolve(workspaceRoot, file))
+        (file) => fs2.existsSync(path3.resolve(workspaceRoot, file))
       ).map((file) => file);
       const allIgnorePatterns = this.config.getIgnoredGlobs();
       if (allIgnorePatterns.length > 0) {
         this.eventEmitter.fileDiscoveryProgress("Applying ignore patterns...");
         const beforeIgnore = discoveredFiles.length;
         discoveredFiles = discoveredFiles.filter(
-          (filePath2) => !this.matchesAnyPattern(filePath2, allIgnorePatterns)
+          (filePath2) => !matchesAnyPattern(filePath2, allIgnorePatterns)
         );
         if (beforeIgnore !== discoveredFiles.length) {
           this.eventEmitter.fileDiscoveryProgress(
@@ -1286,7 +1590,7 @@ var FileExecutionContext = class _FileExecutionContext {
    */
   async discoverFilesFromPath(filePath, gitIgnoredFiles) {
     const workspaceRoot = this.environment.getWorkspaceRoot();
-    const fullPath = path2.resolve(workspaceRoot, filePath);
+    const fullPath = path3.resolve(workspaceRoot, filePath);
     const allIgnorePatterns = this.config.getIgnoredGlobs();
     if (this.isGlobPattern(filePath)) {
       this.eventEmitter.fileDiscoveryProgress(
@@ -1304,7 +1608,7 @@ var FileExecutionContext = class _FileExecutionContext {
         this.eventEmitter.fileDiscoveryProgress(`File ${filePath} is ignored by git`);
         return [];
       }
-      if (this.matchesAnyPattern(filePath, allIgnorePatterns)) {
+      if (matchesAnyPattern(filePath, allIgnorePatterns)) {
         this.eventEmitter.fileDiscoveryProgress(`File ${filePath} is ignored by patterns`);
         return [];
       } else {
@@ -1346,7 +1650,7 @@ var FileExecutionContext = class _FileExecutionContext {
    */
   async discoverFilesFromDirectory(dirPath, ignorePatterns, gitIgnoredFiles) {
     const workspaceRoot = this.environment.getWorkspaceRoot();
-    const globPattern = path2.join(dirPath, "**/*").replace(/\\/g, "/");
+    const globPattern = path3.join(dirPath, "**/*").replace(/\\/g, "/");
     const allIgnorePatterns = ["**/node_modules/**", "**/.git/**", ...ignorePatterns];
     const matches = await glob(globPattern, {
       cwd: workspaceRoot,
@@ -1368,9 +1672,9 @@ var FileExecutionContext = class _FileExecutionContext {
     for (const dir of directories) {
       const stats = fs2.statSync(dir);
       if (!stats.isDirectory()) {
-        const relativePath = path2.relative(workspaceRoot, dir);
+        const relativePath = path3.relative(workspaceRoot, dir);
         const isGitIgnored = gitIgnoredFiles.has(relativePath);
-        const shouldIgnore = this.matchesAnyPattern(relativePath, ignorePatterns);
+        const shouldIgnore = matchesAnyPattern(relativePath, ignorePatterns);
         if (!isGitIgnored && !shouldIgnore) {
           allFiles.push(relativePath);
         }
@@ -1384,21 +1688,13 @@ var FileExecutionContext = class _FileExecutionContext {
         ignore: allIgnorePatterns
       });
       const relativePaths = matches.map((match) => {
-        const absolutePath = path2.resolve(dir, match);
-        return path2.relative(workspaceRoot, absolutePath);
+        const absolutePath = path3.resolve(dir, match);
+        return path3.relative(workspaceRoot, absolutePath);
       }).filter((relativePath) => !gitIgnoredFiles.has(relativePath));
       allFiles.push(...relativePaths);
     }
     return [...new Set(allFiles)];
   }
-  /**
-   * Check if a file matches any of the given patterns using the ignore package
-   */
-  matchesAnyPattern(filePath, patterns) {
-    if (patterns.length === 0) return false;
-    const ig = ignore().add(patterns);
-    return ig.ignores(filePath);
-  }
   /**
    * Check if a file should be processed
    */
@@ -1483,43 +1779,34 @@ var FileExecutionContext = class _FileExecutionContext {
 
 // src/steps/FileFilterStep.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
-import ignore2 from "ignore";
+import * as path4 from "path";
 var FileFilterStep = class {
   environment;
   constructor(environment) {
     this.environment = environment;
   }
-  /**
-   * Check if a file matches any of the given patterns using the ignore package
-   */
-  matchesAnyPattern(filePath, patterns) {
-    if (patterns.length === 0) return false;
-    const ig = ignore2().add(patterns);
-    return ig.ignores(filePath);
-  }
   /**
    * 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);
+    const absoluteFilePath = path4.resolve(workspaceRoot, filePath);
     if ("fs.siblingExists" in condition) {
       const { filename } = condition["fs.siblingExists"];
-      const dir = path3.dirname(absoluteFilePath);
-      const siblingPath = path3.join(dir, filename);
+      const dir = path4.dirname(absoluteFilePath);
+      const siblingPath = path4.join(dir, filename);
       return fs3.existsSync(siblingPath);
     }
     if ("fs.ancestorHas" in condition) {
       const { filename } = condition["fs.ancestorHas"];
-      let currentDir = path3.dirname(absoluteFilePath);
-      const root = path3.parse(currentDir).root;
+      let currentDir = path4.dirname(absoluteFilePath);
+      const root = path4.parse(currentDir).root;
       while (currentDir !== root) {
-        const targetPath = path3.join(currentDir, filename);
+        const targetPath = path4.join(currentDir, filename);
         if (fs3.existsSync(targetPath)) {
           return true;
         }
-        const parentDir = path3.dirname(currentDir);
+        const parentDir = path4.dirname(currentDir);
         if (parentDir === currentDir) break;
         currentDir = parentDir;
       }
@@ -1527,12 +1814,12 @@ var FileFilterStep = class {
     }
     if ("fs.siblingAny" in condition) {
       const { pattern } = condition["fs.siblingAny"];
-      const dir = path3.dirname(absoluteFilePath);
+      const dir = path4.dirname(absoluteFilePath);
       if (!fs3.existsSync(dir)) {
         return false;
       }
       const siblings = fs3.readdirSync(dir);
-      return siblings.some((sibling) => this.matchesAnyPattern(sibling, [pattern]));
+      return siblings.some((sibling) => matchesAnyPattern(sibling, [pattern]));
     }
     return false;
   }
@@ -1561,12 +1848,12 @@ var FileFilterStep = class {
     let filteredPaths = filePaths;
     if ((_a = options.include) == null ? void 0 : _a.length) {
       filteredPaths = filteredPaths.filter(
-        (filePath) => this.matchesAnyPattern(filePath, options.include)
+        (filePath) => matchesAnyPattern(filePath, options.include)
       );
     }
     if ((_b = options.ignore) == null ? void 0 : _b.length) {
       filteredPaths = filteredPaths.filter(
-        (filePath) => !this.matchesAnyPattern(filePath, options.ignore)
+        (filePath) => !matchesAnyPattern(filePath, options.ignore)
       );
     }
     if (Object.keys(options.conditions || {}).length > 0 && filteredPaths.length > 0) {
@@ -1585,126 +1872,6 @@ var FileFilterStep = class {
 // src/steps/FindMatchesStep.ts
 import path8 from "path";
 
-// src/languages.ts
-import { existsSync as existsSync4 } 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 (existsSync4(releaseNode)) {
-    return releaseNode;
-  }
-  const debugNode = path4.join(graphqlDir, "../../build/Debug/tree_sitter_graphql_binding.node");
-  if (existsSync4(debugNode)) {
-    return debugNode;
-  }
-  const soFile = path4.join(graphqlDir, "parser.so");
-  if (existsSync4(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";
@@ -2464,7 +2631,7 @@ var FindMatchesStep = class {
 
 // src/steps/GotoDefinitionStep.ts
 import path9 from "path";
-import ignore3 from "ignore";
+import ignore2 from "ignore";
 var GotoDefinitionStep = class {
   maxDepth = 1;
   environment;
@@ -2631,7 +2798,7 @@ var GotoDefinitionStep = class {
       return relativePath === spec.path;
     }
     if (spec.glob) {
-      const ig = ignore3().add(spec.glob);
+      const ig = ignore2().add(spec.glob);
       return ig.ignores(relativePath);
     }
     if (spec.regex) {
@@ -2645,70 +2812,29 @@ var GotoDefinitionStep = class {
 // src/providers/WispbitViolationValidationProvider.ts
 var WispbitViolationValidationProvider = class {
   config;
-  constructor(config) {
+  useInternalEndpoint;
+  constructor(config, useInternalEndpoint = false) {
     this.config = config;
+    this.useInternalEndpoint = useInternalEndpoint;
   }
   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()
-      })
+    const apiClient = this.config.getApiClient();
+    const rulePayload = {
+      internalId: params.rule.internalId,
+      internalVersionId: params.rule.internalId,
+      contents: params.rule.prompt
+    };
+    const method = this.useInternalEndpoint ? apiClient.validateViolationInternal.bind(apiClient) : apiClient.validateViolation.bind(apiClient);
+    const result = await method({
+      rule: rulePayload,
+      matches: params.matches,
+      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 {
+      validMatches: result.validMatches,
+      skippedMatches: result.skippedMatches
     };
-    return hashString(JSON.stringify(matchData)).substring(0, 16);
   }
 };
 
@@ -2725,31 +2851,20 @@ var LLMStep = class {
     this.storage = new Storage(environment);
   }
   /**
-   * Generate a unique ID for a single match
-   * Hash is based on filePath + range + text
+   * Generate a cache key for a single match LLM validation
    */
-  generateMatchId(match) {
+  generateMatchCacheKey(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
+      text: match.text,
+      prompt: match.text
+      // Include prompt in cache key
     };
-    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`;
+    return JSON.stringify(matchData);
   }
   /**
    * Execute the actual LLM validation for uncached matches
@@ -2759,38 +2874,42 @@ var LLMStep = class {
    */
   async executeLLMValidation(rule, uncachedMatches) {
     const llmStartTime = Date.now();
-    const promptHash = this.hashPrompt(rule.prompt);
-    const validationProvider = new WispbitViolationValidationProvider(this.config);
+    const validationProvider = new WispbitViolationValidationProvider(
+      this.config,
+      this.config.shouldUseInternalEndpoint()
+    );
     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 validationResponse = await validationProvider.validateViolations(validationParams);
+    const newViolationMatches = validationResponse.validMatches.map((match) => ({
+      ...match,
+      metadata: {
+        fromCache: false,
+        llmValidation: {
+          isViolation: true,
+          confidence: 1,
+          reason: "Confirmed violation"
+        }
       }
-      const cacheKey = this.generateMatchCacheKey(result.matchId, promptHash);
+    }));
+    for (const match of validationResponse.validMatches) {
+      const cacheKey = this.generateMatchCacheKey(match);
       const decision = {
-        matchId: result.matchId,
-        isViolation: result.isViolation,
-        confidence: result.confidence,
-        reason: result.reason
+        isViolation: true,
+        confidence: 1,
+        reason: "Confirmed violation"
+      };
+      await this.storage.saveCache(rule.id, cacheKey, decision);
+    }
+    for (const match of validationResponse.skippedMatches) {
+      const cacheKey = this.generateMatchCacheKey(match);
+      const decision = {
+        isViolation: false,
+        confidence: 1,
+        reason: "Not a violation"
       };
       await this.storage.saveCache(rule.id, cacheKey, decision);
     }
@@ -2814,12 +2933,10 @@ var LLMStep = class {
    */
   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 cacheKey = this.generateMatchCacheKey(match);
       const cachedDecision = await this.storage.readCache(rule.id, cacheKey);
       if (cachedDecision) {
         if (cachedDecision.isViolation) {
@@ -2886,7 +3003,7 @@ var RuleExecutor = class {
   /**
    * Execute a single step
    */
-  async executeStep(rule, stepName, stepConfig, filePaths, matches, options) {
+  async executeStep(rule, stepName, stepConfig, filePaths, matches, options, _parentStepName) {
     const stepType = stepConfig.type;
     if (stepType === "ast-grep") {
       const { type: _type, language, ...schema } = stepConfig;
@@ -2903,13 +3020,34 @@ var RuleExecutor = class {
       for (let i = 0; i < stepConfig.steps.length; i++) {
         const subStep = stepConfig.steps[i];
         const subStepName = `${stepName}[${i}]`;
+        this.eventEmitter.startStep(
+          rule.id,
+          subStepName,
+          subStep.type,
+          { filePaths, matches },
+          stepName
+          // parent step name
+        );
+        const subStepStartTime = Date.now();
         const subResult = await this.executeStep(
           rule,
           subStepName,
           subStep,
           filePaths,
           matches,
-          options
+          options,
+          stepName
+          // parent step name
+        );
+        const subStepExecutionTime = Date.now() - subStepStartTime;
+        this.eventEmitter.completeStep(
+          rule.id,
+          subStepName,
+          subStep.type,
+          subResult,
+          subStepExecutionTime,
+          stepName
+          // parent step name
         );
         if (subResult.matches) {
           allMatches = allMatches.concat(subResult.matches);
@@ -3015,13 +3153,7 @@ var RuleExecutor = class {
           options
         );
         const stepExecutionTime = Date.now() - stepStartTime;
-        this.eventEmitter.emit("step:complete", {
-          ruleId,
-          stepName,
-          stepType: stepConfig.type,
-          outputs: result,
-          executionTime: stepExecutionTime
-        });
+        this.eventEmitter.completeStep(ruleId, stepName, stepConfig.type, result, stepExecutionTime);
         if (result.filePaths !== void 0) {
           currentFilePaths = this.executionContext.filterFiles(result.filePaths);
           currentMatches = this.executionContext.filterMatchesByFilePaths(
@@ -3061,8 +3193,8 @@ var InvalidRuleFormatError = class extends Error {
 import { stripVTControlCharacters } from "node:util";
 import chalk from "chalk";
 import ora from "ora";
-var VIOLATION_COLOR = "#ff6b35";
-var SUGGESTION_COLOR = "#4a90e2";
+var VIOLATION_COLOR = "#f87171";
+var SUGGESTION_COLOR = "#60a5fa";
 var SKIPPED_COLOR = "#9b59b6";
 var BRAND_COLOR = "#fbbf24";
 function formatClickableRuleId(ruleId, internalId) {
@@ -3172,9 +3304,9 @@ function printSummary(results, summary) {
     }
     let messageType;
     if (ruleData.severity === "violation") {
-      messageType = chalk.hex(VIOLATION_COLOR)(" violation".padStart(9));
+      messageType = chalk.hex(VIOLATION_COLOR)("\u25A0") + " " + chalk.hex(VIOLATION_COLOR).bold("violation".padStart(8));
     } else if (ruleData.severity === "suggestion") {
-      messageType = chalk.hex(SUGGESTION_COLOR)("suggestion".padEnd(7));
+      messageType = chalk.hex(SUGGESTION_COLOR)("\u25CF") + " " + chalk.hex(SUGGESTION_COLOR).bold("suggestion".padEnd(6));
     } else {
       messageType = chalk.hex(SKIPPED_COLOR)("   skipped".padEnd(9));
     }
@@ -3190,12 +3322,12 @@ function printSummary(results, summary) {
 `;
     } 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 <= 20);
+      const shouldShowCodeSnippets = sortedMatches.length < 10 && sortedMatches.some((match) => match.text && match.text.split("\n").length <= 30);
       if (shouldShowCodeSnippets) {
         sortedMatches.forEach((match, index) => {
-          output += `  ${match.filePath}
+          if (match.text && match.text.split("\n").length <= 30) {
+            output += `  ${match.filePath}
 `;
-          if (match.text && match.text.split("\n").length <= 20) {
             const lines = match.text.split("\n");
             lines.forEach((line, lineIndex) => {
               const lineNumber = match.line + lineIndex;
@@ -3205,6 +3337,10 @@ function printSummary(results, summary) {
               output += `  ${lineNumberBox} ${chalk.dim(line)}
 `;
             });
+          } else {
+            const lineRange = match.endLine ? `(${match.line}:${match.endLine})` : `(${match.line})`;
+            output += `  ${match.filePath} ${chalk.dim(lineRange)}
+`;
           }
           if (index < sortedMatches.length - 1) {
             output += `
@@ -3252,18 +3388,20 @@ function printRulesList(rules) {
   const tableData = [];
   tableData.push([
     "",
-    `${"id".padEnd(12)} ${chalk.dim("\u2502")} ${"severity".padEnd(12)} ${chalk.dim("\u2502")} message`
+    `${"id".padEnd(12)} ${chalk.dim("\u2502")} ${"severity".padEnd(16)} ${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))}`
+    `${chalk.dim("\u2500".repeat(12))} ${chalk.dim("\u253C")} ${chalk.dim("\u2500".repeat(16))} ${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 severityIcon = rule.config.severity === "violation" ? "\u25A0" : "\u25CF";
+    const severityColor = rule.config.severity === "violation" ? chalk.hex(VIOLATION_COLOR).bold : chalk.hex(SUGGESTION_COLOR).bold;
+    const severityIconColor = rule.config.severity === "violation" ? chalk.hex(VIOLATION_COLOR) : chalk.hex(SUGGESTION_COLOR);
+    const severityText = severityIconColor(severityIcon) + " " + 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);
+    const severityPadding = Math.max(0, 16 - (rule.config.severity.length + 2));
     tableData.push([
       "",
       `${ruleId}${" ".repeat(idPadding)} ${chalk.dim("\u2502")} ${severityText}${" ".repeat(severityPadding)} ${chalk.dim("\u2502")} ${rule.config.message}`
@@ -3669,6 +3807,9 @@ async function saveApiKey(apiKey) {
   await fs5.writeFile(configPath, JSON.stringify(newConfig, null, 2));
 }
 async function loadApiKey() {
+  if (process.env.WISPBIT_API_KEY) {
+    return process.env.WISPBIT_API_KEY;
+  }
   const configPath = getConfigFilePath();
   try {
     const configContent = await fs5.readFile(configPath, "utf-8");