qualink 0.4.0 → 0.5.0

package/README.md

@@ -101,18 +101,52 @@ For pipelines with distinct stages, call qualink once per stage with `--stage-na
 
 ## CLI usage
 
+### Single collector
+
 ```bash
 qualink collect <collector> --input <path> --sink elastic [flags]
 ```
 
-Examples:
+```bash
+qualink collect eslint --input eslint-report.json --sink elastic --repo frontend-mono --category frontend --tags frontend,web
+qualink collect sarif --input analyzers.sarif --sink elastic --repo backend-api --category backend --tags backend,api
+qualink collect coverage-dotnet --input coverage.cobertura.xml --sink elastic --repo backend-api
+```
+
+### Multi-collect
+
+Auto-discover report files in a directory tree:
+
+```bash
+qualink collect --dir=./output --repo myapp --sink elastic
+```
+
+Or use a config file for explicit control:
 
 ```bash
-qualink collect eslint --input eslint-report.json --sink elastic --repo frontend-mono --category frontend --tags frontend,web --branch main --commit-sha abc123 --pipeline-run-id 987
-qualink collect sarif --input analyzers.sarif --sink elastic --repo backend-api --category backend --tags backend,api --branch main --commit-sha def456 --pipeline-run-id 654
-qualink collect coverage-dotnet --input coverage.cobertura.xml --sink elastic --repo backend-api --category backend --tags backend,api --branch main --commit-sha def456 --pipeline-run-id 654
+qualink collect --config=qualink.json --repo myapp --sink elastic
+```
 
-# Pipeline tracking (top-level command, not under collect)
+Config file example (`qualink.json`):
+
+```json
+[
+  { "type": "eslint", "input": "packages/*/eslint-report.json" },
+  { "type": "coverage-js", "input": "packages/*/coverage-summary.json" },
+  { "type": "sarif", "input": "**/*.sarif" }
+]
+```
+
+Each entry supports optional overrides: `tags`, `category`, `project`, `solution`, `url`.
+See [qualink-config.schema.json](qualink-config.schema.json) for the full schema.
+
+Auto-discovery recognizes: `eslint-report.json`, `biome-report.json`, `coverage-summary.json`, `coverage.cobertura.xml`, `*.sarif`/`*.sarif.json`, `lhr-*.json` inside `.lighthouseci/`, `junit.xml`, and `TEST-*.xml`.
+
+### Pipeline tracking
+
+Top-level command, not under `collect`:
+
+```bash
 qualink pipeline --status succeeded --sink elastic
 qualink pipeline --status succeeded --duration 125000 --pipeline-name "Build and Deploy"
 qualink pipeline --status succeeded --stage-name build --duration 45000
@@ -127,6 +161,7 @@ Collectors:
 - `coverage-js` (Istanbul/Vitest JSON)
 - `sarif` (Roslyn or generic SARIF JSON)
 - `coverage-dotnet` (Cobertura/OpenCover XML)
+- `junit` (JUnit XML)
 
 ESLint file-level options (optional):
 
@@ -138,12 +173,19 @@ Classification metadata (optional):
 - `--category` for a single broad bucket
 - `--tags` for flexible multi-label filtering (`comma,separated`)
 
+Project hierarchy (auto-detected or explicit):
+
+- `--solution` groups related projects (auto-detected from `.sln` or workspace root `package.json`)
+- `--project` identifies the individual project (auto-detected from nearest `.csproj` or `package.json`)
+
 Metadata auto-detection:
 
 - `repo`: from flag/env, then git origin, then current folder name
 - `branch`: from flag/env, then git branch
 - `commit_sha`: from flag/env, then git commit
 - `pipeline_run_id`: from flag/env, fallback `local-<timestamp>`
+- `project`: from flag/env, then nearest `.csproj`/`package.json`
+- `solution`: from flag/env, then nearest `.sln`/workspace root `package.json`
 
 If needed, you can still pass explicit values with `--repo`, `--branch`, `--commit-sha`, and `--pipeline-run-id`.
 
@@ -160,8 +202,8 @@ Dry run mode:
 Useful env fallbacks:
 
 - `QUALINK_REPO`, `QUALINK_CATEGORY`, `QUALINK_TAGS`, `QUALINK_BRANCH`, `QUALINK_COMMIT_SHA`, `QUALINK_PIPELINE_RUN_ID`
