@fabasoad/sarif-to-slack 1.3.0 → 1.3.2

package/dist/index.cjs

@@ -32,7 +32,6 @@ var index_exports = {};
 __export(index_exports, {
   Color: () => Color,
   FooterType: () => FooterType,
-  LogLevel: () => LogLevel,
   RepresentationType: () => RepresentationType,
   SarifToSlackClient: () => SarifToSlackClient,
   SendIf: () => SendIf
@@ -165,20 +164,91 @@ function sendIfLogMessage(sendIf) {
   }
 }
 
-// src/model/SlackMessage.ts
-var import_webhook = require("@slack/webhook");
+// src/SarifToSlackClient.ts
+var import_node_fs2 = require("fs");
+
+// src/Logger.ts
+var import_tslog = require("tslog");
+var import_zod2 = require("zod");
+
+// src/system.ts
+var import_zod = require("zod");
+
+// src/metadata.json
+var version = "1.3.2";
+var sha = "7f304afbd27622223e810bcac958e15bfde8d56d";
+var buildAt = "2025-10-01T12:12:59Z";
+
+// src/system.ts
+function logMetadata() {
+  const logger = new Logger(logMetadata.name);
+  logger.info(`version: ${version}`);
+  logger.info(`sha: ${sha}`);
+  logger.info(`built at: ${buildAt}`);
+}
+function isDebug() {
+  const parseResult = import_zod.z.stringbool().safeParse(
+    process.env.ACTIONS_STEP_DEBUG
+  );
+  return parseResult.success && parseResult.data;
+}
+
+// src/Logger.ts
+var LogLevelItems = ["silly", "trace", "debug", "info", "warning", "error", "fatal"];
+var Logger = class _Logger {
+  static APP_NAME = "@fabasoad/sarif-to-slack";
+  static DEFAULT_LOG_LEVEL = "info";
+  static DEFAULT_LOG_TEMPLATE = "[{{logLevelName}}] [{{name}}] {{dateIsoStr}} ";
+  static DEFAULT_LOG_COLORED = true;
+  _instance;
+  isLogLevel(v) {
+    return LogLevelItems.includes(v);
+  }
+  getMinLevel() {
+    let result = _Logger.DEFAULT_LOG_LEVEL;
+    if (isDebug()) {
+      result = "silly";
+    } else {
+      const parseResult = import_zod2.z.string().refine((v) => this.isLogLevel(v)).transform((v) => v).safeParse(process.env.SARIF_TO_SLACK_LOG_LEVEL);
+      if (parseResult.success) {
+        result = parseResult.data;
+      }
+    }
+    return LogLevelItems.findIndex((v) => v === result);
+  }
+  getLogTemplate() {
+    const result = import_zod2.z.string().safeParse(process.env.SARIF_TO_SLACK_LOG_TEMPLATE);
+    return result.success ? result.data : _Logger.DEFAULT_LOG_TEMPLATE;
+  }
+  getLogColored() {
+    const result = import_zod2.z.stringbool().safeParse(process.env.SARIF_TO_SLACK_LOG_COLORED);
+    return result.success ? result.data : _Logger.DEFAULT_LOG_COLORED;
+  }
+  constructor(memberName) {
+    this._instance = new import_tslog.Logger({
+      name: `${_Logger.APP_NAME}${memberName === void 0 ? "" : `::${memberName}`}`,
+      minLevel: this.getMinLevel(),
+      type: "pretty",
+      prettyLogTimeZone: "UTC",
+      prettyLogTemplate: this.getLogTemplate(),
+      stylePrettyLogs: this.getLogColored()
+    });
+  }
+  info(...args) {
+    this._instance.info(...args);
+  }
+  warn(...args) {
+    this._instance.warn(...args);
+  }
+  trace(...args) {
+    this._instance.trace(...args);
+  }
+  debug(...args) {
+    this._instance.debug(...args);
+  }
+};
 
 // src/types.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["Silly"] = 0] = "Silly";
-  LogLevel2[LogLevel2["Trace"] = 1] = "Trace";
-  LogLevel2[LogLevel2["Debug"] = 2] = "Debug";
-  LogLevel2[LogLevel2["Info"] = 3] = "Info";
-  LogLevel2[LogLevel2["Warning"] = 4] = "Warning";
-  LogLevel2[LogLevel2["Error"] = 5] = "Error";
-  LogLevel2[LogLevel2["Fatal"] = 6] = "Fatal";
-  return LogLevel2;
-})(LogLevel || {});
 var FooterType = /* @__PURE__ */ ((FooterType2) => {
   FooterType2["PlainText"] = "plain_text";
   FooterType2["Markdown"] = "mrkdwn";
@@ -193,6 +263,12 @@ var RepresentationType = /* @__PURE__ */ ((RepresentationType2) => {
   RepresentationType2[RepresentationType2["CompactGroupBySarifPerSeverity"] = 5] = "CompactGroupBySarifPerSeverity";
   RepresentationType2[RepresentationType2["CompactTotalPerLevel"] = 6] = "CompactTotalPerLevel";
   RepresentationType2[RepresentationType2["CompactTotalPerSeverity"] = 7] = "CompactTotalPerSeverity";
+  RepresentationType2[RepresentationType2["TableGroupByRunPerLevel"] = 8] = "TableGroupByRunPerLevel";
+  RepresentationType2[RepresentationType2["TableGroupByRunPerSeverity"] = 9] = "TableGroupByRunPerSeverity";
+  RepresentationType2[RepresentationType2["TableGroupByToolNamePerLevel"] = 10] = "TableGroupByToolNamePerLevel";
+  RepresentationType2[RepresentationType2["TableGroupByToolNamePerSeverity"] = 11] = "TableGroupByToolNamePerSeverity";
+  RepresentationType2[RepresentationType2["TableGroupBySarifPerLevel"] = 12] = "TableGroupBySarifPerLevel";
+  RepresentationType2[RepresentationType2["TableGroupBySarifPerSeverity"] = 13] = "TableGroupBySarifPerSeverity";
   return RepresentationType2;
 })(RepresentationType || {});
 var SecuritySeverity = /* @__PURE__ */ ((SecuritySeverity2) => {
@@ -204,6 +280,9 @@ var SecuritySeverity = /* @__PURE__ */ ((SecuritySeverity2) => {
   SecuritySeverity2[SecuritySeverity2["Critical"] = 5] = "Critical";
   return SecuritySeverity2;
 })(SecuritySeverity || {});
+var SecuritySeverityValues = Object.values(SecuritySeverity).filter(
+  (v) => typeof v === "string"
+);
 var SecurityLevel = /* @__PURE__ */ ((SecurityLevel2) => {
   SecurityLevel2[SecurityLevel2["Unknown"] = 0] = "Unknown";
   SecurityLevel2[SecurityLevel2["None"] = 1] = "None";
@@ -212,176 +291,64 @@ var SecurityLevel = /* @__PURE__ */ ((SecurityLevel2) => {
   SecurityLevel2[SecurityLevel2["Error"] = 4] = "Error";
   return SecurityLevel2;
 })(SecurityLevel || {});
+var SecurityLevelValues = Object.values(SecurityLevel).filter(
+  (v) => typeof v === "string"
+);
 
-// src/metadata.json
-var version = "1.3.0";
-var sha = "5c2d7ac234dc99d16b3d8ec9c05475ce26a6a573";
-var buildAt = "2025-08-21T13:21:58Z";
-
-// src/model/SlackMessage.ts
-function createSlackMessage(url, opts) {
-  return new SlackMessageImpl(url, opts);
-}
-var SlackMessageImpl = class {
-  _webhook;
-  _gitHubServerUrl;
-  _color;
-  _representation;
-  _header;
-  _footer;
-  _actor;
-  _runId;
-  constructor(url, opts) {
-    this._webhook = new import_webhook.IncomingWebhook(url, {
-      username: opts.username || "SARIF results",
-      icon_url: opts.iconUrl
-    });
-    this._gitHubServerUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
-    this._color = opts.color;
-    this._representation = opts.representation;
-  }
-  withHeader(header) {
-    this._header = {
-      type: "header",
-      text: {
-        type: "plain_text",
-        text: header || process.env.GITHUB_REPOSITORY || "SARIF results"
-      }
-    };
-  }
-  withActor(actor) {
-    this._actor = actor || process.env.GITHUB_ACTOR;
-  }
-  withRun() {
-    this._runId = process.env.GITHUB_RUN_ID;
-  }
-  withFooter(text, type) {
-    const repoName = "fabasoad/sarif-to-slack";
-    const element = text ? { type: type || "plain_text" /* PlainText */, text } : { type: "mrkdwn" /* Markdown */, text: `Generated by <${this._gitHubServerUrl}/${repoName}|@${repoName}@${version}>` };
-    this._footer = {
-      type: "context",
-      elements: [element]
-    };
-  }
-  async send() {
-    const blocks = [];
-    if (this._header) {
-      blocks.push(this._header);
-    }
-    blocks.push({
-      type: "section",
-      text: {
-        type: "mrkdwn",
-        text: this.buildText()
+// src/utils/FileUtils.ts
+var import_node_fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function listFiles(dir, recursive, extension, fileList = []) {
+  if (import_node_fs.default.statSync(dir).isDirectory()) {
+    const entries = import_node_fs.default.readdirSync(dir);
+    entries.forEach((entry) => {
+      const fullPath = path.join(dir, entry);
+      if (recursive && import_node_fs.default.statSync(fullPath).isDirectory()) {
+        listFiles(fullPath, recursive, extension, fileList);
+      } else if (path.extname(fullPath).toLowerCase() === `.${extension}`) {
+        fileList.push(fullPath);
       }
     });
-    if (this._footer) {
-      blocks.push(this._footer);
-    }
-    const { text } = await this._webhook.send({
-      attachments: [{ color: this._color, blocks }]
-    });
-    return text;
   }
-  buildText() {
-    const text = [];
-    if (this._actor) {
-      const actorUrl = `${this._gitHubServerUrl}/${this._actor}`;
-      text.push(`_Triggered by <${actorUrl}|${this._actor}>_`);
-    }
-    text.push(this._representation.compose());
-    if (this._runId) {
-      let runText = "Job ";
-      if (process.env.GITHUB_REPOSITORY) {
-        runText += `<${this._gitHubServerUrl}/${process.env.GITHUB_REPOSITORY}/actions/runs/${this._runId}|#${this._runId}>`;
-      } else {
-        runText += `#${this._runId}`;
-      }
-      text.push(runText);
-    }
-    return text.join("\n\n");
-  }
-};
-
-// src/SarifToSlackClient.ts
-var import_fs2 = require("fs");
-
-// src/Logger.ts
-var import_tslog = require("tslog");
-var Logger = class _Logger {
-  static DEFAULT_LOG_LEVEL = 3 /* Info */;
-  static DEFAULT_LOG_TEMPLATE = "[{{logLevelName}}] [{{name}}] {{dateIsoStr}} ";
-  static DEFAULT_LOG_COLORED = true;
-  static instance;
-  static initialize(opts) {
-    if (!_Logger.instance) {
-      _Logger.instance = new import_tslog.Logger({
-        name: "@fabasoad/sarif-to-slack",
-        minLevel: process.env.ACTIONS_STEP_DEBUG === "true" ? 0 /* Silly */ : opts?.level ?? _Logger.DEFAULT_LOG_LEVEL,
-        type: "pretty",
-        prettyLogTimeZone: "UTC",
-        prettyLogTemplate: opts?.template ?? _Logger.DEFAULT_LOG_TEMPLATE,
-        stylePrettyLogs: opts?.colored ?? _Logger.DEFAULT_LOG_COLORED
-      });
-    }
-  }
-  static warn(...args) {
-    _Logger.instance.warn(...args);
-  }
-  static info(...args) {
-    _Logger.instance.info(...args);
-  }
-  static debug(...args) {
-    _Logger.instance.debug(...args);
-  }
-  static trace(...args) {
-    _Logger.instance.trace(...args);
-  }
-};
-
-// src/System.ts
-var System = class {
-  static initialize() {
-    Logger.info(`@fabasoad/sarif-to-slack version: ${version}`);
-    Logger.info(`@fabasoad/sarif-to-slack sha: ${sha}`);
-    Logger.info(`@fabasoad/sarif-to-slack built at: ${buildAt}`);
-  }
-};
-
-// src/utils/FileUtils.ts
-var import_fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-function listFilesRecursively(dir, extension, fileList = []) {
-  const entries = import_fs.default.readdirSync(dir);
-  entries.forEach((entry) => {
-    const fullPath = path.join(dir, entry);
-    if (import_fs.default.statSync(fullPath).isDirectory()) {
-      listFilesRecursively(fullPath, extension, fileList);
-    } else if (path.extname(fullPath).toLowerCase() === `.${extension}`) {
-      fileList.push(fullPath);
-    }
-  });
   return fileList;
 }
 function extractListOfFiles(opts) {
-  if (!import_fs.default.existsSync(opts.path)) {
+  const logger = new Logger(extractListOfFiles.name);
+  if (!import_node_fs.default.existsSync(opts.path)) {
     throw new Error(`Provided path does not exist: ${opts.path}`);
   }
-  const stats = import_fs.default.statSync(opts.path);
+  const stats = import_node_fs.default.statSync(opts.path);
   if (stats.isDirectory()) {
-    Logger.info(`Provided path is a directory: ${opts.path}`);
-    const files = opts.recursive && listFilesRecursively(opts.path, opts.extension ?? "sarif") || import_fs.default.readdirSync(opts.path);
-    Logger.info(`Found ${files.length} files in ${opts.path} directory with ${opts.extension} extension`);
-    Logger.debug(`Found files: ${files.join(", ")}`);
+    logger.info(`Provided path is a directory: ${opts.path}`);
+    const files = listFiles(opts.path, !!opts.recursive, opts.extension ?? "sarif");
+    logger.info(`Found ${files.length} files in ${opts.path} directory with ${opts.extension} extension`);
+    logger.debug(`Found files: ${files.join(", ")}`);
     return files;
   }
   if (stats.isFile()) {
-    Logger.info(`Provided path is a file: ${opts.path}`);
+    logger.info(`Provided path is a file: ${opts.path}`);
     return [opts.path];
   }
   throw new Error(`Provided path is neither a file nor a directory: ${opts.path}`);
 }
 
+// src/utils/ExtendedArray.ts
+var ExtendedArray = class extends Array {
+  findByProperty(prop, value) {
+    return this.find((v) => v[prop] === value);
+  }
+};
+
+// src/model/FindingArray.ts
+var FindingArray = class extends ExtendedArray {
+  hasSeverityOrHigher(severity) {
+    return Object.values(SecuritySeverity).filter((v) => typeof v === "number").filter((v) => v >= severity).some((v) => this.findByProperty("severity", v) != null);
+  }
+  hasLevelOrHigher(level) {
+    return Object.values(SecurityLevel).filter((v) => typeof v === "number").filter((v) => v >= level).some((v) => this.findByProperty("level", v) != null);
+  }
+};
+
 // src/utils/Comparators.ts
 function findingsComparatorByKey(key) {
   return (a, b) => {
@@ -400,23 +367,6 @@ function findingsComparatorByKey(key) {
   };
 }
 
-// src/utils/ExtendedArray.ts
-var ExtendedArray = class extends Array {
-  findByProperty(prop, value) {
-    return this.find((v) => v[prop] === value);
-  }
-};
-
-// src/model/FindingArray.ts
-var FindingArray = class extends ExtendedArray {
-  hasSeverityOrHigher(severity) {
-    return Object.values(SecuritySeverity).filter((v) => typeof v === "number").filter((v) => v >= severity).some((v) => this.findByProperty("severity", v) != null);
-  }
-  hasLevelOrHigher(level) {
-    return Object.values(SecurityLevel).filter((v) => typeof v === "number").filter((v) => v >= level).some((v) => this.findByProperty("level", v) != null);
-  }
-};
-
 // src/representations/Representation.ts
 var Representation = class {
   _model;
@@ -433,6 +383,9 @@ var Representation = class {
   italic(text) {
     return `_${text}_`;
   }
+  codeBlock(text) {
+    return "```\n" + text + "\n```";
+  }
 };
 
 // src/representations/CompactGroupByRepresentation.ts
@@ -454,7 +407,7 @@ ${summary}`;
     const result = [];
     findings.reduce((grouped, f) => {
       if (!grouped.get(f[key])) {
-        grouped.set(f[key], new Array());
+        grouped.set(f[key], []);
       }
       grouped.get(f[key])?.push(f);
       return grouped;
@@ -606,6 +559,306 @@ var CompactTotalPerLevelRepresentation = class extends CompactTotalRepresentatio
   }
 };
 
+// src/representations/table/Column.ts
+var Column = class {
+  constructor(header, cellsCount) {
+    this.header = header;
+    this._cells = new Array(cellsCount);
+  }
+  _logger = new Logger("Column");
+  _cells;
+  get total() {
+    return this._cells.reduce((sum, c) => {
+      sum += Number(c.value);
+      return sum;
+    }, 0);
+  }
+  get width() {
+    return Math.max(
+      ...this._cells.map((c) => c.getWidth()),
+      this.total.toString().length
+    );
+  }
+  setCell(index, value) {
+    if (index >= 0 && index < this._cells.length) {
+      this._cells[index] = value;
+      const width = this.width;
+      this._cells.forEach((c) => c.setWidth(width));
+    } else {
+      this._logger.warn(`Cell index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`);
+    }
+  }
+};
+
+// src/representations/table/Cell.ts
+var Cell = class {
+  constructor(_value = 0) {
+    this._value = _value;
+    this._width = _value.toString().length;
+  }
+  _width;
+  setWidth(width) {
+    this._width = width > this._width ? width : this._width;
+  }
+  getWidth() {
+    return this._width;
+  }
+  get value() {
+    return this._value;
+  }
+  toString() {
+    const str = this._value.toString();
+    const repeatCount = this._width - str.length;
+    return `${str}${repeatCount > 0 ? " ".repeat(repeatCount) : ""}`;
+  }
+};
+
+// src/representations/table/Row.ts
+var Row = class {
+  constructor(_header, headerWidth, cellsCount) {
+    this._header = _header;
+    this.headerWidth = headerWidth;
+    this._cells = Array.from({ length: cellsCount }, () => new Cell());
+    this._totalWidth = 1;
+  }
+  _logger = new Logger("Row");
+  _cells;
+  _totalWidth;
+  get total() {
+    return this._cells.reduce((sum, c) => {
+      sum += Number(c.value);
+      return sum;
+    }, 0);
+  }
+  setCell(index, value) {
+    if (index >= 0 && index < this._cells.length) {
+      this._cells[index] = value;
+    } else {
+      this._logger.warn(`Setting cell failed. Reason: index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`);
+    }
+  }
+  get totalWidth() {
+    return this._totalWidth;
+  }
+  setTotalWidth(value) {
+    this._totalWidth = value;
+  }
+  toString() {
+    const result = [];
+    result.push(`${this._header}${this.headerWidth > this._header.length ? " ".repeat(this.headerWidth - this._header.length) : ""}`);
+    this._cells.map((c) => c.toString()).forEach((v) => result.push(v));
+    const totalStr = this.total.toString();
+    result.push(`${totalStr}${this._totalWidth > totalStr.length ? " ".repeat(this._totalWidth - totalStr.length) : ""}`);
+    return `|${result.join("|")}|`;
+  }
+};
+
+// src/representations/table/Table.ts
+var HEADER_TOTAL = "Total";
+var Table = class {
+  header;
+  columns;
+  rows;
+  constructor(headers) {
+    this.header = headers.main ?? "";
+    this.columns = Array.from(
+      { length: headers.columns.length },
+      (_, index) => new Column(headers.columns[index], headers.rows.length)
+    );
+    const headerWidth = Math.max(
+      this.header.length,
+      ...headers.rows.map((v) => v.length),
+      HEADER_TOTAL.length
+    );
+    this.rows = Array.from(
+      { length: headers.rows.length },
+      (_, index) => new Row(headers.rows[index], headerWidth, headers.columns.length)
+    );
+  }
+  set(rowIndex, columnIndex, v) {
+    if (rowIndex >= 0 && rowIndex < this.rows.length && columnIndex >= 0 && columnIndex < this.columns.length) {
+      const cell = new Cell(v);
+      cell.setWidth(this.columns[columnIndex].header.length);
+      this.columns[columnIndex].setCell(rowIndex, cell);
+      this.rows[rowIndex].setCell(columnIndex, cell);
+      const rowTotalWidth = Math.max(
+        // Based on the sum of all total values
+        this.rows.reduce((sum, r) => {
+          sum += r.total;
+          return sum;
+        }, 0).toString().length,
+        // Based on the width of "Total" header
+        HEADER_TOTAL.length
+      );
+      this.rows.forEach((r) => r.setTotalWidth(rowTotalWidth));
+    }
+  }
+  toString() {
+    const rowsStr = [];
+    if (this.rows.length > 0 && this.columns.length > 0) {
+      this.rows.forEach((row) => rowsStr.push(row.toString()));
+      const rowSeparator = rowsStr[0].replace(/[^|]/g, "-");
+      rowsStr.unshift(rowSeparator);
+      rowsStr.push(rowSeparator);
+      const rowTotal = [];
+      let sumTotal = 0;
+      for (const column of this.columns) {
+        const total = column.total;
+        rowTotal.push(`${total}${total.toString().length < column.width ? " ".repeat(column.width - total.toString().length) : ""}`);
+        sumTotal += total;
+      }
+      const column1 = `${HEADER_TOTAL}${this.rows[0].headerWidth > HEADER_TOTAL.length ? " ".repeat(this.rows[0].headerWidth - HEADER_TOTAL.length) : ""}`;
+      const columnLast = `${sumTotal}${sumTotal.toString().length < HEADER_TOTAL.length ? " ".repeat(HEADER_TOTAL.length - sumTotal.toString().length) : ""}`;
+      rowsStr.push(`|${column1}|${rowTotal.join("|")}|${columnLast}|`);
+      const rowTop = [
+        this.header + (this.header.length < this.rows[0].headerWidth ? " ".repeat(this.rows[0].headerWidth - this.header.length) : ""),
+        this.columns.map((c) => `${c.header}${c.header.length < c.width ? " ".repeat(c.width - c.header.length) : ""}`).join("|"),
+        HEADER_TOTAL + (HEADER_TOTAL.length < this.rows[0].totalWidth ? " ".repeat(this.rows[0].totalWidth - HEADER_TOTAL.length) : "")
+      ];
+      rowsStr.unshift(`|${rowTop.join("|")}|`);
+    }
+    return rowsStr.join("\n").replace(/[|]/g, " | ");
+  }
+};
+
+// src/representations/TableGroupRepresentation.ts
+var TableGroupRepresentation = class extends Representation {
+  constructor(_keyBy, _keyPer, _values, model) {
+    super(model, "toolName");
+    this._keyBy = _keyBy;
+    this._keyPer = _keyPer;
+    this._values = _values;
+  }
+  _logger = new Logger("TableGroupRepresentation");
+  groupFindingsPer(findings) {
+    return findings.reduce(
+      (grouped, f) => {
+        grouped[f[this._keyPer]].push(f);
+        return grouped;
+      },
+      Array.from({ length: this._values.length }, () => [])
+    );
+  }
+  keyByToString(key) {
+    return key.toString();
+  }
+  groupFindingsBy(findings) {
+    return findings.reduce(
+      (grouped, f) => {
+        const key = this.keyByToString(f[this._keyBy]);
+        if (!grouped.has(key)) {
+          grouped.set(key, []);
+        }
+        grouped.get(key)?.push(f);
+        return grouped;
+      },
+      /* @__PURE__ */ new Map()
+    );
+  }
+  get title() {
+    switch (this._keyBy) {
+      case "toolName":
+        return "Tool";
+      case "runId":
+        return "Run #";
+      case "sarifPath":
+        return "File #";
+      default:
+        return "";
+    }
+  }
+  compose() {
+    const groupedBy = this.groupFindingsBy(this._model.findings);
+    const table = new Table({
+      main: this.title,
+      rows: Array.from(groupedBy.keys()),
+      columns: this._values
+    });
+    let i = 0;
+    for (const findings of groupedBy.values()) {
+      const grouped = this.groupFindingsPer(findings);
+      for (let j = 0; j < grouped.length; j++) {
+        table.set(i, j, grouped[j].length);
+      }
+      i++;
+    }
+    const result = this.codeBlock(table.toString());
+    this._logger.trace(result);
+    return result;
+  }
+};
+
+// src/representations/TableGroupByToolNameRepresentation.ts
+var TableGroupByToolNameRepresentation = class extends TableGroupRepresentation {
+  constructor(keyPer, values, model) {
+    super("toolName", keyPer, values, model);
+  }
+};
+
+// src/representations/TableGroupByToolNamePerLevelRepresentation.ts
+var TableGroupByToolNamePerLevelRepresentation = class extends TableGroupByToolNameRepresentation {
+  constructor(model) {
+    super("level", SecurityLevelValues, model);
+  }
+};
+
+// src/representations/TableGroupByToolNamePerSeverityRepresentation.ts
+var TableGroupByToolNamePerSeverityRepresentation = class extends TableGroupByToolNameRepresentation {
+  constructor(model) {
+    super("severity", SecuritySeverityValues, model);
+  }
+};
+
+// src/representations/TableGroupByRunRepresentation.ts
+var TableGroupByRunRepresentation = class extends TableGroupRepresentation {
+  constructor(keyPer, values, model) {
+    super("runId", keyPer, values, model);
+  }
+};
+
+// src/representations/TableGroupByRunPerLevelRepresentation.ts
+var TableGroupByRunPerLevelRepresentation = class extends TableGroupByRunRepresentation {
+  constructor(model) {
+    super("level", SecurityLevelValues, model);
+  }
+};
+
+// src/representations/TableGroupByRunPerSeverityRepresentation.ts
+var TableGroupByRunPerSeverityRepresentation = class extends TableGroupByRunRepresentation {
+  constructor(model) {
+    super("severity", SecuritySeverityValues, model);
+  }
+};
+
+// src/representations/TableGroupBySarifRepresentation.ts
+var TableGroupBySarifRepresentation = class extends TableGroupRepresentation {
+  _fileToNumberMap = /* @__PURE__ */ new Map();
+  constructor(keyPer, values, model) {
+    super("sarifPath", keyPer, values, model);
+  }
+  keyByToString(key) {
+    const keyStr = key.toString();
+    if (!this._fileToNumberMap.has(keyStr)) {
+      this._fileToNumberMap.set(keyStr, this._fileToNumberMap.size + 1);
+    }
+    return this._fileToNumberMap.get(keyStr)?.toString();
+  }
+};
+
+// src/representations/TableGroupBySarifPerLevelRepresentation.ts
+var TableGroupBySarifPerLevelRepresentation = class extends TableGroupBySarifRepresentation {
+  constructor(model) {
+    super("level", SecurityLevelValues, model);
+  }
+};
+
+// src/representations/TableGroupBySarifPerSeverityRepresentation.ts
+var TableGroupBySarifPerSeverityRepresentation = class extends TableGroupBySarifRepresentation {
+  constructor(model) {
+    super("severity", SecuritySeverityValues, model);
+  }
+};
+
 // src/representations/RepresentationFactory.ts
 function createRepresentation(model, type = 3 /* CompactGroupByToolNamePerSeverity */) {
   switch (type) {
@@ -625,6 +878,18 @@ function createRepresentation(model, type = 3 /* CompactGroupByToolNamePerSeveri
       return new CompactTotalPerLevelRepresentation(model);
     case 7 /* CompactTotalPerSeverity */:
       return new CompactTotalPerSeverityRepresentation(model);
+    case 8 /* TableGroupByRunPerLevel */:
+      return new TableGroupByRunPerLevelRepresentation(model);
+    case 9 /* TableGroupByRunPerSeverity */:
+      return new TableGroupByRunPerSeverityRepresentation(model);
+    case 10 /* TableGroupByToolNamePerLevel */:
+      return new TableGroupByToolNamePerLevelRepresentation(model);
+    case 11 /* TableGroupByToolNamePerSeverity */:
+      return new TableGroupByToolNamePerSeverityRepresentation(model);
+    case 12 /* TableGroupBySarifPerLevel */:
+      return new TableGroupBySarifPerLevelRepresentation(model);
+    case 13 /* TableGroupBySarifPerSeverity */:
+      return new TableGroupBySarifPerSeverityRepresentation(model);
     default:
       throw new Error(`Unknown representation type: ${type}`);
   }
@@ -763,6 +1028,7 @@ function createFinding(opts) {
   return new FindingImpl(opts);
 }
 var FindingImpl = class {
+  _logger = new Logger("FindingImpl");
   _runMetadata;
   _result;
   _sarifPath;
@@ -808,7 +1074,7 @@ var FindingImpl = class {
       this._levelCache = this._processor.tryFindLevel();
     }
     if (this._levelCache === void 0) {
-      Logger.debug(`Unknown level of ${this._rule?.id} rule`);
+      this._logger.debug(`Unknown level of ${this._rule?.id} rule`);
       return 0 /* Unknown */;
     }
     switch (this._levelCache) {
@@ -824,7 +1090,7 @@ var FindingImpl = class {
   }
   get severity() {
     if (this.cvssScore == null || this.cvssScore < 0 || this.cvssScore > 10) {
-      Logger.debug(`Unsupported CVSS score ${this.cvssScore} in ${this._rule?.id} rule`);
+      this._logger.debug(`Unsupported CVSS score ${this.cvssScore} in ${this._rule?.id} rule`);
       return 0 /* Unknown */;
     }
     if (this.cvssScore >= 9) {
@@ -844,167 +1110,257 @@ var FindingImpl = class {
 };
 
 // src/model/color/ColorIdentification.ts
-function logColorTaken(color, prop) {
-  Logger.debug(`Message has ${color?.color} color taken from '${prop}' property.`);
+function logColorTaken(logger, color, prop) {
+  logger.debug(`Message has ${color?.color} color taken from '${prop}' property.`);
 }
-function logPropDefinedButNoFindings(key, val) {
+function logPropDefinedButNoFindings(logger, key, val) {
   const prop = key === "level" ? "byLevel" : "bySeverity";
-  Logger.trace(`'${prop}.${val}' property is defined but no findings with "${val}" ${key} is found. Continue color identification...`);
+  logger.trace(`'${prop}.${val}' property is defined but no findings with "${val}" ${key} is found. Continue color identification...`);
 }
-function logPropIsNotDefined(key, val) {
+function logPropIsNotDefined(logger, key, val) {
   const prop = key === "level" ? "byLevel" : "bySeverity";
-  Logger.trace(`'${prop}.${val}' property is not defined. Continue color identification...`);
+  logger.trace(`'${prop}.${val}' property is not defined. Continue color identification...`);
 }
 function identifyColorCommon(findings, prop, none, unknown, color) {
+  const logger = new Logger(identifyColorCommon.name);
   if (color.none) {
     if (findings.findByProperty(prop, none) != null) {
-      logColorTaken(color.none, `${prop === "severity" ? "bySeverity" : "byLevel"}.none`);
+      logColorTaken(logger, color.none, `${prop === "severity" ? "bySeverity" : "byLevel"}.none`);
       return color.none.color;
     } else {
-      logPropDefinedButNoFindings(prop, "none");
+      logPropDefinedButNoFindings(logger, prop, "none");
     }
   } else {
-    logPropIsNotDefined(prop, "none");
+    logPropIsNotDefined(logger, prop, "none");
   }
   if (color.unknown) {
     if (findings.findByProperty(prop, unknown) != null) {
-      logColorTaken(color.unknown, `${prop === "severity" ? "bySeverity" : "byLevel"}.unknown`);
+      logColorTaken(logger, color.unknown, `${prop === "severity" ? "bySeverity" : "byLevel"}.unknown`);
       return color.unknown.color;
     } else {
-      logPropDefinedButNoFindings(prop, "unknown");
+      logPropDefinedButNoFindings(logger, prop, "unknown");
     }
   } else {
-    logPropIsNotDefined(prop, "unknown");
+    logPropIsNotDefined(logger, prop, "unknown");
   }
   return void 0;
 }
 function identifyColorBySeverity(findings, color) {
+  const logger = new Logger(identifyColorBySeverity.name);
   if (color.critical) {
     if (findings.findByProperty("severity", 5 /* Critical */) != null) {
-      logColorTaken(color.critical, "bySeverity.critical");
+      logColorTaken(logger, color.critical, "bySeverity.critical");
       return color.critical.color;
     } else {
-      logPropDefinedButNoFindings("severity", "critical");
+      logPropDefinedButNoFindings(logger, "severity", "critical");
     }
   } else {
-    logPropIsNotDefined("severity", "critical");
+    logPropIsNotDefined(logger, "severity", "critical");
   }
   if (color.high) {
     if (findings.findByProperty("severity", 4 /* High */) != null) {
-      logColorTaken(color.high, "bySeverity.high");
+      logColorTaken(logger, color.high, "bySeverity.high");
       return color.high.color;
     } else {
-      logPropDefinedButNoFindings("severity", "high");
+      logPropDefinedButNoFindings(logger, "severity", "high");
     }
   } else {
-    logPropIsNotDefined("severity", "high");
+    logPropIsNotDefined(logger, "severity", "high");
   }
   if (color.medium) {
     if (findings.findByProperty("severity", 3 /* Medium */) != null) {
-      logColorTaken(color.medium, "bySeverity.medium");
+      logColorTaken(logger, color.medium, "bySeverity.medium");
       return color.medium.color;
     } else {
-      logPropDefinedButNoFindings("severity", "medium");
+      logPropDefinedButNoFindings(logger, "severity", "medium");
     }
   } else {
-    logPropIsNotDefined("severity", "medium");
+    logPropIsNotDefined(logger, "severity", "medium");
   }
   if (color.low) {
     if (findings.findByProperty("severity", 2 /* Low */) != null) {
-      logColorTaken(color.low, "bySeverity.low");
+      logColorTaken(logger, color.low, "bySeverity.low");
       return color.low.color;
     } else {
-      logPropDefinedButNoFindings("severity", "low");
+      logPropDefinedButNoFindings(logger, "severity", "low");
     }
   } else {
-    logPropIsNotDefined("severity", "low");
+    logPropIsNotDefined(logger, "severity", "low");
   }
   return identifyColorCommon(findings, "severity", 1 /* None */, 0 /* Unknown */, color);
 }
 function identifyColorByLevel(findings, color) {
+  const logger = new Logger(identifyColorByLevel.name);
   if (color.error) {
     if (findings.findByProperty("level", 4 /* Error */) != null) {
-      logColorTaken(color.error, "byLevel.error");
+      logColorTaken(logger, color.error, "byLevel.error");
       return color.error.color;
     } else {
-      logPropDefinedButNoFindings("level", "error");
+      logPropDefinedButNoFindings(logger, "level", "error");
     }
   } else {
-    logPropIsNotDefined("level", "error");
+    logPropIsNotDefined(logger, "level", "error");
   }
   if (color.warning) {
     if (findings.findByProperty("level", 3 /* Warning */) != null) {
-      logColorTaken(color.warning, "byLevel.warning");
+      logColorTaken(logger, color.warning, "byLevel.warning");
       return color.warning.color;
     } else {
-      logPropDefinedButNoFindings("level", "warning");
+      logPropDefinedButNoFindings(logger, "level", "warning");
     }
   } else {
-    logPropIsNotDefined("level", "warning");
+    logPropIsNotDefined(logger, "level", "warning");
   }
   if (color.note != null) {
     if (findings.findByProperty("level", 2 /* Note */) != null) {
-      logColorTaken(color.note, "byLevel.note");
+      logColorTaken(logger, color.note, "byLevel.note");
       return color.note.color;
     } else {
-      logPropDefinedButNoFindings("level", "note");
+      logPropDefinedButNoFindings(logger, "level", "note");
     }
   } else {
-    logPropIsNotDefined("level", "note");
+    logPropIsNotDefined(logger, "level", "note");
   }
   return identifyColorCommon(findings, "level", 1 /* None */, 0 /* Unknown */, color);
 }
 function identifyColor(findings, colorOpts) {
+  const logger = new Logger(identifyColor.name);
   if (!colorOpts) {
-    Logger.debug("Message has no color as color options are not defined.");
+    logger.debug("Message has no color as color options are not defined.");
     return void 0;
   }
-  Logger.trace(`Identifying color for ${findings.length} findings and the following color options:`, JSON.stringify(colorOpts, null, 2));
+  logger.trace(`Identifying color for ${findings.length} findings and the following color options:`, JSON.stringify(colorOpts, null, 2));
   if (colorOpts.bySeverity) {
     const color = identifyColorBySeverity(findings, colorOpts.bySeverity);
     if (color) {
       return color;
     }
-    Logger.trace("None of the properties in 'bySeverity' group is applicable. Continue color identification...");
+    logger.trace("None of the properties in 'bySeverity' group is applicable. Continue color identification...");
   } else {
-    Logger.trace("'bySeverity' group is not defined. Continue color identification...");
+    logger.trace("'bySeverity' group is not defined. Continue color identification...");
   }
   if (colorOpts.byLevel) {
     const color = identifyColorByLevel(findings, colorOpts.byLevel);
     if (color) {
       return color;
     }
-    Logger.trace("None of the properties in 'byLevel' group is applicable. Continue color identification...");
+    logger.trace("None of the properties in 'byLevel' group is applicable. Continue color identification...");
   } else {
-    Logger.trace("'byLevel' group is not defined. Continue color identification...");
+    logger.trace("'byLevel' group is not defined. Continue color identification...");
   }
   if (findings.length === 0) {
-    Logger.trace('There are no findings in the provided SARIF file(s). Checking if color is defined in "empty" property...');
+    logger.trace('There are no findings in the provided SARIF file(s). Checking if color is defined in "empty" property...');
     if (colorOpts.empty?.color) {
-      logColorTaken(colorOpts.empty, "empty");
+      logColorTaken(logger, colorOpts.empty, "empty");
       return colorOpts.empty.color;
     } else {
-      Logger.trace('"empty" color is not defined. Continue color identification...');
+      logger.trace('"empty" color is not defined. Continue color identification...');
     }
   } else {
-    Logger.trace(`"empty" color is not taken into account because there are ${findings.length} findings in the provided SARIF file(s). Continue color identification...`);
+    logger.trace(`"empty" color is not taken into account because there are ${findings.length} findings in the provided SARIF file(s). Continue color identification...`);
   }
   if (colorOpts.default?.color) {
-    logColorTaken(colorOpts.default, "default");
+    logColorTaken(logger, colorOpts.default, "default");
   } else {
-    Logger.debug("Message has no color as none of the defined color options is applicable.");
+    logger.debug("Message has no color as none of the defined color options is applicable.");
   }
   return colorOpts?.default?.color;
 }
 
+// src/model/SlackMessage.ts
+var import_webhook = require("@slack/webhook");
+function createSlackMessage(url, opts) {
+  return new SlackMessageImpl(url, opts);
+}
+var SlackMessageImpl = class {
+  _webhook;
+  _gitHubServerUrl;
+  _color;
+  _representation;
+  _header;
+  _footer;
+  _actor;
+  _runId;
+  constructor(url, opts) {
+    this._webhook = new import_webhook.IncomingWebhook(url, {
+      username: opts.username || "SARIF results",
+      icon_url: opts.iconUrl
+    });
+    this._gitHubServerUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
+    this._color = opts.color;
+    this._representation = opts.representation;
+  }
+  withHeader(header) {
+    this._header = {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: header || process.env.GITHUB_REPOSITORY || "SARIF results"
+      }
+    };
+  }
+  withActor(actor) {
+    this._actor = actor || process.env.GITHUB_ACTOR;
+  }
+  withRun() {
+    this._runId = process.env.GITHUB_RUN_ID;
+  }
+  withFooter(text, type) {
+    const repoName = "fabasoad/sarif-to-slack";
+    const element = text ? { type: type || "plain_text" /* PlainText */, text } : { type: "mrkdwn" /* Markdown */, text: `Generated by <${this._gitHubServerUrl}/${repoName}|@${repoName}@${version}>` };
+    this._footer = {
+      type: "context",
+      elements: [element]
+    };
+  }
+  async send() {
+    const blocks = [];
+    if (this._header) {
+      blocks.push(this._header);
+    }
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: this.buildText()
+      }
+    });
+    if (this._footer) {
+      blocks.push(this._footer);
+    }
+    const { text } = await this._webhook.send({
+      attachments: [{ color: this._color, blocks }]
+    });
+    return text;
+  }
+  buildText() {
+    const text = [];
+    if (this._actor) {
+      const actorUrl = `${this._gitHubServerUrl}/${this._actor}`;
+      text.push(`_Triggered by <${actorUrl}|${this._actor}>_`);
+    }
+    text.push(this._representation.compose());
+    if (this._runId) {
+      let runText = "Job ";
+      if (process.env.GITHUB_REPOSITORY) {
+        runText += `<${this._gitHubServerUrl}/${process.env.GITHUB_REPOSITORY}/actions/runs/${this._runId}|#${this._runId}>`;
+      } else {
+        runText += `#${this._runId}`;
+      }
+      text.push(runText);
+    }
+    return text.join("\n\n");
+  }
+};
+
 // src/SarifToSlackClient.ts
 var SarifToSlackClient = class _SarifToSlackClient {
+  _logger = new Logger("SarifToSlackClient");
   _message;
   _sarifModel;
   _sendIf = 20 /* Always */;
-  constructor(log) {
-    Logger.initialize(log);
-    System.initialize();
+  constructor() {
+    logMetadata();
   }
   static *createRunIdGenerator() {
     let runId = 1;
@@ -1012,11 +1368,22 @@ var SarifToSlackClient = class _SarifToSlackClient {
       yield runId++;
     }
   }
-  static async create(opts) {
-    const instance = new _SarifToSlackClient(opts.log);
+  /**
+   * Creates an instance of {@link SarifToSlackClient} class. It already has all
+   * properties and fields initialized.
+   * @param webhookUrl - Slack webhook URL.
+   * @param opts - An instance of {@link SarifToSlackClientOptions} type.
+   *
+   * @see SarifToSlackClientOptions
+   *
+   * @public
+   */
+  static async create(webhookUrl, opts) {
+    const instance = new _SarifToSlackClient();
+    instance._logger.trace(opts);
     instance._sendIf = opts.sendIf ?? instance._sendIf;
     instance._sarifModel = await _SarifToSlackClient.buildModel(opts.sarif);
-    instance._message = await _SarifToSlackClient.initialize(instance._sarifModel, opts);
+    instance._message = await _SarifToSlackClient.initialize(webhookUrl, opts, instance._sarifModel);
     return instance;
   }
   static async buildModel(sarifOpts) {
@@ -1027,11 +1394,11 @@ var SarifToSlackClient = class _SarifToSlackClient {
     const model = { sarifFiles, runs: [], findings: new FindingArray() };
     const runIdGenerator = _SarifToSlackClient.createRunIdGenerator();
     for (const sarifPath of sarifFiles) {
-      const sarifJson = await import_fs2.promises.readFile(sarifPath, "utf8");
+      const sarifJson = await import_node_fs2.promises.readFile(sarifPath, "utf8");
       const sarifLog = JSON.parse(sarifJson);
       for (const run of sarifLog.runs) {
         const runId = runIdGenerator.next();
-        let runMetadata = void 0;
+        let runMetadata;
         for (const result of run.results ?? []) {
           runMetadata = {
             id: runId.value,
@@ -1053,13 +1420,15 @@ var SarifToSlackClient = class _SarifToSlackClient {
   /**
    * The main function to initialize a list of {@link SlackMessage} objects based
    * on the given SARIF file(s).
-   * @param sarifModel - An instance of SarifModel object.
+   * @param webhookUrl - Slack webhook URL.
    * @param opts - An instance of {@link SarifToSlackClientOptions} object.
+   * @param sarifModel - An instance of SarifModel object.
    * @returns A map where key is the SARIF file and value is an instance of
    * {@link SlackMessage} object.
+   * @internal
    */
-  static async initialize(sarifModel, opts) {
-    const message = createSlackMessage(opts.webhookUrl, {
+  static async initialize(webhookUrl, opts, sarifModel) {
+    const message = createSlackMessage(webhookUrl, {
       username: opts.username,
       iconUrl: opts.iconUrl,
       color: identifyColor(sarifModel.findings, opts.color),
@@ -1094,9 +1463,9 @@ var SarifToSlackClient = class _SarifToSlackClient {
         throw new Error("Slack message was not prepared.");
       }
       const text = await this._message.send();
-      Logger.info("Message sent. Status:", text);
+      this._logger.info("Message sent. Status:", text);
     } else {
-      Logger.info(sendIfLogMessage(this._sendIf));
+      this._logger.info(sendIfLogMessage(this._sendIf));
     }
   }
   get shouldSendMessage() {
@@ -1161,7 +1530,6 @@ var SarifToSlackClient = class _SarifToSlackClient {
 0 && (module.exports = {
   Color,
   FooterType,
-  LogLevel,
   RepresentationType,
   SarifToSlackClient,
   SendIf