@packmind/cli 0.2.5

package/main.cjs

@@ -0,0 +1,4084 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// apps/cli/src/main.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_cmd_ts2 = require("cmd-ts");
+
+// apps/cli/src/infra/commands/LinterCommand.ts
+var import_cmd_ts = require("cmd-ts");
+
+// packages/shared/src/ai/prompts/OpenAIService.ts
+var import_openai = __toESM(require("openai"));
+
+// packages/shared/src/config/infra/Infisical/InfisicalConfig.ts
+var import_sdk = require("@infisical/sdk");
+
+// packages/shared/src/logger/PackmindLogger.ts
+var import_winston = __toESM(require("winston"));
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["SILENT"] = "silent";
+  LogLevel2["ERROR"] = "error";
+  LogLevel2["WARN"] = "warn";
+  LogLevel2["INFO"] = "info";
+  LogLevel2["HTTP"] = "http";
+  LogLevel2["VERBOSE"] = "verbose";
+  LogLevel2["DEBUG"] = "debug";
+  LogLevel2["SILLY"] = "silly";
+  return LogLevel2;
+})(LogLevel || {});
+var PackmindLogger = class {
+  constructor(name, level = "info" /* INFO */) {
+    this.name = name;
+    const envLogLevel = process.env["PACKMIND_LOG_LEVEL"];
+    let finalLevel = level;
+    if (envLogLevel && Object.values(LogLevel).includes(envLogLevel)) {
+      finalLevel = envLogLevel;
+    }
+    this.currentLevel = finalLevel;
+    if (finalLevel !== "silent" /* SILENT */) {
+      this.logger = import_winston.default.createLogger({
+        level: finalLevel,
+        format: import_winston.default.format.combine(
+          import_winston.default.format.timestamp(),
+          import_winston.default.format.errors({ stack: true }),
+          import_winston.default.format.label({ label: this.name }),
+          import_winston.default.format.json()
+        ),
+        transports: [
+          new import_winston.default.transports.Console({
+            format: import_winston.default.format.combine(
+              import_winston.default.format.colorize(),
+              import_winston.default.format.printf(
+                ({ timestamp, level: level2, message, label, ...meta }) => {
+                  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+                  return `${timestamp} [${label}] ${level2}: ${message}${metaStr}`;
+                }
+              )
+            )
+          })
+        ]
+      });
+    } else {
+      this.logger = null;
+    }
+  }
+  error(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.error(message, meta);
+  }
+  warn(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.warn(message, meta);
+  }
+  info(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.info(message, meta);
+  }
+  http(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.http(message, meta);
+  }
+  verbose(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.verbose(message, meta);
+  }
+  debug(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.debug(message, meta);
+  }
+  silly(message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.silly(message, meta);
+  }
+  log(level, message, meta) {
+    if (this.currentLevel === "silent" /* SILENT */ || !this.logger) return;
+    this.logger.log(level, message, meta);
+  }
+  setLevel(level) {
+    this.currentLevel = level;
+    if (level !== "silent" /* SILENT */ && this.logger) {
+      this.logger.level = level;
+    }
+  }
+  getName() {
+    return this.name;
+  }
+};
+
+// packages/shared/src/config/infra/Infisical/InfisicalConfig.ts
+var origin = "InfisicalConfig";
+var InfisicalConfig = class {
+  constructor(clientId, clientSecret, env, projectId, logger = new PackmindLogger(origin)) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.env = env;
+    this.projectId = projectId;
+    this.logger = logger;
+    this.logger.info("Initializing InfisicalConfig", { env, projectId });
+    try {
+      this.client = new import_sdk.InfisicalSDK({
+        siteUrl: "https://eu.infisical.com"
+        // Optional, defaults to https://app.infisical.com
+      });
+      this.logger.info("InfisicalSDK client created successfully", {
+        siteUrl: "https://eu.infisical.com"
+      });
+    } catch (error) {
+      this.logger.error("Failed to create InfisicalSDK client", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async initClient() {
+    this.logger.info("Initializing Infisical client authentication");
+    try {
+      this.logger.debug("Authenticating with Infisical using universal auth");
+      await this.client.auth().universalAuth.login({
+        clientId: this.clientId,
+        clientSecret: this.clientSecret
+      });
+      this.logger.info("Infisical client authenticated successfully");
+    } catch (error) {
+      this.logger.error("Failed to authenticate Infisical client", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async getValue(secretName) {
+    this.logger.info("Retrieving secret from Infisical", {
+      secretName,
+      env: this.env,
+      projectId: this.projectId
+    });
+    try {
+      this.logger.debug("Fetching secret from Infisical API", { secretName });
+      const nameSecret = await this.client.secrets().getSecret({
+        projectId: this.projectId,
+        environment: this.env,
+        secretName
+      });
+      if (nameSecret?.secretValue) {
+        this.logger.info("Secret retrieved from Infisical successfully", {
+          secretName
+        });
+        return nameSecret.secretValue;
+      } else {
+        this.logger.warn("Secret not found or has no value in Infisical", {
+          secretName
+        });
+        return null;
+      }
+    } catch (error) {
+      this.logger.warn("Failed to retrieve secret from Infisical", {
+        secretName,
+        env: this.env,
+        projectId: this.projectId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+
+// packages/shared/src/config/config/Configuration.ts
+var origin2 = "Configuration";
+var Configuration = class _Configuration {
+  constructor() {
+    this.initialized = false;
+    this.initializationPromise = null;
+  }
+  static {
+    this.logger = new PackmindLogger(
+      origin2,
+      "info" /* INFO */
+    );
+  }
+  static getInstance(logger) {
+    if (logger) {
+      _Configuration.logger = logger;
+    }
+    _Configuration.logger.debug("Getting Configuration instance");
+    if (!_Configuration.instance) {
+      _Configuration.logger.info("Creating new Configuration instance");
+      _Configuration.instance = new _Configuration();
+    }
+    return _Configuration.instance;
+  }
+  async initialize(env) {
+    if (this.initialized) {
+      _Configuration.logger.debug("Configuration already initialized, skipping");
+      return;
+    }
+    if (this.initializationPromise) {
+      _Configuration.logger.debug(
+        "Configuration initialization already in progress, waiting for completion"
+      );
+      await this.initializationPromise;
+      return;
+    }
+    this.initializationPromise = this.performInitialization(env);
+    try {
+      await this.initializationPromise;
+    } finally {
+      this.initializationPromise = null;
+    }
+  }
+  async performInitialization(env) {
+    _Configuration.logger.info("Initializing Configuration");
+    try {
+      const configurationMode = env["CONFIGURATION"]?.toLowerCase();
+      _Configuration.logger.debug("Configuration mode detected", {
+        mode: configurationMode
+      });
+      if (configurationMode === "infisical") {
+        _Configuration.logger.info("Initializing Infisical configuration");
+        const clientId = env["INFISICAL_CLIENT_ID"];
+        const clientSecret = env["INFISICAL_CLIENT_SECRET"];
+        const infisicalEnv = env["INFISICAL_ENV"];
+        const projectId = env["INFISICAL_PROJECT_ID"];
+        if (!clientId || !clientSecret || !infisicalEnv || !projectId) {
+          _Configuration.logger.error("Infisical configuration is incomplete", {
+            hasClientId: !!clientId,
+            hasClientSecret: !!clientSecret,
+            hasInfisicalEnv: !!infisicalEnv,
+            hasProjectId: !!projectId
+          });
+          throw new Error(
+            "Infisical configuration is incomplete. Please set INFISICAL_CLIENT_ID, INFISICAL_CLIENT_SECRET, INFISICAL_ENV, and INFISICAL_PROJECT_ID environment variables."
+          );
+        }
+        this.infisicalConfig = new InfisicalConfig(
+          clientId,
+          clientSecret,
+          infisicalEnv,
+          projectId
+        );
+        _Configuration.logger.debug("Initializing Infisical client");
+        await this.infisicalConfig.initClient();
+        _Configuration.logger.info(
+          "Infisical configuration initialized successfully"
+        );
+      } else {
+        _Configuration.logger.info(
+          "Using environment variables only (no Infisical)"
+        );
+      }
+      this.initialized = true;
+      _Configuration.logger.info("Configuration initialization completed");
+    } catch (error) {
+      _Configuration.logger.error("Failed to initialize Configuration", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  static async getConfigWithDefault(key, defaultValue) {
+    const value = await _Configuration.getConfig(key);
+    return value ?? defaultValue;
+  }
+  static async getConfig(key, env = process.env, logger) {
+    if (logger) {
+      _Configuration.logger = logger;
+    }
+    _Configuration.logger.info("Getting configuration value", { key });
+    try {
+      const instance = _Configuration.getInstance();
+      await instance.initialize(env);
+      const envValue = env[key];
+      if (envValue) {
+        _Configuration.logger.debug(
+          "Configuration value found in environment variables",
+          { key }
+        );
+        return envValue;
+      }
+      if (instance.infisicalConfig) {
+        _Configuration.logger.debug(
+          "Checking Infisical for configuration value",
+          { key }
+        );
+        const infisicalValue = await instance.infisicalConfig.getValue(key);
+        if (infisicalValue) {
+          _Configuration.logger.debug("Configuration value found in Infisical", {
+            key
+          });
+          return infisicalValue;
+        }
+      }
+      _Configuration.logger.warn("Configuration value not found", { key });
+      return null;
+    } catch (error) {
+      _Configuration.logger.warn("Failed to get configuration value", {
+        key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+};
+
+// packages/shared/src/cache/Cache.ts
+var import_ioredis = __toESM(require("ioredis"));
+var origin3 = "Cache";
+var Cache = class _Cache {
+  constructor() {
+    this.initialized = false;
+    this.connectionConfig = {
+      host: "redis",
+      port: 6379,
+      maxRetriesPerRequest: 3
+    };
+  }
+  static {
+    this.logger = new PackmindLogger(
+      origin3,
+      "info" /* INFO */
+    );
+  }
+  static {
+    // Default cache expiration time in seconds (5 minutes)
+    this.DEFAULT_EXPIRATION_SECONDS = 300;
+  }
+  /**
+   * Get the singleton instance of Cache
+   */
+  static getInstance() {
+    _Cache.logger.debug("Getting Cache instance");
+    if (!_Cache.instance) {
+      _Cache.logger.info("Creating new Cache instance");
+      _Cache.instance = new _Cache();
+    }
+    return _Cache.instance;
+  }
+  /**
+   * Initialize the Redis client with configuration
+   * This should be called during application startup
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    _Cache.logger.info("Initializing Redis cache client");
+    try {
+      const redisUri = await Configuration.getConfig("REDIS_URI");
+      if (!redisUri) {
+        throw new Error("REDIS_URI configuration is required");
+      }
+      _Cache.logger.info("Using REDIS_URI configuration");
+      this.client = new import_ioredis.default(redisUri, {
+        maxRetriesPerRequest: 3
+      });
+      this.client.on("error", (error) => {
+        _Cache.logger.error("Redis cache client error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+      this.client.on("connect", () => {
+        _Cache.logger.info("Redis cache client connected successfully");
+      });
+      this.initialized = true;
+      _Cache.logger.info("Cache initialization completed");
+    } catch (error) {
+      _Cache.logger.error("Failed to initialize cache", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(
+        `Cache initialization failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Set a value in the cache with optional expiration
+   * @param key - The cache key
+   * @param value - The value to cache (will be JSON serialized)
+   * @param expirationSeconds - Expiration time in seconds (default: 300s)
+   */
+  async set(key, value, expirationSeconds = _Cache.DEFAULT_EXPIRATION_SECONDS) {
+    if (!this.initialized || !this.client) {
+      _Cache.logger.warn("Cache not initialized, skipping set operation", {
+        key
+      });
+      return;
+    }
+    try {
+      const serializedValue = JSON.stringify(value);
+      await this.client.setex(key, expirationSeconds, serializedValue);
+    } catch (error) {
+      _Cache.logger.warn(
+        "Failed to set cache value, continuing without caching",
+        {
+          key,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  /**
+   * Get a value from the cache
+   * @param key - The cache key
+   * @returns The cached value or null if not found, expired, or error occurred
+   */
+  async get(key) {
+    if (!this.initialized || !this.client) {
+      _Cache.logger.warn(
+        "Cache not initialized, returning null for get operation",
+        { key }
+      );
+      return null;
+    }
+    try {
+      const serializedValue = await this.client.get(key);
+      if (serializedValue === null) {
+        return null;
+      }
+      const value = JSON.parse(serializedValue);
+      return value;
+    } catch (error) {
+      _Cache.logger.warn("Failed to get cache value, returning null", {
+        key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Invalidate (delete) a cache entry
+   * @param key - The cache key to invalidate
+   */
+  async invalidate(key) {
+    if (!this.initialized || !this.client) {
+      _Cache.logger.warn(
+        "Cache not initialized, skipping invalidate operation",
+        { key }
+      );
+      return;
+    }
+    try {
+      await this.client.del(key);
+    } catch (error) {
+      _Cache.logger.warn(
+        "Failed to invalidate cache key, continuing without invalidation",
+        {
+          key,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  /**
+   * Disconnect the Redis client (for cleanup during shutdown)
+   */
+  async disconnect() {
+    _Cache.logger.info("Disconnecting cache client");
+    if (this.client) {
+      try {
+        await this.client.disconnect();
+        _Cache.logger.info("Cache client disconnected successfully");
+      } catch (error) {
+        _Cache.logger.error("Error disconnecting cache client", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.initialized = false;
+  }
+  /**
+   * Get cache statistics (for monitoring/debugging)
+   */
+  async getStats() {
+    return {
+      connected: this.client?.status === "ready",
+      initialized: this.initialized
+    };
+  }
+};
+
+// packages/shared/src/types/brandedTypes.ts
+function brandedIdFactory() {
+  return (id) => id;
+}
+
+// packages/shared/src/repositories/AbstractRepository.ts
+var import_common = require("@nestjs/common");
+
+// packages/shared/src/sse/RedisSSEClient.ts
+var import_ioredis2 = __toESM(require("ioredis"));
+var origin4 = "RedisSSEClient";
+var RedisSSEClient = class _RedisSSEClient {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.initialized = false;
+  }
+  static {
+    this.logger = new PackmindLogger(origin4);
+  }
+  static getInstance() {
+    _RedisSSEClient.logger.debug("Getting RedisSSEClient instance");
+    if (!_RedisSSEClient.instance) {
+      _RedisSSEClient.logger.info("Creating new RedisSSEClient instance");
+      _RedisSSEClient.instance = new _RedisSSEClient();
+    }
+    return _RedisSSEClient.instance;
+  }
+  /**
+   * Initialize Redis clients using the same configuration as BullMQ
+   */
+  async initialize() {
+    if (this.initialized) return;
+    _RedisSSEClient.logger.info("Initializing Redis SSE clients");
+    try {
+      const redisURI = await Configuration.getConfig("REDIS_URI") || "redis";
+      this.publisherClient = new import_ioredis2.default(redisURI);
+      this.subscriberClient = new import_ioredis2.default(redisURI);
+      this.publisherClient.on("error", (error) => {
+        _RedisSSEClient.logger.error("Redis publisher client error", {
+          error: error.message
+        });
+      });
+      this.subscriberClient.on("error", (error) => {
+        _RedisSSEClient.logger.error("Redis subscriber client error", {
+          error: error.message
+        });
+      });
+      await this.publisherClient.ping();
+      await this.subscriberClient.ping();
+      this.initialized = true;
+      _RedisSSEClient.logger.info("Redis SSE clients initialized successfully");
+    } catch (error) {
+      _RedisSSEClient.logger.error("Failed to initialize Redis SSE clients", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Publish a message to a Redis channel
+   */
+  async publish(channel, message) {
+    await this.initialize();
+    if (!this.publisherClient) {
+      throw new Error("Publisher client not initialized");
+    }
+    _RedisSSEClient.logger.debug("Publishing message to Redis channel", {
+      channel,
+      messageLength: message.length
+    });
+    try {
+      const subscriberCount = await this.publisherClient.publish(
+        channel,
+        message
+      );
+      _RedisSSEClient.logger.debug("Message published successfully", {
+        channel,
+        subscriberCount
+      });
+      return subscriberCount;
+    } catch (error) {
+      _RedisSSEClient.logger.error("Failed to publish message", {
+        channel,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Subscribe to a Redis channel
+   */
+  async subscribe(channel, callback) {
+    await this.initialize();
+    if (!this.subscriberClient) {
+      throw new Error("Subscriber client not initialized");
+    }
+    _RedisSSEClient.logger.info("Subscribing to Redis channel", { channel });
+    try {
+      this.subscriberClient.on("message", (receivedChannel, message) => {
+        if (receivedChannel === channel) {
+          _RedisSSEClient.logger.debug("Received message from Redis channel", {
+            channel: receivedChannel,
+            messageLength: message.length
+          });
+          callback(message);
+        }
+      });
+      await this.subscriberClient.subscribe(channel);
+      _RedisSSEClient.logger.info("Successfully subscribed to Redis channel", {
+        channel
+      });
+    } catch (error) {
+      _RedisSSEClient.logger.error("Failed to subscribe to Redis channel", {
+        channel,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Unsubscribe from a Redis channel
+   */
+  async unsubscribe(channel) {
+    if (!this.subscriberClient) {
+      return;
+    }
+    _RedisSSEClient.logger.info("Unsubscribing from Redis channel", { channel });
+    try {
+      await this.subscriberClient.unsubscribe(channel);
+      _RedisSSEClient.logger.info(
+        "Successfully unsubscribed from Redis channel",
+        { channel }
+      );
+    } catch (error) {
+      _RedisSSEClient.logger.error("Failed to unsubscribe from Redis channel", {
+        channel,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Clean up Redis connections
+   */
+  async disconnect() {
+    _RedisSSEClient.logger.info("Disconnecting Redis SSE clients");
+    try {
+      if (this.publisherClient) {
+        this.publisherClient.disconnect();
+      }
+      if (this.subscriberClient) {
+        this.subscriberClient.disconnect();
+      }
+      this.initialized = false;
+      _RedisSSEClient.logger.info("Redis SSE clients disconnected successfully");
+    } catch (error) {
+      _RedisSSEClient.logger.error("Error disconnecting Redis SSE clients", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get connection status
+   */
+  isConnected() {
+    return this.initialized && this.publisherClient?.status === "ready" && this.subscriberClient?.status === "ready";
+  }
+};
+
+// packages/shared/src/sse/types.ts
+var SSE_REDIS_CHANNELS = {
+  /**
+   * Channel for subscription management messages
+   * Used when clients subscribe/unsubscribe to specific event types
+   */
+  SUBSCRIPTIONS: "sse:subscriptions",
+  /**
+   * Channel for event notifications
+   * Used to broadcast SSE events to all API instances
+   */
+  EVENTS: "sse:events"
+};
+function createSSEEventMessage(eventType, params, data, targetUserIds) {
+  return {
+    eventType,
+    params,
+    data,
+    targetUserIds,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function serializeSSERedisMessage(message) {
+  try {
+    return JSON.stringify(message);
+  } catch (error) {
+    throw new Error(
+      `Failed to serialize SSE Redis message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// packages/shared/src/types/sse/SSEEvent.ts
+function createProgramStatusChangeEvent(ruleId, language) {
+  return {
+    type: "PROGRAM_STATUS_CHANGE",
+    data: { ruleId, language },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createAssessmentStatusChangeEvent(ruleId, language) {
+  return {
+    type: "ASSESSMENT_STATUS_CHANGE",
+    data: {
+      ruleId,
+      language
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createUserContextChangeEvent(userId, organizationId, changeType, role) {
+  return {
+    type: "USER_CONTEXT_CHANGE",
+    data: {
+      userId,
+      organizationId,
+      changeType,
+      role
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// packages/shared/src/sse/SSEEventPublisher.ts
+var origin5 = "SSEEventPublisher";
+var SSEEventPublisher = class _SSEEventPublisher {
+  static {
+    this.logger = new PackmindLogger(origin5);
+  }
+  /**
+   * Get the singleton instance
+   */
+  static getInstance() {
+    _SSEEventPublisher.logger.debug("Getting SSEEventPublisher instance");
+    if (!_SSEEventPublisher.instance) {
+      _SSEEventPublisher.logger.info("Creating new SSEEventPublisher instance");
+      _SSEEventPublisher.instance = new _SSEEventPublisher();
+      _SSEEventPublisher.redisClient = RedisSSEClient.getInstance();
+    }
+    return _SSEEventPublisher.instance;
+  }
+  constructor() {
+  }
+  /**
+   * Publish a program status change event for cache invalidation
+   * This triggers React Query to refetch the program data
+   */
+  static async publishProgramStatusEvent(programId, ruleId, language, userId, organizationId) {
+    _SSEEventPublisher.logger.info("Publishing program status change event", {
+      programId,
+      ruleId,
+      language,
+      userId,
+      organizationId
+    });
+    try {
+      const event = createProgramStatusChangeEvent(ruleId, language);
+      await _SSEEventPublisher.publishEvent(
+        "program_status_change",
+        [ruleId, language],
+        event,
+        userId ? [userId] : void 0
+      );
+      _SSEEventPublisher.logger.debug(
+        "Successfully published program status change event",
+        { programId, ruleId, language }
+      );
+    } catch (error) {
+      _SSEEventPublisher.logger.error(
+        "Failed to publish program status change event",
+        {
+          programId,
+          userId,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      throw error;
+    }
+  }
+  /**
+   * Publish an assessment status change event for cache invalidation
+   * This triggers React Query to refetch the assessment data
+   */
+  static async publishAssessmentStatusEvent(ruleId, language, userId, organizationId) {
+    _SSEEventPublisher.logger.info("Publishing assessment status change event", {
+      ruleId,
+      language,
+      userId,
+      organizationId
+    });
+    try {
+      const event = createAssessmentStatusChangeEvent(ruleId, language);
+      await _SSEEventPublisher.publishEvent(
+        "assessment_status_change",
+        [ruleId, language],
+        event,
+        userId ? [userId] : void 0
+      );
+      _SSEEventPublisher.logger.debug(
+        "Successfully published assessment status change event",
+        { ruleId, language }
+      );
+    } catch (error) {
+      _SSEEventPublisher.logger.error(
+        "Failed to publish assessment status change event",
+        {
+          userId,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      throw error;
+    }
+  }
+  /**
+   * Publish an event to notify a user that their context (role or membership) changed
+   * This should trigger a refetch of the /me route on the frontend
+   */
+  static async publishUserContextChangeEvent(userId, organizationId, changeType, role) {
+    _SSEEventPublisher.logger.info("Publishing user context change event", {
+      userId,
+      organizationId,
+      changeType,
+      role
+    });
+    try {
+      const event = createUserContextChangeEvent(
+        userId,
+        organizationId,
+        changeType,
+        role
+      );
+      await _SSEEventPublisher.publishEvent("user_context_change", [], event, [
+        userId
+      ]);
+      _SSEEventPublisher.logger.debug(
+        "Successfully published user context change event",
+        {
+          userId,
+          organizationId,
+          changeType
+        }
+      );
+    } catch (error) {
+      _SSEEventPublisher.logger.error(
+        "Failed to publish user context change event",
+        {
+          userId,
+          organizationId,
+          changeType,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      throw error;
+    }
+  }
+  /**
+   * Generic method to publish any SSE event type to Redis pub/sub
+   */
+  static async publishEvent(eventType, params, data, targetUserIds) {
+    _SSEEventPublisher.logger.info("Publishing SSE event", {
+      eventType,
+      params,
+      targetUserIds: targetUserIds?.length || "all"
+    });
+    try {
+      _SSEEventPublisher.getInstance();
+      const redisClient = _SSEEventPublisher.redisClient;
+      const message = createSSEEventMessage(
+        eventType,
+        params,
+        data,
+        targetUserIds
+      );
+      const serializedMessage = serializeSSERedisMessage(message);
+      await redisClient.publish(SSE_REDIS_CHANNELS.EVENTS, serializedMessage);
+      _SSEEventPublisher.logger.debug("Successfully published SSE event", {
+        eventType,
+        params
+      });
+    } catch (error) {
+      _SSEEventPublisher.logger.error("Failed to publish SSE event", {
+        eventType,
+        params,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+
+// packages/shared/src/types/git/GitCommit.ts
+var createGitCommitId = brandedIdFactory();
+
+// packages/shared/src/types/git/GitProvider.ts
+var createGitProviderId = brandedIdFactory();
+
+// packages/shared/src/types/git/GitRepo.ts
+var createGitRepoId = brandedIdFactory();
+
+// packages/shared/src/types/standards/StandardVersion.ts
+var createStandardVersionId = brandedIdFactory();
+
+// packages/shared/src/types/standards/Rule.ts
+var createRuleId = brandedIdFactory();
+
+// packages/shared/src/types/standards/RuleExample.ts
+var createRuleExampleId = brandedIdFactory();
+
+// packages/shared/src/types/standards/Standard.ts
+var createStandardId = brandedIdFactory();
+
+// packages/shared/src/types/accounts/Organization.ts
+var createOrganizationId = brandedIdFactory();
+
+// packages/shared/src/types/accounts/User.ts
+var createUserId = brandedIdFactory();
+
+// packages/shared/src/types/deployments/RenderMode.ts
+var REQUIRED_RENDER_MODE = "PACKMIND" /* PACKMIND */;
+var RENDER_MODE_ORDER = [
+  "PACKMIND" /* PACKMIND */,
+  "AGENTS_MD" /* AGENTS_MD */,
+  "JUNIE" /* JUNIE */,
+  "GH_COPILOT" /* GH_COPILOT */,
+  "CLAUDE" /* CLAUDE */,
+  "CURSOR" /* CURSOR */
+];
+var normalizeRenderModes = (modes) => {
+  const uniqueModes = new Set(modes);
+  uniqueModes.add(REQUIRED_RENDER_MODE);
+  return RENDER_MODE_ORDER.filter((mode) => uniqueModes.has(mode));
+};
+
+// packages/shared/src/types/deployments/RenderModeConfiguration.ts
+var createRenderModeConfigurationId = brandedIdFactory();
+var DEFAULT_ACTIVE_RENDER_MODES = normalizeRenderModes([
+  "AGENTS_MD" /* AGENTS_MD */
+]);
+
+// packages/shared/src/types/deployments/RecipesDeployment.ts
+var createRecipesDeploymentId = brandedIdFactory();
+
+// packages/shared/src/types/deployments/StandardsDeployment.ts
+var createStandardsDeploymentId = brandedIdFactory();
+
+// packages/shared/src/types/deployments/Target.ts
+var createTargetId = brandedIdFactory();
+
+// packages/shared/src/types/recipes/RecipeVersion.ts
+var createRecipeVersionId = brandedIdFactory();
+
+// packages/shared/src/types/recipes/Recipe.ts
+var createRecipeId = brandedIdFactory();
+
+// packages/shared/src/types/spaces/Space.ts
+var createSpaceId = brandedIdFactory();
+
+// packages/shared/src/types/languages/Language.ts
+var ProgrammingLanguage = /* @__PURE__ */ ((ProgrammingLanguage3) => {
+  ProgrammingLanguage3["JAVASCRIPT"] = "JAVASCRIPT";
+  ProgrammingLanguage3["JAVASCRIPT_JSX"] = "JAVASCRIPT_JSX";
+  ProgrammingLanguage3["TYPESCRIPT"] = "TYPESCRIPT";
+  ProgrammingLanguage3["TYPESCRIPT_TSX"] = "TYPESCRIPT_TSX";
+  ProgrammingLanguage3["PYTHON"] = "PYTHON";
+  ProgrammingLanguage3["PHP"] = "PHP";
+  ProgrammingLanguage3["JAVA"] = "JAVA";
+  ProgrammingLanguage3["SCSS"] = "SCSS";
+  ProgrammingLanguage3["HTML"] = "HTML";
+  ProgrammingLanguage3["CSHARP"] = "CSHARP";
+  ProgrammingLanguage3["GENERIC"] = "GENERIC";
+  ProgrammingLanguage3["GO"] = "GO";
+  ProgrammingLanguage3["C"] = "C";
+  ProgrammingLanguage3["CPP"] = "CPP";
+  ProgrammingLanguage3["SQL"] = "SQL";
+  ProgrammingLanguage3["KOTLIN"] = "KOTLIN";
+  ProgrammingLanguage3["VUE"] = "VUE";
+  ProgrammingLanguage3["CSS"] = "CSS";
+  ProgrammingLanguage3["YAML"] = "YAML";
+  ProgrammingLanguage3["JSON"] = "JSON";
+  ProgrammingLanguage3["XML"] = "XML";
+  ProgrammingLanguage3["BASH"] = "BASH";
+  ProgrammingLanguage3["MARKDOWN"] = "MARKDOWN";
+  ProgrammingLanguage3["RUBY"] = "RUBY";
+  ProgrammingLanguage3["RUST"] = "RUST";
+  ProgrammingLanguage3["SAP_ABAP"] = "SAP_ABAP";
+  ProgrammingLanguage3["SAP_CDS"] = "SAP_CDS";
+  ProgrammingLanguage3["SAP_HANA_SQL"] = "SAP_HANA_SQL";
+  ProgrammingLanguage3["SWIFT"] = "SWIFT";
+  ProgrammingLanguage3["PROPERTIES"] = "PROPERTIES";
+  return ProgrammingLanguage3;
+})(ProgrammingLanguage || {});
+var ProgrammingLanguageDetails = {
+  ["GENERIC" /* GENERIC */]: {
+    displayName: "Generic",
+    fileExtensions: []
+  },
+  ["JAVASCRIPT" /* JAVASCRIPT */]: {
+    displayName: "JavaScript",
+    fileExtensions: ["js"]
+  },
+  ["JAVASCRIPT_JSX" /* JAVASCRIPT_JSX */]: {
+    displayName: "JavaScript (JSX)",
+    fileExtensions: ["jsx"]
+  },
+  ["TYPESCRIPT" /* TYPESCRIPT */]: {
+    displayName: "TypeScript",
+    fileExtensions: ["ts"]
+  },
+  ["TYPESCRIPT_TSX" /* TYPESCRIPT_TSX */]: {
+    displayName: "TypeScript (TSX)",
+    fileExtensions: ["tsx"]
+  },
+  ["PYTHON" /* PYTHON */]: {
+    displayName: "Python",
+    fileExtensions: ["py", "pyx", "pyw"]
+  },
+  ["PHP" /* PHP */]: {
+    displayName: "PHP",
+    fileExtensions: ["php", "phtml"]
+  },
+  ["JAVA" /* JAVA */]: {
+    displayName: "Java",
+    fileExtensions: ["java"]
+  },
+  ["SCSS" /* SCSS */]: {
+    displayName: "SCSS",
+    fileExtensions: ["scss"]
+  },
+  ["HTML" /* HTML */]: {
+    displayName: "HTML",
+    fileExtensions: ["html", "htm"]
+  },
+  ["CSHARP" /* CSHARP */]: {
+    displayName: "C#",
+    fileExtensions: ["cs"]
+  },
+  ["GO" /* GO */]: {
+    displayName: "Go",
+    fileExtensions: ["go"]
+  },
+  ["C" /* C */]: {
+    displayName: "C",
+    fileExtensions: ["c", "h"]
+  },
+  ["CPP" /* CPP */]: {
+    displayName: "C++",
+    fileExtensions: ["cpp", "cc", "cxx", "c++", "hpp", "hxx"]
+  },
+  ["SQL" /* SQL */]: {
+    displayName: "SQL",
+    fileExtensions: ["sql"]
+  },
+  ["KOTLIN" /* KOTLIN */]: {
+    displayName: "Kotlin",
+    fileExtensions: ["kt", "kts"]
+  },
+  ["VUE" /* VUE */]: {
+    displayName: "Vue",
+    fileExtensions: ["vue"]
+  },
+  ["CSS" /* CSS */]: {
+    displayName: "CSS",
+    fileExtensions: ["css"]
+  },
+  ["YAML" /* YAML */]: {
+    displayName: "YAML",
+    fileExtensions: ["yaml", "yml"]
+  },
+  ["JSON" /* JSON */]: {
+    displayName: "JSON",
+    fileExtensions: ["json"]
+  },
+  ["XML" /* XML */]: {
+    displayName: "XML",
+    fileExtensions: ["xml"]
+  },
+  ["BASH" /* BASH */]: {
+    displayName: "Bash",
+    fileExtensions: ["sh", "bash"]
+  },
+  ["MARKDOWN" /* MARKDOWN */]: {
+    displayName: "Markdown",
+    fileExtensions: ["md"]
+  },
+  ["RUST" /* RUST */]: {
+    displayName: "Rust",
+    fileExtensions: ["rs"]
+  },
+  ["RUBY" /* RUBY */]: {
+    displayName: "Ruby",
+    fileExtensions: ["rb"]
+  },
+  ["SAP_ABAP" /* SAP_ABAP */]: {
+    displayName: "SAP ABAP",
+    fileExtensions: ["abap", "ab4"]
+  },
+  ["SAP_CDS" /* SAP_CDS */]: {
+    displayName: "SAP CDS",
+    fileExtensions: ["cds"]
+  },
+  ["SAP_HANA_SQL" /* SAP_HANA_SQL */]: {
+    displayName: "SAP HANA SQL",
+    fileExtensions: [
+      "hdbprocedure",
+      "hdbfunction",
+      "hdbview",
+      "hdbcalculationview"
+    ]
+  },
+  ["SWIFT" /* SWIFT */]: {
+    displayName: "Swift",
+    fileExtensions: ["swift"]
+  },
+  ["PROPERTIES" /* PROPERTIES */]: {
+    displayName: "Properties",
+    fileExtensions: ["properties"]
+  }
+};
+var stringToProgrammingLanguage = (input) => {
+  const trimmedInput = input.trim();
+  if (!trimmedInput) {
+    throw new Error("Language input cannot be empty");
+  }
+  const lowerInput = trimmedInput.toLowerCase();
+  for (const enumValue of Object.values(ProgrammingLanguage)) {
+    if (enumValue.toLowerCase() === lowerInput) {
+      return enumValue;
+    }
+  }
+  for (const [language, info] of Object.entries(ProgrammingLanguageDetails)) {
+    if (info.displayName.toLowerCase() === lowerInput) {
+      return language;
+    }
+  }
+  for (const [language, info] of Object.entries(ProgrammingLanguageDetails)) {
+    if (info.fileExtensions.some((ext) => ext.toLowerCase() === lowerInput)) {
+      return language;
+    }
+  }
+  const availableLanguages = Object.values(ProgrammingLanguageDetails).map((info) => info.displayName).join(", ");
+  throw new Error(
+    `Unknown programming language: "${trimmedInput}". Available languages: ${availableLanguages}`
+  );
+};
+
+// packages/shared/src/mail/SmtpMailService.ts
+var import_nodemailer = __toESM(require("nodemailer"));
+
+// packages/shared/src/dataSources/local.ts
+var import_typeorm = require("typeorm");
+var dataSource = makeDatasource();
+function makeDatasource() {
+  try {
+    return new import_typeorm.DataSource({
+      type: "postgres",
+      url: process.env["DATABASE_URL"],
+      entities: [],
+      migrations: []
+    });
+  } catch {
+    return {};
+  }
+}
+
+// apps/cli/src/application/useCases/ExecuteSingleFileAstUseCase.ts
+var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
+  constructor(linterExecutionUseCase) {
+    this.linterExecutionUseCase = linterExecutionUseCase;
+  }
+  static {
+    this.fallbackStandardSlug = "adhoc-linter";
+  }
+  static {
+    this.fallbackRuleContent = "adhoc-rule";
+  }
+  async execute(command2) {
+    const { program, fileContent, language } = command2;
+    const result = await this.linterExecutionUseCase.execute({
+      filePath: "cli-single-file",
+      fileContent,
+      language,
+      programs: [
+        {
+          code: program,
+          ruleContent: _ExecuteSingleFileAstUseCase.fallbackRuleContent,
+          standardSlug: _ExecuteSingleFileAstUseCase.fallbackStandardSlug,
+          sourceCodeState: "AST",
+          language
+        }
+      ]
+    });
+    return result.violations.map(({ line, character }) => ({
+      line,
+      character
+    }));
+  }
+};
+
+// apps/cli/src/application/services/GitService.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var origin6 = "GitService";
+var GitService = class {
+  constructor(logger = new PackmindLogger(origin6)) {
+    this.logger = logger;
+  }
+  async getGitRepositoryRoot(path2) {
+    try {
+      const { stdout } = await execAsync("git rev-parse --show-toplevel", {
+        cwd: path2
+      });
+      const gitRoot = stdout.trim();
+      this.logger.debug("Resolved git repository root", {
+        inputPath: path2,
+        gitRoot
+      });
+      return gitRoot;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(
+          `Failed to get Git repository root. The path '${path2}' does not appear to be inside a Git repository.
+${error.message}`
+        );
+      }
+      throw new Error("Failed to get Git repository root: Unknown error");
+    }
+  }
+  async getCurrentBranches(repoPath) {
+    try {
+      const { stdout } = await execAsync("git branch -a --contains HEAD", {
+        cwd: repoPath
+      });
+      const branches = this.parseBranches(stdout);
+      return { branches };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(
+          `Failed to get Git branches. packmind-cli lint must be run in a Git repository.
+${error.message}`
+        );
+      }
+      throw new Error("Failed to get Git branches: Unknown error");
+    }
+  }
+  async getGitRemoteUrl(repoPath, origin10) {
+    try {
+      const { stdout } = await execAsync("git remote -v", {
+        cwd: repoPath
+      });
+      const remotes = this.parseRemotes(stdout);
+      if (remotes.length === 0) {
+        throw new Error("No Git remotes found in the repository");
+      }
+      let selectedRemote;
+      if (origin10) {
+        const foundRemote = remotes.find((remote) => remote.name === origin10);
+        if (!foundRemote) {
+          throw new Error(`Remote '${origin10}' not found in repository`);
+        }
+        selectedRemote = foundRemote.url;
+      } else if (remotes.length === 1) {
+        selectedRemote = remotes[0].url;
+      } else {
+        const originRemote = remotes.find((remote) => remote.name === "origin");
+        if (!originRemote) {
+          throw new Error(
+            "Multiple remotes found but no 'origin' remote. Please specify the remote name."
+          );
+        }
+        selectedRemote = originRemote.url;
+      }
+      return {
+        gitRemoteUrl: this.normalizeGitUrl(selectedRemote)
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(
+          `Failed to get Git remote URL. packmind-cli lint must be run in a Git repository.
+${error.message}`
+        );
+      }
+      throw new Error("Failed to get Git remote URL: Unknown error");
+    }
+  }
+  parseRemotes(gitRemoteOutput) {
+    const lines = gitRemoteOutput.trim().split("\n");
+    const remotes = [];
+    for (const line of lines) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+      if (match) {
+        const [, name, url, type] = match;
+        if (type === "fetch") {
+          remotes.push({ name, url, type });
+        }
+      }
+    }
+    return remotes;
+  }
+  parseBranches(gitBranchOutput) {
+    const lines = gitBranchOutput.trim().split("\n");
+    const branchNames = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      let branchName = line.trim();
+      if (branchName.startsWith("* ")) {
+        branchName = branchName.substring(2).trim();
+      }
+      if (branchName.startsWith("remotes/origin/")) {
+        branchName = branchName.substring("remotes/origin/".length);
+      }
+      if (branchName.startsWith("remotes/")) {
+        const parts = branchName.split("/");
+        if (parts.length > 2) {
+          branchName = parts.slice(2).join("/");
+        }
+      }
+      if (branchName.includes("HEAD ->")) {
+        continue;
+      }
+      if (branchName) {
+        branchNames.add(branchName);
+      }
+    }
+    return Array.from(branchNames);
+  }
+  normalizeGitUrl(url) {
+    const sshMatch = url.match(/^git@([^:]+):(.+)$/);
+    if (sshMatch) {
+      const [, host, path2] = sshMatch;
+      const cleanPath = path2.replace(/\.git$/, "");
+      return `${host}/${cleanPath}`;
+    }
+    const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+)$/);
+    if (httpsMatch) {
+      const [, host, path2] = httpsMatch;
+      const cleanPath = path2.replace(/\.git$/, "");
+      return `${host}/${cleanPath}`;
+    }
+    return url;
+  }
+};
+
+// apps/cli/src/application/useCases/GetGitRemoteUrlUseCase.ts
+var GetGitRemoteUrlUseCase = class {
+  constructor(gitRemoteUrlService = new GitService()) {
+    this.gitRemoteUrlService = gitRemoteUrlService;
+  }
+  async execute(command2) {
+    const { path: repoPath, origin: origin10 } = command2;
+    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin10);
+  }
+};
+
+// apps/cli/src/application/services/ListFiles.ts
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var ListFiles = class {
+  async listFilesInDirectory(directoryPath, extensions, excludes = [], skipHidden = true) {
+    const results = [];
+    const normalizedExtensions = extensions.map(
+      (ext) => ext.startsWith(".") ? ext : `.${ext}`
+    );
+    const includeAllExtensions = normalizedExtensions.length === 0;
+    await this.findFilesRecursively(
+      directoryPath,
+      normalizedExtensions,
+      excludes,
+      results,
+      includeAllExtensions,
+      skipHidden
+    );
+    return results;
+  }
+  async findFilesRecursively(directoryPath, extensions, excludes, results, includeAllExtensions, skipHidden) {
+    try {
+      const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(directoryPath, entry.name);
+        if (this.shouldExcludePath(fullPath, excludes)) {
+          continue;
+        }
+        if (skipHidden && entry.name.startsWith(".")) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          await this.findFilesRecursively(
+            fullPath,
+            extensions,
+            excludes,
+            results,
+            includeAllExtensions,
+            skipHidden
+          );
+        } else if (entry.isFile()) {
+          const fileExtension = path.extname(entry.name);
+          if (includeAllExtensions || extensions.includes(fileExtension)) {
+            results.push({
+              path: fullPath
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading directory ${directoryPath}:`, error);
+    }
+  }
+  shouldExcludePath(filePath, excludes) {
+    if (excludes.length === 0) {
+      return false;
+    }
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, "/");
+    for (const exclude of excludes) {
+      if (this.matchesGlobPattern(normalizedPath, exclude)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  matchesGlobPattern(filePath, pattern) {
+    if (!pattern.includes("*") && !pattern.includes("/")) {
+      const pathSegments = filePath.split("/");
+      return pathSegments.some((segment) => segment === pattern);
+    }
+    let regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*").replace(/\//g, "\\/");
+    if (!pattern.startsWith("**/")) {
+      regexPattern = "(^|/)" + regexPattern;
+    }
+    if (!pattern.endsWith("/**")) {
+      regexPattern = regexPattern + "($|/)";
+    }
+    const regex = new RegExp(regexPattern);
+    return regex.test(filePath);
+  }
+  async readFileContent(filePath) {
+    try {
+      return await fs.readFile(filePath, "utf-8");
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error);
+      throw error;
+    }
+  }
+};
+
+// apps/cli/src/application/useCases/ListFilesInDirectoryUseCase.ts
+var ListFilesInDirectoryUseCase = class {
+  constructor(listFiles = new ListFiles()) {
+    this.listFiles = listFiles;
+  }
+  async execute(command2) {
+    const { path: directoryPath, extensions, excludes = [] } = command2;
+    const files = await this.listFiles.listFilesInDirectory(
+      directoryPath,
+      extensions,
+      excludes
+    );
+    const filesWithContent = [];
+    for (const file of files) {
+      try {
+        const content = await this.listFiles.readFileContent(file.path);
+        filesWithContent.push({
+          path: file.path,
+          content
+        });
+      } catch (error) {
+        console.error(`Error reading file ${file.path}:`, error);
+      }
+    }
+    return filesWithContent;
+  }
+};
+
+// apps/cli/src/application/useCases/LintFilesInDirectoryUseCase.ts
+var import_minimatch = require("minimatch");
+var origin7 = "LintFilesInDirectoryUseCase";
+var LintFilesInDirectoryUseCase = class {
+  constructor(services, repositories, logger = new PackmindLogger(origin7)) {
+    this.services = services;
+    this.repositories = repositories;
+    this.logger = logger;
+  }
+  fileMatchesScope(filePath, scopePatterns) {
+    if (!scopePatterns || scopePatterns.length === 0) {
+      return true;
+    }
+    return scopePatterns.some((pattern) => (0, import_minimatch.minimatch)(filePath, pattern));
+  }
+  fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
+    if (!scopePatterns || scopePatterns.length === 0) {
+      const effectivePattern = this.buildEffectivePattern(targetPath, null);
+      const matches2 = (0, import_minimatch.minimatch)(filePath, effectivePattern, {
+        matchBase: false
+      });
+      this.logger.debug(
+        `File matching check: file="${filePath}", target="${targetPath}", scope=null, pattern="${effectivePattern}", matches=${matches2}`
+      );
+      return matches2;
+    }
+    const matches = scopePatterns.some((scopePattern) => {
+      const effectivePattern = this.buildEffectivePattern(
+        targetPath,
+        scopePattern
+      );
+      const patternMatches = (0, import_minimatch.minimatch)(filePath, effectivePattern, {
+        matchBase: false
+      });
+      this.logger.debug(
+        `File matching check: file="${filePath}", target="${targetPath}", scope="${scopePattern}", pattern="${effectivePattern}", matches=${patternMatches}`
+      );
+      return patternMatches;
+    });
+    return matches;
+  }
+  buildEffectivePattern(targetPath, scope) {
+    const normalizedTarget = targetPath === "/" ? "/" : targetPath.replace(/\/$/, "");
+    if (!scope) {
+      return normalizedTarget === "/" ? "/**" : normalizedTarget + "/**";
+    }
+    if (scope.startsWith(normalizedTarget + "/") || scope === normalizedTarget) {
+      return scope.endsWith("/") ? scope + "**" : scope;
+    }
+    const cleanScope = scope.startsWith("/") ? scope.substring(1) : scope;
+    let pattern;
+    if (normalizedTarget === "/") {
+      pattern = "/" + cleanScope;
+    } else {
+      pattern = normalizedTarget + "/" + cleanScope;
+    }
+    if (pattern.endsWith("/")) {
+      pattern = pattern + "**";
+    }
+    return pattern;
+  }
+  async execute(command2) {
+    const { path: path2, draftMode, standardSlug, ruleId, language } = command2;
+    this.logger.debug(
+      `Starting linting: path="${path2}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}"`
+    );
+    const gitRepoRoot = await this.services.gitRemoteUrlService.getGitRepositoryRoot(path2);
+    const files = await this.services.listFiles.listFilesInDirectory(
+      gitRepoRoot,
+      [],
+      ["node_modules", "dist", ".min.", ".map.", ".git"]
+    );
+    const { gitRemoteUrl } = await this.services.gitRemoteUrlService.getGitRemoteUrl(gitRepoRoot);
+    const { branches } = await this.services.gitRemoteUrlService.getCurrentBranches(gitRepoRoot);
+    this.logger.debug(
+      `Git repository: url="${gitRemoteUrl}", branches=${JSON.stringify(branches)}, filesCount=${files.length}`
+    );
+    let detectionPrograms;
+    let isDraftMode = false;
+    if (draftMode && standardSlug && ruleId) {
+      isDraftMode = true;
+      const draftProgramsResult = await this.repositories.packmindGateway.getDraftDetectionProgramsForRule(
+        {
+          standardSlug,
+          ruleId,
+          language
+        }
+      );
+      detectionPrograms = {
+        targets: [
+          {
+            name: "Draft Target",
+            path: "/",
+            standards: [
+              {
+                name: standardSlug,
+                slug: standardSlug,
+                scope: draftProgramsResult.scope ? [draftProgramsResult.scope] : [],
+                rules: [
+                  {
+                    content: draftProgramsResult.ruleContent || "Draft Rule",
+                    activeDetectionPrograms: draftProgramsResult.programs.map(
+                      (program) => ({
+                        language: program.language,
+                        detectionProgram: {
+                          mode: program.mode,
+                          code: program.code,
+                          sourceCodeState: program.sourceCodeState
+                        }
+                      })
+                    )
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      };
+    } else if (!draftMode && standardSlug && ruleId) {
+      const activeProgramsResult = await this.repositories.packmindGateway.getActiveDetectionProgramsForRule(
+        {
+          standardSlug,
+          ruleId,
+          language
+        }
+      );
+      detectionPrograms = {
+        targets: [
+          {
+            name: "Active Target",
+            path: "/",
+            standards: [
+              {
+                name: standardSlug,
+                slug: standardSlug,
+                scope: activeProgramsResult.scope ? [activeProgramsResult.scope] : [],
+                rules: [
+                  {
+                    content: activeProgramsResult.ruleContent || "Active Rule",
+                    activeDetectionPrograms: activeProgramsResult.programs.map(
+                      (program) => ({
+                        language: program.language,
+                        detectionProgram: {
+                          mode: program.mode,
+                          code: program.code,
+                          sourceCodeState: program.sourceCodeState
+                        }
+                      })
+                    )
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      };
+    } else {
+      detectionPrograms = await this.repositories.packmindGateway.listExecutionPrograms({
+        gitRemoteUrl,
+        branches
+      });
+    }
+    this.logger.debug(
+      `Retrieved detection programs: targetsCount=${detectionPrograms.targets.length}`
+    );
+    const violations = [];
+    for (const file of files) {
+      const fileViolations = [];
+      const relativeFilePath = file.path.startsWith(gitRepoRoot) ? file.path.substring(gitRepoRoot.length) : file.path;
+      const normalizedFilePath = relativeFilePath.startsWith("/") ? relativeFilePath : "/" + relativeFilePath;
+      this.logger.debug(
+        `Processing file: absolute="${file.path}", relative="${normalizedFilePath}"`
+      );
+      const fileExtension = this.extractExtensionFromFile(file.path);
+      const fileLanguage = this.resolveProgrammingLanguage(fileExtension);
+      if (!fileLanguage) {
+        continue;
+      }
+      const programsByLanguage = /* @__PURE__ */ new Map();
+      for (const target of detectionPrograms.targets) {
+        this.logger.debug(
+          `Processing target: name="${target.name}", path="${target.path}", standardsCount=${target.standards.length}`
+        );
+        for (const standard of target.standards) {
+          this.logger.debug(
+            `Checking standard: name="${standard.name}", scope=${JSON.stringify(standard.scope)}, rulesCount=${standard.rules.length}`
+          );
+          if (!this.fileMatchesTargetAndScope(
+            normalizedFilePath,
+            target.path,
+            standard.scope
+          )) {
+            this.logger.debug(
+              `File "${normalizedFilePath}" does not match target/scope - skipping standard "${standard.name}"`
+            );
+            continue;
+          }
+          if (!isDraftMode) {
+            this.logger.debug(
+              `File "${normalizedFilePath}" matches target/scope - processing standard "${standard.name}"`
+            );
+          }
+          for (const rule of standard.rules) {
+            for (const activeProgram of rule.activeDetectionPrograms) {
+              try {
+                const programLanguage = this.resolveProgrammingLanguage(
+                  activeProgram.language
+                );
+                if (!programLanguage) {
+                  console.error(
+                    `Unsupported language "${activeProgram.language}" for file ${file.path}`
+                  );
+                  continue;
+                }
+                if (programLanguage !== fileLanguage) {
+                  continue;
+                }
+                const programsForLanguage = programsByLanguage.get(programLanguage) ?? [];
+                programsForLanguage.push({
+                  code: activeProgram.detectionProgram.code,
+                  ruleContent: rule.content,
+                  standardSlug: standard.slug,
+                  sourceCodeState: activeProgram.detectionProgram.sourceCodeState,
+                  language: fileLanguage
+                });
+                programsByLanguage.set(programLanguage, programsForLanguage);
+              } catch (error) {
+                console.error(
+                  `Error preparing program for file ${file.path}: ${error}`
+                );
+              }
+            }
+          }
+        }
+      }
+      if (programsByLanguage.size > 0) {
+        try {
+          const fileContent = await this.services.listFiles.readFileContent(
+            file.path
+          );
+          for (const [language2, programs] of programsByLanguage.entries()) {
+            try {
+              const result = await this.executeProgramsForFile({
+                filePath: file.path,
+                fileContent,
+                language: language2,
+                programs
+              });
+              fileViolations.push(...result);
+            } catch (error) {
+              console.error(
+                `Error executing programs for file ${file.path} (${language2}): ${error}`
+              );
+            }
+          }
+        } catch (error) {
+          console.error(
+            `Error reading file content for ${file.path}: ${error}`
+          );
+        }
+      }
+      if (fileViolations.length > 0) {
+        violations.push({
+          file: file.path,
+          violations: fileViolations
+        });
+      }
+    }
+    const totalViolations = violations.reduce(
+      (sum, violation) => sum + violation.violations.length,
+      0
+    );
+    const standardsChecked = Array.from(
+      new Set(
+        detectionPrograms.targets.flatMap(
+          (target) => target.standards.map((standard) => standard.slug)
+        )
+      )
+    );
+    return {
+      gitRemoteUrl,
+      violations,
+      summary: {
+        totalFiles: files.length,
+        violatedFiles: violations.length,
+        totalViolations,
+        standardsChecked
+      }
+    };
+  }
+  resolveProgrammingLanguage(language) {
+    try {
+      return stringToProgrammingLanguage(language);
+    } catch (error) {
+      return null;
+    }
+  }
+  async executeProgramsForFile(command2) {
+    const result = await this.services.linterExecutionUseCase.execute(command2);
+    return result.violations;
+  }
+  extractExtensionFromFile(filePath) {
+    const lastDotIndex = filePath.lastIndexOf(".");
+    if (lastDotIndex === -1 || lastDotIndex === filePath.length - 1) {
+      return "";
+    }
+    return filePath.substring(lastDotIndex + 1);
+  }
+};
+
+// apps/cli/src/infra/repositories/PackmindGateway.ts
+function decodeApiKey(apiKey) {
+  if (!apiKey) {
+    return {
+      payload: { host: "", jwt: "" },
+      isValid: false,
+      error: "Please set the PACKMIND_API_KEY_V3 environment variable"
+    };
+  }
+  try {
+    const trimmedKey = apiKey.trim();
+    const jsonString = Buffer.from(trimmedKey, "base64").toString("utf-8");
+    const payload = JSON.parse(jsonString);
+    if (!payload.host || typeof payload.host !== "string") {
+      return {
+        payload,
+        isValid: false,
+        error: "Invalid API key: missing or invalid host field"
+      };
+    }
+    if (!payload.jwt || typeof payload.jwt !== "string") {
+      return {
+        payload,
+        isValid: false,
+        error: "Invalid API key: missing or invalid jwt field"
+      };
+    }
+    return {
+      payload,
+      isValid: true
+    };
+  } catch (error) {
+    return {
+      payload: { host: "", jwt: "" },
+      isValid: false,
+      error: `Failed to decode API key: ${error}`
+    };
+  }
+}
+var PackmindGateway = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    this.listExecutionPrograms = async (params) => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host } = decodedApiKey.payload;
+      const url = `${host}/api/v0/list-detection-program`;
+      const payload = {
+        gitRemoteUrl: params.gitRemoteUrl,
+        branches: params.branches
+      };
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          let errorMsg = `API request failed: ${response.status} ${response.statusText}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody && errorBody.message) {
+              errorMsg = `${errorBody.message}`;
+            }
+          } catch {
+          }
+          throw new Error(errorMsg);
+        }
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        const err = error;
+        const code = err?.code || err?.cause?.code;
+        if (code === "ECONNREFUSED" || code === "ENOTFOUND" || err?.name === "FetchError" || typeof err?.message === "string" && (err.message.includes("Failed to fetch") || err.message.includes("network") || err.message.includes("NetworkError"))) {
+          throw new Error(
+            `Packmind server is not accessible at ${host}. Please check your network connection or the server URL.`
+          );
+        }
+        throw new Error(
+          `Failed to fetch detection programs: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
+    this.getDraftDetectionProgramsForRule = async (params) => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host } = decodedApiKey.payload;
+      const url = `${host}/api/v0/list-draft-detection-program`;
+      const payload = {
+        standardSlug: params.standardSlug,
+        ruleId: params.ruleId
+      };
+      if (params.language) {
+        payload.language = params.language;
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          let errorMsg = `API request failed: ${response.status} ${response.statusText}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody && errorBody.message) {
+              errorMsg = `${errorBody.message}`;
+            }
+          } catch {
+          }
+          throw new Error(errorMsg);
+        }
+        const result = await response.json();
+        if (result.programs.length === 0) {
+          const languageMsg = params.language ? ` for language ${params.language}` : "";
+          throw new Error(
+            `No draft detection programs found for rule ${params.ruleId} in standard ${params.standardSlug}${languageMsg}`
+          );
+        }
+        const transformedResult = {
+          programs: result.programs.map((program) => ({
+            language: program.language,
+            code: program.code,
+            mode: program.mode,
+            sourceCodeState: program.sourceCodeState
+          })),
+          ruleContent: result.ruleContent,
+          standardSlug: params.standardSlug,
+          scope: result.scope
+        };
+        return transformedResult;
+      } catch (error) {
+        const err = error;
+        const code = err?.code || err?.cause?.code;
+        if (code === "ECONNREFUSED" || code === "ENOTFOUND" || err?.name === "FetchError" || typeof err?.message === "string" && (err.message.includes("Failed to fetch") || err.message.includes("network") || err.message.includes("NetworkError"))) {
+          throw new Error(
+            `Packmind server is not accessible at ${host}. Please check your network connection or the server URL.`
+          );
+        }
+        throw new Error(
+          `Failed to fetch draft detection programs: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
+    this.getActiveDetectionProgramsForRule = async (params) => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host } = decodedApiKey.payload;
+      const url = `${host}/api/v0/list-active-detection-program`;
+      const payload = {
+        standardSlug: params.standardSlug,
+        ruleId: params.ruleId
+      };
+      if (params.language) {
+        payload.language = params.language;
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          let errorMsg = `API request failed: ${response.status} ${response.statusText}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody && errorBody.message) {
+              errorMsg = `${errorBody.message}`;
+            }
+          } catch {
+          }
+          throw new Error(errorMsg);
+        }
+        const result = await response.json();
+        if (result.programs.length === 0) {
+          const languageMsg = params.language ? ` for language ${params.language}` : "";
+          throw new Error(
+            `No active detection programs found for rule ${params.ruleId} in standard ${params.standardSlug}${languageMsg}`
+          );
+        }
+        const transformedResult = {
+          programs: result.programs.map((program) => ({
+            language: program.language,
+            code: program.code,
+            mode: program.mode,
+            sourceCodeState: program.sourceCodeState
+          })),
+          ruleContent: result.ruleContent,
+          standardSlug: params.standardSlug,
+          scope: result.scope
+        };
+        return transformedResult;
+      } catch (error) {
+        const err = error;
+        const code = err?.code || err?.cause?.code;
+        if (code === "ECONNREFUSED" || code === "ENOTFOUND" || err?.name === "FetchError" || typeof err?.message === "string" && (err.message.includes("Failed to fetch") || err.message.includes("network") || err.message.includes("NetworkError"))) {
+          throw new Error(
+            `Packmind server is not accessible at ${host}. Please check your network connection or the server URL.`
+          );
+        }
+        throw new Error(
+          `Failed to fetch active detection programs: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
+  }
+};
+
+// packages/linter-ast/src/core/ParserError.ts
+var ParserNotAvailableError = class extends Error {
+  constructor(language, cause) {
+    super(`Parser for ${language} not available`);
+    this.name = "ParserNotAvailableError";
+    this.originalError = cause;
+  }
+};
+var ParserInitializationError = class extends Error {
+  constructor(language, message, cause) {
+    super(`Failed to initialize parser for ${language}: ${message}`);
+    this.name = "ParserInitializationError";
+    this.originalError = cause;
+  }
+};
+
+// packages/linter-ast/src/core/BaseParser.ts
+var import_path = require("path");
+var import_fs = require("fs");
+var BaseParser = class _BaseParser {
+  constructor() {
+    this.initialized = false;
+  }
+  /**
+   * Helper to locate tree-sitter WASM files for CLI executable
+   */
+  static getTreeSitterWasmPaths() {
+    const execDir = process.argv[0] ? (0, import_path.dirname)(process.argv[0]) : process.cwd();
+    const scriptDir = require.main?.filename ? (0, import_path.dirname)(require.main.filename) : process.cwd();
+    return [
+      // Next to the main script (for npm packages like @packmind/scan)
+      scriptDir,
+      (0, import_path.join)(scriptDir, "tree-sitter"),
+      // Next to the Bun executable in tree-sitter/ subdirectory
+      (0, import_path.join)(execDir, "tree-sitter"),
+      // Fallback paths
+      (0, import_path.join)(process.cwd(), "tree-sitter"),
+      (0, import_path.join)(process.cwd(), "dist/apps/cli-executables/tree-sitter"),
+      (0, import_path.resolve)(__dirname, "tree-sitter"),
+      (0, import_path.resolve)(__dirname, "../../res"),
+      (0, import_path.resolve)(__dirname, "../../../packages/linter-ast/res")
+    ];
+  }
+  /**
+   * Get the locateFile function for TreeSitter Parser initialization
+   */
+  static getTreeSitterLocateFile() {
+    const wasmDirs = _BaseParser.getTreeSitterWasmPaths();
+    return (fileName) => {
+      for (const dir of wasmDirs) {
+        const fullPath = (0, import_path.join)(dir, fileName);
+        if ((0, import_fs.existsSync)(fullPath)) {
+          return fullPath;
+        }
+      }
+      return (0, import_path.join)(process.cwd(), fileName);
+    };
+  }
+  /**
+   * Get all possible paths for a language-specific WASM file
+   */
+  static getLanguageWasmPaths(languageName) {
+    const wasmDirs = _BaseParser.getTreeSitterWasmPaths();
+    const wasmFileName = `tree-sitter-${languageName}.wasm`;
+    return wasmDirs.map((dir) => (0, import_path.join)(dir, wasmFileName)).concat([
+      // Additional fallback paths
+      (0, import_path.resolve)(__dirname, `tree-sitter/${wasmFileName}`),
+      (0, import_path.resolve)(__dirname, wasmFileName),
+      (0, import_path.resolve)(__dirname, `res/${wasmFileName}`),
+      (0, import_path.resolve)(__dirname, `../../res/${wasmFileName}`),
+      (0, import_path.resolve)(__dirname, `../res/${wasmFileName}`),
+      (0, import_path.resolve)(__dirname, `../../../packages/linter-ast/res/${wasmFileName}`),
+      (0, import_path.join)(process.cwd(), `packages/linter-ast/res/${wasmFileName}`)
+    ]);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      children: node.children.map((child) => this.nodeToJson(child))
+    };
+  }
+};
+
+// packages/linter-ast/src/parsers/TypeScriptParser.ts
+var TreeSitter = __toESM(require("web-tree-sitter"));
+var import_fs2 = require("fs");
+var TypeScriptParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("typescript");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs2.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-typescript WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "typescript",
+        "Failed to load TypeScript WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError(
+        "typescript",
+        "Parser not initialized"
+      );
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "typescript",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError(
+        "typescript",
+        "Parser not initialized"
+      );
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "typescript",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "typescript";
+  }
+};
+
+// packages/linter-ast/src/parsers/JavaScriptParser.ts
+var TreeSitter2 = __toESM(require("web-tree-sitter"));
+var import_fs3 = require("fs");
+var JavaScriptParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter2.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("javascript");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs3.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter2.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-javascript WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter2.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "javascript",
+        "Failed to load JavaScript WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError(
+        "javascript",
+        "Parser not initialized"
+      );
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "javascript",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError(
+        "javascript",
+        "Parser not initialized"
+      );
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "javascript",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "javascript";
+  }
+};
+
+// packages/linter-ast/src/parsers/CPPParser.ts
+var TreeSitter3 = __toESM(require("web-tree-sitter"));
+var import_fs4 = require("fs");
+var CPPParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter3.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("cpp");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs4.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter3.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-cpp WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter3.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "cpp",
+        "Failed to load C++ WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("cpp", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("cpp", "Failed to parse source code");
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("cpp", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("cpp", "Failed to parse source code");
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" || node.type === "binary_expression" || node.type === "translation_unit" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "cpp";
+  }
+};
+
+// packages/linter-ast/src/parsers/GoParser.ts
+var TreeSitter4 = __toESM(require("web-tree-sitter"));
+var import_fs5 = require("fs");
+var GoParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter4.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("go");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs5.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter4.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-go WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter4.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "go",
+        "Failed to load Go WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("go", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("go", "Failed to parse source code");
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("go", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("go", "Failed to parse source code");
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "go";
+  }
+};
+
+// packages/linter-ast/src/parsers/KotlinParser.ts
+var TreeSitter5 = __toESM(require("web-tree-sitter"));
+var import_fs6 = require("fs");
+var KotlinParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter5.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("kotlin");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs6.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter5.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-kotlin WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter5.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "kotlin",
+        "Failed to load Kotlin WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("kotlin", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "kotlin",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("kotlin", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "kotlin",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "kotlin";
+  }
+};
+
+// packages/linter-ast/src/parsers/CSSParser.ts
+var TreeSitter6 = __toESM(require("web-tree-sitter"));
+var import_fs7 = require("fs");
+var CSSParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter6.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("css");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs7.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter6.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-css.wasm file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter6.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "css",
+        "Failed to load CSS WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("css", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("css", "Failed to parse source code");
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("css", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("css", "Failed to parse source code");
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" || node.type === "stylesheet" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "css";
+  }
+};
+
+// packages/linter-ast/src/parsers/CSharpParser.ts
+var TreeSitter7 = __toESM(require("web-tree-sitter"));
+var import_fs8 = require("fs");
+var CSharpParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter7.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("c_sharp");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs8.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter7.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-c_sharp WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter7.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "csharp",
+        "Failed to load C# WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("csharp", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "csharp",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("csharp", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "csharp",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" || node.type === "compilation_unit" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "csharp";
+  }
+};
+
+// packages/linter-ast/src/parsers/PHPParser.ts
+var TreeSitter8 = __toESM(require("web-tree-sitter"));
+var import_fs9 = require("fs");
+var PHPParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter8.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("php_only").concat(
+        BaseParser.getLanguageWasmPaths("php")
+      );
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs9.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter8.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-php WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter8.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "php",
+        "Failed to load PHP WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("php", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("php", "Failed to parse source code");
+    }
+    const astJson = this.nodeToJson(tree.rootNode);
+    return astJson;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("php", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError("php", "Failed to parse source code");
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "php";
+  }
+};
+
+// packages/linter-ast/src/parsers/PythonParser.ts
+var TreeSitter9 = __toESM(require("web-tree-sitter"));
+var import_fs10 = require("fs");
+var PythonParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter9.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("python");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs10.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter9.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-python WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter9.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "python",
+        "Failed to load Python WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("python", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "python",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("python", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "python",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "python";
+  }
+};
+
+// packages/linter-ast/src/parsers/RubyParser.ts
+var TreeSitter10 = __toESM(require("web-tree-sitter"));
+var import_fs11 = require("fs");
+var RubyParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter10.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("ruby");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs11.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter10.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-ruby WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter10.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "ruby",
+        "Failed to load Ruby WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("ruby", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "ruby",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("ruby", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "ruby",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "ruby";
+  }
+};
+
+// packages/linter-ast/src/parsers/JSONParser.ts
+var TreeSitter11 = __toESM(require("web-tree-sitter"));
+var import_fs12 = require("fs");
+var JSONParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter11.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("json");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs12.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter11.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-json WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter11.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "json",
+        "Failed to load JSON WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("json", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "json",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("json", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "json",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "document" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "json";
+  }
+};
+
+// packages/linter-ast/src/parsers/HTMLParser.ts
+var TreeSitter12 = __toESM(require("web-tree-sitter"));
+var import_fs13 = require("fs");
+var HTMLParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter12.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("html");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs13.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter12.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-html WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter12.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "html",
+        "Failed to load HTML WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("html", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "html",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("html", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "html",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "html";
+  }
+};
+
+// packages/linter-ast/src/parsers/JavaParser.ts
+var TreeSitter13 = __toESM(require("web-tree-sitter"));
+var import_fs14 = require("fs");
+var JavaParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter13.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("java");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs14.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter13.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-java WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter13.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "java",
+        "Failed to load Java WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("java", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "java",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("java", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "java",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "java";
+  }
+};
+
+// packages/linter-ast/src/parsers/SwiftParser.ts
+var TreeSitter14 = __toESM(require("web-tree-sitter"));
+var import_fs15 = require("fs");
+var SwiftParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter14.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("swift");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs15.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter14.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-swift WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter14.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "swift",
+        "Failed to load Swift WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("swift", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "swift",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("swift", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "swift",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" || node.type === "source_file" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "swift";
+  }
+};
+
+// packages/linter-ast/src/parsers/SCSSParser.ts
+var TreeSitter15 = __toESM(require("web-tree-sitter"));
+var import_fs16 = require("fs");
+var SCSSParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter15.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("scss");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs16.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter15.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-scss WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter15.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "scss",
+        "Failed to load SCSS WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("scss", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "scss",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("scss", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "scss",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "program" || node.type === "stylesheet" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "scss";
+  }
+};
+
+// packages/linter-ast/src/parsers/YAMLParser.ts
+var TreeSitter16 = __toESM(require("web-tree-sitter"));
+var import_fs17 = require("fs");
+var YAMLParser = class extends BaseParser {
+  async initialize() {
+    try {
+      let lang = null;
+      await TreeSitter16.Parser.init({
+        locateFile: BaseParser.getTreeSitterLocateFile()
+      });
+      const wasmPaths = BaseParser.getLanguageWasmPaths("yaml");
+      for (const wasmPath of wasmPaths) {
+        if ((0, import_fs17.existsSync)(wasmPath)) {
+          try {
+            lang = await TreeSitter16.Language.load(wasmPath);
+            break;
+          } catch {
+            continue;
+          }
+        }
+      }
+      if (!lang) {
+        throw new Error(
+          `Failed to load tree-sitter-yaml WASM file. Tried paths: ${wasmPaths.join(", ")}`
+        );
+      }
+      this.parser = new TreeSitter16.Parser();
+      this.parser.setLanguage(lang);
+      this.initialized = true;
+    } catch (error) {
+      throw new ParserInitializationError(
+        "yaml",
+        "Failed to load YAML WASM parser module",
+        error
+      );
+    }
+  }
+  async parse(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("yaml", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "yaml",
+        "Failed to parse source code"
+      );
+    }
+    return this.nodeToJson(tree.rootNode);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseRaw(sourceCode) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (!this.parser) {
+      throw new ParserInitializationError("yaml", "Parser not initialized");
+    }
+    const tree = this.parser.parse(sourceCode);
+    if (!tree) {
+      throw new ParserInitializationError(
+        "yaml",
+        "Failed to parse source code"
+      );
+    }
+    return tree;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  nodeToJson(node) {
+    return {
+      type: node.type,
+      text: node.type === "stream" ? "<skipped>" : node.text,
+      line: node.startPosition.row + 1,
+      children: Array.from({ length: node.childCount }, (_, i) => {
+        const child = node.child(i);
+        return child ? this.nodeToJson(child) : null;
+      }).filter((c) => c !== null)
+    };
+  }
+  getLanguage() {
+    return "yaml";
+  }
+};
+
+// packages/linter-ast/src/core/ParserRegistry.ts
+var ParserRegistry = class {
+  constructor() {
+    this.parsers = /* @__PURE__ */ new Map();
+    this.parserClasses = {
+      typescript: TypeScriptParser,
+      javascript: JavaScriptParser,
+      cpp: CPPParser,
+      go: GoParser,
+      kotlin: KotlinParser,
+      css: CSSParser,
+      csharp: CSharpParser,
+      php: PHPParser,
+      python: PythonParser,
+      ruby: RubyParser,
+      json: JSONParser,
+      html: HTMLParser,
+      java: JavaParser,
+      swift: SwiftParser,
+      scss: SCSSParser,
+      yaml: YAMLParser
+    };
+  }
+  async getParser(language) {
+    const cached = this.parsers.get(language);
+    if (cached) {
+      return cached;
+    }
+    const ParserClass = this.parserClasses[language];
+    if (!ParserClass) {
+      throw new ParserNotAvailableError(language);
+    }
+    const parser = new ParserClass();
+    await parser.initialize();
+    this.parsers.set(language, parser);
+    return parser;
+  }
+  getAvailableParsers() {
+    return Object.keys(this.parserClasses);
+  }
+  clearCache() {
+    this.parsers.clear();
+  }
+};
+
+// packages/linter-ast/src/application/ConsoleLogRemovalService.ts
+var ConsoleLogRemovalService = class {
+  constructor() {
+    this.jsParser = new JavaScriptParser();
+  }
+  /**
+   * Removes all console method calls from JavaScript source code using AST parsing
+   * @param sourceCode The source code to clean
+   * @param language The programming language (must be JAVASCRIPT)
+   * @returns The cleaned source code with console statements removed
+   * @throws Error if language is not JAVASCRIPT
+   */
+  async removeConsoleLogStatements(sourceCode, language) {
+    if (language !== "JAVASCRIPT" /* JAVASCRIPT */) {
+      throw new Error(
+        `ConsoleRemovalService only supports JAVASCRIPT, received: ${language}`
+      );
+    }
+    try {
+      const tree = await this.jsParser.parseRaw(sourceCode);
+      const ast = tree.rootNode;
+      const ranges = [];
+      const visit = (node) => {
+        if (node.type === "expression_statement") {
+          const expr = node.firstChild;
+          if (expr?.type === "call_expression") {
+            const callee = expr.child(0);
+            if (callee?.text.startsWith("console.")) {
+              ranges.push([node.startIndex, node.endIndex]);
+            }
+          }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+          visit(node.child(i));
+        }
+      };
+      visit(ast);
+      ranges.sort((a, b) => b[0] - a[0]);
+      let cleaned = sourceCode;
+      for (const [start, end] of ranges) {
+        cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+      }
+      return cleaned;
+    } catch (error) {
+      throw new Error(`Can not parse JS CODE ${error}`);
+    }
+  }
+};
+
+// packages/linter-ast/src/application/LinterAstAdapter.ts
+var LinterAstAdapter = class {
+  constructor() {
+    this.registry = new ParserRegistry();
+    this.consoleRemovalService = new ConsoleLogRemovalService();
+  }
+  async parseSourceCode(sourceCode, language) {
+    const languageKey = this.mapLanguageToParserKey(language);
+    if (!languageKey) {
+      throw new ParserNotAvailableError(language);
+    }
+    const parser = await this.registry.getParser(languageKey);
+    return parser.parse(sourceCode);
+  }
+  isLanguageSupported(language) {
+    const languageKey = this.mapLanguageToParserKey(language);
+    return languageKey !== null;
+  }
+  getAvailableLanguages() {
+    return [
+      "TYPESCRIPT" /* TYPESCRIPT */,
+      "TYPESCRIPT_TSX" /* TYPESCRIPT_TSX */,
+      "JAVASCRIPT" /* JAVASCRIPT */,
+      "JAVASCRIPT_JSX" /* JAVASCRIPT_JSX */,
+      "CPP" /* CPP */,
+      "GO" /* GO */,
+      "KOTLIN" /* KOTLIN */,
+      "CSS" /* CSS */,
+      "CSHARP" /* CSHARP */,
+      "PHP" /* PHP */,
+      "PYTHON" /* PYTHON */,
+      "RUBY" /* RUBY */,
+      "JSON" /* JSON */,
+      "HTML" /* HTML */,
+      "JAVA" /* JAVA */,
+      "SWIFT" /* SWIFT */,
+      "SCSS" /* SCSS */,
+      "YAML" /* YAML */
+    ];
+  }
+  async removeConsoleStatements(sourceCode, language) {
+    return this.consoleRemovalService.removeConsoleLogStatements(
+      sourceCode,
+      language
+    );
+  }
+  mapLanguageToParserKey(language) {
+    const mapping = {
+      ["TYPESCRIPT" /* TYPESCRIPT */]: "typescript",
+      ["TYPESCRIPT_TSX" /* TYPESCRIPT_TSX */]: "typescript",
+      ["JAVASCRIPT" /* JAVASCRIPT */]: "javascript",
+      ["JAVASCRIPT_JSX" /* JAVASCRIPT_JSX */]: "javascript",
+      ["CPP" /* CPP */]: "cpp",
+      ["GO" /* GO */]: "go",
+      ["KOTLIN" /* KOTLIN */]: "kotlin",
+      ["CSS" /* CSS */]: "css",
+      ["CSHARP" /* CSHARP */]: "csharp",
+      ["PHP" /* PHP */]: "php",
+      ["PYTHON" /* PYTHON */]: "python",
+      ["RUBY" /* RUBY */]: "ruby",
+      ["JSON" /* JSON */]: "json",
+      ["HTML" /* HTML */]: "html",
+      ["JAVA" /* JAVA */]: "java",
+      ["SWIFT" /* SWIFT */]: "swift",
+      ["SCSS" /* SCSS */]: "scss",
+      ["YAML" /* YAML */]: "yaml"
+    };
+    return mapping[language] || null;
+  }
+};
+
+// packages/linter-ast/src/parsers/TypeScriptTSXParser.ts
+var TreeSitter17 = __toESM(require("web-tree-sitter"));
+
+// packages/linter-execution/src/application/useCases/ExecuteLinterProgramsUseCase.ts
+var origin8 = "ExecuteLinterProgramsUseCase";
+var ExecuteLinterProgramsUseCase = class {
+  constructor(linterAstAdapter = new LinterAstAdapter(), logger = new PackmindLogger(origin8)) {
+    this.linterAstAdapter = linterAstAdapter;
+    this.logger = logger;
+  }
+  async execute(command2) {
+    const { filePath, fileContent, language, programs } = command2;
+    if (programs.length === 0) {
+      return {
+        file: filePath,
+        violations: []
+      };
+    }
+    const matchingPrograms = this.filterProgramsByLanguage(programs, language);
+    if (matchingPrograms.length === 0) {
+      return {
+        file: filePath,
+        violations: []
+      };
+    }
+    const violations = [];
+    this.extractAndExecutePrograms(matchingPrograms, fileContent, violations);
+    await this.extractAndExecuteASTPrograms(
+      matchingPrograms,
+      language,
+      filePath,
+      fileContent,
+      violations
+    );
+    return {
+      file: filePath,
+      violations
+    };
+  }
+  async extractAndExecuteASTPrograms(programs, language, filePath, fileContent, violations) {
+    const astPrograms = programs.filter((p) => p.sourceCodeState === "AST");
+    if (astPrograms.length > 0) {
+      if (!this.linterAstAdapter.isLanguageSupported(language)) {
+        this.logger.warn("Unsupported language for AST execution", {
+          language,
+          filePath
+        });
+      } else {
+        let ast;
+        try {
+          ast = await this.linterAstAdapter.parseSourceCode(
+            fileContent,
+            language
+          );
+          const astViolations = astPrograms.flatMap(
+            (program) => this.executeAstProgram(program, ast)
+          );
+          violations.push(...astViolations);
+        } catch (error) {
+          this.logger.error("Failed to parse source code for AST execution", {
+            language,
+            filePath,
+            error: this.normalizeError(error)
+          });
+        }
+      }
+    }
+  }
+  extractAndExecutePrograms(programs, fileContent, violations) {
+    const rawPrograms = programs.filter((p) => p.sourceCodeState === "RAW");
+    if (rawPrograms.length > 0) {
+      const rawViolations = rawPrograms.flatMap(
+        (program) => this.executeRawProgram(program, fileContent)
+      );
+      violations.push(...rawViolations);
+    }
+  }
+  executeRawProgram(program, fileContent) {
+    const ruleName = this.extractRuleName(program.ruleContent);
+    try {
+      const checkSourceCode = this.createProgramFunction(program.code);
+      const rawResult = checkSourceCode(fileContent);
+      return this.mapProgramResult(rawResult, ruleName, program);
+    } catch (error) {
+      this.logger.error("Failed to execute detection program", {
+        standardSlug: program.standardSlug,
+        ruleContent: program.ruleContent,
+        error: this.normalizeError(error)
+      });
+      return [];
+    }
+  }
+  executeAstProgram(program, ast) {
+    const ruleName = this.extractRuleName(program.ruleContent);
+    try {
+      const checkSourceCode = this.createProgramFunction(program.code);
+      const rawResult = checkSourceCode(ast);
+      return this.mapProgramResult(rawResult, ruleName, program);
+    } catch (error) {
+      this.logger.error("Failed to execute detection program", {
+        standardSlug: program.standardSlug,
+        ruleContent: program.ruleContent,
+        error: this.normalizeError(error)
+      });
+      return [];
+    }
+  }
+  createProgramFunction(program) {
+    try {
+      const func = new Function(
+        "input",
+        `
+          ${program}
+          return checkSourceCode(input);
+        `
+      );
+      return func;
+    } catch (error) {
+      throw new Error(`Failed to parse program: ${this.normalizeError(error)}`);
+    }
+  }
+  mapProgramResult(rawResult, ruleName, program) {
+    if (!Array.isArray(rawResult)) {
+      this.logger.warn("Program result is not an array", {
+        standardSlug: program.standardSlug,
+        ruleContent: program.ruleContent
+      });
+      return [];
+    }
+    return rawResult.map((value) => this.toViolation(value, ruleName, program)).filter(
+      (violation) => violation !== null
+    );
+  }
+  toViolation(value, ruleName, program) {
+    let line;
+    let character = 0;
+    if (typeof value === "number" && Number.isFinite(value)) {
+      line = value;
+    } else if (this.isViolationLike(value)) {
+      line = value.line;
+      character = value.character ?? 0;
+    }
+    if (!this.isValidLine(line)) {
+      this.logger.warn("Invalid violation line detected", {
+        standardSlug: program.standardSlug,
+        ruleContent: program.ruleContent,
+        line
+      });
+      return null;
+    }
+    return {
+      line,
+      character,
+      rule: ruleName,
+      standard: program.standardSlug
+    };
+  }
+  isViolationLike(value) {
+    return typeof value === "object" && value !== null && "line" in value && typeof value.line === "number";
+  }
+  isValidLine(line) {
+    return typeof line === "number" && Number.isInteger(line) && line >= 0;
+  }
+  extractRuleName(ruleContent) {
+    if (!ruleContent.includes("/")) {
+      return ruleContent;
+    }
+    return ruleContent.split("/").pop()?.replace(".js", "") ?? ruleContent;
+  }
+  filterProgramsByLanguage(programs, fileLanguage) {
+    const filtered = programs.filter((p) => p.language === fileLanguage);
+    if (filtered.length < programs.length) {
+      this.logger.debug("Filtered out programs with mismatched languages", {
+        totalPrograms: programs.length,
+        matchingPrograms: filtered.length,
+        fileLanguage
+      });
+    }
+    return filtered;
+  }
+  normalizeError(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error && typeof error === "object") {
+      if ("message" in error && typeof error.message === "string") {
+        return error.message;
+      }
+      try {
+        return JSON.stringify(error);
+      } catch {
+        return "[object Object]";
+      }
+    }
+    return String(error);
+  }
+};
+
+// apps/cli/src/PackmindCliHexaFactory.ts
+var PackmindCliHexaFactory = class {
+  constructor(logger) {
+    this.logger = logger;
+    this.repositories = {
+      packmindGateway: new PackmindGateway(
+        process.env.PACKMIND_API_KEY_V3 || ""
+      )
+    };
+    this.services = {
+      listFiles: new ListFiles(),
+      gitRemoteUrlService: new GitService(this.logger),
+      linterExecutionUseCase: new ExecuteLinterProgramsUseCase()
+    };
+    this.useCases = {
+      executeSingleFileAst: new ExecuteSingleFileAstUseCase(
+        this.services.linterExecutionUseCase
+      ),
+      getGitRemoteUrl: new GetGitRemoteUrlUseCase(),
+      listFilesInDirectoryUseCase: new ListFilesInDirectoryUseCase(),
+      lintFilesInDirectory: new LintFilesInDirectoryUseCase(
+        this.services,
+        this.repositories,
+        this.logger
+      )
+    };
+  }
+};
+
+// apps/cli/src/PackmindCliHexa.ts
+var origin9 = "PackmindCliHexa";
+var PackmindCliHexa = class {
+  constructor(logger = new PackmindLogger(origin9)) {
+    this.logger = logger;
+    try {
+      this.hexa = new PackmindCliHexaFactory(this.logger);
+    } catch (error) {
+      this.logger.error("Failed to initialize PackmindCliHexa", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Destroys the DeploymentsHexa and cleans up resources
+   */
+  destroy() {
+    this.logger.info("Destroying PackmindCliHexa");
+    this.logger.info("PackmindCliHexa destroyed");
+  }
+  async getGitRemoteUrl(command2) {
+    return this.hexa.useCases.getGitRemoteUrl.execute(command2);
+  }
+  async executeSingleFileAst(command2) {
+    return this.hexa.useCases.executeSingleFileAst.execute(command2);
+  }
+  async listFilesInDirectory(command2) {
+    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command2);
+  }
+  async lintFilesInDirectory(command2) {
+    return this.hexa.useCases.lintFilesInDirectory.execute(command2);
+  }
+};
+
+// apps/cli/src/infra/repositories/IDELintLogger.ts
+var IDELintLogger = class {
+  logViolations(violations) {
+    violations.forEach((violation) => {
+      this.logViolation(violation);
+    });
+  }
+  logViolation(violation) {
+    violation.violations.forEach(({ line, character, standard, rule }) => {
+      console.log(
+        `${violation.file}:${line}:${character}:error:@${standard}/${rule}`
+      );
+    });
+  }
+};
+
+// apps/cli/src/infra/repositories/HumanReadableLogger.ts
+var import_chalk = __toESM(require("chalk"));
+var HumanReadableLogger = class {
+  logViolations(violations) {
+    violations.forEach((violation) => {
+      this.logViolation(violation);
+    });
+    if (violations.length > 0) {
+      const totalViolationCount = violations.reduce(
+        (acc, violation) => acc + violation.violations.length,
+        0
+      );
+      console.log(
+        import_chalk.default.bgRed.bold("packmind-cli"),
+        import_chalk.default.red(
+          `\u274C Found ${import_chalk.default.bold(totalViolationCount)} violation(s) in ${import_chalk.default.bold(violations.length)} file(s)`
+        )
+      );
+    } else {
+      console.log(
+        import_chalk.default.bgGreen.bold("packmind-cli"),
+        import_chalk.default.green.bold(`\u2705 No violations found`)
+      );
+    }
+  }
+  logViolation(violation) {
+    console.log(import_chalk.default.underline.gray(violation.file));
+    violation.violations.forEach(({ line, character, standard, rule }) => {
+      console.log(
+        import_chalk.default.red(`	${line}:${character}	error	@${standard}/${rule}`)
+      );
+    });
+  }
+};
+
+// apps/cli/src/infra/commands/LinterCommand.ts
+var Logger = {
+  from: async (input) => {
+    switch (input) {
+      case "ide":
+        return "ide" /* ide */;
+      case "human":
+        return "human" /* human */;
+    }
+    throw new Error(
+      `${input} is not a valid value for the --logger option. Expected values are: ide, human`
+    );
+  }
+};
+var RuleID = {
+  from: async (input) => {
+    const match = input.match(/^@([^/]+)\/(.+)$/);
+    if (!match) {
+      throw new Error(
+        "Error: Invalid --rule format. Expected format: @standard-slug/ruleId"
+      );
+    }
+    return {
+      standardSlug: match[1],
+      ruleId: createRuleId(match[2])
+    };
+  }
+};
+var lintCommand = (0, import_cmd_ts.command)({
+  name: "lint",
+  description: "Lint code at the specified path",
+  args: {
+    path: (0, import_cmd_ts.positional)({
+      displayName: "path",
+      description: "Path to lint (e.g., . for current directory)",
+      type: import_cmd_ts.string
+    }),
+    logger: (0, import_cmd_ts.option)({
+      long: "logger",
+      description: "Output format (ide | human). Default is human",
+      type: Logger,
+      defaultValue: () => "human" /* human */,
+      defaultValueIsSerializable: true
+    }),
+    rule: (0, import_cmd_ts.option)({
+      long: "rule",
+      description: "Specify rule in format @standard-slug/ruleId (runs active programs without --draft)",
+      type: (0, import_cmd_ts.optional)(RuleID)
+    }),
+    language: (0, import_cmd_ts.option)({
+      long: "language",
+      description: "Filter detection programs by language",
+      type: (0, import_cmd_ts.optional)(import_cmd_ts.string)
+    }),
+    draft: (0, import_cmd_ts.flag)({
+      long: "draft",
+      description: "Use draft detection programs (requires --rule)"
+    }),
+    debug: (0, import_cmd_ts.flag)({
+      long: "debug",
+      description: "Enable debug logging"
+    })
+  },
+  handler: async ({ path: path2, draft, rule, debug, language, logger }) => {
+    if (draft && !rule) {
+      throw new Error("option --rule is required to use --draft mode");
+    }
+    const startedAt = Date.now();
+    const packmindLogger = new PackmindLogger(
+      "PackmindCLI",
+      debug ? "debug" /* DEBUG */ : "info" /* INFO */
+    );
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    const { violations } = await packmindCliHexa.lintFilesInDirectory({
+      path: path2,
+      draftMode: draft,
+      standardSlug: rule?.standardSlug,
+      ruleId: rule?.ruleId,
+      language
+    });
+    (logger === "ide" /* ide */ ? new IDELintLogger() : new HumanReadableLogger()).logViolations(violations);
+    const durationSeconds = (Date.now() - startedAt) / 1e3;
+    console.log(`Lint completed in ${durationSeconds.toFixed(2)}s`);
+    if (violations.length > 0) {
+      process.exit(1);
+    } else {
+      process.exit(0);
+    }
+  }
+});
+
+// apps/cli/src/main.ts
+var app = (0, import_cmd_ts2.subcommands)({
+  name: "packmind-cli",
+  description: "Packmind CLI tool",
+  cmds: {
+    lint: lintCommand
+  }
+});
+(0, import_cmd_ts2.run)(app, process.argv.slice(2)).catch((error) => {
+  console.error(import_chalk2.default.bgRed.bold("packmind-cli"), import_chalk2.default.red(error.message));
+  process.exit(1);
+});