-- `QUALINK_PACKAGE` (monorepo package name, auto-detected from `PNPM_PACKAGE_NAME`)
-- `QUALINK_PROJECT` (backend project identity)
+- `QUALINK_PROJECT` (auto-detected from nearest `.csproj`/`package.json` or `PNPM_PACKAGE_NAME`)
+- `QUALINK_SOLUTION` (auto-detected from `.sln` or workspace root `package.json`)
 - `QUALINK_PIPELINE_PROVIDER` (auto-detected, fallback: `local`)
 - `QUALINK_ENVIRONMENT` (default: `ci`)
 - `QUALINK_SINK` (default: `elastic`)

package/dist/cli/commands/index.d.ts

@@ -2,6 +2,7 @@ export { biomeCommand } from "./biome.js";
 export { coverageDotnetCommand } from "./coverage-dotnet.js";
 export { coverageJsCommand } from "./coverage-js.js";
 export { eslintCommand } from "./eslint.js";
+export { junitCommand } from "./junit.js";
 export { lighthouseCommand } from "./lighthouse.js";
 export { metaCommand } from "./meta.js";
 export { pipelineCommand } from "./pipeline.js";

package/dist/cli/commands/index.js

@@ -2,6 +2,7 @@ export { biomeCommand } from "./biome.js";
 export { coverageDotnetCommand } from "./coverage-dotnet.js";
 export { coverageJsCommand } from "./coverage-js.js";
 export { eslintCommand } from "./eslint.js";
+export { junitCommand } from "./junit.js";
 export { lighthouseCommand } from "./lighthouse.js";
 export { metaCommand } from "./meta.js";
 export { pipelineCommand } from "./pipeline.js";

package/dist/cli/commands/junit.d.ts

