qualink 0.5.0 → 0.6.0

package/dist/cli/command-factory.js

@@ -1,4 +1,6 @@
+import { stat } from "node:fs/promises";
 import { defineCommand } from "citty";
+import { formatBytes } from "../utils/format.js";
 import { CliError } from "./cli-error.js";
 import { commonArgs, isDryRun } from "./common-args.js";
 import { parseCommonMetadata } from "./parse-metadata.js";
@@ -16,6 +18,11 @@ export function createCollectorCommand(config) {
         async run({ args }) {
             try {
                 const parsedArgs = args;
+                const inputPath = typeof parsedArgs.input === "string" ? parsedArgs.input : undefined;
+                if (inputPath) {
+                    const fileStat = await stat(inputPath);
+                    process.stderr.write(`  read: ${inputPath} (${formatBytes(fileStat.size)})\n`);
+                }
                 const metadata = parseCommonMetadata(parsedArgs);
                 const { metricType, documents } = await config.collect(parsedArgs, metadata);
                 await sendToSink(metricType, parsedArgs, documents);

package/dist/cli/index.js

@@ -1,3 +1,4 @@
+import { relative } from "node:path";
 import { defineCommand, runMain } from "citty";
 import { CliError } from "./cli-error.js";
 import { biomeCommand, coverageDotnetCommand, coverageJsCommand, eslintCommand, junitCommand, lighthouseCommand, metaCommand, pipelineCommand, sarifCommand, } from "./commands/index.js";
@@ -54,6 +55,11 @@ const collectCommand = defineCommand({
 async function runDirMode(dir, args) {
     const metadata = parseCommonMetadata(args);
     const discovered = await discoverFiles(dir);
+    for (const [collectorKey, files] of discovered) {
+        for (const filePath of files) {
+            process.stderr.write(`  scan: ${relative(dir, filePath)} → ${collectorKey}\n`);
+        }
+    }
     const accumulated = new Map();
     const counts = new Map();
     for (const [collectorKey, files] of discovered) {
@@ -78,6 +84,11 @@ async function runConfigMode(configValue, args) {
     const metadata = parseCommonMetadata(args);
     const entries = await parseConfig(configValue);
     const resolved = await resolveConfig(entries, ".");
+    for (const entry of resolved) {
+        for (const filePath of entry.files) {
+            process.stderr.write(`  scan: ${filePath} → ${entry.type}\n`);
+        }
+    }
     const accumulated = new Map();
     const counts = new Map();
     for (const entry of resolved) {

package/dist/cli/send-to-sink.js

@@ -1,3 +1,4 @@
+import { INDEX_BY_TYPE } from "../sinks/elastic.js";
 import { createSink } from "../sinks/index.js";
 import { CliError } from "./cli-error.js";
 import { argValue, envOrArg, isDryRun } from "./common-args.js";
@@ -65,8 +66,22 @@ export async function sendToSink(metricType, args, documents) {
         sinkConfig = sinkConfigBase;
     }
     const sink = createSink(sinkConfig);
-    await sink.send({
+    const { durationMs } = await sink.send({
         metricType,
         documents,
     });
+    const count = documents.length;
+    const ms = Math.round(durationMs);
+    if (sinkKind === "elastic") {
+        const index = INDEX_BY_TYPE[metricType];
+        const url = sinkConfig.elasticUrl ?? "";
+        process.stderr.write(`  sent: ${count} document(s) → elastic ${index} (${url}) ${ms}ms\n`);
+    }
+    else if (sinkKind === "loki") {
+        const url = sinkConfig.lokiUrl ?? "";
+        process.stderr.write(`  sent: ${count} document(s) → loki (${url}) ${ms}ms\n`);
+    }
+    else {
+        process.stderr.write(`  sent: ${count} document(s) → stdout\n`);
+    }
 }

package/dist/sinks/elastic.d.ts

@@ -1,11 +1,12 @@
-import type { NormalizedDocument } from "../types.js";
-import type { SendInput, Sink } from "./types.js";
+import type { MetricType, NormalizedDocument } from "../types.js";
+import type { SendInput, SendResult, Sink } from "./types.js";
 interface ElasticSinkOptions {
     url: string;
     apiKey: string;
     retryMax: number;
     retryBackoffMs: number;
 }
+export declare const INDEX_BY_TYPE: Record<MetricType, string>;
 export declare function buildBulkBody(indexName: string, documents: NormalizedDocument[]): string;
 export declare class ElasticSink implements Sink {
     private readonly url;
@@ -13,6 +14,6 @@ export declare class ElasticSink implements Sink {
     private readonly retryMax;
     private readonly retryBackoffMs;
     constructor(options: ElasticSinkOptions);
-    send(input: SendInput): Promise<void>;
+    send(input: SendInput): Promise<SendResult>;
 }
 export {};

package/dist/sinks/elastic.js

@@ -1,5 +1,5 @@
 import { isRecord } from "../utils/guards.js";
-const INDEX_BY_TYPE = {
+export const INDEX_BY_TYPE = {
     biome: "codequality-biome",
     eslint: "codequality-eslint",
     lighthouse: "codequality-lighthouse",
@@ -63,8 +63,9 @@ export class ElasticSink {
     }
     async send(input) {
         if (input.documents.length === 0) {
-            return;
+            return { durationMs: 0 };
         }
+        const start = performance.now();
         const indexName = INDEX_BY_TYPE[input.metricType];
         let documents = input.documents;
         let attempt = 0;
@@ -99,7 +100,7 @@ export class ElasticSink {
                     if (nonRetryableErrors.length > 0) {
                         throw new Error(`Elastic bulk request completed with ${nonRetryableErrors.length} non-retryable item error(s)`);
                     }
-                    return;
+                    return { durationMs: performance.now() - start };
                 }
                 if (attempt > this.retryMax) {
                     const deadLetterBody = buildBulkBody(indexName, retryable);
@@ -110,7 +111,7 @@ export class ElasticSink {
                 await sleep(this.retryBackoffMs * attempt);
                 continue;
             }
-            return;
+            return { durationMs: performance.now() - start };
         }
     }
 }

package/dist/sinks/loki.d.ts

@@ -1,5 +1,5 @@
 import type { NormalizedDocument } from "../types.js";
-import type { SendInput, Sink } from "./types.js";
+import type { SendInput, SendResult, Sink } from "./types.js";
 export interface LokiSinkOptions {
     url: string;
     username?: string | undefined;
@@ -25,6 +25,6 @@ export declare class LokiSink implements Sink {
     private readonly retryMax;
     private readonly retryBackoffMs;
     constructor(options: LokiSinkOptions);
-    send(input: SendInput): Promise<void>;
+    send(input: SendInput): Promise<SendResult>;
 }
 export {};

package/dist/sinks/loki.js

@@ -48,8 +48,9 @@ export class LokiSink {
     }
     async send(input) {
         if (input.documents.length === 0) {
-            return;
+            return { durationMs: 0 };
         }
+        const start = performance.now();
         const payload = buildLokiPayload(input.documents);
         const body = JSON.stringify(payload);
         const headers = {
@@ -71,7 +72,7 @@ export class LokiSink {
                 body,
             });
             if (response.status === 204 || response.ok) {
-                return;
+                return { durationMs: performance.now() - start };
             }
             const responseText = await response.text();
             if (!isRetryableStatus(response.status) || attempt > this.retryMax) {

package/dist/sinks/stdout.d.ts

@@ -1,4 +1,4 @@
-import type { SendInput, Sink } from "./types.js";
+import type { SendInput, SendResult, Sink } from "./types.js";
 export declare class StdoutSink implements Sink {
-    send(input: SendInput): Promise<void>;
+    send(input: SendInput): Promise<SendResult>;
 }

package/dist/sinks/stdout.js

@@ -6,5 +6,6 @@ export class StdoutSink {
             documents: input.documents,
         };
         process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+        return { durationMs: 0 };
     }
 }

package/dist/sinks/types.d.ts

@@ -3,6 +3,9 @@ export interface SendInput {
     metricType: MetricType;
     documents: NormalizedDocument[];
 }
+export interface SendResult {
+    durationMs: number;
+}
 export interface Sink {
-    send(input: SendInput): Promise<void>;
+    send(input: SendInput): Promise<SendResult>;
 }

package/dist/utils/format.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number): string;

package/dist/utils/format.js

@@ -0,0 +1,11 @@
+const UNITS = ["B", "kB", "MB", "GB"];
+export function formatBytes(bytes) {
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1000 && unitIndex < UNITS.length - 1) {
+        value /= 1000;
+        unitIndex++;
+    }
+    const formatted = unitIndex === 0 ? value.toString() : value.toFixed(1).replace(/\.0$/, "");
+    return `${formatted} ${UNITS[unitIndex]}`;
+}

package/package.json

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