@qanalyzer/forge-commons 1.1.1

package/dist/ci/templates/gitlab.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGitlabUpload = renderGitlabUpload;
+const upload_1 = require("../frameworks/upload");
+const reporter_1 = require("../frameworks/reporter");
+const types_1 = require("../types");
+function gitlabScriptLines(ctx, ...cmds) {
+    return [...(0, reporter_1.reporterPreRunScripts)(ctx), ...cmds].map((c) => `    - ${c}`).join('\n');
+}
+function gitlabSecrets() {
+    return [
+        {
+            name: 'QANALYZER_INGEST_URL',
+            description: 'Forge web trigger URL (launch ingest + binary attach / screenshots / qa.attach)',
+            platformHint: 'Settings → CI/CD → Variables → Add variable (Masked + Protected as needed)',
+        },
+        {
+            name: 'QANALYZER_INGEST_TOKEN',
+            description: 'Bearer token from QAnalyzer configure page (shown once)',
+            platformHint: 'Settings → CI/CD → Variables → Add variable (Masked + Protected)',
+        },
+    ];
+}
+function gitlabVariables() {
+    return [
+        {
+            name: 'JIRA_PROJECT_KEY',
+            description: 'Jira project key allowlisted in QAnalyzer (e.g. AUTH)',
+            platformHint: 'Settings → CI/CD → Variables',
+        },
+    ];
+}
+function renderGitlabReporter(ctx) {
+    (0, reporter_1.assertReporterFramework)(ctx);
+    const nodeVersion = ctx.nodeVersion ?? '22';
+    const label = (0, reporter_1.reporterFrameworkLabel)(ctx);
+    const pkg = (0, reporter_1.reporterPackageName)(ctx);
+    const configHint = (0, reporter_1.reporterConfigHint)(ctx);
+    const jobName = ctx.framework;
+    const content = `# QAnalyzer fragment — ${label} ${pkg} reporter path
+# Requires ${pkg} in package.json and ${configHint}
+stages:
+  - test
+
+${jobName}:
+  stage: test
+  image: node:${nodeVersion}-alpine
+  variables:
+    QANALYZER_MODE: ingest
+    QANALYZER_INGEST_URL: $QANALYZER_INGEST_URL
+    QANALYZER_INGEST_TOKEN: $QANALYZER_INGEST_TOKEN
+    QANALYZER_PROJECT_KEY: $JIRA_PROJECT_KEY
+    QANALYZER_LAUNCH_NAME: $CI_PIPELINE_ID
+    # Optional Test Plan: QANALYZER_PLAN_NAME / QANALYZER_PLAN_ID / QANALYZER_PLAN_KEY
+    # Optional tags: QANALYZER_FIX_VERSION / QANALYZER_SPRINT
+  script:
+    - npm ci
+${gitlabScriptLines(ctx, (0, reporter_1.frameworkReporterRun)(ctx))}
+`;
+    return {
+        platform: 'gitlab',
+        framework: ctx.framework,
+        ingestPath: 'reporter',
+        filename: '.gitlab-ci.yml',
+        content,
+        secretsSetup: gitlabSecrets(),
+        variablesSetup: [...gitlabVariables(), ...(0, reporter_1.planCiVariableHints)(), ...(0, reporter_1.versionTagCiVariableHints)()],
+    };
+}
+/**
+ * GitLab CI — upload path or @qanalyzer/forge-vitest / @qanalyzer/forge-jest reporter path.
+ */
+function renderGitlabUpload(ctx) {
+    if (ctx.ingestPath === 'reporter') {
+        return renderGitlabReporter(ctx);
+    }
+    if (ctx.ingestPath !== 'upload') {
+        throw new types_1.UnsupportedVariantError(ctx.platform, ctx.framework, ctx.ingestPath);
+    }
+    const nodeVersion = ctx.nodeVersion ?? '22';
+    const reportFile = ctx.reportFile ?? 'qanalyzer-results.json';
+    const testCmd = (0, upload_1.frameworkTestCommand)(ctx);
+    const jobName = ctx.framework;
+    const label = (0, upload_1.frameworkLabel)(ctx);
+    const uploadBlock = (0, upload_1.indentUploadCli)(ctx, 6);
+    const content = `# QAnalyzer fragment — merge into your .gitlab-ci.yml
+# ${label} upload path
+stages:
+  - test
+  - report
+
+${jobName}:
+  stage: test
+  image: node:${nodeVersion}-alpine
+  script:
+    - npm ci
+${gitlabScriptLines(ctx, testCmd)}
+  artifacts:
+    when: always
+    paths:
+      - ${reportFile}
+
+qanalyzer_upload:
+  stage: report
+  image: node:${nodeVersion}-alpine
+  when: always
+  needs: [${jobName}]
+  variables:
+    QANALYZER_INGEST_URL: $QANALYZER_INGEST_URL
+    QANALYZER_INGEST_TOKEN: $QANALYZER_INGEST_TOKEN
+  script:
+    - |
+${uploadBlock}
+`;
+    return {
+        platform: 'gitlab',
+        framework: ctx.framework,
+        ingestPath: 'upload',
+        filename: '.gitlab-ci.yml',
+        content,
+        secretsSetup: gitlabSecrets(),
+        variablesSetup: [...gitlabVariables(), ...(0, reporter_1.planCiVariableHints)(), ...(0, reporter_1.versionTagCiVariableHints)()],
+    };
+}