@@ -0,0 +1,76 @@
+export declare const junitCommand: import("citty").CommandDef<{
+    readonly input: {
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly sink: {
+        readonly type: "string";
+        readonly default: "elastic";
+    };
+    readonly repo: {
+        readonly type: "string";
+    };
+    readonly category: {
+        readonly type: "string";
+    };
+    readonly tags: {
+        readonly type: "string";
+    };
+    readonly branch: {
+        readonly type: "string";
+    };
+    readonly "commit-sha": {
+        readonly type: "string";
+    };
+    readonly "pipeline-run-id": {
+        readonly type: "string";
+    };
+    readonly "pipeline-provider": {
+        readonly type: "string";
+    };
+    readonly environment: {
+        readonly type: "string";
+        readonly default: "ci";
+    };
+    readonly solution: {
+        readonly type: "string";
+    };
+    readonly project: {
+        readonly type: "string";
+    };
+    readonly "collector-version": {
+        readonly type: "string";
+    };
+    readonly "elastic-url": {
+        readonly type: "string";
+    };
+    readonly "elastic-api-key": {
+        readonly type: "string";
+    };
+    readonly "loki-url": {
+        readonly type: "string";
+    };
+    readonly "loki-username": {
+        readonly type: "string";
+    };
+    readonly "loki-password": {
+        readonly type: "string";
+    };
+    readonly "loki-tenant-id": {
+        readonly type: "string";
+    };
+    readonly "retry-max": {
+        readonly type: "string";
+    };
+    readonly "retry-backoff-ms": {
+        readonly type: "string";
+    };
+    readonly "allow-empty": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+}>;

package/dist/cli/commands/junit.js

@@ -0,0 +1,12 @@
+import { collectJunit } from "../../collectors/junit.js";
+import { createCollectorCommand } from "../command-factory.js";
+import { loadTextInput } from "../load-input.js";
+export const junitCommand = createCollectorCommand({
+    name: "junit",
+    description: "Collect JUnit XML test results and relay them",
+    async collect(args, metadata) {
+        const input = await loadTextInput(args);
+        const documents = collectJunit(input, metadata);
+        return { metricType: "junit", documents };
+    },
+});

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 import { defineCommand, runMain } from "citty";
 import { CliError } from "./cli-error.js";
-import { biomeCommand, coverageDotnetCommand, coverageJsCommand, eslintCommand, lighthouseCommand, metaCommand, pipelineCommand, sarifCommand, } from "./commands/index.js";
+import { biomeCommand, coverageDotnetCommand, coverageJsCommand, eslintCommand, junitCommand, lighthouseCommand, metaCommand, pipelineCommand, sarifCommand, } from "./commands/index.js";
 import { commonArgs, isDryRun } from "./common-args.js";
 import { parseConfig, resolveConfig } from "./multi-collect/config.js";
 import { discoverFiles } from "./multi-collect/discover.js";
@@ -33,6 +33,7 @@ const collectCommand = defineCommand({
         "coverage-js": coverageJsCommand,
         sarif: sarifCommand,
         "coverage-dotnet": coverageDotnetCommand,
+        junit: junitCommand,
     },
     async run({ args }) {
         const parsedArgs = args;

package/dist/cli/multi-collect/patterns.d.ts

@@ -1,5 +1,5 @@
 import type { MetricType } from "../../types.js";
-export type CollectorKey = Extract<MetricType, "eslint" | "biome" | "coverage-js" | "coverage-dotnet" | "sarif" | "lighthouse">;
+export type CollectorKey = Extract<MetricType, "eslint" | "biome" | "coverage-js" | "coverage-dotnet" | "sarif" | "lighthouse" | "junit">;
 export declare const COLLECTOR_KEYS: readonly CollectorKey[];
 export interface FilePattern {
     /** Match against basename only */

package/dist/cli/multi-collect/patterns.js

@@ -5,14 +5,19 @@ export const COLLECTOR_KEYS = [
     "coverage-dotnet",
     "sarif",
     "lighthouse",
+    "junit",
 ];
 export const COLLECTOR_PATTERNS = {
     eslint: [{ basename: "eslint-report.json" }],
     biome: [{ basename: "biome-report.json" }],
     "coverage-js": [{ basename: "coverage-summary.json" }],
-    "coverage-dotnet": [{ basename: "coverage.cobertura.xml" }],
+    "coverage-dotnet": [
+        { basename: "coverage.cobertura.xml" },
+        { basename: "cobertura-coverage.xml" },
+    ],
     sarif: [{ extensions: [".sarif", ".sarif.json"] }],
     lighthouse: [{ prefix: "lhr-", extensions: [".json"], parentDir: ".lighthouseci" }],
+    junit: [{ basename: "junit.xml" }, { prefix: "TEST-", extensions: [".xml"] }],
 };
 export const IGNORED_DIRS = new Set(["node_modules", ".git"]);
 export function isCollectorKey(value) {

package/dist/cli/multi-collect/run-collector.js

@@ -2,6 +2,7 @@ import { collectBiome } from "../../collectors/biome.js";
 import { collectCoverageDotnet } from "../../collectors/coverage-dotnet.js";
 import { collectCoverageJs } from "../../collectors/coverage-js.js";
 import { collectEslint } from "../../collectors/eslint.js";
+import { collectJunit } from "../../collectors/junit.js";
 import { collectLighthouse } from "../../collectors/lighthouse.js";
 import { collectSarif } from "../../collectors/sarif.js";
 import { readJsonFile, readTextFile } from "../../utils/file.js";
@@ -71,5 +72,10 @@ export async function runCollector(key, filePath, metadata, urlOverride) {
             const documents = collectLighthouse(input, metadata, url);
             return { metricType: "lighthouse", documents };
         }
+        case "junit": {
+            const input = await readTextFile(filePath);
+            const documents = collectJunit(input, metadata);
+            return { metricType: "junit", documents };
+        }
     }
 }

package/dist/collectors/junit.d.ts

@@ -0,0 +1,2 @@
+import type { CommonMetadata, JunitMetricDocument } from "../types.js";
+export declare function collectJunit(xmlInput: string, metadata: CommonMetadata): JunitMetricDocument[];

package/dist/collectors/junit.js

@@ -0,0 +1,106 @@
+import { XMLParser } from "fast-xml-parser";
+import { baseDocument } from "../normalize.js";
+import { isRecord } from "../utils/guards.js";
+function readNumber(record, key) {
+    const value = record[key];
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return 0;
+}
+function parseSuite(suite) {
+    const tests = readNumber(suite, "@_tests");
+    const failures = readNumber(suite, "@_failures");
+    const errors = readNumber(suite, "@_errors");
+    const skipped = readNumber(suite, "@_skipped");
+    const rawTime = suite["@_time"];
+    const time = typeof rawTime === "number"
+        ? rawTime
+        : typeof rawTime === "string" && rawTime.length > 0
+            ? Number(rawTime)
+            : null;
+    return {
+        tests,
+        failures,
+        errors,
+        skipped,
+        time: time !== null && !Number.isNaN(time) ? time : null,
+    };
+}
+function toArray(value) {
+    if (Array.isArray(value))
+        return value;
+    if (value !== undefined && value !== null)
+        return [value];
+    return [];
+}
+export function collectJunit(xmlInput, metadata) {
+    const parser = new XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_",
+        parseAttributeValue: true,
+    });
+    const parsed = parser.parse(xmlInput);
+    if (!isRecord(parsed)) {
+        throw new Error("JUnit XML could not be parsed");
+    }
+    let suites;
+    if (parsed.testsuites !== undefined) {
+        if (isRecord(parsed.testsuites)) {
+            const raw = toArray(parsed.testsuites.testsuite);
+            suites = raw.filter(isRecord);
+        }
+        else {
+            // Empty <testsuites/> — parsed as empty string
+            suites = [];
+        }
+    }
+    else if (isRecord(parsed.testsuite)) {
+        suites = [parsed.testsuite];
+    }
+    else {
+        throw new Error("Unrecognized JUnit XML format. Expected <testsuites> or <testsuite> root");
+    }
+    let totalTests = 0;
+    let totalFailures = 0;
+    let totalErrors = 0;
+    let totalSkipped = 0;
+    let totalTime = 0;
+    for (const suite of suites) {
+        const result = parseSuite(suite);
+        totalTests += result.tests;
+        totalFailures += result.failures;
+        totalErrors += result.errors;
+        totalSkipped += result.skipped;
+        if (result.time !== null && totalTime !== null) {
+            totalTime += result.time;
+        }
+        else {
+            totalTime = null;
+        }
+    }
+    const passed = Math.max(0, totalTests - totalFailures - totalErrors - totalSkipped);
+    const durationMs = totalTime !== null ? Math.round(totalTime * 1000) : null;
+    const doc = {
+        ...baseDocument({
+            metricType: "junit",
+            tool: "junit",
+            languages: [],
+            metadata,
+        }),
+        tests: totalTests,
+        passed,
+        failures: totalFailures,
+        errors: totalErrors,
+        skipped: totalSkipped,
+        duration_ms: durationMs,
+        suites: suites.length,
+    };
+    return [doc];
+}

package/dist/sinks/elastic.js

@@ -6,6 +6,7 @@ const INDEX_BY_TYPE = {
     "coverage-js": "codequality-coverage-js",
     sarif: "codequality-sarif",
     "coverage-dotnet": "codequality-coverage-dotnet",
+    junit: "codequality-junit",
     meta: "codequality-meta",
     pipeline: "codequality-pipeline",
 };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 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" | "pipeline";
+export type MetricType = "biome" | "eslint" | "lighthouse" | "coverage-js" | "sarif" | "coverage-dotnet" | "junit" | "meta" | "pipeline";
 export interface BaseMetricDocument {
     "@timestamp": string;
     metric_type: MetricType;
@@ -106,6 +106,16 @@ export interface DotnetCoverageMetricDocument extends CoverageMetricDocument {
     metric_type: "coverage-dotnet";
     coverage_format: "cobertura" | "opencover" | (string & {});
 }
+export interface JunitMetricDocument extends BaseMetricDocument {
+    metric_type: "junit";
+    tests: number;
+    passed: number;
+    failures: number;
+    errors: number;
+    skipped: number;
+    duration_ms: number | null;
+    suites: number;
+}
 export interface MetaMetricDocument extends BaseMetricDocument {
     metric_type: "meta";
 }
@@ -118,7 +128,7 @@ export interface PipelineMetricDocument extends BaseMetricDocument {
     start_time: string | null;
     stage_name: string | null;
 }
-export type NormalizedDocument = BiomeMetricDocument | EslintMetricDocument | LighthouseMetricDocument | CoverageJsMetricDocument | SarifMetricDocument | DotnetCoverageMetricDocument | MetaMetricDocument | PipelineMetricDocument;
+export type NormalizedDocument = BiomeMetricDocument | EslintMetricDocument | LighthouseMetricDocument | CoverageJsMetricDocument | SarifMetricDocument | DotnetCoverageMetricDocument | JunitMetricDocument | MetaMetricDocument | PipelineMetricDocument;
 export interface CommonMetadata {
     repo: string;
     category: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualink",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Collect, normalize, and relay code quality metrics from CI",
   "license": "MIT",
   "type": "module",