@salesforce-ux/slds-linter 0.2.0 → 0.2.2-alpha-2-alpha.0

package/build/commands/emit.d.ts

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

package/build/commands/emit.js

@@ -0,0 +1,48 @@
+// src/commands/emit.ts
+import chalk from "chalk";
+import { Logger } from "../utils/logger.js";
+import { normalizeCliOptions } from "../utils/config-utils.js";
+import {
+  DEFAULT_ESLINT_CONFIG_PATH,
+  DEFAULT_STYLELINT_CONFIG_PATH
+} from "../services/config.resolver.js";
+import path from "path";
+import { copyFile } from "fs/promises";
+function registerEmitCommand(program) {
+  program.command("emit").description("Emits the configuration files used by slds-linter cli").option(
+    "-d, --directory <path>",
+    "Target directory to emit (defaults to current directory). Support glob patterns"
+  ).action(async (options) => {
+    try {
+      Logger.info(chalk.blue("Emitting configuration files..."));
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStylelint: DEFAULT_STYLELINT_CONFIG_PATH,
+        configEslint: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      const destStyleConfigPath = path.join(
+        normalizedOptions.directory,
+        path.basename(normalizedOptions.configStylelint)
+      );
+      await copyFile(normalizedOptions.configStylelint, destStyleConfigPath);
+      Logger.success(chalk.green(`Stylelint configuration created at:
+${destStyleConfigPath}
+`));
+      const destESLintConfigPath = path.join(
+        normalizedOptions.directory,
+        path.basename(normalizedOptions.configEslint)
+      );
+      await copyFile(normalizedOptions.configEslint, destESLintConfigPath);
+      Logger.success(chalk.green(`ESLint configuration created at:
+${destESLintConfigPath}
+`));
+    } catch (error) {
+      Logger.error(
+        chalk.red(`Failed to emit configuration: ${error.message}`)
+      );
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerEmitCommand
+};

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,55 @@
+// src/commands/lint.ts
+import { Option } from "commander";
+import chalk from "chalk";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions, normalizeDirectoryPath } from "../utils/config-utils.js";
+import { Logger } from "../utils/logger.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+import { lint } from "../executor/index.js";
+function registerLintCommand(program) {
+  program.command("lint").aliases(["lint:styles", "lint:components"]).configureHelp({
+    commandUsage: () => {
+      return `${program.name()} lint [directory] [options]`;
+    }
+  }).description("Run both style and component linting").argument("[directory]", "Target directory to scan (defaults to current directory). Support glob patterns").addOption(new Option("-d, --directory <path>", "Target directory to scan (defaults to current directory). Support glob patterns").hideHelp()).option("--fix", "Automatically fix problems").option("--config-stylelint <path>", "Path to stylelint config file").option("--config-eslint <path>", "Path to eslint config file").option("--editor <editor>", "Editor to open files with (e.g., vscode, atom, sublime). Defaults to vscode", "vscode").action(async (directory, options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting lint process..."));
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStylelint: DEFAULT_STYLELINT_CONFIG_PATH,
+        configEslint: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      if (directory) {
+        normalizedOptions.directory = normalizeDirectoryPath(directory);
+      } else if (options.directory) {
+        Logger.newLine().warning(chalk.yellow(
+          `WARNING: --directory, -d option is deprecated. Supply as argument instead.
+            Example: npx @salesforce-ux/slds-linter lint ${options.directory}`
+        ));
+      }
+      const lintResults = await lint({
+        directory: normalizedOptions.directory,
+        fix: normalizedOptions.fix,
+        configStylelint: normalizedOptions.configStylelint,
+        configEslint: normalizedOptions.configEslint
+      });
+      printLintResults(lintResults, normalizedOptions.editor);
+      const errorCount = lintResults.reduce((sum, r) => sum + r.errors.length, 0);
+      const warningCount = lintResults.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(
+        `
+${chalk.red(`${errorCount} error${errorCount !== 1 ? "s" : ""}`)}  ${chalk.yellow(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`)}`
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`
+Linting completed in ${elapsedTime} seconds.`));
+      process.exit(errorCount > 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,66 @@
+// src/commands/report.ts
+import { Option } from "commander";
+import path from "path";
+import ora from "ora";
+import chalk from "chalk";
+import fs from "fs";
+import { normalizeCliOptions, normalizeDirectoryPath } from "../utils/config-utils.js";
+import { Logger } from "../utils/logger.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+import { report, lint } from "../executor/index.js";
+function registerReportCommand(program) {
+  program.command("report").description("Generate report from linting results").argument("[directory]", "Target directory to scan (defaults to current directory). Support glob patterns").addOption(new Option("-d, --directory <path>", "Target directory to scan (defaults to current directory). Support glob patterns").hideHelp()).option("-o, --output <path>", "Output directory for reports (defaults to current directory)").option("--config-stylelint <path>", "Path to stylelint config file").option("--config-eslint <path>", "Path to eslint config file").addOption(new Option("--format <type>", "Output format").choices(["sarif", "csv"]).default("sarif")).action(async (directory, options) => {
+    const spinner = ora("Starting report generation...");
+    try {
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStylelint: DEFAULT_STYLELINT_CONFIG_PATH,
+        configEslint: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      if (directory) {
+        normalizedOptions.directory = normalizeDirectoryPath(directory);
+      } else if (options.directory) {
+        Logger.newLine().warning(chalk.yellow(
+          `WARNING: --directory, -d option is deprecated. Supply as argument instead.
+            Example: npx @salesforce-ux/slds-linter report ${options.directory}`
+        ));
+      }
+      spinner.start();
+      const reportFormat = normalizedOptions.format?.toLowerCase() || "sarif";
+      const lintResults = await lint({
+        directory: normalizedOptions.directory,
+        configStylelint: normalizedOptions.configStylelint,
+        configEslint: normalizedOptions.configEslint
+      });
+      const reportStream = await report({
+        format: reportFormat
+      }, lintResults);
+      let outputFilePath;
+      if (reportFormat === "sarif") {
+        spinner.text = "Saving SARIF report...";
+        outputFilePath = path.join(normalizedOptions.output, "slds-linter-report.sarif");
+      } else if (reportFormat === "csv") {
+        spinner.text = "Saving CSV report...";
+        outputFilePath = path.join(normalizedOptions.output, "slds-linter-report.csv");
+      } else {
+        throw new Error(`Invalid format: ${reportFormat}. Supported formats: sarif, csv`);
+      }
+      const writeStream = fs.createWriteStream(outputFilePath);
+      reportStream.pipe(writeStream);
+      await new Promise((resolve, reject) => {
+        writeStream.on("finish", resolve);
+        writeStream.on("error", reject);
+      });
+      Logger.success(`${reportFormat.toUpperCase()} report generated: ${outputFilePath}
+`);
+      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/executor/__tests__/executor.test.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/executor/index.ts
+var executor_exports = {};
+__export(executor_exports, {
+  lint: () => lint,
+  report: () => report
+});
+import { Readable } from "stream";
+import { FileScanner } from "../services/file-scanner.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { ReportGenerator, CsvReportGenerator } from "../services/report-generator.js";
+import { LINTER_CLI_VERSION } from "../services/config.resolver.js";
+import { normalizeCliOptions } from "../utils/config-utils.js";
+import { Logger } from "../utils/logger.js";
+async function lint(config) {
+  try {
+    Logger.debug("Starting linting with Node API");
+    const normalizedConfig = normalizeCliOptions(config, {}, true);
+    const styleFiles = await FileScanner.scanFiles(normalizedConfig.directory, {
+      patterns: StyleFilePatterns,
+      batchSize: 100
+    });
+    const componentFiles = await FileScanner.scanFiles(normalizedConfig.directory, {
+      patterns: ComponentFilePatterns,
+      batchSize: 100
+    });
+    const lintOptions = {
+      fix: normalizedConfig.fix,
+      configPath: normalizedConfig.configStylelint
+    };
+    const styleResults = await LintRunner.runLinting(styleFiles, "style", {
+      ...lintOptions,
+      configPath: normalizedConfig.configStylelint
+    });
+    const componentResults = await LintRunner.runLinting(componentFiles, "component", {
+      ...lintOptions,
+      configPath: normalizedConfig.configEslint
+    });
+    const combinedResults = [...styleResults, ...componentResults];
+    return standardizeLintMessages(combinedResults);
+  } catch (error) {
+    const errorMessage = `Linting failed: ${error.message}`;
+    Logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+async function report(config, results) {
+  try {
+    Logger.debug("Starting report generation with Node API");
+    const normalizedConfig = normalizeCliOptions(config, {}, true);
+    const format = normalizedConfig.format || "sarif";
+    const lintResults = results || await lint({
+      directory: normalizedConfig.directory,
+      configStylelint: normalizedConfig.configStylelint,
+      configEslint: normalizedConfig.configEslint
+    });
+    switch (format) {
+      case "sarif":
+        return ReportGenerator.generateSarifReportStream(lintResults, {
+          toolName: "slds-linter",
+          toolVersion: LINTER_CLI_VERSION
+        });
+      case "csv":
+        const csvString = CsvReportGenerator.generateCsvString(lintResults);
+        const csvStream = new Readable();
+        csvStream.push(csvString);
+        csvStream.push(null);
+        return csvStream;
+      default:
+        const errorMessage = `Unsupported format: ${format}`;
+        Logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+  } catch (error) {
+    const errorMessage = `Report generation failed: ${error.message}`;
+    Logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+function standardizeLintMessages(results) {
+  return results.map((result) => ({
+    ...result,
+    errors: result.errors.map((entry) => {
+      let msgObj;
+      try {
+        msgObj = JSON.parse(entry.message);
+        if (typeof msgObj === "object" && "message" in msgObj) {
+          return { ...entry, ...msgObj };
+        }
+      } catch {
+      }
+      return { ...entry, message: entry.message };
+    }),
+    warnings: result.warnings.map((entry) => {
+      let msgObj;
+      try {
+        msgObj = JSON.parse(entry.message);
+        if (typeof msgObj === "object" && "message" in msgObj) {
+          return { ...entry, ...msgObj };
+        }
+      } catch {
+      }
+      return { ...entry, message: entry.message };
+    })
+  }));
+}
+var init_executor = __esm({
+  "src/executor/index.ts"() {
+  }
+});
+
+// src/executor/__tests__/executor.test.ts
+import { lint as lint2, report as report2 } from "../index.js";
+import { LintRunner as LintRunner2 } from "../../services/lint-runner.js";
+import { FileScanner as FileScanner2 } from "../../services/file-scanner.js";
+import { Readable as Readable2 } from "stream";
+import { jest } from "@jest/globals.js";
+var mockLintResult = {
+  filePath: "file1.css",
+  errors: [{ line: 1, column: 1, endColumn: 10, message: "Test error", ruleId: "test-rule", severity: 2 }],
+  warnings: []
+};
+jest.mock("../../services/lint-runner", () => {
+  return {
+    LintRunner: {
+      runLinting: jest.fn().mockImplementation(() => {
+        return Promise.resolve([mockLintResult]);
+      })
+    }
+  };
+});
+jest.mock("../../services/file-scanner", () => {
+  return {
+    FileScanner: {
+      scanFiles: jest.fn().mockImplementation(() => {
+        return Promise.resolve([["file1.css"]]);
+      })
+    }
+  };
+});
+jest.mock("fs/promises");
+xdescribe("Executor functions", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe("lint", () => {
+    it("should scan directory and run linting when no files are provided", async () => {
+      const config = {
+        directory: "./src",
+        fix: true
+      };
+      const results = await lint2(config);
+      expect(FileScanner2.scanFiles).toHaveBeenCalledTimes(2);
+      expect(LintRunner2.runLinting).toHaveBeenCalledTimes(2);
+      expect(results).toHaveLength(2);
+    });
+    it("should use provided files and skip scanning when files are provided", async () => {
+      const config = {
+        files: ["file1.css", "component1.html"]
+      };
+      await lint2(config);
+      expect(FileScanner2.scanFiles).not.toHaveBeenCalled();
+      expect(LintRunner2.runLinting).toHaveBeenCalledTimes(2);
+    });
+  });
+  describe("report", () => {
+    it("should return a readable stream", async () => {
+      const config = {
+        directory: "./src",
+        format: "sarif"
+      };
+      const stream = await report2(config);
+      expect(stream).toBeInstanceOf(Readable2);
+    });
+    it("should use lint results to generate a report", async () => {
+      const lintMock = jest.spyOn((init_executor(), __toCommonJS(executor_exports)), "lint").mockResolvedValue([mockLintResult]);
+      const config = {
+        directory: "./src",
+        format: "sarif"
+      };
+      await report2(config);
+      expect(lintMock).toHaveBeenCalledWith({
+        directory: "./src",
+        configStylelint: expect.any(String),
+        configEslint: expect.any(String)
+      });
+      lintMock.mockRestore();
+    });
+  });
+});
+describe("Executor placeholder tests", () => {
+  it("should be implemented in the future", () => {
+    expect(true).toBe(true);
+  });
+});

package/build/executor/index.d.ts

@@ -0,0 +1,20 @@
+import { Readable } from 'stream';
+import { LintResult, LintConfig, ReportConfig } from '../types';
+/**
+ * Run linting on specified files or directory
+ *
+ * @param config Linting configuration options
+ * @returns Promise resolving to an array of lint results
+ * @throws Error if linting fails
+ */
+export declare function lint(config: LintConfig): Promise<LintResult[]>;
+/**
+ * Generate a report from linting results
+ *
+ * @param config Report configuration options
+ * @param results Optional lint results (if not provided, will run lint)
+ * @returns A readable stream containing the report data
+ * @throws Error if report generation fails
+ */
+export declare function report(config: ReportConfig, results?: LintResult[]): Promise<Readable>;
+export type { LintResult, LintResultEntry, LintConfig, ReportConfig, ExitCode, WorkerResult, SarifResultEntry } from '../types';

package/build/executor/index.js

@@ -0,0 +1,105 @@
+// src/executor/index.ts
+import { Readable } from "stream";
+import { FileScanner } from "../services/file-scanner.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { ReportGenerator, CsvReportGenerator } from "../services/report-generator.js";
+import { LINTER_CLI_VERSION } from "../services/config.resolver.js";
+import { normalizeCliOptions } from "../utils/config-utils.js";
+import { Logger } from "../utils/logger.js";
+async function lint(config) {
+  try {
+    Logger.debug("Starting linting with Node API");
+    const normalizedConfig = normalizeCliOptions(config, {}, true);
+    const styleFiles = await FileScanner.scanFiles(normalizedConfig.directory, {
+      patterns: StyleFilePatterns,
+      batchSize: 100
+    });
+    const componentFiles = await FileScanner.scanFiles(normalizedConfig.directory, {
+      patterns: ComponentFilePatterns,
+      batchSize: 100
+    });
+    const lintOptions = {
+      fix: normalizedConfig.fix,
+      configPath: normalizedConfig.configStylelint
+    };
+    const styleResults = await LintRunner.runLinting(styleFiles, "style", {
+      ...lintOptions,
+      configPath: normalizedConfig.configStylelint
+    });
+    const componentResults = await LintRunner.runLinting(componentFiles, "component", {
+      ...lintOptions,
+      configPath: normalizedConfig.configEslint
+    });
+    const combinedResults = [...styleResults, ...componentResults];
+    return standardizeLintMessages(combinedResults);
+  } catch (error) {
+    const errorMessage = `Linting failed: ${error.message}`;
+    Logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+async function report(config, results) {
+  try {
+    Logger.debug("Starting report generation with Node API");
+    const normalizedConfig = normalizeCliOptions(config, {}, true);
+    const format = normalizedConfig.format || "sarif";
+    const lintResults = results || await lint({
+      directory: normalizedConfig.directory,
+      configStylelint: normalizedConfig.configStylelint,
+      configEslint: normalizedConfig.configEslint
+    });
+    switch (format) {
+      case "sarif":
+        return ReportGenerator.generateSarifReportStream(lintResults, {
+          toolName: "slds-linter",
+          toolVersion: LINTER_CLI_VERSION
+        });
+      case "csv":
+        const csvString = CsvReportGenerator.generateCsvString(lintResults);
+        const csvStream = new Readable();
+        csvStream.push(csvString);
+        csvStream.push(null);
+        return csvStream;
+      default:
+        const errorMessage = `Unsupported format: ${format}`;
+        Logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+  } catch (error) {
+    const errorMessage = `Report generation failed: ${error.message}`;
+    Logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+function standardizeLintMessages(results) {
+  return results.map((result) => ({
+    ...result,
+    errors: result.errors.map((entry) => {
+      let msgObj;
+      try {
+        msgObj = JSON.parse(entry.message);
+        if (typeof msgObj === "object" && "message" in msgObj) {
+          return { ...entry, ...msgObj };
+        }
+      } catch {
+      }
+      return { ...entry, message: entry.message };
+    }),
+    warnings: result.warnings.map((entry) => {
+      let msgObj;
+      try {
+        msgObj = JSON.parse(entry.message);
+        if (typeof msgObj === "object" && "message" in msgObj) {
+          return { ...entry, ...msgObj };
+        }
+      } catch {
+      }
+      return { ...entry, message: entry.message };
+    })
+  }));
+}
+export {
+  lint,
+  report
+};

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { registerLintCommand } from "./commands/lint.js";
+import { registerReportCommand } from "./commands/report.js";
+import { registerEmitCommand } from "./commands/emit.js";
+import { Logger } from "./utils/logger.js";
+import { validateNodeVersion } from "./utils/nodeVersionUtil.js";
+validateNodeVersion();
+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("npx @salesforce-ux/slds-linter@latest").showHelpAfterError();
+function registerVersion() {
+  program.description("SLDS Linter CLI tool for linting styles and components").version("0.2.2-alpha-2-alpha.0");
+}
+registerLintCommand(program);
+registerReportCommand(program);
+registerEmitCommand(program);
+registerVersion();
+program.configureHelp({
+  subcommandTerm: (cmd) => {
+    return cmd.name();
+  }
+});
+program.parse(process.argv);

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

@@ -0,0 +1,47 @@
+// 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";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+describe("FileScanner", () => {
+  const testDir = path.join(__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: {
+        extensions: ["nonexistent"],
+        exclude: []
+      }
+    };
+    const batches = await FileScanner.scanFiles(testDir, options);
+    expect(batches).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,6 @@
+import { Artifact as SarifArtifact } from 'sarif';
+/**
+ * Process artifacts and add file content properties
+ * @param artifacts Array of artifacts to process
+ */
+export declare function processArtifacts(artifacts: SarifArtifact[]): Promise<void>;

package/build/services/artifact-processor.js

@@ -0,0 +1,37 @@
+// src/services/artifact-processor.ts
+import path from "path";
+import fs from "fs/promises";
+import crypto from "crypto";
+var BATCH_SIZE = 10;
+async function processArtifacts(artifacts) {
+  const batches = Array.from(
+    { length: Math.ceil(artifacts.length / BATCH_SIZE) },
+    (_, i) => artifacts.slice(i * BATCH_SIZE, (i + 1) * BATCH_SIZE)
+  );
+  for (const batch of batches) {
+    await Promise.all(
+      batch.map(async (artifact) => {
+        try {
+          artifact.sourceLanguage = "html";
+          if (!artifact.location?.uri) {
+            console.warn("Warning: Artifact missing location URI");
+            return;
+          }
+          const filePath = path.join(process.cwd(), artifact.location.uri);
+          const content = await fs.readFile(filePath, "utf-8");
+          artifact.length = content.length;
+          const hash = crypto.createHash("sha256");
+          hash.update(content);
+          artifact.hashes = {
+            "sha-256": hash.digest("hex")
+          };
+        } catch (error) {
+          console.warn(`Warning: Could not process artifact ${artifact.location?.uri}: ${error.message}`);
+        }
+      })
+    );
+  }
+}
+export {
+  processArtifacts
+};