@salesforce-ux/slds-linter 0.0.12-alpha → 0.0.12-alpha.0

package/build/commands/lint-components.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintComponentsCommand(program: Command): void;

package/build/commands/lint-components.js

@@ -0,0 +1,50 @@
+// src/commands/lint-components.ts
+import chalk from "chalk";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_ESLINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintComponentsCommand(program) {
+  program.command("lint:components").description("Run eslint on all markup files").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config <path>", "Path to eslint config file", DEFAULT_ESLINT_CONFIG_PATH).option("--editor <editor>", "Editor to open files with (vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting linting of component files..."));
+      const normalizedOptions = normalizeCliOptions(options);
+      Logger.info(chalk.blue("Scanning for files..."));
+      const fileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const totalFiles = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Scanned ${totalFiles} file(s).`));
+      Logger.info(chalk.blue("Running linting..."));
+      const results = await LintRunner.runLinting(fileBatches, "component", {
+        fix: options.fix,
+        configPath: options.config
+      });
+      printLintResults(results, normalizedOptions.editor);
+      const errorCount = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const warningCount = results.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(
+        chalk.blue(
+          `
+Summary: Processed ${totalFiles} file(s) with ${chalk.red(
+            errorCount.toString()
+          )} error(s) and ${chalk.yellow(warningCount.toString())} warning(s).`
+        )
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`Component files linting completed in ${elapsedTime} seconds.`));
+      process.exit(errorCount > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Error during linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintComponentsCommand
+};

package/build/commands/lint-styles.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintStylesCommand(program: Command): void;

package/build/commands/lint-styles.js

@@ -0,0 +1,50 @@
+// src/commands/lint-styles.ts
+import chalk from "chalk";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintStylesCommand(program) {
+  program.command("lint:styles").description("Run stylelint on all style files").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config <path>", "Path to stylelint config file", DEFAULT_STYLELINT_CONFIG_PATH).option("--editor <editor>", "Editor to open files with (vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting linting of style files..."));
+      const normalizedOptions = normalizeCliOptions(options);
+      Logger.info(chalk.blue("Scanning for style files..."));
+      const fileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const totalFiles = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Scanned ${totalFiles} file(s).`));
+      Logger.info(chalk.blue("Running stylelint..."));
+      const results = await LintRunner.runLinting(fileBatches, "style", {
+        fix: options.fix,
+        configPath: options.config
+      });
+      printLintResults(results, normalizedOptions.editor);
+      const errorCount = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const warningCount = results.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(
+        chalk.blue(
+          `
+Summary: Processed ${totalFiles} file(s) with ${chalk.red(
+            errorCount.toString()
+          )} error(s) and ${chalk.yellow(warningCount.toString())} warning(s).`
+        )
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`Style files linting completed in ${elapsedTime} seconds.`));
+      process.exit(errorCount > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Error during linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintStylesCommand
+};

package/build/commands/lint.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintCommand(program: Command): void;

package/build/commands/lint.js

