qualink 0.2.0 → 0.4.0

package/dist/cli/parse-metadata.js

@@ -2,10 +2,10 @@ import { asOptionalString } from "../utils/assert.js";
 import { CliError } from "./cli-error.js";
 import { argValue, envOrArg } from "./common-args.js";
 import { detectBranch, detectCommitSha, detectPipelineProvider, detectPipelineRunId, } from "./detect-ci.js";
-import { detectPackageName } from "./detect-package.js";
 import { detectProjectName } from "./detect-project.js";
 import { detectRepo } from "./detect-repo.js";
-const DEFAULT_COLLECTOR_VERSION = "0.1.0";
+import { detectSolution } from "./detect-solution.js";
+export const DEFAULT_COLLECTOR_VERSION = "0.1.0";
 function parseTags(value) {
     if (typeof value !== "string" || value.trim().length === 0) {
         return [];
@@ -42,7 +42,7 @@ export function parseCommonMetadata(args) {
         pipelineRunId,
         pipelineProvider,
         environment: environmentRaw,
-        packageName: asOptionalString(detectPackageName(args)),
+        solution: asOptionalString(detectSolution(args)),
         projectName: asOptionalString(detectProjectName(args)),
         collectorVersion,
     };

package/dist/collectors/eslint.d.ts

@@ -1,6 +1,7 @@
 import type { CommonMetadata, EslintMetricDocument, Language } from "../types.js";
 interface EslintMessage {
     ruleId: string | null;
+    severity?: number | undefined;
 }
 interface EslintFileResult {
     filePath: string;
@@ -9,6 +10,7 @@ interface EslintFileResult {
     fixableErrorCount: number;
     fixableWarningCount: number;
     messages: EslintMessage[];
+    suppressedMessages: EslintMessage[];
 }
 export interface EslintCollectorOptions {
     includeRules: boolean;

package/dist/collectors/eslint.js

@@ -12,16 +12,20 @@ function asEslintResults(input) {
         if (!Array.isArray(messagesRaw)) {
             throw new Error("Invalid ESLint messages array");
         }
-        const messages = messagesRaw.map((message) => {
+        const parseMessages = (raw) => raw.map((message) => {
             if (!isRecord(message)) {
                 return { ruleId: null };
             }
             const ruleValue = message.ruleId;
+            const severity = typeof message.severity === "number" ? message.severity : undefined;
             if (typeof ruleValue !== "string" && ruleValue !== null) {
-                return { ruleId: null };
+                return { ruleId: null, severity };
             }
-            return { ruleId: ruleValue };
+            return { ruleId: ruleValue, severity };
         });
+        const messages = parseMessages(messagesRaw);
+        const suppressedRaw = entry.suppressedMessages;
+        const suppressedMessages = Array.isArray(suppressedRaw) ? parseMessages(suppressedRaw) : [];
         return {
             filePath: typeof entry.filePath === "string" ? entry.filePath : "unknown",
             errorCount: typeof entry.errorCount === "number" ? entry.errorCount : 0,
@@ -29,6 +33,7 @@ function asEslintResults(input) {
             fixableErrorCount: typeof entry.fixableErrorCount === "number" ? entry.fixableErrorCount : 0,
             fixableWarningCount: typeof entry.fixableWarningCount === "number" ? entry.fixableWarningCount : 0,
             messages,
+            suppressedMessages,
         };
     });
 }
@@ -58,7 +63,10 @@ export function collectEslint(input, metadata, options) {
     let warnings = 0;
     let fixableErrors = 0;
     let fixableWarnings = 0;
+    let suppressedErrors = 0;
+    let suppressedWarnings = 0;
     const rules = new Map();
+    const suppressedRules = new Map();
     const files = [];
     for (const row of rows) {
         errors += row.errorCount;
@@ -81,6 +89,20 @@ export function collectEslint(input, metadata, options) {
             const existing = rules.get(message.ruleId) ?? 0;
             rules.set(message.ruleId, existing + 1);
         }
+        for (const message of row.suppressedMessages) {
+            // severity: 2 = error, 1 = warning
+            if (message.severity === 2) {
+                suppressedErrors++;
+            }
+            else {
+                suppressedWarnings++;
+            }
+            if (!message.ruleId) {
+                continue;
+            }
+            const existing = suppressedRules.get(message.ruleId) ?? 0;
+            suppressedRules.set(message.ruleId, existing + 1);
+        }
     }
     const languages = options.languages ?? detectEslintLanguages(rows);
     const doc = {
@@ -94,11 +116,18 @@ export function collectEslint(input, metadata, options) {
         warnings,
         fixable_errors: fixableErrors,
         fixable_warnings: fixableWarnings,
+        suppressed_errors: suppressedErrors,
+        suppressed_warnings: suppressedWarnings,
     };
     if (options.includeRules) {
         const sortedRules = [...rules.entries()].sort((a, b) => b[1] - a[1]);
         const slice = options.topRules > 0 ? sortedRules.slice(0, options.topRules) : sortedRules;
         doc.rules_violated = Object.fromEntries(slice);
+        if (suppressedRules.size > 0) {
+            const sortedSuppressed = [...suppressedRules.entries()].sort((a, b) => b[1] - a[1]);
+            const suppressedSlice = options.topRules > 0 ? sortedSuppressed.slice(0, options.topRules) : sortedSuppressed;
+            doc.suppressed_rules = Object.fromEntries(suppressedSlice);
+        }
     }
     if (files.length > 0 && (options.topFiles > 0 || options.includeAllFiles)) {
         const sortedFiles = [...files].sort((a, b) => {

package/dist/collectors/index.d.ts

@@ -3,4 +3,5 @@ export { collectCoverageDotnet } from "./coverage-dotnet.js";
 export { collectCoverageJs } from "./coverage-js.js";
 export { collectEslint } from "./eslint.js";
 export { collectLighthouse } from "./lighthouse.js";
+export { collectPipeline, normalizeStatus as normalizePipelineStatus } from "./pipeline.js";
 export { collectSarif } from "./sarif.js";

package/dist/collectors/index.js

@@ -3,4 +3,5 @@ export { collectCoverageDotnet } from "./coverage-dotnet.js";
 export { collectCoverageJs } from "./coverage-js.js";
 export { collectEslint } from "./eslint.js";
 export { collectLighthouse } from "./lighthouse.js";
+export { collectPipeline, normalizeStatus as normalizePipelineStatus } from "./pipeline.js";
 export { collectSarif } from "./sarif.js";

package/dist/collectors/lighthouse.d.ts

@@ -1,2 +1,5 @@
 import type { CommonMetadata, LighthouseMetricDocument } from "../types.js";
-export declare function collectLighthouse(input: unknown, metadata: CommonMetadata, url: string): LighthouseMetricDocument[];
+export interface LighthouseCollectorOptions {
+    includeFilmstrip: boolean;
+}
+export declare function collectLighthouse(input: unknown, metadata: CommonMetadata, url: string, options?: LighthouseCollectorOptions): LighthouseMetricDocument[];

package/dist/collectors/lighthouse.js

@@ -12,7 +12,42 @@ function readCategoryScore(categories, key) {
     }
     return toPctFromUnitScore(score);
 }
-export function collectLighthouse(input, metadata, url) {
+function readAuditNumeric(audits, key) {
+    const audit = audits[key];
+    if (!isRecord(audit)) {
+        return undefined;
+    }
+    const value = audit.numericValue;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+}
+function extractFilmstrip(audits) {
+    const thumbnail = audits["screenshot-thumbnails"];
+    if (!isRecord(thumbnail))
+        return undefined;
+    const details = thumbnail.details;
+    if (!isRecord(details))
+        return undefined;
+    if (details.type !== "filmstrip")
+        return undefined;
+    const items = details.items;
+    if (!Array.isArray(items))
+        return undefined;
+    const frames = [];
+    for (const item of items) {
+        if (!isRecord(item))
+            continue;
+        if (typeof item.timing !== "number" || !Number.isFinite(item.timing))
+            continue;
+        if (typeof item.data !== "string")
+            continue;
+        frames.push({ timing: item.timing, data: item.data });
+    }
+    return frames.length > 0 ? frames : undefined;
+}
+export function collectLighthouse(input, metadata, url, options) {
     if (!isRecord(input)) {
         throw new Error("Lighthouse input must be an object");
     }
@@ -33,5 +68,58 @@ export function collectLighthouse(input, metadata, url) {
         best_practices: readCategoryScore(categoriesUnknown, "best-practices"),
         seo: readCategoryScore(categoriesUnknown, "seo"),
     };
+    const audits = input.audits;
+    if (isRecord(audits)) {
+        const fcp = readAuditNumeric(audits, "first-contentful-paint");
+        const lcp = readAuditNumeric(audits, "largest-contentful-paint");
+        const tbt = readAuditNumeric(audits, "total-blocking-time");
+        const cls = readAuditNumeric(audits, "cumulative-layout-shift");
+        const si = readAuditNumeric(audits, "speed-index");
+        const tti = readAuditNumeric(audits, "interactive");
+        const ttfb = readAuditNumeric(audits, "server-response-time");
+        const totalByteWeight = readAuditNumeric(audits, "total-byte-weight");
+        const domSize = readAuditNumeric(audits, "dom-size");
+        if (fcp !== undefined)
+            doc.fcp = fcp;
+        if (lcp !== undefined)
+            doc.lcp = lcp;
+        if (tbt !== undefined)
+            doc.tbt = tbt;
+        if (cls !== undefined)
+            doc.cls = cls;
+        if (si !== undefined)
+            doc.si = si;
+        if (tti !== undefined)
+            doc.tti = tti;
+        if (ttfb !== undefined)
+            doc.ttfb = ttfb;
+        if (totalByteWeight !== undefined)
+            doc.total_byte_weight = totalByteWeight;
+        if (domSize !== undefined)
+            doc.dom_size = domSize;
+        const auditScores = {};
+        const auditValues = {};
+        for (const [id, raw] of Object.entries(audits)) {
+            if (!isRecord(raw))
+                continue;
+            if (typeof raw.score === "number" && Number.isFinite(raw.score)) {
+                auditScores[id] = toPctFromUnitScore(raw.score);
+            }
+            if (typeof raw.numericValue === "number" && Number.isFinite(raw.numericValue)) {
+                auditValues[id] = raw.numericValue;
+            }
+        }
+        if (Object.keys(auditScores).length > 0) {
+            doc.audit_scores = auditScores;
+        }
+        if (Object.keys(auditValues).length > 0) {
+            doc.audit_values = auditValues;
+        }
+        if (options?.includeFilmstrip) {
+            const filmstrip = extractFilmstrip(audits);
+            if (filmstrip)
+                doc.filmstrip = filmstrip;
+        }
+    }
     return [doc];
 }

package/dist/collectors/pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { CommonMetadata, PipelineMetricDocument } from "../types.js";
+export type PipelineStatus = PipelineMetricDocument["pipeline_status"];
+export declare function normalizeStatus(raw: string): PipelineStatus;
+interface PipelineInput {
+    status: string;
+    pipelineName: string;
+    trigger: string;
+    durationMs: number | null;
+    startTime: string | null;
+    stageName: string | null;
+}
+export declare function collectPipeline(input: PipelineInput, metadata: CommonMetadata): PipelineMetricDocument[];
+export {};

package/dist/collectors/pipeline.js

@@ -0,0 +1,31 @@
+import { baseDocument } from "../normalize.js";
+const SUCCEEDED_ALIASES = new Set(["succeeded", "success", "pass", "passed"]);
+const FAILED_ALIASES = new Set(["failed", "failure", "fail"]);
+const CANCELED_ALIASES = new Set(["canceled", "cancelled", "aborted", "skipped"]);
+export function normalizeStatus(raw) {
+    const lower = raw.toLowerCase();
+    if (SUCCEEDED_ALIASES.has(lower))
+        return "succeeded";
+    if (FAILED_ALIASES.has(lower))
+        return "failed";
+    if (CANCELED_ALIASES.has(lower))
+        return "canceled";
+    return "unknown";
+}
+export function collectPipeline(input, metadata) {
+    const doc = {
+        ...baseDocument({
+            metricType: "pipeline",
+            tool: metadata.pipelineProvider,
+            languages: [],
+            metadata,
+        }),
+        pipeline_name: input.pipelineName,
+        pipeline_status: normalizeStatus(input.status),
+        pipeline_trigger: input.trigger,
+        duration_ms: input.durationMs,
+        start_time: input.startTime,
+        stage_name: input.stageName,
+    };
+    return [doc];
+}

package/dist/normalize.js

@@ -6,7 +6,7 @@ export function baseDocument(input) {
         tool: input.tool,
         languages: input.languages,
         repo: metadata.repo,
-        package: metadata.packageName,
+        solution: metadata.solution,
         project: metadata.projectName,
         category: metadata.category,
         tags: metadata.tags,

package/dist/sinks/elastic.js

@@ -7,6 +7,7 @@ const INDEX_BY_TYPE = {
     sarif: "codequality-sarif",
     "coverage-dotnet": "codequality-coverage-dotnet",
     meta: "codequality-meta",
+    pipeline: "codequality-pipeline",
 };
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/types.d.ts

@@ -1,13 +1,13 @@
 export type Language = "js" | "ts" | "csharp" | (string & {});
 export type Environment = "dev" | "test" | "prod" | "ci";
-export type MetricType = "biome" | "eslint" | "lighthouse" | "coverage-js" | "sarif" | "coverage-dotnet" | "meta";
+export type MetricType = "biome" | "eslint" | "lighthouse" | "coverage-js" | "sarif" | "coverage-dotnet" | "meta" | "pipeline";
 export interface BaseMetricDocument {
     "@timestamp": string;
     metric_type: MetricType;
     tool: string;
     languages: Language[];
     repo: string;
-    package: string | null;
+    solution: string | null;
     project: string | null;
     category: string | null;
     tags: string[];
@@ -24,7 +24,10 @@ export interface EslintMetricDocument extends BaseMetricDocument {
     warnings: number;
     fixable_errors: number;
     fixable_warnings: number;
+    suppressed_errors: number;
+    suppressed_warnings: number;
     rules_violated?: Record<string, number>;
+    suppressed_rules?: Record<string, number>;
     top_files?: EslintFileIssue[];
     all_files?: EslintFileIssue[];
 }
@@ -35,6 +38,10 @@ export interface EslintFileIssue {
     fixable_errors: number;
     fixable_warnings: number;
 }
+export interface LighthouseFilmstripFrame {
+    timing: number;
+    data: string;
+}
 export interface LighthouseMetricDocument extends BaseMetricDocument {
     metric_type: "lighthouse";
     url: string;
@@ -42,6 +49,18 @@ export interface LighthouseMetricDocument extends BaseMetricDocument {
     accessibility: number;
     best_practices: number;
     seo: number;
+    fcp?: number;
+    lcp?: number;
+    tbt?: number;
+    cls?: number;
+    si?: number;
+    tti?: number;
+    ttfb?: number;
+    total_byte_weight?: number;
+    dom_size?: number;
+    audit_scores?: Record<string, number>;
+    audit_values?: Record<string, number>;
+    filmstrip?: LighthouseFilmstripFrame[];
 }
 export interface CoverageMetricDocument extends BaseMetricDocument {
     lines_total: number;
@@ -90,7 +109,16 @@ export interface DotnetCoverageMetricDocument extends CoverageMetricDocument {
 export interface MetaMetricDocument extends BaseMetricDocument {
     metric_type: "meta";
 }
-export type NormalizedDocument = BiomeMetricDocument | EslintMetricDocument | LighthouseMetricDocument | CoverageJsMetricDocument | SarifMetricDocument | DotnetCoverageMetricDocument | MetaMetricDocument;
+export interface PipelineMetricDocument extends BaseMetricDocument {
+    metric_type: "pipeline";
+    pipeline_name: string;
+    pipeline_status: "succeeded" | "failed" | "canceled" | "unknown";
+    pipeline_trigger: string;
+    duration_ms: number | null;
+    start_time: string | null;
+    stage_name: string | null;
+}
+export type NormalizedDocument = BiomeMetricDocument | EslintMetricDocument | LighthouseMetricDocument | CoverageJsMetricDocument | SarifMetricDocument | DotnetCoverageMetricDocument | MetaMetricDocument | PipelineMetricDocument;
 export interface CommonMetadata {
     repo: string;
     category: string | null;
@@ -100,7 +128,7 @@ export interface CommonMetadata {
     pipelineRunId: string;
     pipelineProvider: string;
     environment: Environment;
-    packageName: string | null;
+    solution: string | null;
     projectName: string | null;
     collectorVersion: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualink",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Collect, normalize, and relay code quality metrics from CI",
   "license": "MIT",
   "type": "module",
@@ -17,16 +17,16 @@
     "node": ">=22"
   },
   "dependencies": {
-    "citty": "^0.1.6",
-    "fast-xml-parser": "^4.5.1"
+    "citty": "^0.2.1",
+    "fast-xml-parser": "^5.4.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.4",
-    "@types/node": "^24.0.0",
+    "@biomejs/biome": "^2.4.5",
+    "@types/node": "^25.3.3",
     "@vitest/coverage-v8": "^4.0.18",
     "git-cliff": "^2.12.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
+    "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
   "repository": {

package/dist/cli/detect-package.d.ts

@@ -1,3 +0,0 @@
-import { type CommonArgs } from "./common-args.js";
-export declare function isInsideWorkspacePackage(): boolean;
-export declare function detectPackageName(args: CommonArgs): string | undefined;

package/dist/cli/detect-package.js

@@ -1,42 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { argValue, envOrArg } from "./common-args.js";
-import { runGit } from "./git.js";
-export function isInsideWorkspacePackage() {
-    const gitRoot = runGit(["rev-parse", "--show-toplevel"]);
-    if (!gitRoot) {
-        return false;
-    }
-    return resolve(".") !== resolve(gitRoot);
-}
-function readPackageJsonName() {
-    try {
-        const pkgPath = resolve("package.json");
-        if (!existsSync(pkgPath)) {
-            return undefined;
-        }
-        const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (typeof raw === "object" && raw !== null && "name" in raw && typeof raw.name === "string") {
-            return raw.name;
-        }
-    }
-    catch {
-        // ignore
-    }
-    return undefined;
-}
-export function detectPackageName(args) {
-    const explicit = envOrArg(argValue(args, "package"), "QUALINK_PACKAGE");
-    if (explicit) {
-        return explicit;
-    }
-    const pnpmName = process.env.PNPM_PACKAGE_NAME;
-    if (pnpmName && pnpmName.trim().length > 0) {
-        return pnpmName;
-    }
-    // Auto-detect from ./package.json when running inside a workspace subdirectory
-    if (isInsideWorkspacePackage()) {
-        return readPackageJsonName();
-    }
-    return undefined;
-}