@packmind/cli 0.3.4 → 0.5.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.5.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();
 
@@ -208,38 +259,38 @@ var createRuleId = brandedIdFactory();
 var createRuleExampleId = brandedIdFactory();
 
 // packages/types/src/languages/ProgrammingLanguage.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;
+var ProgrammingLanguage = /* @__PURE__ */ ((ProgrammingLanguage4) => {
+  ProgrammingLanguage4["JAVASCRIPT"] = "JAVASCRIPT";
+  ProgrammingLanguage4["JAVASCRIPT_JSX"] = "JAVASCRIPT_JSX";
+  ProgrammingLanguage4["TYPESCRIPT"] = "TYPESCRIPT";
+  ProgrammingLanguage4["TYPESCRIPT_TSX"] = "TYPESCRIPT_TSX";
+  ProgrammingLanguage4["PYTHON"] = "PYTHON";
+  ProgrammingLanguage4["PHP"] = "PHP";
+  ProgrammingLanguage4["JAVA"] = "JAVA";
+  ProgrammingLanguage4["SCSS"] = "SCSS";
+  ProgrammingLanguage4["HTML"] = "HTML";
+  ProgrammingLanguage4["CSHARP"] = "CSHARP";
+  ProgrammingLanguage4["GENERIC"] = "GENERIC";
+  ProgrammingLanguage4["GO"] = "GO";
+  ProgrammingLanguage4["C"] = "C";
+  ProgrammingLanguage4["CPP"] = "CPP";
+  ProgrammingLanguage4["SQL"] = "SQL";
+  ProgrammingLanguage4["KOTLIN"] = "KOTLIN";
+  ProgrammingLanguage4["VUE"] = "VUE";
+  ProgrammingLanguage4["CSS"] = "CSS";
+  ProgrammingLanguage4["YAML"] = "YAML";
+  ProgrammingLanguage4["JSON"] = "JSON";
+  ProgrammingLanguage4["XML"] = "XML";
+  ProgrammingLanguage4["BASH"] = "BASH";
+  ProgrammingLanguage4["MARKDOWN"] = "MARKDOWN";
+  ProgrammingLanguage4["RUBY"] = "RUBY";
+  ProgrammingLanguage4["RUST"] = "RUST";
+  ProgrammingLanguage4["SAP_ABAP"] = "SAP_ABAP";
+  ProgrammingLanguage4["SAP_CDS"] = "SAP_CDS";
+  ProgrammingLanguage4["SAP_HANA_SQL"] = "SAP_HANA_SQL";
+  ProgrammingLanguage4["SWIFT"] = "SWIFT";
+  ProgrammingLanguage4["PROPERTIES"] = "PROPERTIES";
+  return ProgrammingLanguage4;
 })(ProgrammingLanguage || {});
 var ProgrammingLanguageDetails = {
   ["GENERIC" /* GENERIC */]: {
@@ -407,6 +458,304 @@ var createDetectionProgramId = brandedIdFactory();
 // packages/types/src/linter/RuleDetectionAssessment.ts
 var createRuleDetectionAssessmentId = brandedIdFactory();
 
+// packages/types/src/llm/LLMProviderMetadata.ts
+var DEFAULT_OPENAI_MODELS = {
+  model: "gpt-5.1",
+  fastestModel: "gpt-4.1-mini"
+};
+var DEFAULT_ANTHROPIC_MODELS = {
+  model: "claude-sonnet-4-5-20250929",
+  fastestModel: "claude-haiku-4-5-20251001"
+};
+var DEFAULT_GEMINI_MODELS = {
+  model: "gemini-3-pro-preview",
+  fastestModel: "gemini-2.5-flash"
+};
+var DEFAULT_AZURE_OPENAI_API_VERSION = "2024-12-01-preview";
+var LLM_PROVIDER_METADATA = {
+  ["openai" /* OPENAI */]: {
+    id: "openai" /* OPENAI */,
+    displayName: "OpenAI",
+    description: "OpenAI GPT models including GPT-4 and GPT-5. Requires an API key from OpenAI.",
+    defaultModel: DEFAULT_OPENAI_MODELS.model,
+    defaultFastModel: DEFAULT_OPENAI_MODELS.fastestModel,
+    documentationUrl: "https://platform.openai.com/docs",
+    fields: [
+      {
+        name: "apiKey",
+        label: "API Key",
+        type: "password",
+        defaultValue: "",
+        helpMessage: "Your OpenAI API key from platform.openai.com.",
+        optional: false,
+        placeholder: "sk-...",
+        secret: true
+      },
+      {
+        name: "model",
+        label: "Model",
+        type: "text",
+        defaultValue: DEFAULT_OPENAI_MODELS.model,
+        helpMessage: "The primary model to use for standard operations. Defaults to the latest recommended model.",
+        optional: true,
+        placeholder: "gpt-5.1",
+        secret: false
+      },
+      {
+        name: "fastestModel",
+        label: "Fast Model",
+        type: "text",
+        defaultValue: DEFAULT_OPENAI_MODELS.fastestModel,
+        helpMessage: "A faster, more economical model for less complex operations.",
+        optional: true,
+        placeholder: "gpt-4.1-mini",
+        secret: false
+      }
+    ]
+  },
+  ["anthropic" /* ANTHROPIC */]: {
+    id: "anthropic" /* ANTHROPIC */,
+    displayName: "Anthropic Claude",
+    description: "Anthropic Claude models known for safety and helpfulness. Requires an API key from Anthropic.",
+    defaultModel: DEFAULT_ANTHROPIC_MODELS.model,
+    defaultFastModel: DEFAULT_ANTHROPIC_MODELS.fastestModel,
+    documentationUrl: "https://docs.anthropic.com",
+    fields: [
+      {
+        name: "apiKey",
+        label: "API Key",
+        type: "password",
+        defaultValue: "",
+        helpMessage: "Your Anthropic API key from console.anthropic.com.",
+        optional: false,
+        placeholder: "sk-ant-...",
+        secret: true
+      },
+      {
+        name: "model",
+        label: "Model",
+        type: "text",
+        defaultValue: DEFAULT_ANTHROPIC_MODELS.model,
+        helpMessage: "The primary Claude model to use. Defaults to the latest Sonnet model.",
+        optional: true,
+        placeholder: "claude-sonnet-4-5-20250929",
+        secret: false
+      },
+      {
+        name: "fastestModel",
+        label: "Fast Model",
+        type: "text",
+        defaultValue: DEFAULT_ANTHROPIC_MODELS.fastestModel,
+        helpMessage: "A faster Claude model for less complex operations. Defaults to Haiku.",
+        optional: true,
+        placeholder: "claude-haiku-4-5-20251001",
+        secret: false
+      }
+    ]
+  },
+  ["gemini" /* GEMINI */]: {
+    id: "gemini" /* GEMINI */,
+    displayName: "Google Gemini",
+    description: "Google's Gemini models with multimodal capabilities. Requires an API key from Google AI Studio.",
+    defaultModel: DEFAULT_GEMINI_MODELS.model,
+    defaultFastModel: DEFAULT_GEMINI_MODELS.fastestModel,
+    documentationUrl: "https://ai.google.dev/docs",
+    fields: [
+      {
+        name: "apiKey",
+        label: "API Key",
+        type: "password",
+        defaultValue: "",
+        helpMessage: "Your Google AI API key from aistudio.google.com.",
+        optional: false,
+        placeholder: "AIza...",
+        secret: true
+      },
+      {
+        name: "model",
+        label: "Model",
+        type: "text",
+        defaultValue: DEFAULT_GEMINI_MODELS.model,
+        helpMessage: "The primary Gemini model to use. Defaults to the latest Pro model.",
+        optional: true,
+        placeholder: "gemini-3-pro-preview",
+        secret: false
+      },
+      {
+        name: "fastestModel",
+        label: "Fast Model",
+        type: "text",
+        defaultValue: DEFAULT_GEMINI_MODELS.fastestModel,
+        helpMessage: "A faster Gemini model for less complex operations. Defaults to Flash.",
+        optional: true,
+        placeholder: "gemini-2.5-flash",
+        secret: false
+      }
+    ]
+  },
+  ["azure-openai" /* AZURE_OPENAI */]: {
+    id: "azure-openai" /* AZURE_OPENAI */,
+    displayName: "Azure OpenAI",
+    description: "Microsoft Azure-hosted OpenAI models. Requires Azure deployment names and credentials.",
+    defaultModel: "",
+    defaultFastModel: "",
+    documentationUrl: "https://learn.microsoft.com/en-us/azure/ai-services/openai/",
+    fields: [
+      {
+        name: "model",
+        label: "Model Deployment Name",
+        type: "text",
+        defaultValue: "",
+        helpMessage: "The Azure deployment name for the primary model. This is the name you gave your deployment in Azure Portal.",
+        optional: false,
+        placeholder: "my-gpt-4-deployment",
+        secret: false
+      },
+      {
+        name: "fastestModel",
+        label: "Fast Model Deployment Name",
+        type: "text",
+        defaultValue: "",
+        helpMessage: "The Azure deployment name for the fast/economical model.",
+        optional: false,
+        placeholder: "my-gpt-35-turbo-deployment",
+        secret: false
+      },
+      {
+        name: "endpoint",
+        label: "Endpoint URL",
+        type: "url",
+        defaultValue: "",
+        helpMessage: "Your Azure OpenAI endpoint URL.",
+        optional: false,
+        placeholder: "https://your-resource.openai.azure.com",
+        secret: false
+      },
+      {
+        name: "apiKey",
+        label: "API Key",
+        type: "password",
+        defaultValue: "",
+        helpMessage: "Your Azure OpenAI API key.",
+        optional: false,
+        placeholder: "",
+        secret: true
+      },
+      {
+        name: "apiVersion",
+        label: "API Version",
+        type: "text",
+        defaultValue: DEFAULT_AZURE_OPENAI_API_VERSION,
+        helpMessage: "The Azure OpenAI API version to use. Defaults to the latest stable version.",
+        optional: true,
+        placeholder: "2024-12-01-preview",
+        secret: false
+      }
+    ]
+  },
+  ["openai-compatible" /* OPENAI_COMPATIBLE */]: {
+    id: "openai-compatible" /* OPENAI_COMPATIBLE */,
+    displayName: "OpenAI-Compatible",
+    description: "Any OpenAI-compatible API endpoint. Use this for local models (Ollama, LM Studio) or other compatible providers.",
+    defaultModel: "",
+    defaultFastModel: "",
+    documentationUrl: void 0,
+    fields: [
+      {
+        name: "llmEndpoint",
+        label: "Endpoint URL",
+        type: "url",
+        defaultValue: "",
+        helpMessage: "The base URL of the OpenAI-compatible API endpoint (e.g., http://localhost:11434/v1 for Ollama).",
+        optional: false,
+        placeholder: "http://localhost:11434/v1",
+        secret: false
+      },
+      {
+        name: "llmApiKey",
+        label: "API Key",
+        type: "password",
+        defaultValue: "",
+        helpMessage: "API key for authentication. Some local providers may not require this.",
+        optional: false,
+        placeholder: "",
+        secret: true
+      },
+      {
+        name: "model",
+        label: "Model",
+        type: "text",
+        defaultValue: "",
+        helpMessage: "The model identifier to use for standard operations (e.g., llama3, mistral).",
+        optional: false,
+        placeholder: "llama3",
+        secret: false
+      },
+      {
+        name: "fastestModel",
+        label: "Fast Model",
+        type: "text",
+        defaultValue: "",
+        helpMessage: "A faster model for less complex operations. Can be the same as the primary model.",
+        optional: false,
+        placeholder: "llama3",
+        secret: false
+      }
+    ]
+  },
+  ["packmind" /* PACKMIND */]: {
+    id: "packmind" /* PACKMIND */,
+    displayName: "Packmind (SaaS)",
+    description: "Packmind managed LLM service. Uses the platform default provider configuration.",
+    defaultModel: DEFAULT_OPENAI_MODELS.model,
+    defaultFastModel: DEFAULT_OPENAI_MODELS.fastestModel,
+    documentationUrl: void 0,
+    fields: []
+  }
+};
+
+// 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,30 +796,37 @@ 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) {
+  async getGitRepositoryRoot(path7) {
     try {
       const { stdout } = await execAsync("git rev-parse --show-toplevel", {
-        cwd: path5
+        cwd: path7
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path5,
+        inputPath: path7,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path5}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path7}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
+  async tryGetGitRepositoryRoot(path7) {
+    try {
+      return await this.getGitRepositoryRoot(path7);
+    } catch {
+      return null;
+    }
+  }
   async getCurrentBranches(repoPath) {
     try {
       const { stdout } = await execAsync("git branch -a --contains HEAD", {
@@ -488,7 +844,7 @@ ${error.message}`
       throw new Error("Failed to get Git branches: Unknown error");
     }
   }
-  async getGitRemoteUrl(repoPath, origin5) {
+  async getGitRemoteUrl(repoPath, origin11) {
     try {
       const { stdout } = await execAsync("git remote -v", {
         cwd: repoPath
@@ -498,10 +854,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 (origin11) {
+        const foundRemote = remotes.find((remote) => remote.name === origin11);
         if (!foundRemote) {
-          throw new Error(`Remote '${origin5}' not found in repository`);
+          throw new Error(`Remote '${origin11}' not found in repository`);
         }
         selectedRemote = foundRemote.url;
       } else if (remotes.length === 1) {
@@ -571,14 +927,14 @@ ${error.message}`
   normalizeGitUrl(url) {
     const sshMatch = url.match(/^git@([^:]+):(.+)$/);
     if (sshMatch) {
-      const [, host, path5] = sshMatch;
-      const cleanPath = path5.replace(/\.git$/, "");
+      const [, host, path7] = sshMatch;
+      const cleanPath = path7.replace(/\.git$/, "");
       return `${host}/${cleanPath}`;
     }
     const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+)$/);
     if (httpsMatch) {
-      const [, host, path5] = httpsMatch;
-      const cleanPath = path5.replace(/\.git$/, "");
+      const [, host, path7] = httpsMatch;
+      const cleanPath = path7.replace(/\.git$/, "");
       return `${host}/${cleanPath}`;
     }
     return url;
@@ -591,8 +947,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: origin11 } = command3;
+    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin11);
   }
 };
 
@@ -720,10 +1076,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) {
@@ -1057,6 +1413,224 @@ var LintFilesInDirectoryUseCase = class {
   }
 };
 
+// apps/cli/src/application/useCases/LintFilesLocallyUseCase.ts
+var import_minimatch2 = require("minimatch");
+var path3 = __toESM(require("path"));
+var fs3 = __toESM(require("fs/promises"));
+var origin3 = "LintFilesLocallyUseCase";
+var LintFilesLocallyUseCase = class {
+  constructor(services, repositories, logger2 = new PackmindLogger(origin3)) {
+    this.services = services;
+    this.repositories = repositories;
+    this.logger = logger2;
+  }
+  fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
+    if (!scopePatterns || scopePatterns.length === 0) {
+      const effectivePattern = this.buildEffectivePattern(targetPath, null);
+      return (0, import_minimatch2.minimatch)(filePath, effectivePattern, { matchBase: false });
+    }
+    return scopePatterns.some((scopePattern) => {
+      const effectivePattern = this.buildEffectivePattern(
+        targetPath,
+        scopePattern
+      );
+      return (0, import_minimatch2.minimatch)(filePath, effectivePattern, { matchBase: false });
+    });
+  }
+  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(command3) {
+    const { path: userPath } = command3;
+    this.logger.debug(`Starting local linting: path="${userPath}"`);
+    const absoluteUserPath = path3.isAbsolute(userPath) ? userPath : path3.resolve(process.cwd(), userPath);
+    let pathStats;
+    try {
+      pathStats = await fs3.stat(absoluteUserPath);
+    } catch {
+      throw new Error(
+        `The path "${absoluteUserPath}" does not exist or cannot be accessed`
+      );
+    }
+    const isFile = pathStats.isFile();
+    const directoryForConfig = isFile ? path3.dirname(absoluteUserPath) : absoluteUserPath;
+    const gitRepoRoot = await this.services.gitRemoteUrlService.tryGetGitRepositoryRoot(
+      directoryForConfig
+    );
+    const hierarchicalConfig = await this.repositories.configFileRepository.readHierarchicalConfig(
+      directoryForConfig,
+      gitRepoRoot
+    );
+    if (!hierarchicalConfig.hasConfigs) {
+      const boundary = gitRepoRoot ?? "filesystem root";
+      throw new Error(
+        `No packmind.json found between ${directoryForConfig} and ${boundary}. Cannot use local linting.`
+      );
+    }
+    const basePath = gitRepoRoot ?? directoryForConfig;
+    this.logger.debug(
+      `Found ${hierarchicalConfig.configPaths.length} packmind.json file(s)`
+    );
+    for (const configPath of hierarchicalConfig.configPaths) {
+      this.logger.debug(`Using config: ${configPath}`);
+    }
+    const packageSlugs = Object.keys(hierarchicalConfig.packages);
+    this.logger.debug(
+      `Merged ${packageSlugs.length} packages from configuration files`
+    );
+    const detectionPrograms = await this.repositories.packmindGateway.getDetectionProgramsForPackages({
+      packagesSlugs: packageSlugs
+    });
+    this.logger.debug(
+      `Retrieved detection programs: targetsCount=${detectionPrograms.targets.length}`
+    );
+    const files = isFile ? [{ path: absoluteUserPath }] : await this.services.listFiles.listFilesInDirectory(
+      absoluteUserPath,
+      [],
+      ["node_modules", "dist", ".min.", ".map.", ".git"]
+    );
+    this.logger.debug(`Found ${files.length} files to lint`);
+    const violations = [];
+    for (const file of files) {
+      const fileViolations = [];
+      const relativeFilePath = file.path.startsWith(basePath) ? file.path.substring(basePath.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) {
+        for (const standard of target.standards) {
+          if (!this.fileMatchesTargetAndScope(
+            normalizedFilePath,
+            target.path,
+            standard.scope
+          )) {
+            continue;
+          }
+          for (const rule of standard.rules) {
+            for (const activeProgram of rule.activeDetectionPrograms) {
+              try {
+                const programLanguage = this.resolveProgrammingLanguage(
+                  activeProgram.language
+                );
+                if (!programLanguage || 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 [language, programs] of programsByLanguage.entries()) {
+            try {
+              const result = await this.executeProgramsForFile({
+                filePath: file.path,
+                fileContent,
+                language,
+                programs
+              });
+              fileViolations.push(...result);
+            } catch (error) {
+              console.error(
+                `Error executing programs for file ${file.path} (${language}): ${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 {
+      violations,
+      summary: {
+        totalFiles: files.length,
+        violatedFiles: violations.length,
+        totalViolations,
+        standardsChecked
+      }
+    };
+  }
+  resolveProgrammingLanguage(language) {
+    try {
+      return stringToProgrammingLanguage(language);
+    } catch {
+      return null;
+    }
+  }
+  async executeProgramsForFile(command3) {
+    const result = await this.services.linterExecutionUseCase.execute(command3);
+    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 decodeJwt(jwt) {
   try {
@@ -1113,7 +1687,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 +1698,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 +1722,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;
@@ -1155,29 +1737,29 @@ var PackmindGateway = class {
           );
         }
         throw new Error(
-          `Failed to pull content: Error: ${err?.message || JSON.stringify(error)}`
+          `Failed to fetch content: Error: ${err?.message || JSON.stringify(error)}`
         );
       }
     };
-    this.listExecutionPrograms = async (params) => {
+    this.listPackages = async () => {
       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
-      };
+      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: "POST",
+          method: "GET",
           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}`;
@@ -1188,10 +1770,12 @@ 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;
+        return result.packages;
       } catch (error) {
         const err = error;
         const code = err?.code || err?.cause?.code;
@@ -1201,22 +1785,68 @@ var PackmindGateway = class {
           );
         }
         throw new Error(
-          `Failed to fetch detection programs: Error: ${err?.message || JSON.stringify(error)}`
+          `Failed to list packages: Error: ${err?.message || JSON.stringify(error)}`
         );
       }
     };
-    this.getDraftDetectionProgramsForRule = async (params) => {
+    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-draft-detection-program`;
+      const url = `${host}/api/v0/list-detection-program`;
       const payload = {
-        standardSlug: params.standardSlug,
-        ruleId: params.ruleId
+        gitRemoteUrl: params.gitRemoteUrl,
+        branches: params.branches
       };
-      if (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();
+        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 {
@@ -1337,6 +1967,101 @@ 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)}`
+        );
+      }
+    };
+    this.getDetectionProgramsForPackages = 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/detection-programs-for-packages`;
+      const payload = {
+        packagesSlugs: params.packagesSlugs
+      };
+      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 for packages: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
   }
 };
 
@@ -3009,11 +3734,11 @@ var LinterAstAdapter = class {
 var TreeSitter17 = __toESM(require("web-tree-sitter"));
 
 // packages/linter-execution/src/application/useCases/ExecuteLinterProgramsUseCase.ts
-var origin3 = "ExecuteLinterProgramsUseCase";
+var origin4 = "ExecuteLinterProgramsUseCase";
 var ExecuteLinterProgramsUseCase = class {
-  constructor(linterAstAdapter = new LinterAstAdapter(), logger = new PackmindLogger(origin3)) {
+  constructor(linterAstAdapter = new LinterAstAdapter(), logger2 = new PackmindLogger(origin4)) {
     this.linterAstAdapter = linterAstAdapter;
-    this.logger = logger;
+    this.logger = logger2;
   }
   async execute(command3) {
     const { filePath, fileContent, language, programs } = command3;
@@ -3206,149 +3931,1340 @@ 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/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 {};
   }
-  async execute(command3) {
-    const baseDirectory = command3.baseDirectory || process.cwd();
-    const result = {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      errors: []
-    };
+}
+
+// packages/node-utils/src/cache/Cache.ts
+var import_ioredis = __toESM(require("ioredis"));
+
+// packages/node-utils/src/config/infra/Infisical/InfisicalConfig.ts
+var import_sdk = require("@infisical/sdk");
+var origin5 = "InfisicalConfig";
+var InfisicalConfig = class {
+  constructor(clientId, clientSecret, env, projectId, logger2 = new PackmindLogger(origin5)) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.env = env;
+    this.projectId = projectId;
+    this.logger = logger2;
+    this.logger.info("Initializing InfisicalConfig", { env, projectId });
     try {
-      const response = await this.packmindGateway.getPullData({});
-      for (const file of response.fileUpdates.createOrUpdate) {
-        try {
-          await this.createOrUpdateFile(
-            baseDirectory,
-            file.path,
-            file.content,
-            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}`);
-        }
-      }
+      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) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      result.errors.push(`Failed to pull data: ${errorMsg}`);
-    }
-    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++;
-    }
-  }
-  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++;
+      this.logger.error("Failed to create InfisicalSDK client", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
   }
