@packmind/cli 0.5.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.5.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,6 +257,31 @@ 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__ */ ((ProgrammingLanguage4) => {
   ProgrammingLanguage4["JAVASCRIPT"] = "JAVASCRIPT";
@@ -793,36 +817,49 @@ 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(path7) {
+  async getGitRepositoryRoot(path8) {
     try {
       const { stdout } = await execAsync("git rev-parse --show-toplevel", {
-        cwd: path7
+        cwd: path8
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path7,
+        inputPath: path8,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path7}' 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(path7) {
+  async tryGetGitRepositoryRoot(path8) {
     try {
-      return await this.getGitRepositoryRoot(path7);
+      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;
     }
@@ -927,18 +964,181 @@ ${error.message}`
   normalizeGitUrl(url) {
     const sshMatch = url.match(/^git@([^:]+):(.+)$/);
     if (sshMatch) {
-      const [, host, path7] = sshMatch;
-      const cleanPath = path7.replace(/\.git$/, "");
+      const [, host, urlPath] = sshMatch;
+      const cleanPath = urlPath.replace(/\.git$/, "");
       return `${host}/${cleanPath}`;
     }
     const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+)$/);
     if (httpsMatch) {
-      const [, host, path7] = httpsMatch;
-      const cleanPath = path7.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
@@ -954,7 +1154,7 @@ var GetGitRemoteUrlUseCase = class {
 
 // 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 = [];
@@ -976,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;
         }
@@ -993,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
@@ -1009,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;
@@ -1072,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 {
@@ -1139,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);
@@ -1154,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}"`
     );
@@ -1170,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(
@@ -1371,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
     );
@@ -1384,10 +1644,10 @@ var LintFilesInDirectoryUseCase = class {
     );
     return {
       gitRemoteUrl,
-      violations,
+      violations: filteredViolations,
       summary: {
         totalFiles: files.length,
-        violatedFiles: violations.length,
+        violatedFiles: filteredViolations.length,
         totalViolations,
         standardsChecked
       }
@@ -1415,7 +1675,7 @@ var LintFilesInDirectoryUseCase = class {
 
 // apps/cli/src/application/useCases/LintFilesLocallyUseCase.ts
 var import_minimatch2 = require("minimatch");
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var fs3 = __toESM(require("fs/promises"));
 var origin3 = "LintFilesLocallyUseCase";
 var LintFilesLocallyUseCase = class {
@@ -1423,6 +1683,7 @@ var LintFilesLocallyUseCase = class {
     this.services = services;
     this.repositories = repositories;
     this.logger = logger2;
+    this.detectionProgramsCache = /* @__PURE__ */ new Map();
   }
   fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
     if (!scopePatterns || scopePatterns.length === 0) {
@@ -1458,9 +1719,12 @@ var LintFilesLocallyUseCase = class {
     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);
+    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);
@@ -1470,44 +1734,78 @@ var LintFilesLocallyUseCase = class {
       );
     }
     const isFile = pathStats.isFile();
-    const directoryForConfig = isFile ? path3.dirname(absoluteUserPath) : absoluteUserPath;
+    const directoryForConfig = isFile ? path4.dirname(absoluteUserPath) : absoluteUserPath;
     const gitRepoRoot = await this.services.gitRemoteUrlService.tryGetGitRepositoryRoot(
       directoryForConfig
     );
-    const hierarchicalConfig = await this.repositories.configFileRepository.readHierarchicalConfig(
+    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 (!hierarchicalConfig.hasConfigs) {
+    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 = gitRepoRoot ?? directoryForConfig;
+    const basePath = allConfigs.basePath;
     this.logger.debug(
-      `Found ${hierarchicalConfig.configPaths.length} packmind.json file(s)`
+      `Found ${allConfigs.configs.length} packmind.json file(s)`
     );
-    for (const configPath of hierarchicalConfig.configPaths) {
-      this.logger.debug(`Using config: ${configPath}`);
+    for (const config of allConfigs.configs) {
+      this.logger.debug(
+        `Using config: ${config.absoluteTargetPath}/packmind.json (target: ${config.targetPath})`
+      );
     }
-    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(
+    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;
@@ -1520,38 +1818,46 @@ var LintFilesLocallyUseCase = class {
       if (!fileLanguage) {
         continue;
       }
+      const matchingTargets = this.findMatchingTargets(
+        file.path,
+        allConfigs.configs
+      );
       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;
+      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}`
+                  );
                 }
-                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}`
-                );
               }
             }
           }
@@ -1590,27 +1896,64 @@ var LintFilesLocallyUseCase = 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
     );
-    const standardsChecked = Array.from(
-      new Set(
-        detectionPrograms.targets.flatMap(
-          (target) => target.standards.map((standard) => standard.slug)
-        )
-      )
-    );
     return {
-      violations,
+      violations: filteredViolations,
       summary: {
         totalFiles: files.length,
-        violatedFiles: violations.length,
+        violatedFiles: filteredViolations.length,
         totalViolations,
-        standardsChecked
+        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);
@@ -2065,6 +2408,71 @@ var PackmindGateway = class {
   }
 };
 
+// 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;
+    });
+  }
+};
+
 // packages/linter-ast/src/core/ParserError.ts
 var ParserNotAvailableError = class extends Error {
   constructor(language, cause) {
@@ -3867,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)) {
@@ -4813,7 +5221,7 @@ ${sectionBlock}
 
 // apps/cli/src/application/useCases/PullDataUseCase.ts
 var fs4 = __toESM(require("fs/promises"));
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 var PullDataUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
@@ -4869,8 +5277,8 @@ var PullDataUseCase = class {
     return result;
   }
   async createOrUpdateFile(baseDirectory, file, result) {
-    const fullPath = path4.join(baseDirectory, file.path);
-    const directory = path4.dirname(fullPath);
+    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) {
@@ -4927,7 +5335,7 @@ var PullDataUseCase = class {
     }
   }
   async deleteFile(baseDirectory, filePath, result) {
-    const fullPath = path4.join(baseDirectory, filePath);
+    const fullPath = path5.join(baseDirectory, filePath);
     const fileExists = await this.fileExists(fullPath);
     if (fileExists) {
       await fs4.unlink(fullPath);
@@ -5011,10 +5419,41 @@ var GetPackageSummaryUseCase = class {
 
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
 var fs5 = __toESM(require("fs/promises"));
-var path5 = __toESM(require("path"));
+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",
@@ -5025,12 +5464,12 @@ var ConfigFileRepository = class {
     ];
   }
   async writeConfig(baseDirectory, config) {
-    const configPath = path5.join(baseDirectory, this.CONFIG_FILENAME);
+    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 = path5.join(baseDirectory, this.CONFIG_FILENAME);
+    const configPath = path6.join(baseDirectory, this.CONFIG_FILENAME);
     try {
       const configContent = await fs5.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
@@ -5044,9 +5483,11 @@ var ConfigFileRepository = class {
       if (error.code === "ENOENT") {
         return null;
       }
-      throw new Error(
-        `Failed to read packmind.json: ${error.message}`
-      );
+      if (!this.warnedFiles.has(configPath)) {
+        this.warnedFiles.add(configPath);
+        logWarningConsole(`\u26A0 Skipping malformed config file: ${configPath}`);
+      }
+      return null;
     }
   }
   /**
@@ -5057,7 +5498,7 @@ var ConfigFileRepository = class {
    * @returns Array of directory paths that contain a packmind.json file
    */
   async findDescendantConfigs(directory) {
-    const normalizedDir = path5.resolve(directory);
+    const normalizedDir = path6.resolve(directory);
     const results = [];
     const searchRecursively = async (currentDir) => {
       let entries;
@@ -5073,7 +5514,7 @@ var ConfigFileRepository = class {
         if (this.EXCLUDED_DIRECTORIES.includes(entry.name)) {
           continue;
         }
-        const entryPath = path5.join(currentDir, entry.name);
+        const entryPath = path6.join(currentDir, entry.name);
         const config = await this.readConfig(entryPath);
         if (config) {
           results.push(entryPath);
@@ -5095,19 +5536,19 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = path5.resolve(startDirectory);
-    const normalizedStop = stopDirectory ? path5.resolve(stopDirectory) : null;
+    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(path5.join(currentDir, this.CONFIG_FILENAME));
+        configPaths.push(path6.join(currentDir, this.CONFIG_FILENAME));
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = path5.dirname(currentDir);
+      const parentDir = path6.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -5127,6 +5568,82 @@ var ConfigFileRepository = class {
       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
@@ -5142,7 +5659,8 @@ var PackmindCliHexaFactory = class {
     this.services = {
       listFiles: new ListFiles(),
       gitRemoteUrlService: new GitService(this.logger),
-      linterExecutionUseCase: new ExecuteLinterProgramsUseCase()
+      linterExecutionUseCase: new ExecuteLinterProgramsUseCase(),
+      diffViolationFilterService: new DiffViolationFilterService()
     };
     this.useCases = {
       executeSingleFileAst: new ExecuteSingleFileAstUseCase(
@@ -5238,8 +5756,8 @@ var PackmindCliHexa = class {
       (version) => version !== "*"
     );
     if (hasNonWildcardVersions) {
-      console.log(
-        "WARN: Package versions are not supported yet, getting the latest version"
+      logWarningConsole(
+        "Package versions are not supported yet, getting the latest version"
       );
     }
     return Object.keys(config.packages);
@@ -5284,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) => {
@@ -5295,24 +5812,18 @@ 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}`)
       );
     });
   }
@@ -5320,6 +5831,99 @@ var HumanReadableLogger = class {
 
 // 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) => {
     switch (input) {
@@ -5347,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",
@@ -5380,72 +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: path7, 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 targetPath = path7 ?? ".";
-    const hasArguments = !!(draft || rule || language);
-    const absolutePath = pathModule.isAbsolute(targetPath) ? targetPath : pathModule.resolve(process.cwd(), targetPath);
-    let useLocalLinting = false;
-    let lintTargets = [];
-    if (!hasArguments) {
-      const stopDirectory = await packmindCliHexa.tryGetGitRepositoryRoot(absolutePath);
-      const hierarchicalConfig = await packmindCliHexa.readHierarchicalConfig(
-        absolutePath,
-        stopDirectory
-      );
-      if (hierarchicalConfig.hasConfigs) {
-        useLocalLinting = true;
-        const rootConfig = await packmindCliHexa.readHierarchicalConfig(
-          absolutePath,
-          absolutePath
-        );
-        if (rootConfig.hasConfigs) {
-          lintTargets.push(absolutePath);
-        }
-        const descendantTargets = await packmindCliHexa.findDescendantConfigs(absolutePath);
-        lintTargets = [...lintTargets, ...descendantTargets];
-        if (lintTargets.length === 0) {
-          lintTargets.push(absolutePath);
-        }
-      }
-    }
-    let violations = [];
-    if (useLocalLinting && lintTargets.length > 0) {
-      for (const target of lintTargets) {
-        packmindLogger.debug(`Linting target: ${target}`);
-        const result = await packmindCliHexa.lintFilesLocally({
-          path: target
-        });
-        violations = [...violations, ...result.violations];
-      }
-    } else {
-      const result = await packmindCliHexa.lintFilesInDirectory({
-        path: targetPath,
-        draftMode: draft,
-        standardSlug: rule?.standardSlug,
-        ruleId: rule?.ruleId,
-        language
-      });
-      violations = result.violations;
-    }
-    (logger2 === "ide" /* ide */ ? new IDELintLogger() : new HumanReadableLogger()).logViolations(violations);
-    const durationSeconds = (Date.now() - startedAt) / 1e3;
-    console.log(`Lint completed in ${durationSeconds.toFixed(2)}s`);
-    if (violations.length > 0) {
-      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);
   }
 });
 
@@ -5506,7 +6085,7 @@ function extractWasmFiles() {
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
 var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/PullCommand.ts
 var import_cmd_ts2 = require("cmd-ts");
@@ -5541,14 +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.name} (${pkg.slug})`);
+        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) {
-            console.log(`  ${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:");
@@ -5623,7 +6216,7 @@ var pullCommand = (0, import_cmd_ts2.command)({
     }
     const allPackages = [.../* @__PURE__ */ new Set([...configPackages, ...packagesSlugs])];
     if (allPackages.length === 0) {
-      console.log("WARN config packmind.json not found");
+      logWarningConsole("config packmind.json not found");
       console.log(
         "Usage: packmind-cli install <package-slug> [package-slug...]"
       );
@@ -5737,29 +6330,23 @@ added ${result.filesCreated} files, changed ${result.filesUpdated} files, remove
 // 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 !== path6.parse(searchDir).root) {
-    if (fs6.existsSync(path6.join(searchDir, ".git"))) {
-      gitRootFound = true;
-      break;
-    }
-    searchDir = path6.dirname(searchDir);
-  }
-  while (currentDir !== path6.parse(currentDir).root) {
-    const envPath2 = path6.join(currentDir, ".env");
+  let parentDir = path7.dirname(searchDir);
+  while (searchDir !== parentDir) {
+    const envPath2 = path7.join(searchDir, ".env");
     if (fs6.existsSync(envPath2)) {
       return envPath2;
     }
-    if (gitRootFound && fs6.existsSync(path6.join(currentDir, ".git"))) {
-      break;
-    }
-    if (!gitRootFound && currentDir !== startDir) {
-      break;
+    if (searchDir === stopDir) {
+      return null;
     }
-    currentDir = path6.dirname(currentDir);
+    searchDir = parentDir;
+    parentDir = path7.dirname(searchDir);
   }
   return null;
 }
@@ -5789,6 +6376,6 @@ var app = (0, import_cmd_ts3.subcommands)({
   }
 });
 (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);
 });