@@ -0,0 +1,86 @@
+// src/commands/lint.ts
+import chalk from "chalk";
+import path from "path";
+import { createClickableLineCol } from "../utils/editorLinkUtil.js";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintCommand(program) {
+  program.command("lint").description("Run both style and component linting").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config-style <path>", "Path to stylelint config file", DEFAULT_STYLELINT_CONFIG_PATH).option("--config-eslint <path>", "Path to eslint config file", DEFAULT_ESLINT_CONFIG_PATH).option("--editor <editor>", "Editor to open files with (e.g., vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting full linting process..."));
+      const normalizedOptions = normalizeCliOptions(options);
+      Logger.info(chalk.blue("\nScanning style files..."));
+      const styleFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const totalStyleFiles = styleFileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Found ${totalStyleFiles} style file(s). Running stylelint...
+`));
+      const styleResults = await LintRunner.runLinting(styleFileBatches, "style", {
+        fix: options.fix,
+        configPath: options.configStyle
+      });
+      styleResults.forEach((result) => {
+        const hasErrors = result.errors?.length > 0;
+        const hasWarnings = result.warnings?.length > 0;
+        if (!hasErrors && !hasWarnings) return;
+        const absolutePath = result.filePath || "";
+        const relativeFile = path.relative(process.cwd(), absolutePath) || "Unknown file";
+        Logger.info(`
+${chalk.bold(relativeFile)}`);
+        result.errors?.forEach((err) => {
+          const lineCol = `${err.line}:${err.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, err.line, err.column, normalizedOptions.editor);
+          const ruleId = err.ruleId ? chalk.dim(err.ruleId) : "";
+          Logger.error(`  ${clickable}  ${err.message}  ${ruleId}`);
+        });
+        result.warnings?.forEach((warn) => {
+          const lineCol = `${warn.line}:${warn.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, warn.line, warn.column, normalizedOptions.editor);
+          const ruleId = warn.ruleId ? chalk.dim(warn.ruleId) : "";
+          Logger.warning(`  ${clickable}  ${warn.message}  ${ruleId}`);
+        });
+      });
+      const styleErrorCount = styleResults.reduce((sum, r) => sum + r.errors.length, 0);
+      const styleWarningCount = styleResults.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(chalk.blue("\nScanning component files..."));
+      const componentFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const totalComponentFiles = componentFileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Found ${totalComponentFiles} component file(s). Running eslint...
+`));
+      const componentResults = await LintRunner.runLinting(componentFileBatches, "component", {
+        fix: options.fix,
+        configPath: options.configEslint
+      });
+      printLintResults(componentResults, normalizedOptions.editor);
+      const componentErrorCount = componentResults.reduce((sum, r) => sum + r.errors.length, 0);
+      const componentWarningCount = componentResults.reduce((sum, r) => sum + r.warnings.length, 0);
+      const totalErrors = styleErrorCount + componentErrorCount;
+      const totalWarnings = styleWarningCount + componentWarningCount;
+      Logger.info(
+        `
+${chalk.red(`${totalErrors} error${totalErrors !== 1 ? "s" : ""}`)}  ${chalk.yellow(`${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`)}`
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`
+Full linting completed in ${elapsedTime} seconds.`));
+      process.exit(totalErrors > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Failed to complete linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintCommand
+};

package/build/commands/report.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerReportCommand(program: Command): void;

package/build/commands/report.js

