@packmind/cli 0.3.4 → 0.4.0

package/main.cjs

@@ -13,6 +13,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -30,6 +33,48 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// apps/cli/package.json
+var require_package = __commonJS({
+  "apps/cli/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@packmind/cli",
+      version: "0.4.0",
+      description: "A command-line interface for Packmind linting and code quality checks",
+      private: false,
+      bin: {
+        "packmind-cli": "./main.cjs"
+      },
+      main: "./main.cjs",
+      files: [
+        "main.cjs",
+        "*.wasm",
+        "stubs",
+        "CHANGELOG.MD"
+      ],
+      keywords: [
+        "packmind",
+        "linting",
+        "code-quality",
+        "cli",
+        "static-analysis"
+      ],
+      author: "Packmind",
+      license: "UNLICENSED",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/PackmindHub/packmind.git",
+        directory: "apps/cli"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      scripts: {
+        "packmind-cli": "ts-node --project tsconfig.app.json src/main.ts"
+      }
+    };
+  }
+});
+
 // apps/cli/src/main.ts
 var import_chalk2 = __toESM(require("chalk"));
 var import_cmd_ts3 = require("cmd-ts");
@@ -183,6 +228,12 @@ var createRecipesDeploymentId = brandedIdFactory();
 // packages/types/src/deployments/StandardsDeploymentId.ts
 var createStandardsDeploymentId = brandedIdFactory();
 
+// packages/types/src/deployments/PackagesDeploymentId.ts
+var createPackagesDeploymentId = brandedIdFactory();
+
+// packages/types/src/deployments/Package.ts
+var createPackageId = brandedIdFactory();
+
 // packages/types/src/git/GitRepoId.ts
 var createGitRepoId = brandedIdFactory();
 
@@ -407,6 +458,48 @@ var createDetectionProgramId = brandedIdFactory();
 // packages/types/src/linter/RuleDetectionAssessment.ts
 var createRuleDetectionAssessmentId = brandedIdFactory();
 