-  async fileExists(filePath) {
+  async initClient() {
+    this.logger.info("Initializing Infisical client authentication");
     try {
-      await fs3.access(filePath);
-      return true;
-    } catch {
-      return false;
+      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;
     }
   }
-};
-
-// 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
-      ),
-      pullData: new PullDataUseCase(this.repositories.packmindGateway)
-    };
-  }
-};
-
-// apps/cli/src/PackmindCliHexa.ts
-var origin4 = "PackmindCliHexa";
-var PackmindCliHexa = class {
-  constructor(logger = new PackmindLogger(origin4)) {
-    this.logger = logger;
+  async getValue(secretName) {
+    this.logger.info("Retrieving secret from Infisical", {
+      secretName,
+      env: this.env,
+      projectId: this.projectId
+    });
     try {
-      this.hexa = new PackmindCliHexaFactory(this.logger);
+      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.error("Failed to initialize PackmindCliHexa", {
+      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;
     }
   }
-  /**
-   * Destroys the DeploymentsHexa and cleans up resources
-   */
-  destroy() {
-    this.logger.info("Destroying PackmindCliHexa");
-    this.logger.info("PackmindCliHexa destroyed");
-  }
-  async getGitRemoteUrl(command3) {
-    return this.hexa.useCases.getGitRemoteUrl.execute(command3);
+};
+
+// packages/node-utils/src/config/config/Configuration.ts
+var origin6 = "Configuration";
+var Configuration = class _Configuration {
+  constructor() {
+    this.initialized = false;
+    this.initializationPromise = null;
   }
-  async executeSingleFileAst(command3) {
-    return this.hexa.useCases.executeSingleFileAst.execute(command3);
+  static {
+    this.logger = new PackmindLogger(
+      origin6,
+      "info" /* INFO */
+    );
   }
-  async listFilesInDirectory(command3) {
-    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command3);
+  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 {
+          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) {
+          _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;
+        }
+      }
+    } 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 {
+          const infisicalValue = await instance.infisicalConfig.getValue(key);
+          if (infisicalValue) {
+            _Configuration.logger.debug(
+              "Configuration value found in Infisical",
+              {
+                key
+              }
+            );
+            return infisicalValue;
+          }
+        } catch (error) {
+          _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) {
+      _Configuration.logger.warn("Failed to get configuration value", {
+        key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+};
+
+// packages/node-utils/src/cache/Cache.ts
+var origin7 = "Cache";
+var Cache = class _Cache {
+  constructor() {
+    this.initialized = false;
+    this.connectionConfig = {
+      host: "redis",
+      port: 6379,
+      maxRetriesPerRequest: 3
+    };
+  }
+  static {
+    this.logger = new PackmindLogger(
+      origin7,
+      "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/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 origin8 = "RedisSSEClient";
+var RedisSSEClient = class _RedisSSEClient {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.initialized = false;
+  }
+  static {
+    this.logger = new PackmindLogger(origin8);
+  }
+  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 origin9 = "SSEEventPublisher";
+var SSEEventPublisher = class _SSEEventPublisher {
+  static {
+    this.logger = new PackmindLogger(origin9);
+  }
+  /**
+   * 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;
+}
+
+// apps/cli/src/application/useCases/PullDataUseCase.ts
+var fs4 = __toESM(require("fs/promises"));
+var path4 = __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: [],
+      recipesCount: 0,
+      standardsCount: 0
+    };
+    const response = await this.packmindGateway.getPullData({
+      packagesSlugs: command3.packagesSlugs
+    });
+    const uniqueFilesMap = /* @__PURE__ */ new Map();
+    for (const file of response.fileUpdates.createOrUpdate) {
+      uniqueFilesMap.set(file.path, file);
+    }
+    const uniqueFiles = Array.from(uniqueFilesMap.values());
+    for (const file of uniqueFiles) {
+      if (file.path.includes(".packmind/recipes/") && file.path.endsWith(".md")) {
+        result.recipesCount++;
+      } else if (file.path.includes(".packmind/standards/") && file.path.endsWith(".md")) {
+        result.standardsCount++;
+      }
+    }
+    try {
+      for (const file of uniqueFiles) {
+        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 = path4.join(baseDirectory, file.path);
+    const directory = path4.dirname(fullPath);
+    await fs4.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 fs4.readFile(fullPath, "utf-8");
+      const commentMarker = this.extractCommentMarker(content);
+      let finalContent;
+      if (!commentMarker) {
+        finalContent = content;
+      } else {
+        finalContent = this.mergeContentWithMarkers(
+          existingContent,
+          content,
+          commentMarker
+        );
+      }
+      await fs4.writeFile(fullPath, finalContent, "utf-8");
+      result.filesUpdated++;
+    } else {
+      await fs4.writeFile(fullPath, content, "utf-8");
+      result.filesCreated++;
+    }
+  }
+  async handleSectionsUpdate(fullPath, sections, fileExists, result) {
+    let currentContent = "";
+    if (fileExists) {
+      currentContent = await fs4.readFile(fullPath, "utf-8");
+    }
+    const mergedContent = mergeSectionsIntoFileContent(
+      currentContent,
+      sections
+    );
+    await fs4.writeFile(fullPath, mergedContent, "utf-8");
+    if (fileExists) {
+      result.filesUpdated++;
+    } else {
+      result.filesCreated++;
+    }
+  }
+  async deleteFile(baseDirectory, filePath, result) {
+    const fullPath = path4.join(baseDirectory, filePath);
+    const fileExists = await this.fileExists(fullPath);
+    if (fileExists) {
+      await fs4.unlink(fullPath);
+      result.filesDeleted++;
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await fs4.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/infra/repositories/ConfigFileRepository.ts
+var fs5 = __toESM(require("fs/promises"));
+var path5 = __toESM(require("path"));
+var ConfigFileRepository = class {
+  constructor() {
+    this.CONFIG_FILENAME = "packmind.json";
+    this.EXCLUDED_DIRECTORIES = [
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "coverage",
+      ".nx"
+    ];
+  }
+  async writeConfig(baseDirectory, config) {
+    const configPath = path5.join(baseDirectory, this.CONFIG_FILENAME);
+    const configContent = JSON.stringify(config, null, 2) + "\n";
+    await fs5.writeFile(configPath, configContent, "utf-8");
+  }
+  async readConfig(baseDirectory) {
+    const configPath = path5.join(baseDirectory, this.CONFIG_FILENAME);
+    try {
+      const configContent = await fs5.readFile(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      if (!config.packages || typeof config.packages !== "object") {
+        throw new Error(
+          "Invalid packmind.json structure. Expected { packages: { ... } }"
+        );
+      }
+      return config;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw new Error(
+        `Failed to read packmind.json: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Recursively finds all directories containing packmind.json in descendant folders.
+   * Excludes common build/dependency directories (node_modules, .git, dist, etc.)
+   *
+   * @param directory - The root directory to search from
+   * @returns Array of directory paths that contain a packmind.json file
+   */
+  async findDescendantConfigs(directory) {
+    const normalizedDir = path5.resolve(directory);
+    const results = [];
+    const searchRecursively = async (currentDir) => {
+      let entries;
+      try {
+        entries = await fs5.readdir(currentDir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        if (this.EXCLUDED_DIRECTORIES.includes(entry.name)) {
+          continue;
+        }
+        const entryPath = path5.join(currentDir, entry.name);
+        const config = await this.readConfig(entryPath);
+        if (config) {
+          results.push(entryPath);
+        }
+        await searchRecursively(entryPath);
+      }
+    };
+    await searchRecursively(normalizedDir);
+    return results;
+  }
+  /**
+   * Reads all packmind.json files from startDirectory up to stopDirectory (inclusive)
+   * and merges their package configurations.
+   *
+   * @param startDirectory - Directory to start searching from (typically the lint target)
+   * @param stopDirectory - Directory to stop searching at (typically git repo root), or null to walk to filesystem root
+   * @returns Merged configuration from all found packmind.json files
+   */
+  async readHierarchicalConfig(startDirectory, stopDirectory) {
+    const configs = [];
+    const configPaths = [];
+    const normalizedStart = path5.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path5.resolve(stopDirectory) : null;
+    let currentDir = normalizedStart;
+    while (true) {
+      const config = await this.readConfig(currentDir);
+      if (config) {
+        configs.push(config);
+        configPaths.push(path5.join(currentDir, this.CONFIG_FILENAME));
+      }
+      if (normalizedStop !== null && currentDir === normalizedStop) {
+        break;
+      }
+      const parentDir = path5.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+    const mergedPackages = {};
+    for (const config of configs) {
+      for (const [slug, version] of Object.entries(config.packages)) {
+        if (!(slug in mergedPackages)) {
+          mergedPackages[slug] = version;
+        }
+      }
+    }
+    return {
+      packages: mergedPackages,
+      configPaths,
+      hasConfigs: configs.length > 0
+    };
+  }
+};
+
+// apps/cli/src/PackmindCliHexaFactory.ts
+var PackmindCliHexaFactory = class {
+  constructor(logger2) {
+    this.logger = logger2;
+    this.repositories = {
+      packmindGateway: new PackmindGateway(
+        process.env.PACKMIND_API_KEY_V3 || ""
+      ),
+      configFileRepository: new ConfigFileRepository()
+    };
+    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
+      ),
+      lintFilesLocally: new LintFilesLocallyUseCase(
+        this.services,
+        this.repositories,
+        this.logger
+      ),
+      pullData: new PullDataUseCase(this.repositories.packmindGateway),
+      listPackages: new ListPackagesUseCase(this.repositories.packmindGateway),
+      getPackageBySlug: new GetPackageSummaryUseCase(
+        this.repositories.packmindGateway
+      )
+    };
+  }
+};
+
+// apps/cli/src/PackmindCliHexa.ts
+var origin10 = "PackmindCliHexa";
+var PackmindCliHexa = class {
+  constructor(logger2 = new PackmindLogger(origin10)) {
+    this.logger = logger2;
+    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(command3) {
+    return this.hexa.useCases.getGitRemoteUrl.execute(command3);
+  }
+  async executeSingleFileAst(command3) {
+    return this.hexa.useCases.executeSingleFileAst.execute(command3);
+  }
+  async listFilesInDirectory(command3) {
+    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command3);
   }
   async lintFilesInDirectory(command3) {
     return this.hexa.useCases.lintFilesInDirectory.execute(command3);
   }
+  async lintFilesLocally(command3) {
+    return this.hexa.useCases.lintFilesLocally.execute(command3);
+  }
   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);
+  }
+  async writeConfig(baseDirectory, packagesSlugs) {
+    const config = {
+      packages: packagesSlugs.reduce(
+        (acc, slug) => {
+          acc[slug] = "*";
+          return acc;
+        },
+        {}
+      )
+    };
+    await this.hexa.repositories.configFileRepository.writeConfig(
+      baseDirectory,
+      config
+    );
+  }
+  async readConfig(baseDirectory) {
+    const config = await this.hexa.repositories.configFileRepository.readConfig(
+      baseDirectory
+    );
+    if (!config) return [];
+    const hasNonWildcardVersions = Object.values(config.packages).some(
+      (version) => version !== "*"
+    );
+    if (hasNonWildcardVersions) {
+      console.log(
+        "WARN: Package versions are not supported yet, getting the latest version"
+      );
+    }
+    return Object.keys(config.packages);
+  }
+  async readHierarchicalConfig(startDirectory, stopDirectory) {
+    return this.hexa.repositories.configFileRepository.readHierarchicalConfig(
+      startDirectory,
+      stopDirectory
+    );
+  }
+  async findDescendantConfigs(directory) {
+    return this.hexa.repositories.configFileRepository.findDescendantConfigs(
+      directory
+    );
+  }
+  async getGitRepositoryRoot(directory) {
+    return this.hexa.services.gitRemoteUrlService.getGitRepositoryRoot(
+      directory
+    );
+  }
+  async tryGetGitRepositoryRoot(directory) {
+    return this.hexa.services.gitRemoteUrlService.tryGetGitRepositoryRoot(
+      directory
+    );
+  }
 };
 
 // apps/cli/src/infra/repositories/IDELintLogger.ts
@@ -3403,6 +5319,7 @@ var HumanReadableLogger = class {
 };
 
 // apps/cli/src/infra/commands/LinterCommand.ts
+var pathModule = __toESM(require("path"));
 var Logger = {
   from: async (input) => {
     switch (input) {
@@ -3465,7 +5382,7 @@ var lintCommand = (0, import_cmd_ts.command)({
       description: "Enable debug logging"
     })
   },
-  handler: async ({ path: path5, draft, rule, debug, language, logger }) => {
+  handler: async ({ path: path7, draft, rule, debug, language, logger: logger2 }) => {
     if (draft && !rule) {
       throw new Error("option --rule is required to use --draft mode");
     }
@@ -3475,14 +5392,53 @@ var lintCommand = (0, import_cmd_ts.command)({
       debug ? "debug" /* DEBUG */ : "info" /* INFO */
     );
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
-    const { violations } = await packmindCliHexa.lintFilesInDirectory({
-      path: path5 ?? ".",
-      draftMode: draft,
-      standardSlug: rule?.standardSlug,
-      ruleId: rule?.ruleId,
-      language
-    });
-    (logger === "ide" /* ide */ ? new IDELintLogger() : new HumanReadableLogger()).logViolations(violations);
+    const targetPath = path7 ?? ".";
+    const hasArguments = !!(draft || rule || language);
+    const absolutePath = pathModule.isAbsolute(targetPath) ? targetPath : pathModule.resolve(process.cwd(), targetPath);
+    let useLocalLinting = false;
+    let lintTargets = [];
+    if (!hasArguments) {
+      const stopDirectory = await packmindCliHexa.tryGetGitRepositoryRoot(absolutePath);
+      const hierarchicalConfig = await packmindCliHexa.readHierarchicalConfig(
+        absolutePath,
+        stopDirectory
+      );
+      if (hierarchicalConfig.hasConfigs) {
+        useLocalLinting = true;
+        const rootConfig = await packmindCliHexa.readHierarchicalConfig(
+          absolutePath,
+          absolutePath
+        );
+        if (rootConfig.hasConfigs) {
+          lintTargets.push(absolutePath);
+        }
+        const descendantTargets = await packmindCliHexa.findDescendantConfigs(absolutePath);
+        lintTargets = [...lintTargets, ...descendantTargets];
+        if (lintTargets.length === 0) {
+          lintTargets.push(absolutePath);
+        }
+      }
+    }
+    let violations = [];
+    if (useLocalLinting && lintTargets.length > 0) {
+      for (const target of lintTargets) {
+        packmindLogger.debug(`Linting target: ${target}`);
+        const result = await packmindCliHexa.lintFilesLocally({
+          path: target
+        });
+        violations = [...violations, ...result.violations];
+      }
+    } else {
+      const result = await packmindCliHexa.lintFilesInDirectory({
+        path: targetPath,
+        draftMode: draft,
+        standardSlug: rule?.standardSlug,
+        ruleId: rule?.ruleId,
+        language
+      });
+      violations = result.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) {
@@ -3549,27 +5505,158 @@ function extractWasmFiles() {
 
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/PullCommand.ts
 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.name} (${pkg.slug})`);
+          if (pkg.description) {
+            console.log(`  ${pkg.description}`);
+            console.log("");
+          }
+        });
+        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);
+      }
+    }
+    let configPackages;
+    let configExists = false;
     try {
+      configPackages = await packmindCliHexa.readConfig(process.cwd());
+      configExists = configPackages.length > 0;
+    } catch (error) {
+      console.error("ERROR Failed to parse packmind.json");
+      if (error instanceof Error) {
+        console.error(`ERROR ${error.message}`);
+      } else {
+        console.error(`ERROR ${String(error)}`);
+      }
+      console.error(
+        "\n\u{1F4A1} Please fix the packmind.json file or delete it to continue."
+      );
+      process.exit(1);
+    }
+    const allPackages = [.../* @__PURE__ */ new Set([...configPackages, ...packagesSlugs])];
+    if (allPackages.length === 0) {
+      console.log("WARN config packmind.json not found");
+      console.log(
+        "Usage: packmind-cli install <package-slug> [package-slug...]"
+      );
+      console.log("       packmind-cli install --list");
+      console.log("");
+      console.log("Examples:");
+      console.log("  packmind-cli install backend");
+      console.log("  packmind-cli install backend frontend");
+      console.log("  packmind-cli install --list  # Show available packages");
+      console.log("");
+      console.log("Install recipes and standards from the specified packages.");
+      process.exit(0);
+    }
+    if (!configExists && packagesSlugs.length > 0) {
+      console.log("INFO initializing packmind.json");
+    }
+    try {
+      const packageCount = allPackages.length;
+      const packageWord = packageCount === 1 ? "package" : "packages";
+      console.log(
+        `Fetching ${packageCount} ${packageWord}: ${allPackages.join(", ")}...`
+      );
       const result = await packmindCliHexa.pullData({
-        baseDirectory: process.cwd()
+        baseDirectory: process.cwd(),
+        packagesSlugs: allPackages
       });
-      console.log("\n\u2705 Pull completed successfully!");
-      console.log(`   Files created: ${result.filesCreated}`);
-      console.log(`   Files updated: ${result.filesUpdated}`);
-      console.log(`   Files deleted: ${result.filesDeleted}`);
+      console.log(
+        `Installing ${result.recipesCount} recipes and ${result.standardsCount} standards...`
+      );
+      console.log(
+        `
+added ${result.filesCreated} files, changed ${result.filesUpdated} files, removed ${result.filesDeleted} files`
+      );
       if (result.errors.length > 0) {
         console.log("\n\u26A0\uFE0F  Errors encountered:");
         result.errors.forEach((error) => {
@@ -3577,41 +5664,102 @@ var pullCommand = (0, import_cmd_ts2.command)({
         });
         process.exit(1);
       }
+      await packmindCliHexa.writeConfig(process.cwd(), allPackages);
     } catch (error) {
-      console.error("\n\u274C Failed to pull content:");
-      console.error(
-        `   ${error instanceof Error ? error.message : String(error)}`
-      );
+      console.error("\n\u274C Failed to install content:");
+      if (error instanceof Error) {
+        const errorObj = error;
+        if (errorObj.statusCode === 404) {
+          console.error(`   ${errorObj.message}`);
+          if (configExists && configPackages.length > 0) {
+            const missingPackages = allPackages.filter(
+              (pkg) => configPackages.includes(pkg)
+            );
+            if (missingPackages.length > 0) {
+              console.error(
+                "\n\u{1F4A1} Either remove the following package(s) from packmind.json:"
+              );
+              missingPackages.forEach((pkg) => {
+                console.error(`     "${pkg}"`);
+              });
+              console.error("   Or ensure that:");
+              console.error(
+                "     - The package slug exists and is correctly spelled"
+              );
+              console.error("     - The package exists in your organization");
+              console.error("     - You have the correct API key configured");
+            } else {
+              console.error("\n\u{1F4A1} Troubleshooting tips:");
+              console.error(
+                "   - Check if the package slug exists and is correctly spelled"
+              );
+              console.error(
+                "   - Check that the package exists in your organization"
+              );
+              console.error(
+                "   - Ensure you have the correct API key configured"
+              );
+            }
+          } else {
+            console.error("\n\u{1F4A1} Troubleshooting tips:");
+            console.error(
+              "   - Check if the package slug exists and is correctly spelled"
+            );
+            console.error(
+              "   - Check that the package exists in your organization"
+            );
+            console.error(
+              "   - Ensure you have the correct API key configured"
+            );
+          }
+        } 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;
   let gitRootFound = false;
   let searchDir = currentDir;
-  while (searchDir !== path4.parse(searchDir).root) {
-    if (fs4.existsSync(path4.join(searchDir, ".git"))) {
+  while (searchDir !== path6.parse(searchDir).root) {
+    if (fs6.existsSync(path6.join(searchDir, ".git"))) {
       gitRootFound = true;
       break;
     }
-    searchDir = path4.dirname(searchDir);
+    searchDir = path6.dirname(searchDir);
   }
-  while (currentDir !== path4.parse(currentDir).root) {
-    const envPath2 = path4.join(currentDir, ".env");
-    if (fs4.existsSync(envPath2)) {
+  while (currentDir !== path6.parse(currentDir).root) {
+    const envPath2 = path6.join(currentDir, ".env");
+    if (fs6.existsSync(envPath2)) {
       return envPath2;
     }
-    if (gitRootFound && fs4.existsSync(path4.join(currentDir, ".git"))) {
+    if (gitRootFound && fs6.existsSync(path6.join(currentDir, ".git"))) {
       break;
     }
     if (!gitRootFound && currentDir !== startDir) {
       break;
     }
-    currentDir = path4.dirname(currentDir);
+    currentDir = path6.dirname(currentDir);
   }
   return null;
 }
@@ -3626,15 +5774,21 @@ 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",
   cmds: {
     lint: lintCommand,
-    pull: pullCommand
+    pull: pullCommand,
+    install: 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);
 });