@@ -0,0 +1,50 @@
+// src/commands/report.ts
+import path from "path";
+import ora from "ora";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { ReportGenerator } from "../services/report-generator.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH, LINTER_CLI_VERSION } from "../services/config.resolver.js";
+function registerReportCommand(program) {
+  program.command("report").description("Generate SARIF report from linting results").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("-o, --output <path>", "Output directory for reports (defaults to current directory)").option("--config-style <path>", "Path to stylelint config file", DEFAULT_STYLELINT_CONFIG_PATH).option("--config-eslint <path>", "Path to eslint config file", DEFAULT_ESLINT_CONFIG_PATH).action(async (options) => {
+    const spinner = ora("Starting report generation...").start();
+    try {
+      const normalizedOptions = normalizeCliOptions(options);
+      spinner.text = "Running styles linting...";
+      const styleFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const styleResults = await LintRunner.runLinting(styleFileBatches, "style", {
+        configPath: options.configStyle
+      });
+      spinner.text = "Running components linting...";
+      const componentFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const componentResults = await LintRunner.runLinting(componentFileBatches, "component", {
+        configPath: options.configEslint
+      });
+      spinner.text = "Generating combined report...";
+      const combinedReportPath = path.join(normalizedOptions.output, "slds-linter-report.sarif");
+      await ReportGenerator.generateSarifReport([...styleResults, ...componentResults], {
+        outputPath: combinedReportPath,
+        toolName: "slds-linter",
+        toolVersion: LINTER_CLI_VERSION
+      });
+      spinner.succeed("Report generation completed");
+      process.exit(0);
+    } catch (error) {
+      spinner?.fail("Report generation failed");
+      Logger.error(`Failed to generate report: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerReportCommand
+};

package/build/index.d.ts

@@ -1 +1,2 @@
-export declare function exampleFunction(filePath: string): string;
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { registerLintStylesCommand } from "./commands/lint-styles.js";
+import { registerLintComponentsCommand } from "./commands/lint-components.js";
+import { registerLintCommand } from "./commands/lint.js";
+import { registerReportCommand } from "./commands/report.js";
+import { Logger } from "./utils/logger.js";
+process.on("unhandledRejection", (error) => {
+  Logger.error(`Unhandled rejection: ${error}`);
+  process.exit(1);
+});
+process.on("uncaughtException", (error) => {
+  Logger.error(`Uncaught exception: ${error}`);
+  process.exit(1);
+});
+var program = new Command();
+program.name("linting-cli").description("A CLI tool for linting styles and components").version("1.0.0");
+registerLintStylesCommand(program);
+registerLintComponentsCommand(program);
+registerLintCommand(program);
+registerReportCommand(program);
+program.parse(process.argv);

package/build/services/__tests__/file-scanner.test.js

@@ -0,0 +1,44 @@
+// src/services/__tests__/file-scanner.test.ts
+import path from "path";
+import { FileScanner } from "../file-scanner.js";
+import { StyleFilePatterns } from "../file-patterns.js";
+import { mkdir, writeFile, rm } from "fs/promises";
+describe("FileScanner", () => {
+  const testDir = path.join(import.meta.dirname, "fixtures");
+  beforeAll(async () => {
+    await mkdir(testDir, { recursive: true });
+    await writeFile(
+      path.join(testDir, "test.css"),
+      "body { color: red; }"
+    );
+    await writeFile(
+      path.join(testDir, "test.scss"),
+      "$color: red;"
+    );
+  });
+  afterAll(async () => {
+    await rm(testDir, { recursive: true });
+  });
+  it("should scan and batch files correctly", async () => {
+    const options = {
+      patterns: StyleFilePatterns,
+      batchSize: 1
+    };
+    const batches = await FileScanner.scanFiles(testDir, options);
+    expect(batches).toHaveLength(2);
+    expect(batches[0]).toHaveLength(1);
+    expect(batches[1]).toHaveLength(1);
+    expect(batches[0][0]).toMatch(/test\.(css|scss)$/);
+    expect(batches[1][0]).toMatch(/test\.(css|scss)$/);
+  });
+  it("should handle invalid files gracefully", async () => {
+    const options = {
+      patterns: {
+        include: ["**/*.nonexistent"],
+        exclude: []
+      }
+    };
+    const batches = await FileScanner.scanFiles(testDir, options);
+    expect(batches).toHaveLength(0);
+  });
+});

package/build/services/batch-processor.d.ts

@@ -0,0 +1,29 @@
+export interface BatchProcessorOptions {
+    maxWorkers?: number;
+    timeoutMs?: number;
+}
+export interface BatchTask<T> {
+    files: string[];
+    config: T;
+}
+export interface BatchResult {
+    success: boolean;
+    error?: string;
+    results: any[];
+}
+export declare class BatchProcessor {
+    private static DEFAULT_MAX_WORKERS;
+    private static DEFAULT_TIMEOUT_MS;
+    /**
+     * Process batches of files in parallel using worker threads
+     * @param batches Array of file batches to process
+     * @param workerScript Path to the worker script
+     * @param taskConfig Configuration to pass to each worker
+     * @param options Processing options
+     */
+    static processBatches<T>(batches: string[][], workerScript: string, taskConfig: T, options?: BatchProcessorOptions): Promise<BatchResult[]>;
+    /**
+     * Creates a new worker with timeout handling
+     */
+    private static createWorker;
+}

package/build/services/batch-processor.js

@@ -0,0 +1,84 @@
+// src/services/batch-processor.ts
+import { Worker } from "worker_threads";
+import os from "os";
+import { Logger } from "../utils/logger.js";
+var AVAILABLE_CPUS = os.cpus().length - 1;
+var BatchProcessor = class {
+  static DEFAULT_MAX_WORKERS = Math.max(1, Math.min(4, AVAILABLE_CPUS));
+  static DEFAULT_TIMEOUT_MS = 3e5;
+  // 5 minutes
+  /**
+   * Process batches of files in parallel using worker threads
+   * @param batches Array of file batches to process
+   * @param workerScript Path to the worker script
+   * @param taskConfig Configuration to pass to each worker
+   * @param options Processing options
+   */
+  static async processBatches(batches, workerScript, taskConfig, options = {}) {
+    const maxWorkers = options.maxWorkers || this.DEFAULT_MAX_WORKERS;
+    const timeoutMs = options.timeoutMs || this.DEFAULT_TIMEOUT_MS;
+    Logger.debug(`Starting batch processing with ${maxWorkers} workers`);
+    Logger.debug(`Processing ${batches.length} batches`);
+    const results = [];
+    const activeWorkers = /* @__PURE__ */ new Set();
+    let currentBatchIndex = 0;
+    try {
+      while (currentBatchIndex < batches.length || activeWorkers.size > 0) {
+        while (activeWorkers.size < maxWorkers && currentBatchIndex < batches.length) {
+          const batchIndex = currentBatchIndex++;
+          const batch = batches[batchIndex];
+          const worker = this.createWorker(
+            workerScript,
+            { files: batch, config: taskConfig },
+            timeoutMs
+          );
+          activeWorkers.add(worker);
+          worker.on("message", (result) => {
+            results.push(result);
+            activeWorkers.delete(worker);
+            Logger.debug(`Completed batch ${batchIndex} of ${batches.length}`);
+          }).on("error", (error) => {
+            results.push({
+              success: false,
+              error: error.message,
+              results: []
+            });
+            activeWorkers.delete(worker);
+            Logger.error(`Worker error in batch ${batchIndex}: ${error.message}`);
+          }).on("exit", (code) => {
+            if (code !== 0) {
+              Logger.warning(`Worker exited with code ${code}`);
+            }
+            activeWorkers.delete(worker);
+          });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      return results;
+    } catch (error) {
+      Logger.error(`Batch processing failed: ${error.message}`);
+      throw error;
+    } finally {
+      for (const worker of activeWorkers) {
+        worker.terminate();
+      }
+    }
+  }
+  /**
+   * Creates a new worker with timeout handling
+   */
+  static createWorker(scriptPath, task, timeoutMs) {
+    const worker = new Worker(scriptPath, {
+      workerData: task
+    });
+    const timeoutId = setTimeout(() => {
+      Logger.warning(`Worker timeout after ${timeoutMs}ms`);
+      worker.terminate();
+    }, timeoutMs);
+    worker.once("exit", () => clearTimeout(timeoutId));
+    return worker;
+  }
+};
+export {
+  BatchProcessor
+};

package/build/services/config.resolver.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_ESLINT_CONFIG_PATH: string;
+export declare const DEFAULT_STYLELINT_CONFIG_PATH: string;
+export declare const STYLELINT_VERSION: string;
+export declare const ESLINT_VERSION: string;
+export declare const LINTER_CLI_VERSION: string;
+export declare const getRuleDescription: (ruleId: string) => string;

package/build/services/config.resolver.js

@@ -0,0 +1,23 @@
+// src/services/config.resolver.ts
+import { fileURLToPath } from "url";
+import stylelintPackage from "stylelint/package.json" with { type: "json" };
+import eslintPackage from "eslint/package.json" with { type: "json" };
+import cliPackage from "../../package.json" with { type: "json" };
+import { ruleMetadata } from "@salesforce-ux/stylelint-plugin-slds";
+var DEFAULT_ESLINT_CONFIG_PATH = fileURLToPath(import.meta.resolve("@salesforce-ux/eslint-plugin-slds/.eslintrc.yml"));
+var DEFAULT_STYLELINT_CONFIG_PATH = fileURLToPath(import.meta.resolve("@salesforce-ux/stylelint-plugin-slds/.stylelintrc.yml"));
+var STYLELINT_VERSION = stylelintPackage.version;
+var ESLINT_VERSION = eslintPackage.version;
+var LINTER_CLI_VERSION = cliPackage.version;
+var getRuleDescription = (ruleId) => {
+  const ruleIdWithoutNameSpace = `${ruleId}`.replace(/\@salesforce-ux\//, "");
+  return ruleMetadata(ruleIdWithoutNameSpace)?.ruleDesc || "--";
+};
+export {
+  DEFAULT_ESLINT_CONFIG_PATH,
+  DEFAULT_STYLELINT_CONFIG_PATH,
+  ESLINT_VERSION,
+  LINTER_CLI_VERSION,
+  STYLELINT_VERSION,
+  getRuleDescription
+};

package/build/services/file-patterns.d.ts

@@ -0,0 +1,3 @@
+import { FilePattern } from './file-scanner';
+export declare const StyleFilePatterns: FilePattern;
+export declare const ComponentFilePatterns: FilePattern;

package/build/services/file-patterns.js

@@ -0,0 +1,33 @@
+// src/services/file-patterns.ts
+var StyleFilePatterns = {
+  include: [
+    "**/*.css",
+    "**/*.scss",
+    "**/*.less",
+    "**/*.sass"
+  ],
+  exclude: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**"
+  ]
+};
+var ComponentFilePatterns = {
+  include: [
+    "**/*.html",
+    "**/*.cmp",
+    "**/*.component",
+    "**/*.app",
+    "**/*.page",
+    "**/*.interface"
+  ],
+  exclude: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**"
+  ]
+};
+export {
+  ComponentFilePatterns,
+  StyleFilePatterns
+};

package/build/services/file-scanner.d.ts

@@ -0,0 +1,26 @@
+export interface FilePattern {
+    include: string[];
+    exclude?: string[];
+}
+export interface ScanOptions {
+    patterns: FilePattern;
+    batchSize?: number;
+}
+export declare class FileScanner {
+    private static DEFAULT_BATCH_SIZE;
+    /**
+     * Scans directory for files matching the given patterns
+     * @param directory Base directory to scan
+     * @param options Scanning options including patterns and batch size
+     * @returns Array of file paths in batches
+     */
+    static scanFiles(directory: string, options: ScanOptions): Promise<string[][]>;
+    /**
+     * Validates that files exist and are readable
+     */
+    private static validateFiles;
+    /**
+     * Splits array of files into batches
+     */
+    private static createBatches;
+}

package/build/services/file-scanner.js

@@ -0,0 +1,69 @@
+// src/services/file-scanner.ts
+import { promises as fs } from "fs";
+import { glob } from "glob";
+import { Logger } from "../utils/logger.js";
+var FileScanner = class {
+  static DEFAULT_BATCH_SIZE = 100;
+  /**
+   * Scans directory for files matching the given patterns
+   * @param directory Base directory to scan
+   * @param options Scanning options including patterns and batch size
+   * @returns Array of file paths in batches
+   */
+  static async scanFiles(directory, options) {
+    try {
+      Logger.debug(`Scanning directory: ${directory}`);
+      Logger.debug(`Include patterns: ${options.patterns.include.join(", ")}`);
+      const allFiles = [];
+      for (const pattern of options.patterns.include) {
+        const files = await glob(pattern, {
+          cwd: directory,
+          ignore: options.patterns.exclude,
+          withFileTypes: true,
+          dot: true
+          // Include .dot files
+        }).then((matches) => matches.filter((match) => match.isFile()).map((match) => {
+          return match.fullpath();
+        }));
+        allFiles.push(...files);
+      }
+      const uniqueFiles = [...new Set(allFiles)];
+      const validFiles = await this.validateFiles(uniqueFiles);
+      const batchSize = options.batchSize || this.DEFAULT_BATCH_SIZE;
+      const batches = this.createBatches(validFiles, batchSize);
+      Logger.debug(`Found ${validFiles.length} files, split into ${batches.length} batches`);
+      return batches;
+    } catch (error) {
+      Logger.error(`Failed to scan files: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Validates that files exist and are readable
+   */
+  static async validateFiles(files) {
+    const validFiles = [];
+    for (const file of files) {
+      try {
+        await fs.access(file, fs.constants.R_OK);
+        validFiles.push(file);
+      } catch (error) {
+        Logger.warning(`Skipping inaccessible file: ${file}`);
+      }
+    }
+    return validFiles;
+  }
+  /**
+   * Splits array of files into batches
+   */
+  static createBatches(files, batchSize) {
+    const batches = [];
+    for (let i = 0; i < files.length; i += batchSize) {
+      batches.push(files.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+};
+export {
+  FileScanner
+};

package/build/services/lint-runner.d.ts

@@ -0,0 +1,17 @@
+import { LintResult } from '../types';
+export interface LintOptions {
+    fix?: boolean;
+    configPath?: string;
+    maxWorkers?: number;
+    timeoutMs?: number;
+}
+export declare class LintRunner {
+    /**
+     * Run linting on batches of files
+     */
+    static runLinting(fileBatches: string[][], workerType: 'style' | 'component', options?: LintOptions): Promise<LintResult[]>;
+    /**
+     * Process and normalize worker results
+     */
+    private static processResults;
+}