+// packages/types/src/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 createDetectionHeuristicsUpdatedEvent(ruleId, language, detectionHeuristicsId) {
+  return {
+    type: "DETECTION_HEURISTICS_UPDATED",
+    data: {
+      ruleId,
+      language,
+      detectionHeuristicsId
+    },
+    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()
+  };
+}
+
 // apps/cli/src/application/useCases/ExecuteSingleFileAstUseCase.ts
 var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
   constructor(linterExecutionUseCase) {
@@ -447,8 +540,8 @@ var import_util = require("util");
 var execAsync = (0, import_util.promisify)(import_child_process.exec);
 var origin = "GitService";
 var GitService = class {
-  constructor(logger = new PackmindLogger(origin)) {
-    this.logger = logger;
+  constructor(logger2 = new PackmindLogger(origin)) {
+    this.logger = logger2;
   }
   async getGitRepositoryRoot(path5) {
     try {
@@ -488,7 +581,7 @@ ${error.message}`
       throw new Error("Failed to get Git branches: Unknown error");
     }
   }
-  async getGitRemoteUrl(repoPath, origin5) {
+  async getGitRemoteUrl(repoPath, origin10) {
     try {
       const { stdout } = await execAsync("git remote -v", {
         cwd: repoPath
@@ -498,10 +591,10 @@ ${error.message}`
         throw new Error("No Git remotes found in the repository");
       }
       let selectedRemote;
-      if (origin5) {
-        const foundRemote = remotes.find((remote) => remote.name === origin5);
+      if (origin10) {
+        const foundRemote = remotes.find((remote) => remote.name === origin10);
         if (!foundRemote) {
-          throw new Error(`Remote '${origin5}' not found in repository`);
+          throw new Error(`Remote '${origin10}' not found in repository`);
         }
         selectedRemote = foundRemote.url;
       } else if (remotes.length === 1) {
@@ -591,8 +684,8 @@ var GetGitRemoteUrlUseCase = class {
     this.gitRemoteUrlService = gitRemoteUrlService;
   }
   async execute(command3) {
-    const { path: repoPath, origin: origin5 } = command3;
-    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin5);
+    const { path: repoPath, origin: origin10 } = command3;
+    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin10);
   }
 };
 
@@ -720,10 +813,10 @@ var path2 = __toESM(require("path"));
 var fs2 = __toESM(require("fs/promises"));
 var origin2 = "LintFilesInDirectoryUseCase";
 var LintFilesInDirectoryUseCase = class {
-  constructor(services, repositories, logger = new PackmindLogger(origin2)) {
+  constructor(services, repositories, logger2 = new PackmindLogger(origin2)) {
     this.services = services;
     this.repositories = repositories;
-    this.logger = logger;
+    this.logger = logger2;
   }
   fileMatchesScope(filePath, scopePatterns) {
     if (!scopePatterns || scopePatterns.length === 0) {
@@ -1113,7 +1206,7 @@ function decodeApiKey(apiKey) {
 var PackmindGateway = class {
   constructor(apiKey) {
     this.apiKey = apiKey;
-    this.getPullData = async () => {
+    this.getPullData = async (command3) => {
       const decodedApiKey = decodeApiKey(this.apiKey);
       if (!decodedApiKey.isValid) {
         throw new Error(`Invalid API key: ${decodedApiKey.error}`);
@@ -1124,7 +1217,13 @@ var PackmindGateway = class {
         throw new Error("Invalid JWT: missing organizationId");
       }
       const organizationId = jwtPayload.organization.id;
-      const url = `${host}/api/v0/organizations/${organizationId}/pull`;
+      const queryParams = new URLSearchParams();
+      if (command3.packagesSlugs && command3.packagesSlugs.length > 0) {
+        command3.packagesSlugs.forEach((slug) => {
+          queryParams.append("packageSlug", slug);
+        });
+      }
+      const url = `${host}/api/v0/organizations/${organizationId}/pull?${queryParams.toString()}`;
       try {
         const response = await fetch(url, {
           method: "GET",
@@ -1142,7 +1241,9 @@ var PackmindGateway = class {
             }
           } catch {
           }
-          throw new Error(errorMsg);
+          const error = new Error(errorMsg);
+          error.statusCode = response.status;
+          throw error;
         }
         const result = await response.json();
         return result;
@@ -1159,6 +1260,54 @@ var PackmindGateway = class {
         );
       }
     };
+    this.listPackages = async () => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host, jwt } = decodedApiKey.payload;
+      const jwtPayload = decodeJwt(jwt);
+      if (!jwtPayload?.organization?.id) {
+        throw new Error("Invalid JWT: missing organizationId");
+      }
+      const organizationId = jwtPayload.organization.id;
+      const url = `${host}/api/v0/organizations/${organizationId}/packages`;
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        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 {
+          }
+          const error = new Error(errorMsg);
+          error.statusCode = response.status;
+          throw error;
+        }
+        const result = await response.json();
+        return result.packages;
+      } 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 list packages: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
     this.listExecutionPrograms = async (params) => {
       const decodedApiKey = decodeApiKey(this.apiKey);
       if (!decodedApiKey.isValid) {
@@ -1337,6 +1486,56 @@ var PackmindGateway = class {
         );
       }
     };
+    this.getPackageSummary = async ({
+      slug
+    }) => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host, jwt } = decodedApiKey.payload;
+      const jwtPayload = decodeJwt(jwt);
+      if (!jwtPayload?.organization?.id) {
+        throw new Error("Invalid JWT: missing organizationId");
+      }
+      const organizationId = jwtPayload.organization.id;
+      const url = `${host}/api/v0/organizations/${organizationId}/packages/${encodeURIComponent(slug)}`;
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        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 {
+          }
+          const error = new Error(errorMsg);
+          error.statusCode = response.status;
+          throw error;
+        }
+        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 get package '${slug}': Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
   }
 };
 
@@ -3011,9 +3210,9 @@ var TreeSitter17 = __toESM(require("web-tree-sitter"));
 // packages/linter-execution/src/application/useCases/ExecuteLinterProgramsUseCase.ts
 var origin3 = "ExecuteLinterProgramsUseCase";
 var ExecuteLinterProgramsUseCase = class {
-  constructor(linterAstAdapter = new LinterAstAdapter(), logger = new PackmindLogger(origin3)) {
+  constructor(linterAstAdapter = new LinterAstAdapter(), logger2 = new PackmindLogger(origin3)) {
     this.linterAstAdapter = linterAstAdapter;
-    this.logger = logger;
+    this.logger = logger2;
   }
   async execute(command3) {
     const { filePath, fileContent, language, programs } = command3;
@@ -3206,90 +3405,1078 @@ var ExecuteLinterProgramsUseCase = class {
   }
 };
 
-// apps/cli/src/application/useCases/PullDataUseCase.ts
-var fs3 = __toESM(require("fs/promises"));
-var path3 = __toESM(require("path"));
-var PullDataUseCase = class {
-  constructor(packmindGateway) {
-    this.packmindGateway = packmindGateway;
+// packages/node-utils/src/ai/prompts/OpenAIService.ts
+var import_openai = __toESM(require("openai"));
+
+// packages/node-utils/src/config/infra/Infisical/InfisicalConfig.ts
+var import_sdk = require("@infisical/sdk");
+var origin4 = "InfisicalConfig";
+var InfisicalConfig = class {
+  constructor(clientId, clientSecret, env, projectId, logger2 = new PackmindLogger(origin4)) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.env = env;
+    this.projectId = projectId;
+    this.logger = logger2;
+    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 execute(command3) {
-    const baseDirectory = command3.baseDirectory || process.cwd();
-    const result = {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      errors: []
-    };
+  async initClient() {
+    this.logger.info("Initializing Infisical client authentication");
     try {
-      const response = await this.packmindGateway.getPullData({});
-      for (const file of response.fileUpdates.createOrUpdate) {
+      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/node-utils/src/config/config/Configuration.ts
+var origin5 = "Configuration";
+var Configuration = class _Configuration {
+  constructor() {
+    this.initialized = false;
+    this.initializationPromise = null;
+  }
+  static {
+    this.logger = new PackmindLogger(
+      origin5,
+      "info" /* INFO */
+    );
+  }
+  static getInstance(logger2) {
+    if (logger2) {
+      _Configuration.logger = logger2;
+    }
+    _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");
+    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, falling back to environment variables only",
+          {
+            hasClientId: !!clientId,
+            hasClientSecret: !!clientSecret,
+            hasInfisicalEnv: !!infisicalEnv,
+            hasProjectId: !!projectId
+          }
+        );
+        this.infisicalConfig = void 0;
+      } else {
         try {
-          await this.createOrUpdateFile(
-            baseDirectory,
-            file.path,
-            file.content,
-            result
+          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"
           );
         } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          result.errors.push(
-            `Failed to create/update ${file.path}: ${errorMsg}`
+          _Configuration.logger.error(
+            "Failed to initialize Infisical, falling back to environment variables only",
+            {
+              error: error instanceof Error ? error.message : String(error)
+            }
           );
+          this.infisicalConfig = void 0;
         }
       }
-      for (const file of response.fileUpdates.delete) {
+    } else {
+      _Configuration.logger.info(
+        "Using environment variables only (no Infisical)"
+      );
+    }
+    this.initialized = true;
+    _Configuration.logger.info("Configuration initialization completed");
+  }
+  static async getConfigWithDefault(key, defaultValue) {
+    const value = await _Configuration.getConfig(key);
+    return value ?? defaultValue;
+  }
+  static async getConfig(key, env = process.env, logger2) {
+    if (logger2) {
+      _Configuration.logger = logger2;
+    }
+    _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 }
+        );
         try {
-          await this.deleteFile(baseDirectory, file.path, result);
+          const infisicalValue = await instance.infisicalConfig.getValue(key);
+          if (infisicalValue) {
+            _Configuration.logger.debug(
+              "Configuration value found in Infisical",
+              {
+                key
+              }
+            );
+            return infisicalValue;
+          }
         } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          result.errors.push(`Failed to delete ${file.path}: ${errorMsg}`);
+          _Configuration.logger.error(
+            "Failed to retrieve value from Infisical, value not available",
+            {
+              key,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          );
         }
       }
+      _Configuration.logger.warn("Configuration value not found", { key });
+      return null;
     } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      result.errors.push(`Failed to pull data: ${errorMsg}`);
+      _Configuration.logger.warn("Failed to get configuration value", {
+        key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
     }
-    return result;
   }
-  async createOrUpdateFile(baseDirectory, filePath, content, result) {
-    const fullPath = path3.join(baseDirectory, filePath);
-    const directory = path3.dirname(fullPath);
-    await fs3.mkdir(directory, { recursive: true });
-    const fileExists = await this.fileExists(fullPath);
-    if (fileExists) {
-      await fs3.appendFile(fullPath, content, "utf-8");
-      result.filesUpdated++;
-    } else {
-      await fs3.writeFile(fullPath, content, "utf-8");
-      result.filesCreated++;
-    }
+};
+
+// packages/node-utils/src/cache/Cache.ts
+var import_ioredis = __toESM(require("ioredis"));
+var origin6 = "Cache";
+var Cache = class _Cache {
+  constructor() {
+    this.initialized = false;
+    this.connectionConfig = {
+      host: "redis",
+      port: 6379,
+      maxRetriesPerRequest: 3
+    };
   }
-  async deleteFile(baseDirectory, filePath, result) {
-    const fullPath = path3.join(baseDirectory, filePath);
-    const fileExists = await this.fileExists(fullPath);
-    if (fileExists) {
-      await fs3.unlink(fullPath);
-      result.filesDeleted++;
+  static {
+    this.logger = new PackmindLogger(
+      origin6,
+      "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;
   }
-  async fileExists(filePath) {
+  /**
+   * 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 {
-      await fs3.access(filePath);
-      return true;
-    } catch {
-      return false;
+      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)}`
+      );
     }
   }
-};
-
-// apps/cli/src/PackmindCliHexaFactory.ts
-var PackmindCliHexaFactory = class {
-  constructor(logger) {
-    this.logger = logger;
-    this.repositories = {
-      packmindGateway: new PackmindGateway(
-        process.env.PACKMIND_API_KEY_V3 || ""
+  /**
+   * 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/node-utils/src/jobs/infra/bullMQ/WorkerQueue.ts
+var import_bullmq2 = require("bullmq");
+
+// packages/node-utils/src/jobs/infra/bullMQ/AbstractQueue.ts
+var import_bullmq = require("bullmq");
+
+// packages/node-utils/src/jobs/infra/DelayedJobsFactory.ts
+var logger = new PackmindLogger("DelayedJobsFactory");
+
+// packages/node-utils/src/mail/SmtpMailService.ts
+var import_nodemailer = __toESM(require("nodemailer"));
+
+// packages/node-utils/src/nest/Public.ts
+var import_common = require("@nestjs/common");
+
+// packages/node-utils/src/repositories/AbstractRepository.ts
+var import_common2 = require("@nestjs/common");
+
+// packages/node-utils/src/sse/RedisSSEClient.ts
+var import_ioredis2 = __toESM(require("ioredis"));
+var origin7 = "RedisSSEClient";
+var RedisSSEClient = class _RedisSSEClient {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.initialized = false;
+  }
+  static {
+    this.logger = new PackmindLogger(origin7);
+  }
+  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/node-utils/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/node-utils/src/sse/SSEEventPublisher.ts
+var origin8 = "SSEEventPublisher";
+var SSEEventPublisher = class _SSEEventPublisher {
+  static {
+    this.logger = new PackmindLogger(origin8);
+  }
+  /**
+   * 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 a detection heuristics updated event for cache invalidation
+   * This triggers React Query to refetch the heuristics data
+   */
+  static async publishDetectionHeuristicsUpdatedEvent(ruleId, language, detectionHeuristicsId, userId, organizationId) {
+    _SSEEventPublisher.logger.info(
+      "Publishing detection heuristics updated event",
+      {
+        ruleId,
+        language,
+        detectionHeuristicsId,
+        userId,
+        organizationId
+      }
+    );
+    try {
+      const event = createDetectionHeuristicsUpdatedEvent(
+        ruleId,
+        language,
+        detectionHeuristicsId
+      );
+      await _SSEEventPublisher.publishEvent(
+        "detection_heuristics_updated",
+        [ruleId, language, detectionHeuristicsId],
+        event,
+        userId ? [userId] : void 0
+      );
+      _SSEEventPublisher.logger.debug(
+        "Successfully published detection heuristics updated event",
+        { ruleId, language, detectionHeuristicsId }
+      );
+    } catch (error) {
+      _SSEEventPublisher.logger.error(
+        "Failed to publish detection heuristics updated event",
+        {
+          ruleId,
+          language,
+          detectionHeuristicsId,
+          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/node-utils/src/text/sectionMerge.ts
+function mergeSectionsIntoFileContent(existingContent, sections) {
+  let result = existingContent;
+  for (const section of sections) {
+    const startMarker = `<!-- start: ${section.key} -->`;
+    const endMarker = `<!-- end: ${section.key} -->`;
+    const startIndex = result.indexOf(startMarker);
+    const endIndex = result.indexOf(endMarker);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+      const before = result.substring(0, startIndex + startMarker.length);
+      const after = result.substring(endIndex);
+      result = `${before}
+${section.content}
+${after}`;
+    } else {
+      const sectionBlock = `${startMarker}
+${section.content}
+${endMarker}`;
+      if (result.trim() === "") {
+        result = sectionBlock;
+      } else {
+        result = result.endsWith("\n") ? `${result}${sectionBlock}
+` : `${result}
+${sectionBlock}
+`;
+      }
+    }
+  }
+  return result;
+}
+
+// packages/node-utils/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/PullDataUseCase.ts
+var fs3 = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var PullDataUseCase = class {
+  constructor(packmindGateway) {
+    this.packmindGateway = packmindGateway;
+  }
+  async execute(command3) {
+    const baseDirectory = command3.baseDirectory || process.cwd();
+    const result = {
+      filesCreated: 0,
+      filesUpdated: 0,
+      filesDeleted: 0,
+      errors: []
+    };
+    const response = await this.packmindGateway.getPullData({
+      packagesSlugs: command3.packagesSlugs
+    });
+    try {
+      for (const file of response.fileUpdates.createOrUpdate) {
+        try {
+          await this.createOrUpdateFile(baseDirectory, file, result);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          result.errors.push(
+            `Failed to create/update ${file.path}: ${errorMsg}`
+          );
+        }
+      }
+      for (const file of response.fileUpdates.delete) {
+        try {
+          await this.deleteFile(baseDirectory, file.path, result);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          result.errors.push(`Failed to delete ${file.path}: ${errorMsg}`);
+        }
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      result.errors.push(`Failed to pull data: ${errorMsg}`);
+    }
+    return result;
+  }
+  async createOrUpdateFile(baseDirectory, file, result) {
+    const fullPath = path3.join(baseDirectory, file.path);
+    const directory = path3.dirname(fullPath);
+    await fs3.mkdir(directory, { recursive: true });
+    const fileExists = await this.fileExists(fullPath);
+    if (file.content !== void 0) {
+      await this.handleFullContentUpdate(
+        fullPath,
+        file.content,
+        fileExists,
+        result
+      );
+    } else if (file.sections !== void 0) {
+      await this.handleSectionsUpdate(
+        fullPath,
+        file.sections,
+        fileExists,
+        result
+      );
+    }
+  }
+  async handleFullContentUpdate(fullPath, content, fileExists, result) {
+    if (fileExists) {
+      const existingContent = await fs3.readFile(fullPath, "utf-8");
+      const commentMarker = this.extractCommentMarker(content);
+      let finalContent;
+      if (!commentMarker) {
+        finalContent = content;
+      } else {
+        finalContent = this.mergeContentWithMarkers(
+          existingContent,
+          content,
+          commentMarker
+        );
+      }
+      await fs3.writeFile(fullPath, finalContent, "utf-8");
+      result.filesUpdated++;
+    } else {
+      await fs3.writeFile(fullPath, content, "utf-8");
+      result.filesCreated++;
+    }
+  }
+  async handleSectionsUpdate(fullPath, sections, fileExists, result) {
+    let currentContent = "";
+    if (fileExists) {
+      currentContent = await fs3.readFile(fullPath, "utf-8");
+    }
+    const mergedContent = mergeSectionsIntoFileContent(
+      currentContent,
+      sections
+    );
+    await fs3.writeFile(fullPath, mergedContent, "utf-8");
+    if (fileExists) {
+      result.filesUpdated++;
+    } else {
+      result.filesCreated++;
+    }
+  }
+  async deleteFile(baseDirectory, filePath, result) {
+    const fullPath = path3.join(baseDirectory, filePath);
+    const fileExists = await this.fileExists(fullPath);
+    if (fileExists) {
+      await fs3.unlink(fullPath);
+      result.filesDeleted++;
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await fs3.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Extracts the comment marker from content if it's wrapped with HTML comments.
+   * E.g., "<!-- start: Packmind recipes -->" returns "Packmind recipes"
+   */
+  extractCommentMarker(content) {
+    const startMarkerPattern = /<!--\s*start:\s*([^-]+?)\s*-->/;
+    const match = content.match(startMarkerPattern);
+    return match ? match[1].trim() : null;
+  }
+  /**
+   * Merges new content with existing content using comment markers.
+   * If the section exists, replaces it; otherwise, appends it.
+   */
+  mergeContentWithMarkers(existingContent, newContent, commentMarker) {
+    const startMarker = `<!-- start: ${commentMarker} -->`;
+    const endMarker = `<!-- end: ${commentMarker} -->`;
+    const newSectionPattern = new RegExp(
+      `${this.escapeRegex(startMarker)}([\\s\\S]*?)${this.escapeRegex(endMarker)}`
+    );
+    const newSectionMatch = newContent.match(newSectionPattern);
+    const newSectionContent = newSectionMatch ? newSectionMatch[1].trim() : newContent;
+    const existingSectionPattern = new RegExp(
+      `${this.escapeRegex(startMarker)}[\\s\\S]*?${this.escapeRegex(endMarker)}`,
+      "g"
+    );
+    if (existingSectionPattern.test(existingContent)) {
+      return existingContent.replace(
+        existingSectionPattern,
+        `${startMarker}
+${newSectionContent}
+${endMarker}`
+      );
+    } else {
+      return `${existingContent}
+${startMarker}
+${newSectionContent}
+${endMarker}`;
+    }
+  }
+  /**
+   * Escapes special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+
+// apps/cli/src/application/useCases/ListPackagesUseCase.ts
+var ListPackagesUseCase = class {
+  constructor(packmindGateway) {
+    this.packmindGateway = packmindGateway;
+  }
+  async execute() {
+    return this.packmindGateway.listPackages({});
+  }
+};
+
+// apps/cli/src/application/useCases/GetPackageSummaryUseCase.ts
+var GetPackageSummaryUseCase = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  async execute(command3) {
+    return this.gateway.getPackageSummary(command3);
+  }
+};
+
+// apps/cli/src/PackmindCliHexaFactory.ts
+var PackmindCliHexaFactory = class {
+  constructor(logger2) {
+    this.logger = logger2;
+    this.repositories = {
+      packmindGateway: new PackmindGateway(
+        process.env.PACKMIND_API_KEY_V3 || ""
       )
     };
     this.services = {
@@ -3308,16 +4495,20 @@ var PackmindCliHexaFactory = class {
         this.repositories,
         this.logger
       ),
-      pullData: new PullDataUseCase(this.repositories.packmindGateway)
+      pullData: new PullDataUseCase(this.repositories.packmindGateway),
+      listPackages: new ListPackagesUseCase(this.repositories.packmindGateway),
+      getPackageBySlug: new GetPackageSummaryUseCase(
+        this.repositories.packmindGateway
+      )
     };
   }
 };
 
 // apps/cli/src/PackmindCliHexa.ts
-var origin4 = "PackmindCliHexa";
+var origin9 = "PackmindCliHexa";
 var PackmindCliHexa = class {
-  constructor(logger = new PackmindLogger(origin4)) {
-    this.logger = logger;
+  constructor(logger2 = new PackmindLogger(origin9)) {
+    this.logger = logger2;
     try {
       this.hexa = new PackmindCliHexaFactory(this.logger);
     } catch (error) {
@@ -3349,6 +4540,12 @@ var PackmindCliHexa = class {
   async pullData(command3) {
     return this.hexa.useCases.pullData.execute(command3);
   }
+  async listPackages(command3) {
+    return this.hexa.useCases.listPackages.execute(command3);
+  }
+  async getPackageBySlug(command3) {
+    return this.hexa.useCases.getPackageBySlug.execute(command3);
+  }
 };
 
 // apps/cli/src/infra/repositories/IDELintLogger.ts
@@ -3465,7 +4662,7 @@ var lintCommand = (0, import_cmd_ts.command)({
       description: "Enable debug logging"
     })
   },
-  handler: async ({ path: path5, draft, rule, debug, language, logger }) => {
+  handler: async ({ path: path5, draft, rule, debug, language, logger: logger2 }) => {
     if (draft && !rule) {
       throw new Error("option --rule is required to use --draft mode");
     }
@@ -3482,7 +4679,7 @@ var lintCommand = (0, import_cmd_ts.command)({
       ruleId: rule?.ruleId,
       language
     });
-    (logger === "ide" /* ide */ ? new IDELintLogger() : new HumanReadableLogger()).logViolations(violations);
+    (logger2 === "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) {
@@ -3556,15 +4753,113 @@ var path4 = __toESM(require("path"));
 var import_cmd_ts2 = require("cmd-ts");
 var pullCommand = (0, import_cmd_ts2.command)({
   name: "pull",
-  description: "Pull recipes and standards from Packmind and save them to the current directory",
-  args: {},
-  handler: async () => {
-    console.log("Pulling content from Packmind...");
+  description: "Pull recipes and standards from specified packages and save them to the current directory",
+  args: {
+    list: (0, import_cmd_ts2.flag)({
+      long: "list",
+      description: "List available packages"
+    }),
+    show: (0, import_cmd_ts2.option)({
+      type: import_cmd_ts2.string,
+      long: "show",
+      description: "Show details of a specific package",
+      defaultValue: () => ""
+    }),
+    packagesSlugs: (0, import_cmd_ts2.restPositionals)({
+      type: import_cmd_ts2.string,
+      displayName: "packages",
+      description: "Package slugs to pull content from (e.g., backend frontend)"
+    })
+  },
+  handler: async ({ list, show, packagesSlugs }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    if (list) {
+      try {
+        console.log("Fetching available packages...\n");
+        const packages = await packmindCliHexa.listPackages({});
+        if (packages.length === 0) {
+          console.log("No packages found.");
+          process.exit(0);
+        }
+        console.log("Available packages:");
+        packages.forEach((pkg) => {
+          console.log(`  - ${pkg.slug}: ${pkg.description || pkg.name}`);
+        });
+        process.exit(0);
+      } catch (error) {
+        console.error("\n\u274C Failed to list packages:");
+        if (error instanceof Error) {
+          console.error(`   ${error.message}`);
+        } else {
+          console.error(`   ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    }
+    if (show) {
+      try {
+        console.log(`Fetching package details for '${show}'...
+`);
+        const pkg = await packmindCliHexa.getPackageBySlug({ slug: show });
+        console.log(`${pkg.name} (${pkg.slug}):
+`);
+        if (pkg.description) {
+          console.log(`${pkg.description}
+`);
+        }
+        if (pkg.standards && pkg.standards.length > 0) {
+          console.log("Standards:");
+          pkg.standards.forEach((standard) => {
+            if (standard.summary) {
+              console.log(`  - ${standard.name}: ${standard.summary}`);
+            } else {
+              console.log(`  - ${standard.name}`);
+            }
+          });
+          console.log("");
+        }
+        if (pkg.recipes && pkg.recipes.length > 0) {
+          console.log("Recipes:");
+          pkg.recipes.forEach((recipe) => {
+            if (recipe.summary) {
+              console.log(`  - ${recipe.name}: ${recipe.summary}`);
+            } else {
+              console.log(`  - ${recipe.name}`);
+            }
+          });
+          console.log("");
+        }
+        process.exit(0);
+      } catch (error) {
+        console.error("\n\u274C Failed to fetch package details:");
+        if (error instanceof Error) {
+          console.error(`   ${error.message}`);
+        } else {
+          console.error(`   ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    }
+    if (packagesSlugs.length === 0) {
+      console.log("Usage: packmind-cli pull <package-slug> [package-slug...]");
+      console.log("       packmind-cli pull --list");
+      console.log("");
+      console.log("Examples:");
+      console.log("  packmind-cli pull backend");
+      console.log("  packmind-cli pull backend frontend");
+      console.log("  packmind-cli pull --list  # Show available packages");
+      console.log("");
+      console.log("Pull recipes and standards from the specified packages.");
+      process.exit(0);
+    }
+    console.log(
+      `Pulling content from packages: ${packagesSlugs.join(", ")}...`
+    );
     try {
       const result = await packmindCliHexa.pullData({
-        baseDirectory: process.cwd()
+        baseDirectory: process.cwd(),
+        packagesSlugs
       });
       console.log("\n\u2705 Pull completed successfully!");
       console.log(`   Files created: ${result.filesCreated}`);
@@ -3579,15 +4874,37 @@ var pullCommand = (0, import_cmd_ts2.command)({
       }
     } catch (error) {
       console.error("\n\u274C Failed to pull content:");
-      console.error(
-        `   ${error instanceof Error ? error.message : String(error)}`
-      );
+      if (error instanceof Error) {
+        const errorObj = error;
+        if (errorObj.statusCode === 404) {
+          console.error(`   ${errorObj.message}`);
+          console.error(
+            "\n\u{1F4A1} Use `packmind-cli pull --list` to show available packages"
+          );
+        } else {
+          console.error(`   ${errorObj.message}`);
+          const apiErrorObj = error;
+          if (apiErrorObj.response?.data?.message) {
+            console.error(`
+   Details: ${apiErrorObj.response.data.message}`);
+          }
+          console.error("\n\u{1F4A1} Troubleshooting tips:");
+          console.error("   - Verify that the package slugs are correct");
+          console.error(
+            "   - Check that the packages exist in your organization"
+          );
+          console.error("   - Ensure you have the correct API key configured");
+        }
+      } else {
+        console.error(`   ${String(error)}`);
+      }
       process.exit(1);
     }
   }
 });
 
 // apps/cli/src/main.ts
+var { version: CLI_VERSION } = require_package();
 function findEnvFile() {
   let currentDir = process.cwd();
   const startDir = currentDir;
@@ -3626,6 +4943,11 @@ if (hasEmbeddedWasmFiles()) {
   } catch {
   }
 }
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(`packmind-cli version ${CLI_VERSION}`);
+  process.exit(0);
+}
 var app = (0, import_cmd_ts3.subcommands)({
   name: "packmind-cli",
   description: "Packmind CLI tool",
@@ -3634,7 +4956,7 @@ var app = (0, import_cmd_ts3.subcommands)({
     pull: pullCommand
   }
 });
-(0, import_cmd_ts3.run)(app, process.argv.slice(2)).catch((error) => {
+(0, import_cmd_ts3.run)(app, args).catch((error) => {
   console.error(import_chalk2.default.bgRed.bold("packmind-cli"), import_chalk2.default.red(error.message));
   process.exit(1);
 });