@packmind/cli 0.4.0 → 0.5.0

package/main.cjs

@@ -38,7 +38,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.4.0",
+      version: "0.5.0",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -259,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 */]: {
@@ -458,6 +458,262 @@ 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 {
@@ -543,27 +799,34 @@ var GitService = class {
   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", {
@@ -581,7 +844,7 @@ ${error.message}`
       throw new Error("Failed to get Git branches: Unknown error");
     }
   }
-  async getGitRemoteUrl(repoPath, origin10) {
+  async getGitRemoteUrl(repoPath, origin11) {
     try {
       const { stdout } = await execAsync("git remote -v", {
         cwd: repoPath
@@ -591,10 +854,10 @@ ${error.message}`
         throw new Error("No Git remotes found in the repository");
       }
       let selectedRemote;
-      if (origin10) {
-        const foundRemote = remotes.find((remote) => remote.name === origin10);
+      if (origin11) {
+        const foundRemote = remotes.find((remote) => remote.name === origin11);
         if (!foundRemote) {
-          throw new Error(`Remote '${origin10}' not found in repository`);
+          throw new Error(`Remote '${origin11}' not found in repository`);
         }
         selectedRemote = foundRemote.url;
       } else if (remotes.length === 1) {
@@ -664,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;
@@ -684,8 +947,8 @@ var GetGitRemoteUrlUseCase = class {
     this.gitRemoteUrlService = gitRemoteUrlService;
   }
   async execute(command3) {
-    const { path: repoPath, origin: origin10 } = command3;
-    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin10);
+    const { path: repoPath, origin: origin11 } = command3;
+    return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin11);
   }
 };
 
@@ -1150,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 {
@@ -1256,7 +1737,7 @@ 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)}`
         );
       }
     };
@@ -1536,6 +2017,51 @@ var PackmindGateway = class {
         );
       }
     };
+    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)}`
+        );
+      }
+    };
   }
 };
 
@@ -3208,9 +3734,9 @@ 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(), logger2 = new PackmindLogger(origin3)) {
+  constructor(linterAstAdapter = new LinterAstAdapter(), logger2 = new PackmindLogger(origin4)) {
     this.linterAstAdapter = linterAstAdapter;
     this.logger = logger2;
   }
@@ -3405,14 +3931,30 @@ var ExecuteLinterProgramsUseCase = class {
   }
 };
 
