omp-plugin-duplicate-detector 0.1.0

package/src/jscpd-engine.ts

@@ -0,0 +1,797 @@
+import { execFile } from "node:child_process";
+import * as path from "node:path";
+import {
+	Detector,
+	type IClone,
+	type IMapFrame,
+	type IOptions,
+	type IStore,
+	MemoryStore,
+} from "@jscpd/core";
+import { getFormatByFile, Tokenizer } from "@jscpd/tokenizer";
+import ignore from "ignore";
+import { cloneIdentity } from "./duplicate-ledger";
+import { isTestFile, type TestFileDetectorOptions } from "./test-detector";
+
+export interface IgnoreFilterOptions extends TestFileDetectorOptions {}
+
+export interface JscpdIndexManagerOptions extends TestFileDetectorOptions {
+	minTokens?: number;
+	minLines?: number;
+	maxLines?: number;
+	ignorePatterns?: string[];
+	formatsExts?: Record<string, string[]>;
+	crossFormats?: boolean;
+	maxIndexedFiles?: number;
+}
+
+export type BaselineStatus =
+	| "idle"
+	| "complete"
+	| "skipped_not_git"
+	| "capped_file_count"
+	| "capped_source_bytes"
+	| "failed"
+	| "cancelled"
+	| "disabled";
+/** Maximum file size in bytes to tokenize (100 KiB matches jscpd defaults) */
+export const MAX_FILE_SIZE_BYTES = 100 * 1024;
+
+/** Hard circuit breaker: Maximum files indexed during baseline initialization */
+export const MAX_INDEXED_FILES = 10000;
+
+/** Hard circuit breaker: Maximum total source bytes across all indexed files (64 MiB) */
+export const MAX_TOTAL_SOURCE_BYTES = 64 * 1024 * 1024;
+
+/** Maximum tracked Git paths to inspect */
+export const MAX_GIT_PATHS = 10000;
+
+/**
+ * Common generated, lockfile, minified, and metadata file patterns
+ * automatically excluded from code duplication analysis.
+ */
+const DEFAULT_NOISE_PATTERNS = [
+	"*.lock",
+	"*.lockb",
+	"*-lock.json",
+	"*-lock.yaml",
+	"*-lock.yml",
+	"*.lock.json",
+	"*.min.js",
+	"*.min.css",
+	"*.min.*",
+	"*.bundle.js",
+	"*.map",
+	"*.generated.*",
+	"*.designer.cs",
+	"*.designer.vb",
+	".DS_Store",
+	"node_modules",
+];
+
+/**
+ * Non-code data, documentation, and metadata formats excluded from default code duplicate analysis.
+ */
+const DEFAULT_NON_CODE_FORMATS: ReadonlySet<string> = new Set([
+	"abnf",
+	"apacheconf",
+	"arff",
+	"asciidoc",
+	"bnf",
+	"comments",
+	"csp",
+	"csv",
+	"diff",
+	"dns-zone-file",
+	"dot",
+	"ebnf",
+	"editorconfig",
+	"excel-formula",
+	"gedcom",
+	"gettext",
+	"git",
+	"hpkp",
+	"hsts",
+	"http",
+	"ignore",
+	"ini",
+	"json",
+	"json5",
+	"keymap",
+	"latex",
+	"log",
+	"markdown",
+	"mermaid",
+	"nginx",
+	"plant-uml",
+	"properties",
+	"regex",
+	"rest",
+	"roboconf",
+	"shell-session",
+	"sparql",
+	"tap",
+	"textile",
+	"toml",
+	"turtle",
+	"txt",
+	"uri",
+	"url",
+	"wiki",
+	"yaml",
+]);
+
+/**
+ * Resolves whether a file corresponds to a supported source code format for duplicate detection.
+ * Filters out non-code documentation, data, logs, and diff formats by default.
+ * If user explicitly maps an extension via formatsExts, user configuration takes precedence.
+ */
+export function getSupportedCodeFormat(
+	filePath: string,
+	formatsExts?: Record<string, string[]>,
+): string | undefined {
+	const format = getFormatByFile(filePath, formatsExts);
+	if (!format) {
+		return undefined;
+	}
+
+	// If user explicitly configured this format under formatsExts, honor user intent
+	if (formatsExts && format in formatsExts) {
+		return format;
+	}
+
+	if (DEFAULT_NON_CODE_FORMATS.has(format)) {
+		return undefined;
+	}
+
+	// Filter out non-code markup data files (e.g. standalone .svg, .xml, .xsl, and .xslt data files)
+	if (format === "markup") {
+		const ext = path.extname(filePath).toLowerCase();
+		if (ext === ".svg" || ext === ".xml" || ext === ".xsl" || ext === ".xslt") {
+			return undefined;
+		}
+	}
+
+	return format;
+}
+
+/** Standard generated code header comment markers */
+const GENERATED_HEADER_MARKERS = [
+	/@generated\b/i,
+	/\bauto-generated\b/i,
+	/\bautomatically generated\b/i,
+	/\bGENERATED BY\b/i,
+	/\bDO NOT EDIT\b/i,
+	/\bDO NOT MODIFY\b/i,
+	/<auto-generated\b/i,
+	/<autogenerated\b/i,
+];
+
+export function execGit(
+	args: string[],
+	cwd: string,
+	options: { signal?: AbortSignal; maxBuffer?: number } = {},
+): Promise<{ stdout: string; stderr: string }> {
+	const { promise, resolve, reject } = Promise.withResolvers<{
+		stdout: string;
+		stderr: string;
+	}>();
+	execFile(
+		"git",
+		args,
+		{
+			cwd,
+			signal: options.signal,
+			maxBuffer: options.maxBuffer,
+			windowsHide: true,
+		},
+		(err, stdout, stderr) => {
+			if (err) return reject(err);
+			resolve({ stdout: String(stdout), stderr: String(stderr) });
+		},
+	);
+	return promise;
+}
+
+/**
+ * Check if file content contains standard code-generation markers in the header.
+ */
+export function isGeneratedContent(content: string): boolean {
+	const head = content.slice(0, 2048);
+	return GENERATED_HEADER_MARKERS.some((pattern) => pattern.test(head));
+}
+
+/**
+ * Creates a path ignore predicate matching against default noise patterns
+ * and provided user/project ignore patterns.
+ */
+export function createIgnoreFilter(
+	userIgnorePatterns: string[] = [],
+	options: IgnoreFilterOptions = {},
+): (relPath: string) => boolean {
+	const ig = ignore().add(DEFAULT_NOISE_PATTERNS).add(userIgnorePatterns);
+	const shouldIgnoreTests = options.ignoreTests !== false;
+	return (relPath: string) => {
+		if (!relPath || typeof relPath !== "string") return false;
+		const normalized = relPath.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+		if (!normalized || normalized === ".") return false;
+		if (
+			normalized.startsWith("../") ||
+			normalized === ".." ||
+			normalized.startsWith("/") ||
+			path.isAbsolute(normalized)
+		) {
+			return false;
+		}
+		if (shouldIgnoreTests && isTestFile(normalized, options)) {
+			return true;
+		}
+		try {
+			return ig.ignores(normalized);
+		} catch {
+			return false;
+		}
+	};
+}
+
+/**
+ * Check whether a directory is inside a valid Git working tree.
+ */
+export async function isInsideGitWorkTree(
+	dir: string,
+	signal?: AbortSignal,
+): Promise<boolean> {
+	try {
+		const { stdout } = await execGit(
+			["rev-parse", "--is-inside-work-tree"],
+			dir,
+			{ signal },
+		);
+		return stdout.trim() === "true";
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Retrieve tracked Git files beneath rootDir (using `git ls-files --cached`).
+ * Does NOT enumerate untracked files (`--others`), preventing runaway traversal.
+ */
+export async function getTrackedGitFiles(
+	rootDir: string,
+	options: {
+		userIgnorePatterns?: string[];
+		ignoreTests?: boolean;
+		customTestPatterns?: string[];
+		excludeTestPatterns?: string[];
+		signal?: AbortSignal;
+		maxPaths?: number;
+	} = {},
+): Promise<string[]> {
+	if (!(await isInsideGitWorkTree(rootDir, options.signal))) {
+		return [];
+	}
+
+	const maxPaths = options.maxPaths ?? MAX_GIT_PATHS;
+	const ignoreFilter = createIgnoreFilter(options.userIgnorePatterns ?? [], {
+		ignoreTests: options.ignoreTests,
+		customTestPatterns: options.customTestPatterns,
+		excludeTestPatterns: options.excludeTestPatterns,
+	});
+
+	try {
+		const { stdout } = await execGit(
+			["ls-files", "--cached", "-z", "--", "."],
+			rootDir,
+			{
+				signal: options.signal,
+				maxBuffer: 16 * 1024 * 1024,
+			},
+		);
+
+		const entries = stdout.split("\0");
+		const results: string[] = [];
+		for (const entry of entries) {
+			if (options.signal?.aborted) break;
+			const trimmed = entry.trim();
+			if (!trimmed) continue;
+
+			if (results.length >= maxPaths) break;
+
+			const relPath = trimmed.replace(/\\/g, "/").replace(/^\.\//, "");
+			if (
+				!relPath ||
+				relPath === ".." ||
+				relPath.startsWith("../") ||
+				relPath.startsWith("/") ||
+				path.isAbsolute(relPath)
+			) {
+				continue;
+			}
+			if (ignoreFilter(relPath)) continue;
+			results.push(path.resolve(rootDir, trimmed));
+		}
+		return results;
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Isolated overlay store for running non-mutating snippet queries.
+ * Prevents virtual query frames from polluting the persistent MemoryStore.
+ */
+class IsolatedMemoryStore implements IStore<IMapFrame> {
+	#namespace = "";
+	readonly #baseValues: Record<string, Record<string, IMapFrame>>;
+	readonly #overlayValues: Record<string, Record<string, IMapFrame>> = {};
+
+	constructor(baseValues: Record<string, Record<string, IMapFrame>>) {
+		this.#baseValues = baseValues;
+	}
+
+	namespace(ns: string): void {
+		this.#namespace = ns;
+		this.#overlayValues[ns] = this.#overlayValues[ns] || {};
+	}
+
+	get(key: string): Promise<IMapFrame> {
+		const overlay = this.#overlayValues[this.#namespace];
+		if (overlay && key in overlay) {
+			return Promise.resolve(overlay[key]!);
+		}
+		const base = this.#baseValues[this.#namespace];
+		if (base && key in base) {
+			return Promise.resolve(base[key]!);
+		}
+		return Promise.reject(new Error("not found"));
+	}
+
+	set(key: string, value: IMapFrame): Promise<IMapFrame> {
+		if (!this.#overlayValues[this.#namespace]) {
+			this.#overlayValues[this.#namespace] = {};
+		}
+		this.#overlayValues[this.#namespace]![key] = value;
+		return Promise.resolve(value);
+	}
+
+	close(): void {
+		// No-op for isolated overlay
+	}
+}
+
+/**
+ * Subclass of MemoryStore that allows extracting the underlying namespace map
+ * and evicting all frames for a given source file.
+ */
+class ExportableMemoryStore extends MemoryStore<IMapFrame> {
+	getNamespaceValues(): Record<string, Record<string, IMapFrame>> {
+		return this.values;
+	}
+
+	deleteBySourceId(sourceId: string): void {
+		for (const ns of Object.keys(this.values)) {
+			const nsMap = this.values[ns];
+			if (!nsMap) continue;
+			for (const key of Object.keys(nsMap)) {
+				const frame = nsMap[key];
+				if (frame && frame.sourceId === sourceId) {
+					delete nsMap[key];
+				}
+			}
+		}
+	}
+}
+
+export class JscpdIndexManager {
+	readonly #tokenizer: Tokenizer;
+	readonly #store: ExportableMemoryStore;
+	readonly #options: IOptions & { maxIndexedFiles?: number };
+	readonly #managerOptions: JscpdIndexManagerOptions;
+	#detector: Detector;
+	#indexedFiles = new Set<string>();
+	#discoveredClones: IClone[] = [];
+	#initialized = false;
+	#initPromise: Promise<number> | null = null;
+	#mutationQueue: Promise<void> = Promise.resolve();
+	#rootDir = "";
+	#baselineStatus: BaselineStatus = "idle";
+	#totalSourceBytes = 0;
+
+	constructor(options: JscpdIndexManagerOptions = {}) {
+		this.#tokenizer = new Tokenizer();
+		this.#store = new ExportableMemoryStore();
+		this.#managerOptions = { ...options };
+		this.#options = {
+			minTokens: options.minTokens ?? 40,
+			minLines: options.minLines ?? 5,
+			maxLines: options.maxLines ?? 500,
+			formatsExts: options.formatsExts,
+			maxIndexedFiles: options.maxIndexedFiles,
+		};
+		this.#detector = new Detector(
+			this.#tokenizer,
+			this.#store,
+			[],
+			this.#options,
+		);
+	}
+
+	get isInitialized(): boolean {
+		return this.#initialized;
+	}
+
+	get indexedCount(): number {
+		return this.#indexedFiles.size;
+	}
+
+	get rootDir(): string {
+		return this.#rootDir;
+	}
+
+	get baselineStatus(): BaselineStatus {
+		return this.#baselineStatus;
+	}
+
+	get totalSourceBytes(): number {
+		return this.#totalSourceBytes;
+	}
+
+	get discoveredClones(): IClone[] {
+		return this.#discoveredClones.slice();
+	}
+
+	/**
+	 * Reset all store contents and index state.
+	 */
+	reset(): void {
+		this.#store.close();
+		this.#indexedFiles.clear();
+		this.#discoveredClones = [];
+		this.#initialized = false;
+		this.#initPromise = null;
+		this.#baselineStatus = "idle";
+		this.#totalSourceBytes = 0;
+		this.#detector = new Detector(
+			this.#tokenizer,
+			this.#store,
+			[],
+			this.#options,
+		);
+	}
+
+	/**
+	 * Scan and index the workspace directory into the token store.
+	 * Only scans Git-tracked files in a valid Git worktree.
+	 * Coalesces concurrent initialization requests.
+	 */
+	async initialize(
+		rootDir: string,
+		ignorePatterns?: string[],
+		signal?: AbortSignal,
+	): Promise<number> {
+		if (this.#initPromise) {
+			return this.#initPromise;
+		}
+
+		this.#initPromise = this.#runInitialize(
+			rootDir,
+			ignorePatterns,
+			signal,
+		).finally(() => {
+			this.#initPromise = null;
+		});
+
+		return this.#initPromise;
+	}
+
+	async #runInitialize(
+		rootDir: string,
+		ignorePatterns?: string[],
+		signal?: AbortSignal,
+	): Promise<number> {
+		this.#rootDir = path.resolve(rootDir);
+		this.reset();
+
+		if (signal?.aborted) {
+			this.#baselineStatus = "cancelled";
+			this.#initialized = false;
+			return 0;
+		}
+
+		const isGit = await isInsideGitWorkTree(this.#rootDir, signal);
+		if (!isGit) {
+			this.#baselineStatus = "skipped_not_git";
+			this.#initialized = true;
+			return 0;
+		}
+
+		const userIgnores =
+			ignorePatterns && ignorePatterns.length > 0 ? ignorePatterns : [];
+		const maxIndexedFiles = this.#options.maxIndexedFiles ?? MAX_INDEXED_FILES;
+		const files = await getTrackedGitFiles(this.#rootDir, {
+			userIgnorePatterns: userIgnores,
+			ignoreTests: this.#managerOptions.ignoreTests,
+			customTestPatterns: this.#managerOptions.customTestPatterns,
+			excludeTestPatterns: this.#managerOptions.excludeTestPatterns,
+			signal,
+			maxPaths: Math.max(MAX_GIT_PATHS, maxIndexedFiles),
+		});
+
+		const seenCloneIds = new Set<string>();
+		let status: BaselineStatus = "complete";
+
+		for (const filePath of files) {
+			if (signal?.aborted) {
+				status = "cancelled";
+				break;
+			}
+
+			if (this.#indexedFiles.size >= maxIndexedFiles) {
+				status = "capped_file_count";
+				break;
+			}
+
+			const relPath = path
+				.relative(this.#rootDir, filePath)
+				.replace(/\\/g, "/");
+			const format = getSupportedCodeFormat(
+				filePath,
+				this.#options.formatsExts,
+			);
+			if (!format) continue;
+
+			try {
+				const file = Bun.file(filePath);
+				const size = file.size;
+				if (size > MAX_FILE_SIZE_BYTES) continue;
+
+				if (this.#totalSourceBytes + size > MAX_TOTAL_SOURCE_BYTES) {
+					status = "capped_source_bytes";
+					break;
+				}
+
+				const content = await file.text();
+				if (isGeneratedContent(content)) continue;
+
+				this.#totalSourceBytes += size;
+				const clones = await this.#detector.detect(relPath, content, format);
+
+				this.#indexedFiles.add(relPath);
+
+				for (const clone of clones) {
+					const id = cloneIdentity(clone);
+					if (!seenCloneIds.has(id)) {
+						seenCloneIds.add(id);
+						this.#discoveredClones.push(clone);
+					}
+				}
+			} catch {
+				// Skip unreadable files
+			}
+		}
+
+		this.#baselineStatus = signal?.aborted ? "cancelled" : status;
+		this.#initialized = !signal?.aborted;
+		return this.#indexedFiles.size;
+	}
+
+	/**
+	 * Check a code snippet or modified file against the indexed repository without polluting the persistent store.
+	 * Returns clones matching against existing repository files or intra-file duplicates.
+	 */
+	async checkSnippet(targetPath: string, content: string): Promise<IClone[]> {
+		if (this.#initPromise) {
+			await this.#initPromise;
+		}
+
+		const format = getSupportedCodeFormat(
+			targetPath,
+			this.#options.formatsExts,
+		);
+		if (!format) return [];
+
+		const relPath = (
+			path.isAbsolute(targetPath) && this.#rootDir
+				? path.relative(this.#rootDir, targetPath)
+				: targetPath
+		).replace(/\\/g, "/");
+
+		const virtualId = `virtual:${relPath}`;
+
+		// Use an isolated overlay store to avoid polluting the persistent MemoryStore with virtual frames
+		const overlayStore = new IsolatedMemoryStore(
+			this.#store.getNamespaceValues(),
+		);
+		const queryDetector = new Detector(
+			this.#tokenizer,
+			overlayStore,
+			[],
+			this.#options,
+		);
+
+		const allClones = await queryDetector.detect(virtualId, content, format);
+
+		// Filter clones:
+		const relevantClones: IClone[] = [];
+		for (const clone of allClones) {
+			const isAQuery = clone.duplicationA.sourceId === virtualId;
+			const isBQuery = clone.duplicationB.sourceId === virtualId;
+
+			if (isAQuery && !isBQuery) {
+				if (clone.duplicationB.sourceId !== relPath) {
+					relevantClones.push(clone);
+				}
+			} else if (!isAQuery && isBQuery) {
+				if (clone.duplicationA.sourceId !== relPath) {
+					relevantClones.push({
+						...clone,
+						duplicationA: clone.duplicationB,
+						duplicationB: clone.duplicationA,
+					});
+				}
+			} else if (isAQuery && isBQuery) {
+				relevantClones.push(clone);
+			}
+		}
+
+		return relevantClones;
+	}
+
+	/**
+	 * Update the index when a file is written or edited (Hot Index).
+	 * Serialized through a promise queue to prevent namespace race conditions.
+	 * Evicts stale token frames for the file before re-indexing.
+	 */
+	async updateFile(targetPath: string, content: string): Promise<void> {
+		if (this.#initPromise) {
+			await this.#initPromise;
+		}
+
+		const mutation = async () => {
+			const format = getSupportedCodeFormat(
+				targetPath,
+				this.#options.formatsExts,
+			);
+			if (!format) return;
+
+			const relPath = (
+				path.isAbsolute(targetPath) && this.#rootDir
+					? path.relative(this.#rootDir, targetPath)
+					: targetPath
+			).replace(/\\/g, "/");
+
+			// Evict old frames for this source file
+			this.#store.deleteBySourceId(relPath);
+
+			// Re-detect and index new frames
+			await this.#detector.detect(relPath, content, format);
+			this.#indexedFiles.add(relPath);
+		};
+
+		this.#mutationQueue = this.#mutationQueue.then(mutation, mutation);
+		return this.#mutationQueue;
+	}
+
+	/**
+	 * Format discovered clones into a Markdown report.
+	 */
+	formatReport(
+		clones: IClone[] = this.#discoveredClones,
+		scanPath = this.#rootDir,
+		options?: FormatReportOptions,
+	): string {
+		return formatReport(clones, scanPath, {
+			indexedCount: this.#indexedFiles.size,
+			baselineStatus: this.#baselineStatus,
+			maxIndexedFiles: this.#options.maxIndexedFiles ?? MAX_INDEXED_FILES,
+			minLines: this.#options.minLines,
+			minTokens: this.#options.minTokens,
+			...options,
+		});
+	}
+}
+
+export interface FormatReportOptions {
+	indexedCount?: number;
+	baselineStatus?: BaselineStatus;
+	maxIndexedFiles?: number;
+	minLines?: number;
+	minTokens?: number;
+	maxClones?: number;
+	maxBytes?: number;
+	artifactId?: string;
+}
+
+/**
+ * Formats discovered clone clusters into a Markdown report.
+ * Supports top-N capping and byte limits with artifact:// recovery links matching oh-my-pi conventions.
+ */
+export function formatReport(
+	clones: IClone[] = [],
+	scanPath = ".",
+	options?: FormatReportOptions,
+): string {
+	let report = "# Duplicate Code Report\n\n";
+	if (typeof options?.indexedCount === "number") {
+		report += `- **Indexed Files**: ${options.indexedCount}\n`;
+	}
+	report += `- **Scan Target**: \`${scanPath || "."}\`\n`;
+	report += `- **Duplicate Clusters Found**: ${clones.length}\n`;
+
+	if (options?.baselineStatus === "skipped_not_git") {
+		report +=
+			"- **Baseline Status**: Skipped (Directory is not inside a Git working tree; automatic scan requires Git-tracked files)\n";
+	} else if (options?.baselineStatus === "capped_file_count") {
+		const maxFiles = (
+			options?.maxIndexedFiles ?? MAX_INDEXED_FILES
+		).toLocaleString();
+		report += `- **Baseline Status**: Capped at ${maxFiles} files limit\n`;
+	} else if (options?.baselineStatus === "capped_source_bytes") {
+		report +=
+			"- **Baseline Status**: Capped at 64 MiB total source size limit\n";
+	}
+
+	report += "\n";
+
+	if (clones.length === 0) {
+		const minLines = options?.minLines ?? 5;
+		const minTokens = options?.minTokens ?? 40;
+		report += `No duplicate code blocks found matching threshold (minLines: ${minLines}, minTokens: ${minTokens}).\n`;
+		return report;
+	}
+
+	report += "## Detected Clones\n\n";
+
+	const maxClones = options?.maxClones;
+	const maxBytes = options?.maxBytes;
+	const artifactId = options?.artifactId;
+
+	const countToRender =
+		typeof maxClones === "number" && maxClones > 0
+			? Math.min(clones.length, maxClones)
+			: clones.length;
+
+	let renderedClones = 0;
+
+	for (let i = 0; i < countToRender; i++) {
+		const clone = clones[i]!;
+		const a = clone.duplicationA;
+		const b = clone.duplicationB;
+		const linesCount = a.end.line - a.start.line + 1;
+
+		let block = `### Clone #${i + 1} (${linesCount} lines, format: ${clone.format})\n`;
+		block += `- **Location A**: \`${a.sourceId}:${a.start.line}-${a.end.line}\`\n`;
+		block += `- **Location B**: \`${b.sourceId}:${b.start.line}-${b.end.line}\`\n`;
+
+		if (a.fragment) {
+			block += `\n\`\`\`${clone.format}\n${a.fragment.trim()}\n\`\`\`\n`;
+		}
+		block += "\n";
+
+		if (typeof maxBytes === "number" && maxBytes > 0) {
+			const estimatedTotal = Buffer.byteLength(report + block, "utf-8") + 512;
+			if (renderedClones > 0 && estimatedTotal > maxBytes) {
+				break;
+			}
+		}
+
+		report += block;
+		renderedClones++;
+	}
+
+	const omittedCount = clones.length - renderedClones;
+	if (omittedCount > 0) {
+		report += `*Showing top ${renderedClones} of ${clones.length} duplicate clusters (${omittedCount} additional cluster${omittedCount === 1 ? "" : "s"} omitted from inline context).*`;
+		if (artifactId) {
+			report += `\n*Read \`artifact://${artifactId}\` for the complete report with all ${clones.length} duplicate clusters.*`;
+		}
+		report += "\n\n";
+	}
+
+	if (artifactId) {
+		report += `[raw output: artifact://${artifactId}]\n`;
+	}
+
+	return report;
+}