package/dist/ci/templates/jenkins.d.ts

@@ -0,0 +1,5 @@
+import type { CiTemplateContext, CiTemplateResult } from '../types';
+/**
+ * Jenkins — upload path or @qanalyzer/forge-vitest / @qanalyzer/forge-jest reporter path.
+ */
+export declare function renderJenkinsUpload(ctx: CiTemplateContext): CiTemplateResult;

package/dist/ci/templates/jenkins.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJenkinsUpload = renderJenkinsUpload;
+const upload_1 = require("../frameworks/upload");
+const reporter_1 = require("../frameworks/reporter");
+const types_1 = require("../types");
+function jenkinsShLines(indent, ctx, ...cmds) {
+    // Use sh -c so redirects in Playwright JSON upload (`> file`) work.
+    return [...(0, reporter_1.reporterPreRunScripts)(ctx), ...cmds]
+        .map((cmd) => `${indent}sh -c '${cmd.replace(/'/g, `'\"'\"'`)}'`)
+        .join('\n');
+}
+function jenkinsSecrets() {
+    return [
+        {
+            name: 'qanalyzer-ingest-url',
+            description: 'Secret text credential: Forge web trigger URL (ingest + attach)',
+            platformHint: "Manage Jenkins → Credentials → Add → Secret text; ID `qanalyzer-ingest-url`",
+        },
+        {
+            name: 'qanalyzer-ingest-token',
+            description: 'Secret text credential: Bearer token from QAnalyzer configure page',
+            platformHint: "Manage Jenkins → Credentials → Add → Secret text; ID `qanalyzer-ingest-token`",
+        },
+    ];
+}
+function jenkinsVariables() {
+    return [
+        {
+            name: 'JIRA_PROJECT_KEY',
+            description: 'Jira project key allowlisted in QAnalyzer (set in Jenkinsfile environment)',
+            platformHint: 'pipeline environment { JIRA_PROJECT_KEY = \'…\' } or Jenkins folder property',
+        },
+    ];
+}
+function renderJenkinsReporter(ctx) {
+    (0, reporter_1.assertReporterFramework)(ctx);
+    const label = (0, reporter_1.reporterFrameworkLabel)(ctx);
+    const pkg = (0, reporter_1.reporterPackageName)(ctx);
+    const configHint = (0, reporter_1.reporterConfigHint)(ctx);
+    const content = `// QAnalyzer fragment — ${label} ${pkg} reporter path
+// Requires ${pkg} in package.json and ${configHint}
+pipeline {
+  agent any
+  environment {
+    JIRA_PROJECT_KEY = '${ctx.projectKey}'
+    QANALYZER_MODE = 'ingest'
+    QANALYZER_PROJECT_KEY = '${ctx.projectKey}'
+  }
+  stages {
+    stage('Test') {
+      steps {
+        withCredentials([
+          string(credentialsId: 'qanalyzer-ingest-url', variable: 'QANALYZER_INGEST_URL'),
+          string(credentialsId: 'qanalyzer-ingest-token', variable: 'QANALYZER_INGEST_TOKEN'),
+        ]) {
+          sh 'npm ci'
+${jenkinsShLines('          ', ctx, (0, reporter_1.frameworkReporterRun)(ctx))}
+        }
+      }
+    }
+  }
+}
+`;
+    return {
+        platform: 'jenkins',
+        framework: ctx.framework,
+        ingestPath: 'reporter',
+        filename: 'Jenkinsfile',
+        content,
+        secretsSetup: jenkinsSecrets(),
+        variablesSetup: [...jenkinsVariables(), ...(0, reporter_1.planCiVariableHints)(), ...(0, reporter_1.versionTagCiVariableHints)()],
+    };
+}
+/**
+ * Jenkins — upload path or @qanalyzer/forge-vitest / @qanalyzer/forge-jest reporter path.
+ */
+function renderJenkinsUpload(ctx) {
+    if (ctx.ingestPath === 'reporter') {
+        return renderJenkinsReporter(ctx);
+    }
+    if (ctx.ingestPath !== 'upload') {
+        throw new types_1.UnsupportedVariantError(ctx.platform, ctx.framework, ctx.ingestPath);
+    }
+    const testCmd = (0, upload_1.frameworkTestCommand)(ctx);
+    const label = (0, upload_1.frameworkLabel)(ctx);
+    const uploadBlock = (0, upload_1.indentUploadCli)(ctx, 10);
+    const content = `// QAnalyzer fragment — ${label} upload path — merge into your Jenkinsfile
+pipeline {
+  agent any
+  environment {
+    JIRA_PROJECT_KEY = '${ctx.projectKey}'
+  }
+  stages {
+    stage('Test') {
+      steps {
+        sh 'npm ci'
+${jenkinsShLines('        ', ctx, testCmd)}
+      }
+    }
+  }
+  post {
+    always {
+      withCredentials([
+        string(credentialsId: 'qanalyzer-ingest-url', variable: 'QANALYZER_INGEST_URL'),
+        string(credentialsId: 'qanalyzer-ingest-token', variable: 'QANALYZER_INGEST_TOKEN'),
+      ]) {
+        sh '''
+${uploadBlock}
+        '''
+      }
+    }
+  }
+}
+`;
+    return {
+        platform: 'jenkins',
+        framework: ctx.framework,
+        ingestPath: 'upload',
+        filename: 'Jenkinsfile',
+        content,
+        secretsSetup: jenkinsSecrets(),
+        variablesSetup: [...jenkinsVariables(), ...(0, reporter_1.planCiVariableHints)(), ...(0, reporter_1.versionTagCiVariableHints)()],
+    };
+}

package/dist/ci/types.d.ts

@@ -0,0 +1,58 @@
+export type CiPlatform = 'github' | 'gitlab' | 'azure-devops' | 'jenkins' | 'bitbucket';
+export type CiFramework = 'vitest' | 'jest' | 'mocha' | 'cucumberjs' | 'cypress' | 'playwright' | 'wdio';
+export type CiIngestPath = 'upload' | 'reporter';
+export interface CiTemplateContext {
+    platform: CiPlatform;
+    framework: CiFramework;
+    ingestPath: CiIngestPath;
+    /** Pre-filled from Forge site config / user selection */
+    projectKey: string;
+    /** From site_config — never inlined as a token; YAML uses secret placeholders */
+    ingestUrl?: string;
+    ingestUrlSecret: string;
+    ingestTokenSecret: string;
+    nodeVersion?: string;
+    reportFile?: string;
+    /** Platform-specific expression for --project (may use vars.* or literal) */
+    projectKeyExpr?: string;
+    launchNameExpr?: string;
+    /** Platform expression for QANALYZER_INGEST_URL env value */
+    ingestUrlExpr?: string;
+    /** Platform expression for QANALYZER_INGEST_TOKEN env value */
+    ingestTokenExpr?: string;
+    /** Platform “always run” guard (e.g. if: always()) */
+    alwaysGuard?: string;
+    includeTestStep?: boolean;
+    includeUploadStep?: boolean;
+}
+export interface CiSecretHint {
+    name: string;
+    description: string;
+    platformHint: string;
+}
+export interface CiVariableHint {
+    name: string;
+    description: string;
+    platformHint: string;
+}
+export interface CiTemplateResult {
+    platform: CiPlatform;
+    framework: CiFramework;
+    ingestPath: CiIngestPath;
+    filename: string;
+    content: string;
+    secretsSetup: CiSecretHint[];
+    variablesSetup: CiVariableHint[];
+}
+export interface CiTemplateVariant {
+    platform: CiPlatform;
+    framework: CiFramework;
+    ingestPath: CiIngestPath;
+}
+export type CiTemplatePartial = Partial<CiTemplateContext> & Pick<CiTemplateContext, 'platform' | 'framework' | 'ingestPath' | 'projectKey'>;
+export declare class UnsupportedVariantError extends Error {
+    readonly platform: CiPlatform;
+    readonly framework: CiFramework;
+    readonly ingestPath: CiIngestPath;
+    constructor(platform: CiPlatform, framework: CiFramework, ingestPath: CiIngestPath);
+}

package/dist/ci/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedVariantError = void 0;
+class UnsupportedVariantError extends Error {
+    platform;
+    framework;
+    ingestPath;
+    constructor(platform, framework, ingestPath) {
+        super(`Unsupported CI template variant: ${platform} / ${framework} / ${ingestPath}`);
+        this.name = 'UnsupportedVariantError';
+        this.platform = platform;
+        this.framework = framework;
+        this.ingestPath = ingestPath;
+    }
+}
+exports.UnsupportedVariantError = UnsupportedVariantError;

package/dist/client/attach-client.d.ts

@@ -0,0 +1,48 @@
+import type { LoggerInterface } from '../utils';
+export type AttachClientOptions = {
+    /**
+     * Shared Forge CI webtrigger URL (`QANALYZER_INGEST_URL`).
+     * Legacy `QANALYZER_ATTACH_URL` is accepted as a fallback alias.
+     */
+    url?: string;
+    /** Same Bearer token as ingest (`QANALYZER_INGEST_TOKEN`). */
+    token?: string;
+    timeoutMs?: number;
+    /** Max decoded file bytes (default 3_000_000). */
+    maxBytes?: number;
+    logger?: LoggerInterface;
+};
+export type AttachUploadInput = {
+    projectKey: string;
+    issueKey: string;
+    fileName: string;
+    mimeType: string;
+    content: Buffer | Uint8Array | string;
+};
+export type AttachUploadResult = {
+    issueKey: string;
+    /**
+     * Jira attachment id when the proxy returns it. Static Forge webtriggers only echo
+     * `{"ok":true}`, so callers should treat this as optional and fall back to issue+filename.
+     */
+    id?: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+};
+export declare const DEFAULT_MAX_ATTACH_BYTES = 3000000;
+/** Append `action=attach` so the shared ingest webtrigger dispatches correctly. */
+export declare function withAttachAction(url: string): string;
+/**
+ * Client for Phase 3 Forge attach proxy → Jira Attachment API.
+ * Uses the shared ingest webtrigger URL; sends JSON + base64 (not FR41).
+ */
+export declare class AttachClient {
+    private readonly url?;
+    private readonly token?;
+    private readonly timeoutMs;
+    private readonly maxBytes;
+    private readonly logger?;
+    constructor(options?: AttachClientOptions);
+    upload(input: AttachUploadInput): Promise<AttachUploadResult>;
+}

package/dist/client/attach-client.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachClient = exports.DEFAULT_MAX_ATTACH_BYTES = void 0;
+exports.withAttachAction = withAttachAction;
+const env_enum_1 = require("../env/env-enum");
+exports.DEFAULT_MAX_ATTACH_BYTES = 3_000_000;
+function toBuffer(content) {
+    if (typeof content === 'string') {
+        return Buffer.from(content, 'utf8');
+    }
+    if (Buffer.isBuffer(content)) {
+        return content;
+    }
+    return Buffer.from(content);
+}
+function readEnv(name) {
+    const value = process.env[name];
+    return value === '' ? undefined : value;
+}
+/** Append `action=attach` so the shared ingest webtrigger dispatches correctly. */
+function withAttachAction(url) {
+    if (/[?&]action=/i.test(url)) {
+        return url;
+    }
+    return `${url}${url.includes('?') ? '&' : '?'}action=attach`;
+}
+/**
+ * Client for Phase 3 Forge attach proxy → Jira Attachment API.
+ * Uses the shared ingest webtrigger URL; sends JSON + base64 (not FR41).
+ */
+class AttachClient {
+    url;
+    token;
+    timeoutMs;
+    maxBytes;
+    logger;
+    constructor(options = {}) {
+        this.url =
+            options.url ??
+                readEnv('QANALYZER_ATTACH_URL') ??
+                readEnv(env_enum_1.EnvIngestEnum.url);
+        this.token = options.token ?? readEnv(env_enum_1.EnvIngestEnum.token);
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxBytes = options.maxBytes ?? exports.DEFAULT_MAX_ATTACH_BYTES;
+        this.logger = options.logger;
+    }
+    async upload(input) {
+        if (!this.url) {
+            throw new Error('attach.url (or QANALYZER_INGEST_URL) is required to upload attachments');
+        }
+        if (!this.token) {
+            throw new Error('attach.token (or QANALYZER_INGEST_TOKEN) is required to upload attachments');
+        }
+        const content = toBuffer(input.content);
+        if (content.length > this.maxBytes) {
+            throw new Error(`Attachment is ${content.length} bytes; max allowed is ${this.maxBytes} bytes`);
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const endpoint = withAttachAction(this.url);
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.token}`,
+                    'X-QAnalyzer-Action': 'attach',
+                },
+                body: JSON.stringify({
+                    projectKey: input.projectKey,
+                    issueKey: input.issueKey,
+                    fileName: input.fileName,
+                    mimeType: input.mimeType,
+                    contentBase64: content.toString('base64'),
+                }),
+                signal: controller.signal,
+            });
+            const text = await response.text();
+            let body = text;
+            try {
+                body = text ? JSON.parse(text) : null;
+            }
+            catch {
+                // keep raw
+            }
+            if (!response.ok) {
+                const errMsg = typeof body === 'object' &&
+                    body &&
+                    'error' in body &&
+                    typeof body.error === 'string'
+                    ? body.error
+                    : typeof body === 'string'
+                        ? body
+                        : JSON.stringify(body);
+                throw new Error(`Forge attach failed with HTTP ${response.status}: ${errMsg}`);
+            }
+            const ok = body;
+            // Static Forge webtrigger success body is fixed `{"ok":true}` — no attachment id.
+            const id = ok?.id != null && String(ok.id) !== '' ? String(ok.id) : undefined;
+            this.logger?.log(id
+                ? `Attachment uploaded to ${ok.issueKey ?? input.issueKey} id=${id}`
+                : `Attachment uploaded to ${input.issueKey} (static ok)`);
+            return {
+                issueKey: ok?.issueKey ?? input.issueKey,
+                id,
+                filename: ok?.filename ?? input.fileName,
+                mimeType: ok?.mimeType ?? input.mimeType,
+                size: typeof ok?.size === 'number' ? ok.size : content.length,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Forge attach timed out after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.AttachClient = AttachClient;

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { IngestClient, type IngestClientOptions, type IngestResponse } from './ingest-client';
+export { AttachClient, DEFAULT_MAX_ATTACH_BYTES, type AttachClientOptions, type AttachUploadInput, type AttachUploadResult, } from './attach-client';

package/dist/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_ATTACH_BYTES = exports.AttachClient = exports.IngestClient = void 0;
+var ingest_client_1 = require("./ingest-client");
+Object.defineProperty(exports, "IngestClient", { enumerable: true, get: function () { return ingest_client_1.IngestClient; } });
+var attach_client_1 = require("./attach-client");
+Object.defineProperty(exports, "AttachClient", { enumerable: true, get: function () { return attach_client_1.AttachClient; } });
+Object.defineProperty(exports, "DEFAULT_MAX_ATTACH_BYTES", { enumerable: true, get: function () { return attach_client_1.DEFAULT_MAX_ATTACH_BYTES; } });

package/dist/client/ingest-client.d.ts

@@ -0,0 +1,19 @@
+import type { IngestOptionsType } from '../config';
+import type { IngestPayload } from '../models';
+import type { LoggerInterface } from '../utils';
+export type IngestClientOptions = IngestOptionsType & {
+    logger?: LoggerInterface;
+};
+export type IngestResponse = {
+    status: number;
+    body: unknown;
+};
+export declare class IngestClient {
+    private readonly url?;
+    private readonly token?;
+    private readonly timeoutMs;
+    private readonly maxPayloadBytes;
+    private readonly logger?;
+    constructor(options?: IngestClientOptions);
+    send(payload: IngestPayload): Promise<IngestResponse>;
+}

package/dist/client/ingest-client.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IngestClient = void 0;
+const models_1 = require("../models");
+class IngestClient {
+    url;
+    token;
+    timeoutMs;
+    maxPayloadBytes;
+    logger;
+    constructor(options = {}) {
+        this.url = options.url;
+        this.token = options.token;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxPayloadBytes = options.maxPayloadBytes ?? 4_500_000;
+        this.logger = options.logger;
+    }
+    async send(payload) {
+        if (!this.url) {
+            throw new Error('ingest.url (or QANALYZER_INGEST_URL) is required in ingest mode');
+        }
+        if (!this.token) {
+            throw new Error('ingest.token (or QANALYZER_INGEST_TOKEN) is required in ingest mode');
+        }
+        const bytes = (0, models_1.estimatePayloadBytes)(payload);
+        if (bytes > this.maxPayloadBytes) {
+            throw new Error(`Ingest payload is ${bytes} bytes; max allowed is ${this.maxPayloadBytes} bytes`);
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.token}`,
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            const text = await response.text();
+            let body = text;
+            try {
+                body = text ? JSON.parse(text) : null;
+            }
+            catch {
+                // keep raw text
+            }
+            if (!response.ok) {
+                throw new Error(`Forge ingest failed with HTTP ${response.status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`);
+            }
+            this.logger?.log(`Ingest accepted (HTTP ${response.status})`);
+            return { status: response.status, body };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Forge ingest timed out after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.IngestClient = IngestClient;

package/dist/config/config-loader.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigType } from './config-type';
+export declare class ConfigLoader {
+    private readonly paths;
+    constructor(paths?: string[]);
+    private read;
+    load(): ConfigType | null;
+}
+export declare function loadConfig(paths?: string[]): ConfigType | null;

package/dist/config/config-loader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+exports.loadConfig = loadConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const DEFAULT_PATHS = ['qanalyzer.config.json', '.qanalyzerc'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertConfigShape(json, fileLabel) {
+    if (!isRecord(json)) {
+        throw new Error(`Invalid config: "${fileLabel}" must be a JSON object`);
+    }
+    if (json.mode !== undefined && typeof json.mode !== 'string') {
+        throw new Error(`Invalid config: "mode" must be a string`);
+    }
+    if (json.projectKey !== undefined && typeof json.projectKey !== 'string') {
+        throw new Error(`Invalid config: "projectKey" must be a string`);
+    }
+}
+class ConfigLoader {
+    paths;
+    constructor(paths = DEFAULT_PATHS) {
+        this.paths = paths;
+    }
+    read() {
+        for (const configPath of this.paths) {
+            const filePath = (0, path_1.join)(process.cwd(), configPath);
+            try {
+                return (0, fs_1.readFileSync)(filePath, 'utf8');
+            }
+            catch (error) {
+                const code = error instanceof Error && 'code' in error
+                    ? String(error.code)
+                    : '';
+                if (code !== 'ENOENT' && code !== 'EISDIR') {
+                    throw new Error(`Cannot read config file "${configPath}"`, { cause: error });
+                }
+            }
+        }
+        return null;
+    }
+    load() {
+        const data = this.read();
+        if (!data)
+            return null;
+        let json;
+        try {
+            json = JSON.parse(data);
+        }
+        catch (error) {
+            throw new Error('Invalid config: file is not valid JSON', { cause: error });
+        }
+        assertConfigShape(json, 'root');
+        return json;
+    }
+}
+exports.ConfigLoader = ConfigLoader;
+function loadConfig(paths) {
+    return new ConfigLoader(paths).load();
+}