-// packages/node-utils/src/ai/prompts/OpenAIService.ts
-var import_openai = __toESM(require("openai"));
+// 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 {};
+  }
+}
+
+// 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 origin4 = "InfisicalConfig";
+var origin5 = "InfisicalConfig";
 var InfisicalConfig = class {
-  constructor(clientId, clientSecret, env, projectId, logger2 = new PackmindLogger(origin4)) {
+  constructor(clientId, clientSecret, env, projectId, logger2 = new PackmindLogger(origin5)) {
     this.clientId = clientId;
     this.clientSecret = clientSecret;
     this.env = env;
@@ -3487,7 +4029,7 @@ var InfisicalConfig = class {
 };
 
 // packages/node-utils/src/config/config/Configuration.ts
-var origin5 = "Configuration";
+var origin6 = "Configuration";
 var Configuration = class _Configuration {
   constructor() {
     this.initialized = false;
@@ -3495,7 +4037,7 @@ var Configuration = class _Configuration {
   }
   static {
     this.logger = new PackmindLogger(
-      origin5,
+      origin6,
       "info" /* INFO */
     );
   }
@@ -3642,8 +4184,7 @@ var Configuration = class _Configuration {
 };
 
 // packages/node-utils/src/cache/Cache.ts
-var import_ioredis = __toESM(require("ioredis"));
-var origin6 = "Cache";
+var origin7 = "Cache";
 var Cache = class _Cache {
   constructor() {
     this.initialized = false;
@@ -3655,7 +4196,7 @@ var Cache = class _Cache {
   }
   static {
     this.logger = new PackmindLogger(
-      origin6,
+      origin7,
       "info" /* INFO */
     );
   }
@@ -3837,14 +4378,14 @@ var import_common2 = require("@nestjs/common");
 
 // packages/node-utils/src/sse/RedisSSEClient.ts
 var import_ioredis2 = __toESM(require("ioredis"));
-var origin7 = "RedisSSEClient";
+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(origin7);
+    this.logger = new PackmindLogger(origin8);
   }
   static getInstance() {
     _RedisSSEClient.logger.debug("Getting RedisSSEClient instance");
@@ -4028,10 +4569,10 @@ function serializeSSERedisMessage(message) {
 }
 
 // packages/node-utils/src/sse/SSEEventPublisher.ts
-var origin8 = "SSEEventPublisher";
+var origin9 = "SSEEventPublisher";
 var SSEEventPublisher = class _SSEEventPublisher {
   static {
-    this.logger = new PackmindLogger(origin8);
+    this.logger = new PackmindLogger(origin9);
   }
   /**
    * Get the singleton instance
@@ -4270,25 +4811,9 @@ ${sectionBlock}
   return result;
 }
 
-// packages/node-utils/src/dataSources/local.ts
-var import_typeorm = require("typeorm");
-var dataSource = makeDatasource();
-function makeDatasource() {
-  try {
-    return new import_typeorm.DataSource({
-      type: "postgres",
-      url: process.env["DATABASE_URL"],
-      entities: [],
-      migrations: []
-    });
-  } catch {
-    return {};
-  }
-}
-
 // apps/cli/src/application/useCases/PullDataUseCase.ts
-var fs3 = __toESM(require("fs/promises"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
 var PullDataUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
@@ -4299,13 +4824,27 @@ var PullDataUseCase = class {
       filesCreated: 0,
       filesUpdated: 0,
       filesDeleted: 0,
-      errors: []
+      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 response.fileUpdates.createOrUpdate) {
+      for (const file of uniqueFiles) {
         try {
           await this.createOrUpdateFile(baseDirectory, file, result);
         } catch (error) {
@@ -4330,9 +4869,9 @@ var PullDataUseCase = class {
     return result;
   }
   async createOrUpdateFile(baseDirectory, file, result) {
-    const fullPath = path3.join(baseDirectory, file.path);
-    const directory = path3.dirname(fullPath);
-    await fs3.mkdir(directory, { recursive: true });
+    const 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(
@@ -4352,7 +4891,7 @@ var PullDataUseCase = class {
   }
   async handleFullContentUpdate(fullPath, content, fileExists, result) {
     if (fileExists) {
-      const existingContent = await fs3.readFile(fullPath, "utf-8");
+      const existingContent = await fs4.readFile(fullPath, "utf-8");
       const commentMarker = this.extractCommentMarker(content);
       let finalContent;
       if (!commentMarker) {
@@ -4364,23 +4903,23 @@ var PullDataUseCase = class {
           commentMarker
         );
       }
-      await fs3.writeFile(fullPath, finalContent, "utf-8");
+      await fs4.writeFile(fullPath, finalContent, "utf-8");
       result.filesUpdated++;
     } else {
-      await fs3.writeFile(fullPath, content, "utf-8");
+      await fs4.writeFile(fullPath, content, "utf-8");
       result.filesCreated++;
     }
   }
   async handleSectionsUpdate(fullPath, sections, fileExists, result) {
     let currentContent = "";
     if (fileExists) {
-      currentContent = await fs3.readFile(fullPath, "utf-8");
+      currentContent = await fs4.readFile(fullPath, "utf-8");
     }
     const mergedContent = mergeSectionsIntoFileContent(
       currentContent,
       sections
     );
-    await fs3.writeFile(fullPath, mergedContent, "utf-8");
+    await fs4.writeFile(fullPath, mergedContent, "utf-8");
     if (fileExists) {
       result.filesUpdated++;
     } else {
@@ -4388,16 +4927,16 @@ var PullDataUseCase = class {
     }
   }
   async deleteFile(baseDirectory, filePath, result) {
-    const fullPath = path3.join(baseDirectory, filePath);
+    const fullPath = path4.join(baseDirectory, filePath);
     const fileExists = await this.fileExists(fullPath);
     if (fileExists) {
-      await fs3.unlink(fullPath);
+      await fs4.unlink(fullPath);
       result.filesDeleted++;
     }
   }
   async fileExists(filePath) {
     try {
-      await fs3.access(filePath);
+      await fs4.access(filePath);
       return true;
     } catch {
       return false;
@@ -4470,6 +5009,126 @@ var GetPackageSummaryUseCase = class {
   }
 };
 
+// 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) {
@@ -4477,7 +5136,8 @@ var PackmindCliHexaFactory = class {
     this.repositories = {
       packmindGateway: new PackmindGateway(
         process.env.PACKMIND_API_KEY_V3 || ""
-      )
+      ),
+      configFileRepository: new ConfigFileRepository()
     };
     this.services = {
       listFiles: new ListFiles(),
@@ -4495,6 +5155,11 @@ var PackmindCliHexaFactory = class {
         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(
@@ -4505,9 +5170,9 @@ var PackmindCliHexaFactory = class {
 };
 
 // apps/cli/src/PackmindCliHexa.ts
-var origin9 = "PackmindCliHexa";
+var origin10 = "PackmindCliHexa";
 var PackmindCliHexa = class {
-  constructor(logger2 = new PackmindLogger(origin9)) {
+  constructor(logger2 = new PackmindLogger(origin10)) {
     this.logger = logger2;
     try {
       this.hexa = new PackmindCliHexaFactory(this.logger);
@@ -4537,6 +5202,9 @@ var PackmindCliHexa = class {
   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);
   }
@@ -4546,6 +5214,57 @@ var PackmindCliHexa = class {
   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
@@ -4600,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) {
@@ -4662,7 +5382,7 @@ var lintCommand = (0, import_cmd_ts.command)({
       description: "Enable debug logging"
     })
   },
-  handler: async ({ path: path5, draft, rule, debug, language, logger: logger2 }) => {
+  handler: async ({ path: path7, draft, rule, debug, language, logger: logger2 }) => {
     if (draft && !rule) {
       throw new Error("option --rule is required to use --draft mode");
     }
@@ -4672,13 +5392,52 @@ 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
-    });
+    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`);
@@ -4746,8 +5505,8 @@ 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");
@@ -4784,7 +5543,11 @@ var pullCommand = (0, import_cmd_ts2.command)({
         }
         console.log("Available packages:");
         packages.forEach((pkg) => {
-          console.log(`  - ${pkg.slug}: ${pkg.description || pkg.name}`);
+          console.log(`- ${pkg.name} (${pkg.slug})`);
+          if (pkg.description) {
+            console.log(`  ${pkg.description}`);
+            console.log("");
+          }
         });
         process.exit(0);
       } catch (error) {
@@ -4841,30 +5604,59 @@ var pullCommand = (0, import_cmd_ts2.command)({
         process.exit(1);
       }
     }
-    if (packagesSlugs.length === 0) {
-      console.log("Usage: packmind-cli pull <package-slug> [package-slug...]");
-      console.log("       packmind-cli pull --list");
+    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 pull backend");
-      console.log("  packmind-cli pull backend frontend");
-      console.log("  packmind-cli pull --list  # Show available packages");
+      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("Pull recipes and standards from the specified packages.");
+      console.log("Install recipes and standards from the specified packages.");
       process.exit(0);
     }
-    console.log(
-      `Pulling content from packages: ${packagesSlugs.join(", ")}...`
-    );
+    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(),
-        packagesSlugs
+        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) => {
@@ -4872,15 +5664,54 @@ 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("\n\u274C Failed to install content:");
       if (error instanceof Error) {
         const errorObj = error;
         if (errorObj.statusCode === 404) {
           console.error(`   ${errorObj.message}`);
-          console.error(
-            "\n\u{1F4A1} Use `packmind-cli pull --list` to show available packages"
-          );
+          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;
@@ -4910,25 +5741,25 @@ function findEnvFile() {
   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;
 }
@@ -4953,7 +5784,8 @@ var app = (0, import_cmd_ts3.subcommands)({
   description: "Packmind CLI tool",
   cmds: {
     lint: lintCommand,
-    pull: pullCommand
+    pull: pullCommand,
+    install: pullCommand
   }
 });
 (0, import_cmd_ts3.run)(app, args).catch((error) => {