@aqa-pulse/cli 0.1.0

package/dist/backend/upload-report.d.ts

@@ -0,0 +1,13 @@
+import { type DashboardRunMetadata, type PrecomputedCodeQualitySourceFacts } from '../dashboard-utils';
+import type { IngestionResult } from './contracts';
+export interface UploadReportOptions {
+    baseUrl: string;
+    workspaceSlug: string;
+    workspaceApiKey: string;
+    reportPath: string;
+    sourceFile: string;
+    sourceFactsPath: string | null;
+    precomputedSourceFacts: PrecomputedCodeQualitySourceFacts | null;
+    metadata: Partial<DashboardRunMetadata>;
+}
+export declare function uploadReportToWorkspace(options: UploadReportOptions): Promise<IngestionResult>;

package/dist/backend/upload-report.js

@@ -0,0 +1,338 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadReportToWorkspace = uploadReportToWorkspace;
+/**
+ * Назначение: консольная утилита для загрузки отчётов из CI или вручную.
+ * Она обменивает ключ workspace на токен загрузки и отправляет отчёт
+ * в self-hosted backend без участия интерфейса.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const error_utils_1 = require("../shared/error-utils");
+const dashboard_utils_1 = require("../dashboard-utils");
+const upload_report_artifacts_1 = require("./upload-report-artifacts");
+const generate_source_facts_1 = require("./generate-source-facts");
+if (require.main === module) {
+    void main();
+}
+async function main() {
+    try {
+        const cliOptions = parseCliOptions(process.argv.slice(2));
+        const resolvedOptions = resolveUploadOptions(cliOptions);
+        const result = await uploadReportToWorkspace(resolvedOptions);
+        if (cliOptions.json) {
+            process.stdout.write(`${JSON.stringify({
+                workspaceSlug: resolvedOptions.workspaceSlug,
+                baseUrl: resolvedOptions.baseUrl,
+                reportPath: resolvedOptions.reportPath,
+                sourceFile: resolvedOptions.sourceFile,
+                sourceFactsPath: resolvedOptions.sourceFactsPath,
+                result,
+            }, null, 2)}\n`);
+        }
+        else {
+            printHumanReadableOutput(resolvedOptions, result);
+        }
+    }
+    catch (error) {
+        console.error(`Ошибка upload report: ${(0, error_utils_1.getErrorMessage)(error)}`);
+        process.exitCode = 1;
+    }
+}
+async function uploadReportToWorkspace(options) {
+    const accessToken = await exchangeWorkspaceApiKey(options);
+    const report = (0, upload_report_artifacts_1.prepareReporterReportForUpload)((0, dashboard_utils_1.loadReporterReport)(options.reportPath), {
+        reportPath: options.reportPath,
+        preparedReportPath: normalizeOptionalText(process.env.AQA_PULSE_PREPARED_REPORT_PATH),
+        debugAttachmentsSummary: isEnabledFlag(process.env.AQA_PULSE_DEBUG_ATTACHMENTS_SUMMARY),
+        inlineAttachmentsTotalMaxSizeBytes: parsePositiveInteger(process.env.AQA_PULSE_INLINE_ATTACHMENTS_TOTAL_MAX_SIZE_BYTES),
+    });
+    const payload = {
+        report,
+        metadata: {
+            branch: normalizeOptionalText(options.metadata.branch),
+            commit: normalizeOptionalText(options.metadata.commit),
+            author: normalizeOptionalText(options.metadata.author),
+        },
+        sourceFile: options.sourceFile,
+        precomputedSourceFacts: options.precomputedSourceFacts ?? undefined,
+    };
+    return postJson(`${options.baseUrl}/api/workspaces/${encodeURIComponent(options.workspaceSlug)}/ingestions`, payload, {
+        authorization: `Bearer ${accessToken}`,
+    });
+}
+function parseCliOptions(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        printHelp();
+        process.exit(0);
+    }
+    const options = { json: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const currentArg = args[index];
+        if (currentArg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (currentArg === '--generate-source-facts') {
+            options.generateSourceFacts = true;
+            continue;
+        }
+        const nextArg = args[index + 1];
+        if (!nextArg || nextArg.startsWith('--')) {
+            throw new Error(`Для аргумента ${currentArg} нужно передать значение.`);
+        }
+        if (currentArg === '--base-url') {
+            options.baseUrl = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--workspace-slug') {
+            options.workspaceSlug = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--workspace-api-key') {
+            options.workspaceApiKey = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--report' || currentArg === '--report-path') {
+            options.reportPath = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--source-file') {
+            options.sourceFile = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--source-facts') {
+            options.sourceFactsPath = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--repo-root') {
+            options.repoRoot = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--branch') {
+            options.branch = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--commit') {
+            options.commit = nextArg;
+            index += 1;
+            continue;
+        }
+        if (currentArg === '--author') {
+            options.author = nextArg;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Неизвестный аргумент: ${currentArg}`);
+    }
+    return options;
+}
+function resolveUploadOptions(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl ?? process.env.AQA_PULSE_BASE_URL);
+    const workspaceSlug = requireNonEmptyText(options.workspaceSlug ?? process.env.AQA_PULSE_WORKSPACE_SLUG, 'AQA_PULSE_WORKSPACE_SLUG');
+    const workspaceApiKey = requireNonEmptyText(options.workspaceApiKey ?? process.env.AQA_PULSE_WORKSPACE_API_KEY, 'AQA_PULSE_WORKSPACE_API_KEY');
+    const reportPath = requireNonEmptyText(options.reportPath ?? process.env.AQA_PULSE_REPORT_PATH ?? process.env.PW_LLM_REPORT ?? 'test-results/dashboard/data.json', '--report / AQA_PULSE_REPORT_PATH / PW_LLM_REPORT');
+    const sourceFile = normalizeOptionalText(options.sourceFile) ?? buildDefaultSourceFile(reportPath);
+    const shouldGenerateSourceFacts = options.generateSourceFacts === true || isEnabledFlag(process.env.AQA_PULSE_GENERATE_SOURCE_FACTS);
+    const sourceFactsPath = normalizeOptionalText(options.sourceFactsPath ?? process.env.AQA_PULSE_SOURCE_FACTS_PATH)
+        ?? (shouldGenerateSourceFacts ? path.join(path.dirname(path.resolve(reportPath)), 'source-facts.json') : null);
+    const precomputedSourceFacts = sourceFactsPath
+        ? resolvePrecomputedSourceFacts(sourceFactsPath, reportPath, options.repoRoot ?? process.env.AQA_PULSE_SOURCE_ROOT ?? process.env.AQA_PULSE_REPO_ROOT, shouldGenerateSourceFacts)
+        : null;
+    return {
+        baseUrl,
+        workspaceSlug,
+        workspaceApiKey,
+        reportPath,
+        sourceFile,
+        sourceFactsPath,
+        precomputedSourceFacts,
+        metadata: {
+            branch: normalizeOptionalText(options.branch ?? process.env.CI_COMMIT_REF_NAME ?? process.env.GITHUB_REF_NAME),
+            commit: normalizeOptionalText(options.commit ?? process.env.CI_COMMIT_SHA ?? process.env.GITHUB_SHA),
+            author: normalizeOptionalText(options.author ?? process.env.GITLAB_USER_NAME ?? process.env.CI_COMMIT_AUTHOR ?? process.env.GITHUB_ACTOR ?? 'CI upload'),
+        },
+    };
+}
+async function exchangeWorkspaceApiKey(options) {
+    const response = await fetch(`${options.baseUrl}/auth/workspaces/${encodeURIComponent(options.workspaceSlug)}/api-keys/login`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({ token: options.workspaceApiKey }),
+    });
+    const payload = await readJsonPayload(response);
+    if (!response.ok || !payload?.accessToken) {
+        throw new Error(readPayloadErrorMessage(payload, response.status, 'Не удалось получить ingestion JWT.'));
+    }
+    return payload.accessToken;
+}
+async function postJson(url, body, extraHeaders = {}) {
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...extraHeaders,
+        },
+        body: JSON.stringify(body),
+    });
+    const payload = await readJsonPayload(response);
+    if (!response.ok || payload === null) {
+        throw new Error(readPayloadErrorMessage(payload, response.status, 'Upload ingestion report завершился ошибкой.'));
+    }
+    return payload;
+}
+async function readJsonPayload(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return null;
+    }
+    return JSON.parse(text);
+}
+function readPayloadErrorMessage(payload, status, fallback) {
+    return normalizeOptionalText(payload?.error) ?? `${fallback} HTTP ${status}.`;
+}
+function printHumanReadableOutput(options, result) {
+    console.log('AQA Pulse report upload завершён.');
+    console.log('');
+    console.log(`Workspace slug: ${options.workspaceSlug}`);
+    console.log(`Base URL: ${options.baseUrl}`);
+    console.log(`Report path: ${options.reportPath}`);
+    console.log(`Source file: ${options.sourceFile}`);
+    if (options.sourceFactsPath) {
+        console.log(`Source facts path: ${options.sourceFactsPath}`);
+    }
+    console.log(`Run id: ${result.runId}`);
+    console.log(`Summary generated at: ${result.summaryGeneratedAt}`);
+    console.log(`Dashboard summary path: ${result.summaryPath}`);
+    console.log(`History path: ${result.historyPath}`);
+}
+function printHelp() {
+    console.log('aqa-pulse-server upload-report [options]');
+    console.log('');
+    console.log('Опции:');
+    console.log('  --base-url <url>                Base URL сервера, иначе AQA_PULSE_BASE_URL');
+    console.log('  --workspace-slug <slug>         Workspace slug, иначе AQA_PULSE_WORKSPACE_SLUG');
+    console.log('  --workspace-api-key <key>       Raw workspace API key, иначе AQA_PULSE_WORKSPACE_API_KEY');
+    console.log('  --report <path>                 Путь к report JSON, иначе AQA_PULSE_REPORT_PATH / PW_LLM_REPORT / test-results/dashboard/data.json');
+    console.log('  --source-file <value>           Явный sourceFile для ingestion payload');
+    console.log('  --source-facts <path>           JSON с precomputed source facts для code-quality metrics');
+    console.log('  --generate-source-facts         Сгенерировать source-facts перед upload, если файл не найден');
+    console.log('  --repo-root <path>              Корень repo для --generate-source-facts, иначе текущая директория');
+    console.log('  --branch <value>                Явная branch metadata');
+    console.log('  --commit <value>                Явная commit metadata');
+    console.log('  --author <value>                Явный author metadata');
+    console.log('  --json                          Печатать результат в JSON');
+    console.log('');
+    console.log('Дополнительные env для attachment-aware upload:');
+    console.log('  AQA_PULSE_SOURCE_FACTS_PATH                     Путь к JSON с precomputed source facts');
+    console.log('  AQA_PULSE_GENERATE_SOURCE_FACTS=true             Автоматически сгенерировать source facts перед upload');
+    console.log('  AQA_PULSE_SOURCE_ROOT / AQA_PULSE_REPO_ROOT       Корень repo для генерации source facts');
+    console.log('  AQA_PULSE_PREPARED_REPORT_PATH                   Сохранить подготовленный payload report в JSON');
+    console.log('  AQA_PULSE_DEBUG_ATTACHMENTS_SUMMARY=true         Печатать debug summary по найденным attachment');
+    console.log('  AQA_PULSE_INLINE_ATTACHMENTS_TOTAL_MAX_SIZE_BYTES Общий budget inline attachment в байтах');
+}
+function normalizeBaseUrl(value) {
+    const normalized = requireNonEmptyText(value, 'AQA_PULSE_BASE_URL').replace(/\/+$/g, '');
+    if (!/^https?:\/\//i.test(normalized)) {
+        throw new Error(`Base URL должен начинаться с http:// или https://, получено: ${normalized}`);
+    }
+    return normalized;
+}
+function buildDefaultSourceFile(reportPath) {
+    const gitlabProjectPath = normalizeOptionalText(process.env.CI_PROJECT_PATH);
+    const gitlabPipelineId = normalizeOptionalText(process.env.CI_PIPELINE_ID);
+    const gitlabJobName = normalizeOptionalText(process.env.CI_JOB_NAME);
+    if (gitlabProjectPath && gitlabPipelineId && gitlabJobName) {
+        return `gitlab://${gitlabProjectPath}/${gitlabPipelineId}/${gitlabJobName}`;
+    }
+    const githubRepository = normalizeOptionalText(process.env.GITHUB_REPOSITORY);
+    const githubRunId = normalizeOptionalText(process.env.GITHUB_RUN_ID);
+    const githubJob = normalizeOptionalText(process.env.GITHUB_JOB);
+    if (githubRepository && githubRunId && githubJob) {
+        return `github://${githubRepository}/${githubRunId}/${githubJob}`;
+    }
+    return `manual://${reportPath.replace(/\\/g, '/')}`;
+}
+function requireNonEmptyText(value, label) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        throw new Error(`Нужно передать ${label}.`);
+    }
+    return normalized;
+}
+function normalizeOptionalText(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function parsePositiveInteger(value) {
+    if (!value || value.trim().length === 0) {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function isEnabledFlag(value) {
+    const normalized = normalizeOptionalText(value)?.toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes';
+}
+function readJsonFile(filePath, label) {
+    const resolvedFilePath = requireNonEmptyText(filePath, label);
+    const fileContent = fs.readFileSync(resolvedFilePath, 'utf8');
+    return JSON.parse(fileContent);
+}
+function resolvePrecomputedSourceFacts(sourceFactsPath, reportPath, repoRoot, shouldGenerate) {
+    if (fs.existsSync(sourceFactsPath)) {
+        return readJsonFile(sourceFactsPath, '--source-facts / AQA_PULSE_SOURCE_FACTS_PATH');
+    }
+    if (!shouldGenerate) {
+        throw new Error(`Не найден source facts file: ${sourceFactsPath}`);
+    }
+    const report = (0, dashboard_utils_1.loadReporterReport)(reportPath);
+    const resolvedRepoRoot = path.resolve(repoRoot ?? process.cwd());
+    const sourceFacts = (0, generate_source_facts_1.buildPrecomputedSourceFacts)(report, resolvedRepoRoot, path.resolve(reportPath));
+    fs.mkdirSync(path.dirname(path.resolve(sourceFactsPath)), { recursive: true });
+    fs.writeFileSync(sourceFactsPath, `${JSON.stringify(sourceFacts, null, 2)}\n`, 'utf8');
+    return sourceFacts;
+}