@packmind/cli 0.4.0 → 0.6.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.6.0",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -76,7 +76,6 @@ var require_package = __commonJS({
 });
 
 // apps/cli/src/main.ts
-var import_chalk2 = __toESM(require("chalk"));
 var import_cmd_ts3 = require("cmd-ts");
 
 // apps/cli/src/infra/commands/LinterCommand.ts
@@ -258,39 +257,64 @@ var createRuleId = brandedIdFactory();
 // packages/types/src/standards/RuleExampleId.ts
 var createRuleExampleId = brandedIdFactory();
 
+// packages/types/src/events/PackmindEvent.ts
+var PackmindEvent = class {
+  constructor(payload) {
+    this.payload = payload;
+  }
+  /**
+   * Get the event name from the static property.
+   * Used internally by the event emitter.
+   */
+  get name() {
+    return this.constructor.eventName;
+  }
+};
+
+// packages/types/src/events/UserEvent.ts
+var UserEvent = class extends PackmindEvent {
+};
+
+// packages/types/src/standards/events/StandardUpdatedEvent.ts
+var StandardUpdatedEvent = class extends UserEvent {
+  static {
+    this.eventName = "standards.standard.updated";
+  }
+};
+
 // 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 +482,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 {
@@ -537,33 +817,53 @@ var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
 // apps/cli/src/application/services/GitService.ts
 var import_child_process = require("child_process");
 var import_util = require("util");
