@supernovaio/cli 2.0.38 → 2.0.40

package/dist/utils/analyze-command.js

@@ -0,0 +1,606 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="48ae5534-bfe7-5b1e-a760-916b78e71f6d")}catch(e){}}();
+import { Flags } from "@oclif/core";
+import { runCodeAnalysis } from "../code-analyzer/orchestrator/run-analysis.js";
+import AdmZip from "adm-zip";
+import axios, { isAxiosError } from "axios";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { SentryCommand } from "../types/index.js";
+import { watchAnalyzeStatus } from "./analyze-status.js";
+import { createApiClient } from "./http-client.js";
+export const AnalyzeCommandConfigSchema = z.object({
+    exclude: z.array(z.string()).optional(),
+    designSystemId: z.string().optional(),
+    package: z.union([z.string(), z.array(z.string())]).optional(),
+    dryRun: z.boolean().optional(),
+    noWait: z.boolean().optional(),
+});
+export const analyzeFlags = {
+    designSystemId: Flags.string({ char: "d", description: "Design system ID" }),
+    package: Flags.string({
+        char: "p",
+        description: "Package name eg. @design-system-package. Can be repeated.",
+        multiple: true,
+    }),
+    exclude: Flags.string({
+        description: "Path to exclude from stories/docs/adoption scan. Can be repeated.",
+        multiple: true,
+    }),
+    dryRun: Flags.boolean({
+        description: "Run and write local snapshot only. Never uploads.",
+        default: false,
+    }),
+    noWait: Flags.boolean({
+        description: "Start processing and exit without waiting for completion.",
+        default: false,
+    }),
+};
+export class AnalyzeCommandBase extends SentryCommand {
+    get commandId() {
+        return this.id ?? this.constructor.name;
+    }
+    get configSchema() {
+        return AnalyzeCommandConfigSchema;
+    }
+    async executeAnalyze(flags, scannerType) {
+        const rootDir = process.cwd();
+        const config = this.configService.get();
+        const analyzeConfig = config?.analyze ?? {};
+        const configuredDesignSystemId = config?.designSystemId;
+        const packageFlags = normalizeStringList(flags.package);
+        const configuredPackages = normalizeStringList(analyzeConfig.packages);
+        const componentPackages = packageFlags.length > 0 ? packageFlags : configuredPackages;
+        if (componentPackages.length === 0) {
+            this.error("Parameter --package is required.");
+        }
+        const excludedPackages = normalizeStringList(analyzeConfig.excludedPackages);
+        const repoId = analyzeConfig.repoId ?? crypto.randomUUID();
+        const dryRun = flags.dryRun ?? false;
+        const noWait = flags.noWait ?? false;
+        const analyzeDesignSystemId = flags.designSystemId ?? configuredDesignSystemId;
+        const uploadContext = dryRun
+            ? null
+            : {
+                apiClient: await createApiClient(this.env),
+                designSystemId: analyzeDesignSystemId ?? (await this.promptDesignSystemId()),
+            };
+        const executionTargets = resolveExecutionTargets({
+            componentPackages,
+            excludedPackages,
+            rootDir,
+            scannerType,
+        });
+        const plannedTargets = executionTargets.map((executionTarget, index) => createPlannedExecutionTarget({
+            executionTarget,
+            index,
+            rootDir,
+            total: executionTargets.length,
+        }));
+        this.logPhase("Analyze started");
+        this.log(`Root: ${path.basename(rootDir) || rootDir}`);
+        this.log(`Targets: ${plannedTargets.length}`);
+        this.log(`Scan types: ${summarizeScanTypes(executionTargets)}`);
+        this.logPhase("Plan");
+        for (const plannedTarget of plannedTargets) {
+            const discoverySuffix = plannedTarget.executionTarget.discovery ? "  discovery" : "";
+            this.log(`${plannedTarget.targetId} ${padScanType(plannedTarget.executionTarget.scanType)}  pkg=${plannedTarget.packageLabel}  path=${plannedTarget.pathLabel}${discoverySuffix}`);
+        }
+        const preparedUploads = [];
+        let skippedTargets = 0;
+        let skippedNoAdoption = 0;
+        let skippedNoComponents = 0;
+        this.logPhase("Analyze phase");
+        for (const plannedTarget of plannedTargets) {
+            const { analyzeTarget, executionTarget, packageLabel, pathLabel, targetId } = plannedTarget;
+            this.log(`${targetId} ${formatStatus("start")} ${padScanType(executionTarget.scanType)}  path=${pathLabel}  pkg=${packageLabel}`);
+            if (executionTarget.scanType === "components" && !analyzeTarget) {
+                const nodeModulesMessage = createMissingComponentsSourceMessage(executionTarget.importFrom);
+                if (scannerType === "components") {
+                    this.error(nodeModulesMessage);
+                }
+                skippedTargets += 1;
+                this.log(`${targetId} ${formatStatus("skip")} ${padScanType(executionTarget.scanType)}  ${nodeModulesMessage}`);
+                continue;
+            }
+            if (!analyzeTarget) {
+                this.error(`Analyze target could not be resolved for ${stringifyImportFrom(executionTarget.importFrom)}.`);
+            }
+            const analysisResult = await runCodeAnalysis({
+                designSystemId: analyzeDesignSystemId,
+                excludePaths: flags.exclude,
+                importFrom: analyzeTarget.importFrom,
+                mode: executionTarget.scanType,
+                projectRoot: analyzeTarget.rootDir,
+                snapshotBaseRoot: shouldWriteSnapshotsToExecutionRoot(analyzeTarget.rootDir) ? rootDir : undefined,
+            });
+            const hasUsage = executionTarget.scanType === "usage" && hasUsageInSnapshot(analysisResult.snapshotRoot);
+            if (executionTarget.scanType === "usage" && !hasUsage) {
+                skippedTargets += 1;
+                skippedNoAdoption += 1;
+                this.log(`${targetId} ${formatStatus("skip")} ${padScanType(executionTarget.scanType)}  no adoption detected`);
+                continue;
+            }
+            if (executionTarget.scanType === "components" && analysisResult.components.length === 0) {
+                skippedTargets += 1;
+                skippedNoComponents += 1;
+                this.log(`${targetId} ${formatStatus("skip")} ${padScanType(executionTarget.scanType)}  no components detected`);
+                continue;
+            }
+            if (executionTarget.scanType === "components") {
+                this.log(`${targetId} ${formatStatus("done")} ${padScanType(executionTarget.scanType)}  snapshot=${analysisResult.snapshotId}  count=${analysisResult.components.length}`);
+            }
+            else {
+                this.log(`${targetId} ${formatStatus("done")} ${padScanType(executionTarget.scanType)}  snapshot=${analysisResult.snapshotId}  count=${countUsageRecordsInSnapshot(analysisResult.snapshotRoot)}`);
+            }
+            preparedUploads.push({
+                localSnapshotId: analysisResult.snapshotId,
+                packageLabel,
+                pathLabel,
+                repoId,
+                repoPackageName: readPackageName(analyzeTarget.rootDir),
+                scannerType: executionTarget.scanType,
+                snapshotRoot: analysisResult.snapshotRoot,
+                targetId,
+            });
+        }
+        this.logPhase("Analyze summary");
+        this.log(`Local snapshots: ${preparedUploads.length}`);
+        this.log(`Skipped: ${skippedTargets}`);
+        if (skippedNoAdoption > 0) {
+            this.log(`- no adoption: ${skippedNoAdoption}`);
+        }
+        if (skippedNoComponents > 0) {
+            this.log(`- no components: ${skippedNoComponents}`);
+        }
+        if (preparedUploads.length === 0) {
+            this.log("No analyzable results found. You are likely running the command from the wrong directory.");
+            return;
+        }
+        this.log(`Ready to upload: ${preparedUploads.length}`);
+        if (dryRun) {
+            this.persistAnalyzeConfig({
+                analyzeConfig,
+                designSystemId: analyzeDesignSystemId,
+                excludedPackages,
+                packages: componentPackages,
+                repoId,
+            });
+            this.log("Upload skipped (dry-run enabled).");
+            return;
+        }
+        if (!uploadContext) {
+            this.error("Upload context is missing.");
+        }
+        const { apiClient, designSystemId } = uploadContext;
+        this.logPhase("Upload phase");
+        const uploadResults = await Promise.allSettled(preparedUploads.map((upload, index) => this.uploadSnapshot({
+            apiClient,
+            designSystemId,
+            uploadId: formatSequenceId("U", index + 1, preparedUploads.length),
+            repoId: upload.repoId,
+            repoPackageName: upload.repoPackageName,
+            scannerType: upload.scannerType,
+            snapshotRoot: upload.snapshotRoot,
+            localSnapshotId: upload.localSnapshotId,
+            packageLabel: upload.packageLabel,
+            pathLabel: upload.pathLabel,
+            targetId: upload.targetId,
+        })));
+        const failedUploads = uploadResults.filter((result) => result.status === "rejected");
+        if (failedUploads.length > 0) {
+            throw new AggregateError(failedUploads.map(failure => failure.reason), `${failedUploads.length} snapshot upload(s) failed.`);
+        }
+        this.logPhase("Upload summary");
+        this.log(`Uploaded snapshots: ${preparedUploads.length}/${preparedUploads.length}`);
+        this.log(`- components: ${preparedUploads.filter(upload => upload.scannerType === "components").length}`);
+        this.log(`- usage: ${preparedUploads.filter(upload => upload.scannerType === "usage").length}`);
+        const processingRun = await this.startProcessingRun({
+            apiClient,
+            designSystemId,
+        });
+        this.persistAnalyzeConfig({
+            analyzeConfig,
+            designSystemId,
+            excludedPackages,
+            packages: componentPackages,
+            repoId,
+        });
+        if (noWait) {
+            this.log("Processing continues in the background. Use `supernova analyze status` to check progress.");
+            return;
+        }
+        this.logPhase("Watch phase");
+        await watchAnalyzeStatus({
+            apiClient,
+            designSystemId,
+            error: message => this.error(message),
+        });
+        this.logPhase("Analyze complete");
+        this.log(`Processing run: ${processingRun.processingRunId}`);
+        this.log(`Uploaded: ${preparedUploads.length}/${preparedUploads.length}`);
+    }
+    logPhase(title) {
+        this.log("");
+        this.log(title);
+    }
+    persistAnalyzeConfig(input) {
+        const { analyzeConfig, designSystemId, excludedPackages, packages, repoId } = input;
+        this.configService.update({
+            analyze: {
+                ...analyzeConfig,
+                repoId,
+                packages,
+                excludedPackages,
+            },
+            ...(designSystemId ? { designSystemId } : {}),
+        });
+    }
+    async uploadSnapshot(input) {
+        const { apiClient, designSystemId, localSnapshotId, packageLabel, pathLabel, repoId, repoPackageName, scannerType, snapshotRoot, targetId, uploadId, } = input;
+        const initPath = `/code-snapshots/upload`;
+        const local = await this.createArchiveFromSnapshotRoot(snapshotRoot);
+        const initPayload = {
+            archiveChecksum: local.checksum,
+            archiveName: local.archiveName,
+            archiveSize: local.sizeBytes,
+            designSystemId,
+            repoId,
+            repoPackageName,
+            scannerType: toApiScannerType(scannerType),
+        };
+        this.log(`${uploadId} ${formatStatus("start")} ${padScanType(scannerType)}  source=${targetId}  path=${pathLabel}  pkg=${packageLabel}  snapshot=${localSnapshotId}`);
+        let initResponse;
+        try {
+            const response = await apiClient.post(initPath, initPayload);
+            initResponse = response.data.result;
+            this.log(`${uploadId} INIT  ${formatStatus("done")}`);
+        }
+        catch (error) {
+            this.log(`${uploadId} INIT  ${formatStatus("fail")}`);
+            this.logHttpError("upload init", error);
+            this.error(`Snapshot upload initialization failed (${scannerType}).`);
+        }
+        if (!initResponse.uploadUrl) {
+            this.error(`Snapshot upload init response does not contain uploadUrl (${scannerType}).`);
+        }
+        try {
+            await axios.put(initResponse.uploadUrl, local.archive, {
+                headers: {
+                    "Content-Length": local.archive.length,
+                    "Content-Type": "application/zip",
+                },
+            });
+            this.log(`${uploadId} PUT   ${formatStatus("done")}`);
+        }
+        catch (error) {
+            this.log(`${uploadId} PUT   ${formatStatus("fail")}`);
+            this.logHttpError("signed upload PUT", error);
+            this.error(`Snapshot archive upload failed (${scannerType}).`);
+        }
+        const finalizePath = `/code-snapshots/${initResponse.snapshotId}/finalize`;
+        try {
+            await apiClient.post(finalizePath, {});
+            this.log(`${uploadId} FINAL ${formatStatus("done")}  remoteSnapshotId=${initResponse.snapshotId}`);
+        }
+        catch (error) {
+            this.log(`${uploadId} FINAL ${formatStatus("fail")}`);
+            this.logHttpError("finalize", error);
+            this.error(`Snapshot finalize failed (${scannerType}).`);
+        }
+    }
+    async startProcessingRun(input) {
+        const { apiClient, designSystemId } = input;
+        const processingPath = `/code-snapshots/process-run`;
+        this.logPhase("Processing phase");
+        this.log(`${formatStatus("start")} processing run`);
+        try {
+            const response = await apiClient.post(processingPath, {
+                designSystemId,
+            });
+            this.log(`${formatStatus("done")} processing run  id=${response.data.result.processingRunId}  snapshots=${response.data.result.snapshotIds.length}`);
+            return response.data.result;
+        }
+        catch (error) {
+            this.log(`${formatStatus("fail")} processing run`);
+            this.logHttpError("process-run", error);
+            this.error("Failed to start batch processing run.");
+        }
+    }
+    async createArchiveFromSnapshotRoot(snapshotRoot) {
+        const zip = new AdmZip();
+        zip.addLocalFolder(snapshotRoot);
+        const archive = zip.toBuffer();
+        const checksum = crypto.createHash("sha256").update(archive).digest("hex");
+        return {
+            archive,
+            archiveName: `${path.basename(snapshotRoot)}.zip`,
+            checksum,
+            sizeBytes: archive.byteLength,
+        };
+    }
+    logHttpError(step, error) {
+        if (isAxiosError(error)) {
+            const status = error.response?.status;
+            const data = typeof error.response?.data === "string" ? error.response.data : JSON.stringify(error.response?.data, null, 2);
+            this.log(`${step}, http error${status ? ` ${status}` : ""}: ${data ?? error.message}`);
+            return;
+        }
+        this.log(`${step}, error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function toApiScannerType(scannerType) {
+    return scannerType === "components" ? "Components" : "Usage";
+}
+function readPackageName(rootDir) {
+    const packageJsonPath = path.join(rootDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return path.basename(rootDir);
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return packageJson.name ?? path.basename(rootDir);
+}
+function resolveExecutionTargets(input) {
+    const result = [];
+    if (input.scannerType === "components" || input.scannerType === "all") {
+        result.push(...input.componentPackages.map(importFrom => ({
+            discovery: false,
+            importFrom,
+            rootDir: input.rootDir,
+            scanType: "components",
+        })));
+    }
+    if (input.scannerType === "usage" || input.scannerType === "all") {
+        result.push(...resolveUsageExecutionTargets({
+            componentPackages: input.componentPackages,
+            excludedPackages: input.excludedPackages,
+            rootDir: input.rootDir,
+        }));
+    }
+    return result;
+}
+function resolveUsageExecutionTargets(input) {
+    const { componentPackages, excludedPackages, rootDir } = input;
+    const candidatePackageDirs = resolveCandidatePackageDirs(rootDir);
+    const excludedNames = new Set(excludedPackages);
+    const componentPackageNames = resolveComponentPackageNames(rootDir, candidatePackageDirs, componentPackages);
+    if (candidatePackageDirs.length <= 1) {
+        const rootPackageName = readPackageName(rootDir);
+        if (excludedNames.has(rootPackageName)) {
+            return [];
+        }
+        return [{ discovery: false, importFrom: componentPackages, rootDir, scanType: "usage" }];
+    }
+    return candidatePackageDirs
+        .filter(packageDir => {
+        const packageName = readPackageName(packageDir);
+        return !excludedNames.has(packageName) && !componentPackageNames.has(packageName);
+    })
+        .map(packageDir => ({
+        discovery: true,
+        importFrom: componentPackages,
+        rootDir: packageDir,
+        scanType: "usage",
+    }));
+}
+function resolveCandidatePackageDirs(rootDir) {
+    const workspacePackageDirs = resolveWorkspacePackageDirs(rootDir);
+    if (workspacePackageDirs.length > 0) {
+        return workspacePackageDirs;
+    }
+    return resolveDirectChildPackageDirs(rootDir);
+}
+function resolveWorkspacePackageDirs(rootDir) {
+    const rootPackageJsonPath = path.join(rootDir, "package.json");
+    if (!fs.existsSync(rootPackageJsonPath)) {
+        return [];
+    }
+    const rootPackageJson = JSON.parse(fs.readFileSync(rootPackageJsonPath, "utf8"));
+    const workspacePatterns = Array.isArray(rootPackageJson.workspaces)
+        ? rootPackageJson.workspaces
+        : (rootPackageJson.workspaces?.packages ?? []);
+    const packageDirs = [];
+    for (const pattern of workspacePatterns) {
+        const normalized = pattern.replaceAll("\\", "/");
+        if (!normalized.includes("*")) {
+            const workspaceDir = path.resolve(rootDir, normalized);
+            if (fs.existsSync(path.join(workspaceDir, "package.json"))) {
+                packageDirs.push(workspaceDir);
+            }
+            continue;
+        }
+        if (!normalized.endsWith("/*")) {
+            continue;
+        }
+        const baseDir = path.resolve(rootDir, normalized.slice(0, -2));
+        if (!fs.existsSync(baseDir) || !fs.statSync(baseDir).isDirectory()) {
+            continue;
+        }
+        for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const candidate = path.join(baseDir, entry.name);
+            if (fs.existsSync(path.join(candidate, "package.json"))) {
+                packageDirs.push(candidate);
+            }
+        }
+    }
+    return [...new Set(packageDirs)];
+}
+function resolveDirectChildPackageDirs(rootDir) {
+    if (!fs.existsSync(rootDir) || !fs.statSync(rootDir).isDirectory()) {
+        return [];
+    }
+    const result = [];
+    for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const packageDir = path.join(rootDir, entry.name);
+        if (fs.existsSync(path.join(packageDir, "package.json"))) {
+            result.push(packageDir);
+        }
+    }
+    return result;
+}
+function resolveComponentPackageNames(rootDir, candidatePackageDirs, componentPackages) {
+    const byName = new Map(candidatePackageDirs.map(packageDir => [readPackageName(packageDir), packageDir]));
+    const names = new Set();
+    for (const componentPackage of componentPackages) {
+        if (byName.has(componentPackage)) {
+            names.add(componentPackage);
+            continue;
+        }
+        const explicitPath = path.resolve(rootDir, componentPackage);
+        if (!fs.existsSync(explicitPath) || !fs.statSync(explicitPath).isDirectory()) {
+            continue;
+        }
+        names.add(readPackageName(explicitPath));
+    }
+    return names;
+}
+function hasUsageInSnapshot(snapshotRoot) {
+    return countUsageRecordsInSnapshot(snapshotRoot) > 0;
+}
+function countUsageRecordsInSnapshot(snapshotRoot) {
+    const usageFilePath = path.join(snapshotRoot, "raw", "component-usage.json");
+    if (!fs.existsSync(usageFilePath)) {
+        return 0;
+    }
+    try {
+        const usageJson = JSON.parse(fs.readFileSync(usageFilePath, "utf8"));
+        const usageRecords = usageJson.records ?? {};
+        return Object.values(usageRecords).filter(item => (item.count ?? 0) > 0).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function shouldWriteSnapshotsToExecutionRoot(projectRoot) {
+    return projectRoot.split(path.sep).includes("node_modules");
+}
+function resolveAnalyzeTarget(input) {
+    if (input.scannerType === "usage") {
+        return { importFrom: input.importFrom, rootDir: input.rootDir };
+    }
+    const importFrom = Array.isArray(input.importFrom) ? input.importFrom[0] : input.importFrom;
+    if (!importFrom) {
+        return { importFrom: ".", rootDir: input.rootDir };
+    }
+    if (readPackageName(input.rootDir) === importFrom) {
+        if (hasSourceEntry(input.rootDir)) {
+            return { importFrom: "src", rootDir: input.rootDir };
+        }
+        return { importFrom: ".", rootDir: input.rootDir };
+    }
+    const workspacePackageDir = findPackageDirByName(resolveCandidatePackageDirs(input.rootDir), importFrom);
+    if (workspacePackageDir) {
+        if (hasSourceEntry(workspacePackageDir)) {
+            return { importFrom: "src", rootDir: workspacePackageDir };
+        }
+        return { importFrom: ".", rootDir: workspacePackageDir };
+    }
+    const explicitPath = path.resolve(input.rootDir, importFrom);
+    if (fs.existsSync(explicitPath) && fs.statSync(explicitPath).isDirectory()) {
+        if (hasSourceEntry(explicitPath)) {
+            return { importFrom: "src", rootDir: explicitPath };
+        }
+        return { importFrom: ".", rootDir: explicitPath };
+    }
+    return null;
+}
+function normalizeStringList(value) {
+    if (!value) {
+        return [];
+    }
+    const list = Array.isArray(value) ? value : [value];
+    return [...new Set(list.map(item => item.trim()).filter(Boolean))];
+}
+function stringifyImportFrom(importFrom) {
+    return Array.isArray(importFrom) ? importFrom.join(",") : importFrom;
+}
+function findPackageDirByName(packageDirs, packageName) {
+    for (const packageDir of packageDirs) {
+        const packageJsonPath = path.join(packageDir, "package.json");
+        if (!fs.existsSync(packageJsonPath)) {
+            continue;
+        }
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+            if (packageJson.name === packageName) {
+                return packageDir;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function hasSourceEntry(packageDir) {
+    return (fs.existsSync(path.join(packageDir, "src", "index.ts")) || fs.existsSync(path.join(packageDir, "src", "index.tsx")));
+}
+function createMissingComponentsSourceMessage(importFrom) {
+    return `Package ${stringifyImportFrom(importFrom)} could not be resolved from local source. Component analysis must run against source code, so the components scan was skipped. Run the command from the package source instead.`;
+}
+function createPlannedExecutionTarget(input) {
+    const { executionTarget, index, rootDir, total } = input;
+    const analyzeTarget = resolveAnalyzeTarget({
+        importFrom: executionTarget.importFrom,
+        rootDir: executionTarget.rootDir,
+        scannerType: executionTarget.scanType,
+    });
+    return {
+        analyzeTarget,
+        executionTarget,
+        packageLabel: stringifyImportFrom(executionTarget.importFrom),
+        pathLabel: formatPathLabel(rootDir, analyzeTarget?.rootDir ?? executionTarget.rootDir),
+        targetId: formatSequenceId("", index + 1, total),
+    };
+}
+function summarizeScanTypes(executionTargets) {
+    const components = executionTargets.filter(target => target.scanType === "components").length;
+    const usage = executionTargets.filter(target => target.scanType === "usage").length;
+    return `${components} components, ${usage} usage`;
+}
+function padScanType(scanType) {
+    return scanType.padEnd("components".length, " ");
+}
+function formatSequenceId(prefix, index, total) {
+    const width = String(total).length;
+    const left = String(index).padStart(width, "0");
+    const right = String(total).padStart(width, "0");
+    return `[${prefix}${left}/${right}]`;
+}
+function formatPathLabel(rootDir, targetPath) {
+    const relativePath = path.relative(rootDir, targetPath) || ".";
+    if (relativePath.length <= 48) {
+        return relativePath;
+    }
+    const segments = relativePath.split(path.sep);
+    return segments.length > 2 ? `.../${segments.slice(-2).join("/")}` : relativePath;
+}
+function formatStatus(status) {
+    const labels = {
+        done: "DONE ",
+        fail: "FAIL ",
+        skip: "SKIP ",
+        start: "START",
+    };
+    const colorEnabled = process.stdout.isTTY && !process.env.NO_COLOR;
+    if (!colorEnabled) {
+        return labels[status];
+    }
+    const colors = {
+        done: "\u001B[32m",
+        fail: "\u001B[31m",
+        skip: "\u001B[33m",
+        start: "\u001B[36m",
+    };
+    return `${colors[status]}${labels[status]}\u001B[0m`;
+}
+//# sourceMappingURL=analyze-command.js.map
+//# debugId=48ae5534-bfe7-5b1e-a760-916b78e71f6d