+var path = __toESM(require("path"));
 var execAsync = (0, import_util.promisify)(import_child_process.exec);
 var origin = "GitService";
 var GitService = class {
   constructor(logger2 = new PackmindLogger(origin)) {
     this.logger = logger2;
   }
-  async getGitRepositoryRoot(path5) {
+  async getGitRepositoryRoot(path8) {
     try {
       const { stdout } = await execAsync("git rev-parse --show-toplevel", {
-        cwd: path5
+        cwd: path8
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path5,
+        inputPath: path8,
         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 '${path8}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
+  async tryGetGitRepositoryRoot(path8) {
+    try {
+      return await this.getGitRepositoryRoot(path8);
+    } catch {
+      return null;
+    }
+  }
+  getGitRepositoryRootSync(cwd) {
+    try {
+      const result = (0, import_child_process.execSync)("git rev-parse --show-toplevel", {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        encoding: "utf-8"
+      });
+      return result.trim();
+    } catch {
+      return null;
+    }
+  }
   async getCurrentBranches(repoPath) {
     try {
       const { stdout } = await execAsync("git branch -a --contains HEAD", {
@@ -581,7 +881,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 +891,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,18 +964,181 @@ ${error.message}`
   normalizeGitUrl(url) {
     const sshMatch = url.match(/^git@([^:]+):(.+)$/);
     if (sshMatch) {
-      const [, host, path5] = sshMatch;
-      const cleanPath = path5.replace(/\.git$/, "");
+      const [, host, urlPath] = sshMatch;
+      const cleanPath = urlPath.replace(/\.git$/, "");
       return `${host}/${cleanPath}`;
     }
     const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+)$/);
     if (httpsMatch) {
-      const [, host, path5] = httpsMatch;
-      const cleanPath = path5.replace(/\.git$/, "");
+      const [, host, urlPath] = httpsMatch;
+      const cleanPath = urlPath.replace(/\.git$/, "");
       return `${host}/${cleanPath}`;
     }
     return url;
   }
+  /**
+   * Gets files that have been modified (staged + unstaged) compared to HEAD.
+   * Returns absolute file paths.
+   */
+  async getModifiedFiles(repoPath) {
+    const gitRoot = await this.getGitRepositoryRoot(repoPath);
+    const trackedFiles = await this.getTrackedModifiedFiles(gitRoot);
+    const untrackedFiles = await this.getUntrackedFiles(gitRoot);
+    const allFiles = [.../* @__PURE__ */ new Set([...trackedFiles, ...untrackedFiles])];
+    this.logger.debug("Found modified files", {
+      trackedCount: trackedFiles.length,
+      untrackedCount: untrackedFiles.length,
+      totalCount: allFiles.length
+    });
+    return allFiles;
+  }
+  /**
+   * Gets tracked files that have been modified (staged + unstaged) compared to HEAD.
+   * Returns absolute file paths.
+   */
+  async getTrackedModifiedFiles(gitRoot) {
+    try {
+      const { stdout } = await execAsync("git diff --name-only HEAD", {
+        cwd: gitRoot
+      });
+      return stdout.trim().split("\n").filter((line) => line.length > 0).map((relativePath) => path.join(gitRoot, relativePath));
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("unknown revision")) {
+        this.logger.debug(
+          "HEAD does not exist (first commit), getting staged files only"
+        );
+        return this.getStagedFilesWithoutHead(gitRoot);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets staged files when HEAD doesn't exist (first commit scenario).
+   */
+  async getStagedFilesWithoutHead(gitRoot) {
+    const { stdout } = await execAsync("git diff --cached --name-only", {
+      cwd: gitRoot
+    });
+    return stdout.trim().split("\n").filter((line) => line.length > 0).map((relativePath) => path.join(gitRoot, relativePath));
+  }
+  /**
+   * Gets untracked files (new files not yet added to git).
+   * Returns absolute file paths.
+   */
+  async getUntrackedFiles(repoPath) {
+    const gitRoot = await this.getGitRepositoryRoot(repoPath);
+    const { stdout } = await execAsync(
+      "git ls-files --others --exclude-standard",
+      {
+        cwd: gitRoot
+      }
+    );
+    return stdout.trim().split("\n").filter((line) => line.length > 0).map((relativePath) => path.join(gitRoot, relativePath));
+  }
+  /**
+   * Gets line-level diff information for modified files.
+   * For untracked files, all lines are considered modified (new file).
+   * Returns ModifiedLine objects with absolute file paths.
+   */
+  async getModifiedLines(repoPath) {
+    const gitRoot = await this.getGitRepositoryRoot(repoPath);
+    const modifiedLines = [];
+    const trackedModifications = await this.getTrackedModifiedLines(gitRoot);
+    modifiedLines.push(...trackedModifications);
+    const untrackedFiles = await this.getUntrackedFiles(gitRoot);
+    for (const filePath of untrackedFiles) {
+      const lineCount = await this.countFileLines(filePath);
+      if (lineCount > 0) {
+        modifiedLines.push({
+          file: filePath,
+          startLine: 1,
+          lineCount
+        });
+      }
+    }
+    this.logger.debug("Found modified lines", {
+      trackedEntries: trackedModifications.length,
+      untrackedFiles: untrackedFiles.length,
+      totalEntries: modifiedLines.length
+    });
+    return modifiedLines;
+  }
+  /**
+   * Parses git diff output to extract line-level modifications.
+   */
+  async getTrackedModifiedLines(gitRoot) {
+    try {
+      const { stdout } = await execAsync("git diff HEAD --unified=0", {
+        cwd: gitRoot,
+        maxBuffer: 50 * 1024 * 1024
+        // 50MB buffer for large diffs
+      });
+      return this.parseDiffOutput(stdout, gitRoot);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("unknown revision")) {
+        this.logger.debug(
+          "HEAD does not exist (first commit), getting staged diff only"
+        );
+        return this.getStagedModifiedLinesWithoutHead(gitRoot);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets modified lines from staged files when HEAD doesn't exist.
+   */
+  async getStagedModifiedLinesWithoutHead(gitRoot) {
+    const { stdout } = await execAsync("git diff --cached --unified=0", {
+      cwd: gitRoot,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    return this.parseDiffOutput(stdout, gitRoot);
+  }
+  /**
+   * Parses unified diff output to extract modified line ranges.
+   * Format: @@ -oldStart,oldCount +newStart,newCount @@
+   */
+  parseDiffOutput(diffOutput, gitRoot) {
+    const modifiedLines = [];
+    const lines = diffOutput.split("\n");
+    let currentFile = null;
+    for (const line of lines) {
+      const fileMatch = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+      if (fileMatch) {
+        currentFile = path.join(gitRoot, fileMatch[2]);
+        continue;
+      }
+      const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+      if (hunkMatch && currentFile) {
+        const startLine = parseInt(hunkMatch[1], 10);
+        const lineCount = hunkMatch[2] ? parseInt(hunkMatch[2], 10) : 1;
+        if (lineCount > 0) {
+          modifiedLines.push({
+            file: currentFile,
+            startLine,
+            lineCount
+          });
+        }
+      }
+    }
+    return modifiedLines;
+  }
+  /**
+   * Counts the number of lines in a file.
+   */
+  async countFileLines(filePath) {
+    try {
+      const { stdout } = await execAsync(`wc -l < "${filePath}"`);
+      const count = parseInt(stdout.trim(), 10);
+      if (count === 0) {
+        const { stdout: content } = await execAsync(`head -c 1 "${filePath}"`);
+        return content.length > 0 ? 1 : 0;
+      }
+      return count;
+    } catch {
+      return 0;
+    }
+  }
 };
 
 // apps/cli/src/application/useCases/GetGitRemoteUrlUseCase.ts
@@ -684,14 +1147,14 @@ 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);
   }
 };
 
 // apps/cli/src/application/services/ListFiles.ts
 var fs = __toESM(require("fs/promises"));
-var path = __toESM(require("path"));
+var path2 = __toESM(require("path"));
 var ListFiles = class {
   async listFilesInDirectory(directoryPath, extensions, excludes = [], skipHidden = true) {
     const results = [];
@@ -713,7 +1176,7 @@ var ListFiles = class {
     try {
       const entries = await fs.readdir(directoryPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path.join(directoryPath, entry.name);
+        const fullPath = path2.join(directoryPath, entry.name);
         if (this.shouldExcludePath(fullPath, excludes)) {
           continue;
         }
@@ -730,7 +1193,7 @@ var ListFiles = class {
             skipHidden
           );
         } else if (entry.isFile()) {
-          const fileExtension = path.extname(entry.name);
+          const fileExtension = path2.extname(entry.name);
           if (includeAllExtensions || extensions.includes(fileExtension)) {
             results.push({
               path: fullPath
@@ -746,7 +1209,7 @@ var ListFiles = class {
     if (excludes.length === 0) {
       return false;
     }
-    const normalizedPath = path.normalize(filePath).replace(/\\/g, "/");
+    const normalizedPath = path2.normalize(filePath).replace(/\\/g, "/");
     for (const exclude of excludes) {
       if (this.matchesGlobPattern(normalizedPath, exclude)) {
         return true;
@@ -809,7 +1272,7 @@ var ListFilesInDirectoryUseCase = class {
 
 // apps/cli/src/application/useCases/LintFilesInDirectoryUseCase.ts
 var import_minimatch = require("minimatch");
-var path2 = __toESM(require("path"));
+var path3 = __toESM(require("path"));
 var fs2 = __toESM(require("fs/promises"));
 var origin2 = "LintFilesInDirectoryUseCase";
 var LintFilesInDirectoryUseCase = class {
@@ -876,12 +1339,13 @@ var LintFilesInDirectoryUseCase = class {
       draftMode,
       standardSlug,
       ruleId,
-      language
+      language,
+      diffMode
     } = command3;
     this.logger.debug(
-      `Starting linting: path="${userPath}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}"`
+      `Starting linting: path="${userPath}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}", diffMode="${diffMode ?? "none"}"`
     );
-    const absoluteUserPath = path2.isAbsolute(userPath) ? userPath : path2.resolve(process.cwd(), userPath);
+    const absoluteUserPath = path3.isAbsolute(userPath) ? userPath : path3.resolve(process.cwd(), userPath);
     let pathStats;
     try {
       pathStats = await fs2.stat(absoluteUserPath);
@@ -891,7 +1355,7 @@ var LintFilesInDirectoryUseCase = class {
       );
     }
     const isFile = pathStats.isFile();
-    const directoryForGitOps = isFile ? path2.dirname(absoluteUserPath) : absoluteUserPath;
+    const directoryForGitOps = isFile ? path3.dirname(absoluteUserPath) : absoluteUserPath;
     this.logger.debug(
       `Path type: ${isFile ? "file" : "directory"}, gitOpsDir="${directoryForGitOps}"`
     );
@@ -907,11 +1371,60 @@ var LintFilesInDirectoryUseCase = class {
     this.logger.debug(
       `Resolved paths: gitRoot="${gitRepoRoot}", lintPath="${absoluteLintPath}"`
     );
-    const files = isFile ? [{ path: absoluteLintPath }] : await this.services.listFiles.listFilesInDirectory(
+    let modifiedFiles = null;
+    let modifiedLines = null;
+    if (diffMode) {
+      if (diffMode === "files" /* FILES */) {
+        modifiedFiles = await this.services.gitRemoteUrlService.getModifiedFiles(gitRepoRoot);
+        this.logger.debug(`Found ${modifiedFiles.length} modified files`);
+        if (modifiedFiles.length === 0) {
+          const { gitRemoteUrl: gitRemoteUrl2 } = await this.services.gitRemoteUrlService.getGitRemoteUrl(
+            gitRepoRoot
+          );
+          return {
+            gitRemoteUrl: gitRemoteUrl2,
+            violations: [],
+            summary: {
+              totalFiles: 0,
+              violatedFiles: 0,
+              totalViolations: 0,
+              standardsChecked: []
+            }
+          };
+        }
+      } else if (diffMode === "lines" /* LINES */) {
+        modifiedLines = await this.services.gitRemoteUrlService.getModifiedLines(gitRepoRoot);
+        modifiedFiles = [...new Set(modifiedLines.map((ml) => ml.file))];
+        this.logger.debug(
+          `Found ${modifiedLines.length} modified line ranges in ${modifiedFiles.length} files`
+        );
+        if (modifiedFiles.length === 0) {
+          const { gitRemoteUrl: gitRemoteUrl2 } = await this.services.gitRemoteUrlService.getGitRemoteUrl(
+            gitRepoRoot
+          );
+          return {
+            gitRemoteUrl: gitRemoteUrl2,
+            violations: [],
+            summary: {
+              totalFiles: 0,
+              violatedFiles: 0,
+              totalViolations: 0,
+              standardsChecked: []
+            }
+          };
+        }
+      }
+    }
+    let files = isFile ? [{ path: absoluteLintPath }] : await this.services.listFiles.listFilesInDirectory(
       absoluteLintPath,
       [],
       ["node_modules", "dist", ".min.", ".map.", ".git"]
     );
+    if (modifiedFiles) {
+      const modifiedFilesSet = new Set(modifiedFiles);
+      files = files.filter((file) => modifiedFilesSet.has(file.path));
+      this.logger.debug(`Filtered to ${files.length} modified files`);
+    }
     const { gitRemoteUrl } = await this.services.gitRemoteUrlService.getGitRemoteUrl(gitRepoRoot);
     const { branches } = await this.services.gitRemoteUrlService.getCurrentBranches(gitRepoRoot);
     this.logger.debug(
@@ -1108,7 +1621,17 @@ var LintFilesInDirectoryUseCase = class {
         });
       }
     }
-    const totalViolations = violations.reduce(
+    let filteredViolations = violations;
+    if (diffMode === "lines" /* LINES */ && modifiedLines) {
+      filteredViolations = this.services.diffViolationFilterService.filterByLines(
+        violations,
+        modifiedLines
+      );
+      this.logger.debug(
+        `Filtered violations by lines: ${violations.length} -> ${filteredViolations.length}`
+      );
+    }
+    const totalViolations = filteredViolations.reduce(
       (sum, violation) => sum + violation.violations.length,
       0
     );
@@ -1121,10 +1644,10 @@ var LintFilesInDirectoryUseCase = class {
     );
     return {
       gitRemoteUrl,
-      violations,
+      violations: filteredViolations,
       summary: {
         totalFiles: files.length,
-        violatedFiles: violations.length,
+        violatedFiles: filteredViolations.length,
         totalViolations,
         standardsChecked
       }
@@ -1150,6 +1673,307 @@ var LintFilesInDirectoryUseCase = class {
   }
 };
 
+// apps/cli/src/application/useCases/LintFilesLocallyUseCase.ts
+var import_minimatch2 = require("minimatch");
+var path4 = __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;
+    this.detectionProgramsCache = /* @__PURE__ */ new Map();
+  }
+  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, diffMode } = command3;
+    this.logger.debug(
+      `Starting local linting: path="${userPath}", diffMode="${diffMode ?? "none"}"`
+    );
+    this.detectionProgramsCache.clear();
+    const absoluteUserPath = path4.isAbsolute(userPath) ? userPath : path4.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 ? path4.dirname(absoluteUserPath) : absoluteUserPath;
+    const gitRepoRoot = await this.services.gitRemoteUrlService.tryGetGitRepositoryRoot(
+      directoryForConfig
+    );
+    let modifiedFiles = null;
+    let modifiedLines = null;
+    if (diffMode && gitRepoRoot) {
+      if (diffMode === "files" /* FILES */) {
+        modifiedFiles = await this.services.gitRemoteUrlService.getModifiedFiles(gitRepoRoot);
+        this.logger.debug(`Found ${modifiedFiles.length} modified files`);
+        if (modifiedFiles.length === 0) {
+          return {
+            violations: [],
+            summary: {
+              totalFiles: 0,
+              violatedFiles: 0,
+              totalViolations: 0,
+              standardsChecked: []
+            }
+          };
+        }
+      } else if (diffMode === "lines" /* LINES */) {
+        modifiedLines = await this.services.gitRemoteUrlService.getModifiedLines(gitRepoRoot);
+        modifiedFiles = [...new Set(modifiedLines.map((ml) => ml.file))];
+        this.logger.debug(
+          `Found ${modifiedLines.length} modified line ranges in ${modifiedFiles.length} files`
+        );
+        if (modifiedFiles.length === 0) {
+          return {
+            violations: [],
+            summary: {
+              totalFiles: 0,
+              violatedFiles: 0,
+              totalViolations: 0,
+              standardsChecked: []
+            }
+          };
+        }
+      }
+    }
+    const allConfigs = await this.repositories.configFileRepository.findAllConfigsInTree(
+      directoryForConfig,
+      gitRepoRoot
+    );
+    if (!allConfigs.hasConfigs) {
+      const boundary = gitRepoRoot ?? "filesystem root";
+      throw new Error(
+        `No packmind.json found between ${directoryForConfig} and ${boundary}. Cannot use local linting.`
+      );
+    }
+    const basePath = allConfigs.basePath;
+    this.logger.debug(
+      `Found ${allConfigs.configs.length} packmind.json file(s)`
+    );
+    for (const config of allConfigs.configs) {
+      this.logger.debug(
+        `Using config: ${config.absoluteTargetPath}/packmind.json (target: ${config.targetPath})`
+      );
+    }
+    let files = isFile ? [{ path: absoluteUserPath }] : await this.services.listFiles.listFilesInDirectory(
+      absoluteUserPath,
+      [],
+      ["node_modules", "dist", ".min.", ".map.", ".git"]
+    );
+    if (modifiedFiles) {
+      const modifiedFilesSet = new Set(modifiedFiles);
+      files = files.filter((file) => modifiedFilesSet.has(file.path));
+      this.logger.debug(`Filtered to ${files.length} modified files`);
+    }
+    this.logger.debug(`Found ${files.length} files to lint`);
+    const violations = [];
+    const allStandardsChecked = /* @__PURE__ */ new Set();
+    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 matchingTargets = this.findMatchingTargets(
+        file.path,
+        allConfigs.configs
+      );
+      const programsByLanguage = /* @__PURE__ */ new Map();
+      for (const targetConfig of matchingTargets) {
+        const detectionPrograms = await this.getDetectionProgramsForTarget(targetConfig);
+        for (const target of detectionPrograms.targets) {
+          for (const standard of target.standards) {
+            if (!this.fileMatchesTargetAndScope(
+              normalizedFilePath,
+              targetConfig.targetPath,
+              standard.scope
+            )) {
+              continue;
+            }
+            allStandardsChecked.add(standard.slug);
+            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
+        });
+      }
+    }
+    let filteredViolations = violations;
+    if (diffMode === "lines" /* LINES */ && modifiedLines) {
+      filteredViolations = this.services.diffViolationFilterService.filterByLines(
+        violations,
+        modifiedLines
+      );
+      this.logger.debug(
+        `Filtered violations by lines: ${violations.length} -> ${filteredViolations.length}`
+      );
+    }
+    const totalViolations = filteredViolations.reduce(
+      (sum, violation) => sum + violation.violations.length,
+      0
+    );
+    return {
+      violations: filteredViolations,
+      summary: {
+        totalFiles: files.length,
+        violatedFiles: filteredViolations.length,
+        totalViolations,
+        standardsChecked: Array.from(allStandardsChecked)
+      }
+    };
+  }
+  /**
+   * Finds all targets (configs) that are ancestors of the given file path.
+   * A target matches if the file is located within or under the target's directory.
+   */
+  findMatchingTargets(absoluteFilePath, configs) {
+    return configs.filter(
+      (config) => absoluteFilePath.startsWith(config.absoluteTargetPath + "/") || absoluteFilePath === config.absoluteTargetPath
+    );
+  }
+  /**
+   * Gets detection programs for a target, using cache to avoid redundant API calls.
+   * Cache key is the sorted package slugs to handle identical package sets.
+   */
+  async getDetectionProgramsForTarget(targetConfig) {
+    const packageSlugs = Object.keys(targetConfig.packages).sort(
+      (a, b) => a.localeCompare(b)
+    );
+    const cacheKey = packageSlugs.join(",");
+    const cached = this.detectionProgramsCache.get(cacheKey);
+    if (cached) {
+      this.logger.debug(
+        `Using cached detection programs for packages: ${cacheKey}`
+      );
+      return cached;
+    }
+    this.logger.debug(
+      `Fetching detection programs for packages: ${packageSlugs.join(", ")}`
+    );
+    const detectionPrograms = await this.repositories.packmindGateway.getDetectionProgramsForPackages({
+      packagesSlugs: packageSlugs
+    });
+    this.detectionProgramsCache.set(cacheKey, detectionPrograms);
+    return detectionPrograms;
+  }
+  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 +2080,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)}`
         );
       }
     };
@@ -1535,7 +2359,117 @@ var PackmindGateway = class {
           `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)}`
+        );
+      }
+    };
+  }
+};
+
+// apps/cli/src/application/services/DiffViolationFilterService.ts
+var DiffViolationFilterService = class {
+  /**
+   * Filters violations to only include those in modified files.
+   * @param violations - The list of violations to filter
+   * @param modifiedFiles - The list of absolute paths of modified files
+   * @returns Violations that occur in modified files
+   */
+  filterByFiles(violations, modifiedFiles) {
+    const modifiedFilesSet = new Set(modifiedFiles);
+    return violations.filter(
+      (violation) => modifiedFilesSet.has(violation.file)
+    );
+  }
+  /**
+   * Filters violations to only include those on modified lines.
+   * @param violations - The list of violations to filter
+   * @param modifiedLines - The list of modified line ranges
+   * @returns Violations that occur on modified lines
+   */
+  filterByLines(violations, modifiedLines) {
+    const modifiedLinesByFile = this.groupModifiedLinesByFile(modifiedLines);
+    return violations.map((violation) => {
+      const fileModifications = modifiedLinesByFile.get(violation.file);
+      if (!fileModifications) {
+        return null;
+      }
+      const filteredViolations = violation.violations.filter(
+        (singleViolation) => this.isLineInModifiedRanges(
+          singleViolation.line,
+          fileModifications
+        )
+      );
+      if (filteredViolations.length === 0) {
+        return null;
+      }
+      return {
+        file: violation.file,
+        violations: filteredViolations
+      };
+    }).filter((v) => v !== null);
+  }
+  /**
+   * Groups modified lines by file path for efficient lookup.
+   */
+  groupModifiedLinesByFile(modifiedLines) {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const modification of modifiedLines) {
+      const existing = byFile.get(modification.file) ?? [];
+      existing.push(modification);
+      byFile.set(modification.file, existing);
+    }
+    return byFile;
+  }
+  /**
+   * Checks if a line number falls within any of the modified line ranges.
+   */
+  isLineInModifiedRanges(line, modifications) {
+    return modifications.some((mod) => {
+      const endLine = mod.startLine + mod.lineCount - 1;
+      return line >= mod.startLine && line <= endLine;
+    });
   }
 };
 
@@ -3208,9 +4142,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;
   }
@@ -3341,9 +4275,9 @@ var ExecuteLinterProgramsUseCase = class {
     let line;
     let character = 0;
     if (typeof value === "number" && Number.isFinite(value)) {
-      line = value;
+      line = value + 1;
     } else if (this.isViolationLike(value)) {
-      line = value.line;
+      line = value.line + 1;
       character = value.character ?? 0;
     }
     if (!this.isValidLine(line)) {
@@ -3405,14 +4339,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 +4437,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 +4445,7 @@ var Configuration = class _Configuration {
   }
   static {
     this.logger = new PackmindLogger(
-      origin5,
+      origin6,
       "info" /* INFO */
     );
   }
@@ -3642,8 +4592,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 +4604,7 @@ var Cache = class _Cache {
   }
   static {
     this.logger = new PackmindLogger(
-      origin6,
+      origin7,
       "info" /* INFO */
     );
   }
@@ -3837,14 +4786,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 +4977,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 +5219,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 path5 = __toESM(require("path"));
 var PullDataUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
@@ -4299,13 +5232,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 +5277,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 = path5.join(baseDirectory, file.path);
+    const directory = path5.dirname(fullPath);
+    await fs4.mkdir(directory, { recursive: true });
     const fileExists = await this.fileExists(fullPath);
     if (file.content !== void 0) {
       await this.handleFullContentUpdate(
@@ -4352,7 +5299,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 +5311,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 +5335,16 @@ var PullDataUseCase = class {
     }
   }
   async deleteFile(baseDirectory, filePath, result) {
-    const fullPath = path3.join(baseDirectory, filePath);
+    const fullPath = path5.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 +5417,235 @@ var GetPackageSummaryUseCase = class {
   }
 };
 
+// apps/cli/src/infra/repositories/ConfigFileRepository.ts
+var fs5 = __toESM(require("fs/promises"));
+var path6 = __toESM(require("path"));
+
+// apps/cli/src/infra/utils/consoleLogger.ts
+var import_chalk = __toESM(require("chalk"));
+var CLI_PREFIX = "packmind-cli";
+function logWarningConsole(message) {
+  console.warn(import_chalk.default.bgYellow.bold(CLI_PREFIX), import_chalk.default.yellow(message));
+}
+function logErrorConsole(message) {
+  console.error(import_chalk.default.bgRed.bold(CLI_PREFIX), import_chalk.default.red(message));
+}
+function logSuccessConsole(message) {
+  console.log(import_chalk.default.bgGreen.bold(CLI_PREFIX), import_chalk.default.green.bold(message));
+}
+function formatSlug(text) {
+  return import_chalk.default.blue.bold(text);
+}
+function formatLabel(text) {
+  return import_chalk.default.dim(text);
+}
+function formatError(text) {
+  return import_chalk.default.red(text);
+}
+function formatBold(text) {
+  return import_chalk.default.bold(text);
+}
+function formatFilePath(text) {
+  return import_chalk.default.underline.gray(text);
+}
+
+// apps/cli/src/infra/repositories/ConfigFileRepository.ts
+var ConfigFileRepository = class {
+  constructor() {
+    this.CONFIG_FILENAME = "packmind.json";
+    this.warnedFiles = /* @__PURE__ */ new Set();
+    this.EXCLUDED_DIRECTORIES = [
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "coverage",
+      ".nx"
+    ];
+  }
+  async writeConfig(baseDirectory, config) {
+    const configPath = path6.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 = path6.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;
+      }
+      if (!this.warnedFiles.has(configPath)) {
+        this.warnedFiles.add(configPath);
+        logWarningConsole(`\u26A0 Skipping malformed config file: ${configPath}`);
+      }
+      return null;
+    }
+  }
+  /**
+   * 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 = path6.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 = path6.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 = path6.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path6.resolve(stopDirectory) : null;
+    let currentDir = normalizedStart;
+    while (true) {
+      const config = await this.readConfig(currentDir);
+      if (config) {
+        configs.push(config);
+        configPaths.push(path6.join(currentDir, this.CONFIG_FILENAME));
+      }
+      if (normalizedStop !== null && currentDir === normalizedStop) {
+        break;
+      }
+      const parentDir = path6.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
+    };
+  }
+  /**
+   * Finds all packmind.json files in the tree (both ancestors and descendants)
+   * and returns each config with its target path.
+   *
+   * @param startDirectory - Directory to start searching from (typically the lint target)
+   * @param stopDirectory - Directory to stop ancestor search at (typically git repo root), also used as base for descendants search
+   * @returns All configs found with their target paths
+   */
+  async findAllConfigsInTree(startDirectory, stopDirectory) {
+    const normalizedStart = path6.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path6.resolve(stopDirectory) : null;
+    const basePath = normalizedStop ?? normalizedStart;
+    const configsMap = /* @__PURE__ */ new Map();
+    let currentDir = normalizedStart;
+    while (true) {
+      const config = await this.readConfig(currentDir);
+      if (config) {
+        const targetPath = this.computeRelativeTargetPath(currentDir, basePath);
+        configsMap.set(currentDir, {
+          targetPath,
+          absoluteTargetPath: currentDir,
+          packages: config.packages
+        });
+      }
+      if (normalizedStop !== null && currentDir === normalizedStop) {
+        break;
+      }
+      const parentDir = path6.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+    const searchRoot = normalizedStop ?? normalizedStart;
+    const descendantDirs = await this.findDescendantConfigs(searchRoot);
+    for (const descendantDir of descendantDirs) {
+      if (configsMap.has(descendantDir)) {
+        continue;
+      }
+      const config = await this.readConfig(descendantDir);
+      if (config) {
+        const targetPath = this.computeRelativeTargetPath(
+          descendantDir,
+          basePath
+        );
+        configsMap.set(descendantDir, {
+          targetPath,
+          absoluteTargetPath: descendantDir,
+          packages: config.packages
+        });
+      }
+    }
+    if (!configsMap.has(searchRoot)) {
+      const rootConfig = await this.readConfig(searchRoot);
+      if (rootConfig) {
+        configsMap.set(searchRoot, {
+          targetPath: "/",
+          absoluteTargetPath: searchRoot,
+          packages: rootConfig.packages
+        });
+      }
+    }
+    const configs = Array.from(configsMap.values());
+    return {
+      configs,
+      hasConfigs: configs.length > 0,
+      basePath
+    };
+  }
+  computeRelativeTargetPath(absolutePath, basePath) {
+    if (absolutePath === basePath) {
+      return "/";
+    }
+    const relativePath = absolutePath.substring(basePath.length);
+    return relativePath.startsWith("/") ? relativePath : "/" + relativePath;
+  }
+};
+
 // apps/cli/src/PackmindCliHexaFactory.ts
 var PackmindCliHexaFactory = class {
   constructor(logger2) {
@@ -4477,12 +5653,14 @@ var PackmindCliHexaFactory = class {
     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()
+      linterExecutionUseCase: new ExecuteLinterProgramsUseCase(),
+      diffViolationFilterService: new DiffViolationFilterService()
     };
     this.useCases = {
       executeSingleFileAst: new ExecuteSingleFileAstUseCase(
@@ -4495,6 +5673,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 +5688,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 +5720,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 +5732,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) {
+      logWarningConsole(
+        "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
@@ -4565,7 +5802,6 @@ var IDELintLogger = class {
 };
 
 // apps/cli/src/infra/repositories/HumanReadableLogger.ts
-var import_chalk = __toESM(require("chalk"));
 var HumanReadableLogger = class {
   logViolations(violations) {
     violations.forEach((violation) => {
@@ -4576,29 +5812,117 @@ var HumanReadableLogger = class {
         (acc, violation) => acc + violation.violations.length,
         0
       );
-      console.log(
-        import_chalk.default.bgRed.bold("packmind-cli"),
-        import_chalk.default.red(
-          `\u274C Found ${import_chalk.default.bold(totalViolationCount)} violation(s) in ${import_chalk.default.bold(violations.length)} file(s)`
-        )
+      logErrorConsole(
+        `\u274C Found ${formatBold(String(totalViolationCount))} violation(s) in ${formatBold(String(violations.length))} file(s)`
       );
     } else {
-      console.log(
-        import_chalk.default.bgGreen.bold("packmind-cli"),
-        import_chalk.default.green.bold(`\u2705 No violations found`)
-      );
+      logSuccessConsole(`\u2705 No violations found`);
     }
   }
   logViolation(violation) {
-    console.log(import_chalk.default.underline.gray(violation.file));
+    console.log(formatFilePath(violation.file));
     violation.violations.forEach(({ line, character, standard, rule }) => {
       console.log(
-        import_chalk.default.red(`	${line}:${character}	error	@${standard}/${rule}`)
+        formatError(`	${line}:${character}	error	@${standard}/${rule}`)
       );
     });
   }
 };
 
+// apps/cli/src/infra/commands/LinterCommand.ts
+var pathModule = __toESM(require("path"));
+
+// apps/cli/src/infra/commands/lintHandler.ts
+var MISSING_API_KEY_ERROR = "Please set the PACKMIND_API_KEY_V3 environment variable";
+function isMissingApiKeyError(error) {
+  if (error instanceof Error) {
+    return error.message.includes(MISSING_API_KEY_ERROR);
+  }
+  return false;
+}
+async function lintHandler(args2, deps) {
+  const {
+    path: path8,
+    draft,
+    rule,
+    language,
+    logger: logger2,
+    continueOnError,
+    continueOnMissingKey,
+    diff
+  } = args2;
+  const {
+    packmindCliHexa,
+    humanReadableLogger,
+    ideLintLogger,
+    resolvePath,
+    exit
+  } = deps;
+  if (draft && !rule) {
+    throw new Error("option --rule is required to use --draft mode");
+  }
+  const startedAt = Date.now();
+  const targetPath = path8 ?? ".";
+  const hasArguments = !!(draft || rule || language);
+  const absolutePath = resolvePath(targetPath);
+  if (diff) {
+    const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(absolutePath);
+    if (!gitRoot) {
+      throw new Error(
+        "The --diff option requires the project to be in a Git repository"
+      );
+    }
+  }
+  let useLocalLinting = false;
+  if (!hasArguments) {
+    const stopDirectory = await packmindCliHexa.tryGetGitRepositoryRoot(absolutePath);
+    const hierarchicalConfig = await packmindCliHexa.readHierarchicalConfig(
+      absolutePath,
+      stopDirectory
+    );
+    if (hierarchicalConfig.hasConfigs) {
+      useLocalLinting = true;
+    }
+  }
+  let violations = [];
+  try {
+    if (useLocalLinting) {
+      const result = await packmindCliHexa.lintFilesLocally({
+        path: absolutePath,
+        diffMode: diff
+      });
+      violations = result.violations;
+    } else {
+      const result = await packmindCliHexa.lintFilesInDirectory({
+        path: targetPath,
+        draftMode: draft,
+        standardSlug: rule?.standardSlug,
+        ruleId: rule?.ruleId,
+        language,
+        diffMode: diff
+      });
+      violations = result.violations;
+    }
+  } catch (error) {
+    if (isMissingApiKeyError(error) && continueOnMissingKey) {
+      console.warn("Warning: No PACKMIND_API_KEY_V3 set, linting is skipped.");
+      exit(0);
+      return;
+    }
+    throw error;
+  }
+  (logger2 === "ide" /* ide */ ? ideLintLogger : humanReadableLogger).logViolations(
+    violations
+  );
+  const durationSeconds = (Date.now() - startedAt) / 1e3;
+  console.log(`Lint completed in ${durationSeconds.toFixed(2)}s`);
+  if (violations.length > 0 && !continueOnError) {
+    exit(1);
+  } else {
+    exit(0);
+  }
+}
+
 // apps/cli/src/infra/commands/LinterCommand.ts
 var Logger = {
   from: async (input) => {
@@ -4627,6 +5951,19 @@ var RuleID = {
     };
   }
 };
+var DiffModeType = {
+  from: async (input) => {
+    switch (input) {
+      case "files":
+        return "files" /* FILES */;
+      case "lines":
+        return "lines" /* LINES */;
+    }
+    throw new Error(
+      `${input} is not a valid value for the --diff option. Expected values are: files, lines`
+    );
+  }
+};
 var lintCommand = (0, import_cmd_ts.command)({
   name: "lint",
   description: "Lint code at the specified path",
@@ -4660,33 +5997,34 @@ var lintCommand = (0, import_cmd_ts.command)({
     debug: (0, import_cmd_ts.flag)({
       long: "debug",
       description: "Enable debug logging"
+    }),
+    continueOnError: (0, import_cmd_ts.flag)({
+      long: "continue-on-error",
+      description: "Exit with status code 0 even if violations are found"
+    }),
+    continueOnMissingKey: (0, import_cmd_ts.flag)({
+      long: "continue-on-missing-key",
+      description: "Skip linting and exit with status code 0 if PACKMIND_API_KEY_V3 is not set"
+    }),
+    diff: (0, import_cmd_ts.option)({
+      long: "diff",
+      description: "Filter violations by git diff (files | lines)",
+      type: (0, import_cmd_ts.optional)(DiffModeType)
     })
   },
-  handler: async ({ path: path5, draft, rule, debug, language, logger: logger2 }) => {
-    if (draft && !rule) {
-      throw new Error("option --rule is required to use --draft mode");
-    }
-    const startedAt = Date.now();
+  handler: async (args2) => {
     const packmindLogger = new PackmindLogger(
       "PackmindCLI",
-      debug ? "debug" /* DEBUG */ : "info" /* INFO */
+      args2.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
-    });
-    (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) {
-      process.exit(1);
-    } else {
-      process.exit(0);
-    }
+    const deps = {
+      packmindCliHexa: new PackmindCliHexa(packmindLogger),
+      humanReadableLogger: new HumanReadableLogger(),
+      ideLintLogger: new IDELintLogger(),
+      resolvePath: (targetPath) => pathModule.isAbsolute(targetPath) ? targetPath : pathModule.resolve(process.cwd(), targetPath),
+      exit: (code) => process.exit(code)
+    };
+    await lintHandler(args2, deps);
   }
 });
 
@@ -4746,8 +6084,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 path7 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/PullCommand.ts
 var import_cmd_ts2 = require("cmd-ts");
@@ -4782,10 +6120,28 @@ var pullCommand = (0, import_cmd_ts2.command)({
           console.log("No packages found.");
           process.exit(0);
         }
-        console.log("Available packages:");
-        packages.forEach((pkg) => {
-          console.log(`  - ${pkg.slug}: ${pkg.description || pkg.name}`);
+        const sortedPackages = [...packages].sort(
+          (a, b) => a.slug.localeCompare(b.slug)
+        );
+        console.log("Available packages:\n");
+        sortedPackages.forEach((pkg, index) => {
+          console.log(`- ${formatSlug(pkg.slug)}`);
+          console.log(`    ${formatLabel("Name:")} ${pkg.name}`);
+          if (pkg.description) {
+            const descriptionLines = pkg.description.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+            const [firstLine, ...restLines] = descriptionLines;
+            console.log(`    ${formatLabel("Description:")} ${firstLine}`);
+            restLines.forEach((line) => {
+              console.log(`                 ${line}`);
+            });
+          }
+          if (index < sortedPackages.length - 1) {
+            console.log("");
+          }
         });
+        const exampleSlug = formatSlug(sortedPackages[0].slug);
+        console.log("\nHow to install a package:\n");
+        console.log(`  $ packmind-cli install ${exampleSlug}`);
         process.exit(0);
       } catch (error) {
         console.error("\n\u274C Failed to list packages:");
@@ -4841,30 +6197,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) {
+      logWarningConsole("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 +6257,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;
@@ -4906,29 +6330,23 @@ var pullCommand = (0, import_cmd_ts2.command)({
 // apps/cli/src/main.ts
 var { version: CLI_VERSION } = require_package();
 function findEnvFile() {
-  let currentDir = process.cwd();
-  const startDir = currentDir;
-  let gitRootFound = false;
+  const currentDir = process.cwd();
+  const gitService = new GitService();
+  const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
+  const filesystemRoot = path7.parse(currentDir).root;
+  const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  while (searchDir !== path4.parse(searchDir).root) {
-    if (fs4.existsSync(path4.join(searchDir, ".git"))) {
-      gitRootFound = true;
-      break;
-    }
-    searchDir = path4.dirname(searchDir);
-  }
-  while (currentDir !== path4.parse(currentDir).root) {
-    const envPath2 = path4.join(currentDir, ".env");
-    if (fs4.existsSync(envPath2)) {
+  let parentDir = path7.dirname(searchDir);
+  while (searchDir !== parentDir) {
+    const envPath2 = path7.join(searchDir, ".env");
+    if (fs6.existsSync(envPath2)) {
       return envPath2;
     }
-    if (gitRootFound && fs4.existsSync(path4.join(currentDir, ".git"))) {
-      break;
-    }
-    if (!gitRootFound && currentDir !== startDir) {
-      break;
+    if (searchDir === stopDir) {
+      return null;
     }
-    currentDir = path4.dirname(currentDir);
+    searchDir = parentDir;
+    parentDir = path7.dirname(searchDir);
   }
   return null;
 }
@@ -4953,10 +6371,11 @@ 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) => {
-  console.error(import_chalk2.default.bgRed.bold("packmind-cli"), import_chalk2.default.red(error.message));
+  logErrorConsole(error.message);
   process.exit(1);
 });