codoc-cli 0.1.2

package/dist/config/codoc-config-atlassian.js

@@ -0,0 +1,89 @@
+//#region src/config/codoc-config-atlassian.ts
+/** Noms des variables d'env portant les identifiants Confluence d'un environnement donné. */
+function confluenceEnvVarNames(key) {
+	const suffix = key.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+	return {
+		userVar: `CONFLUENCE_${suffix}_USERNAME`,
+		tokenVar: `CONFLUENCE_${suffix}_API_TOKEN`
+	};
+}
+function confluenceEnvRequirements(envs) {
+	return Object.keys(envs ?? {}).flatMap((key) => {
+		const { userVar, tokenVar } = confluenceEnvVarNames(key);
+		return [{
+			name: userVar,
+			secret: false,
+			hint: `Identifiant Atlassian (email) pour l'environnement Confluence "${key}".`
+		}, {
+			name: tokenVar,
+			hint: `Token API Atlassian pour l'environnement Confluence "${key}".`,
+			generateUrl: "https://kleegroup.atlassian.net/servicedesk/customer/portal/27/group/230 -> Demande d'utilisation clé API -> https://id.atlassian.com/manage-profile/security/api-tokens -> Créer un jeton d'API"
+		}];
+	});
+}
+/** Retourne l'environnement s'il n'y en a qu'un seul, sinon `undefined`. */
+function onlySingleEnv(envs) {
+	return envs.length === 1 ? envs[0] : void 0;
+}
+/** Sous-ensemble de `jira:` utile à codoc (macro Jira Confluence) - un seul jeu de valeurs pour tous les environnements. */
+function parseJiraLink(raw) {
+	return {
+		serverId: raw?.serverId?.toString(),
+		server: raw?.server?.toString()
+	};
+}
+function parseDrawio(raw) {
+	return {
+		macroName: raw?.macroName ?? "drawio",
+		width: raw?.width,
+		edgeStyle: raw?.edgeStyle,
+		edgeAnchor: raw?.edgeAnchor,
+		colWidth: raw?.colWidth,
+		rowStep: raw?.rowStep
+	};
+}
+function resolveAtlassianEnvironment(key, envYaml, missing, jira, drawio) {
+	const baseUrl = envYaml?.baseUrl;
+	const spaceKey = envYaml?.spaceKey;
+	const userVar = `CONFLUENCE_${key.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_USERNAME`;
+	const tokenVar = `CONFLUENCE_${key.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_TOKEN`;
+	const username = process.env[userVar];
+	const apiToken = process.env[tokenVar];
+	if (!baseUrl) missing.push(`atlassian.environments.${key}.baseUrl   → codoc.yaml`);
+	if (!spaceKey) missing.push(`atlassian.environments.${key}.spaceKey  → codoc.yaml`);
+	if (!username) missing.push(`${userVar} → .env-codoc`);
+	if (!apiToken) missing.push(`${tokenVar} → .env-codoc`);
+	return {
+		key,
+		baseUrl,
+		username,
+		apiToken,
+		spaceKey,
+		defaultParentPageId: envYaml?.defaultParentPageId?.toString(),
+		jira,
+		drawio
+	};
+}
+function parseAtlassianEnvironments(raw) {
+	const missing = [];
+	const jira = parseJiraLink(raw.jira);
+	const drawio = parseDrawio(raw.drawio);
+	const envs = raw.atlassian?.environments;
+	if (!envs || !Object.keys(envs).length) throw new Error("Aucun environnement Atlassian défini : ajoute une section `atlassian.environments:` dans codoc.yaml.");
+	const resolved = Object.entries(envs).map(([key, envYaml]) => resolveAtlassianEnvironment(key, envYaml, missing, jira, drawio));
+	if (missing.length) throw new Error("Configuration Atlassian incomplète - valeurs manquantes :\n\n" + missing.map((m) => `  ${m}`).join("\n") + "\n");
+	return resolved;
+}
+function resolveDocEnvironmentByKey(config, doc) {
+	const envs = config.atlassian.environments;
+	if (doc.env) {
+		const env = envs.find((e) => e.key === doc.env);
+		if (!env) throw new Error(`Document "${doc.path}" : environnement "${doc.env}" inconnu. Environnements définis : ${envs.map((e) => e.key).join(", ")}.`);
+		return env;
+	}
+	const onlyEnv = onlySingleEnv(envs);
+	if (onlyEnv) return onlyEnv;
+	throw new Error(`Document "${doc.path}" : champ "env" requis (plusieurs environnements définis : ${envs.map((e) => e.key).join(", ")}).`);
+}
+//#endregion
+export { confluenceEnvRequirements, onlySingleEnv, parseAtlassianEnvironments, resolveDocEnvironmentByKey };

package/dist/config/codoc-config-raw.js

@@ -0,0 +1,21 @@
+import { fileExists, readFile } from "../services/files-service.js";
+import { CONFIG_PATH } from "./codoc-paths.js";
+import yaml from "js-yaml";
+//#region src/config/codoc-config-raw.ts
+/** Normalise une valeur yaml optionnelle (string ou tableau) en tableau de strings non vides et trimées. */
+function asStringList(v) {
+	if (!v) return [];
+	return (Array.isArray(v) ? v : [v]).map((s) => String(s).trim()).filter(Boolean);
+}
+let cache;
+function loadRawConfig(options = {}) {
+	if (cache) return cache;
+	if (!fileExists(CONFIG_PATH)) {
+		if (options.required) throw new Error(`Configuration introuvable : ${CONFIG_PATH}`);
+		return {};
+	}
+	cache = yaml.load(readFile(CONFIG_PATH)) ?? {};
+	return cache;
+}
+//#endregion
+export { asStringList, loadRawConfig };

package/dist/config/codoc-config.js

@@ -0,0 +1,50 @@
+import { onlySingleEnv, parseAtlassianEnvironments, resolveDocEnvironmentByKey } from "./codoc-config-atlassian.js";
+import { asStringList, loadRawConfig } from "./codoc-config-raw.js";
+//#region src/config/codoc-config.ts
+let cache;
+function parseGitlab(raw) {
+	return {
+		baseUrl: raw?.baseUrl,
+		defaultBranch: raw?.defaultBranch
+	};
+}
+/** Ignore les overrides sans `path`, ou dont les `keywords` sont vides une fois normalisés. */
+function parseKeywordOverrides(raw) {
+	return (raw ?? []).map((o) => ({
+		path: o.path,
+		keywords: asStringList(o.keywords)
+	})).filter((o) => Boolean(o.path) && o.keywords.length > 0);
+}
+function parseDocs(raw) {
+	return (raw ?? []).map((doc) => ({
+		codocId: doc.codocId?.toString(),
+		path: doc.path,
+		maintainedIn: doc.maintainedIn === "confluence" ? "confluence" : "code",
+		env: doc.env,
+		imagesDir: doc.imagesDir,
+		keywords: asStringList(doc.keywords),
+		keywordOverrides: parseKeywordOverrides(doc.keywordOverrides),
+		generateSummary: doc.generateSummary ?? true,
+		confluence: {
+			title: doc.confluence?.title,
+			parentPageId: doc.confluence?.parentPageId?.toString(),
+			titlePrefix: doc.confluence?.titlePrefix,
+			titleSuffix: doc.confluence?.titleSuffix
+		}
+	}));
+}
+function getGitlabConfig() {
+	return parseGitlab(loadRawConfig().gitlab);
+}
+function getCodocConfig() {
+	if (cache) return cache;
+	const raw = loadRawConfig({ required: true });
+	cache = {
+		atlassian: { environments: parseAtlassianEnvironments(raw) },
+		gitlab: parseGitlab(raw.gitlab),
+		docs: parseDocs(raw.docs)
+	};
+	return cache;
+}
+//#endregion
+export { getCodocConfig, getGitlabConfig, onlySingleEnv, resolveDocEnvironmentByKey as resolveDocEnvironment };

package/dist/config/codoc-paths.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+//#region src/config/codoc-paths.ts
+const PROJECT_ROOT = process.cwd();
+const CONFIG_PATH = path.join(PROJECT_ROOT, "codoc.yaml");
+const STATE_FILE = path.join(PROJECT_ROOT, "codoc.lock");
+const ENV_FILE = path.join(PROJECT_ROOT, ".env");
+const CODOC_ENV_FILE = path.join(PROJECT_ROOT, ".env-codoc");
+//#endregion
+export { CODOC_ENV_FILE, CONFIG_PATH, ENV_FILE, PROJECT_ROOT, STATE_FILE };

package/dist/hooks/command_not_found.js

@@ -0,0 +1,7 @@
+//#region src/hooks/command_not_found.ts
+const hook = async function(options) {
+	const id = options.id.replaceAll(":", " ");
+	this.error(`La commande « codoc ${id} » n'existe pas. Lance « codoc help » pour la liste des commandes.`, { exit: 2 });
+};
+//#endregion
+export { hook as default };

package/dist/hooks/init/check-for-update.js

@@ -0,0 +1,68 @@
+import { log } from "../../services/log/logger.js";
+import { execa } from "execa";
+import ora from "ora";
+//#region src/hooks/init/check-for-update.ts
+const PACKAGE_NAME = "codoc-cli";
+async function currentGlobalVersion() {
+	return (await execa("npm", [
+		"list",
+		"-g",
+		PACKAGE_NAME
+	], { reject: false })).stdout.split(`${PACKAGE_NAME}@`)[1]?.split(/\s/)[0];
+}
+/** Compare deux versions "x.y.z" segment par segment - true si `candidate` est strictement plus récente que `current`. */
+function isNewerVersion(candidate, current) {
+	const a = candidate.split(".").map(Number);
+	const b = current.split(".").map(Number);
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const diff = (a[i] ?? 0) - (b[i] ?? 0);
+		if (diff !== 0) return diff > 0;
+	}
+	return false;
+}
+async function latestVersion() {
+	const result = await execa("npm", [
+		"view",
+		PACKAGE_NAME,
+		"version"
+	], { reject: false });
+	return result.failed ? void 0 : result.stdout.trim();
+}
+async function update(version) {
+	const spinner = ora(`Mise à jour de codoc (${version}) en cours…`).start();
+	const result = await execa("npm", [
+		"install",
+		"-g",
+		`${PACKAGE_NAME}@${version}`
+	], { reject: false });
+	spinner.stop();
+	if (result.failed) {
+		log.error1(`Mise à jour échouée : ${result.stderr || result.shortMessage}`);
+		return false;
+	}
+	log.success1(`[UPDATED] codoc mis à jour en ${version}.`);
+	return true;
+}
+/** Relance la commande d'origine (argv tel que tapé par l'utilisateur) via le binaire global fraîchement mis à jour. */
+async function rerunWithUpdatedBinary() {
+	const result = await execa("codoc", process.argv.slice(2), {
+		reject: false,
+		stdio: "inherit"
+	});
+	if (result.failed && !result.exitCode) return false;
+	process.exit(result.exitCode ?? 0);
+}
+const hook = async function() {
+	if (process.env.CI || !process.stdout.isTTY) return;
+	try {
+		const [current, latest] = await Promise.all([currentGlobalVersion(), latestVersion()]);
+		if (!current || !latest || !isNewerVersion(latest, current)) return;
+		this.warn(`Une nouvelle version de codoc est disponible : ${current} → ${latest}.`);
+		if (!await update(latest)) return;
+		if (!await rerunWithUpdatedBinary()) this.warn("[SKIPPED] Relance automatique impossible - relance ta commande pour utiliser la nouvelle version.");
+	} catch (err) {
+		this.warn(`[SKIPPED] Vérification de mise à jour ignorée : ${err.message}`);
+	}
+};
+//#endregion
+export { hook as default, isNewerVersion };

package/dist/hooks/init/load-env.js

@@ -0,0 +1,15 @@
+import { CODOC_ENV_FILE, ENV_FILE } from "../../config/codoc-paths.js";
+import dotenv from "dotenv";
+//#region src/hooks/init/load-env.ts
+const hook = async function() {
+	dotenv.config({
+		path: CODOC_ENV_FILE,
+		quiet: true
+	});
+	dotenv.config({
+		path: ENV_FILE,
+		quiet: true
+	});
+};
+//#endregion
+export { hook as default };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { run } from "@oclif/core";
+export { run };

package/dist/services/codoc-id.js

@@ -0,0 +1,7 @@
+import crypto from "node:crypto";
+//#region src/services/codoc-id.ts
+function generateRandomCodocId() {
+	return crypto.randomBytes(4).toString("hex");
+}
+//#endregion
+export { generateRandomCodocId };

package/dist/services/confluence/attachments.js

@@ -0,0 +1,56 @@
+import { describeError } from "../../clients/confluence/utils/confluence-util.js";
+import { basename } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/services/confluence/attachments.ts
+async function fetchAttachmentBinary(attachments, pageId, filename) {
+	const att = await attachments.find(pageId, filename);
+	if (!att) return { notFound: true };
+	const errors = {};
+	try {
+		const buffer = await attachments.downloadV1(att.downloadPath);
+		return {
+			data: Buffer.from(buffer),
+			via: "v1",
+			bytes: buffer.byteLength
+		};
+	} catch (err) {
+		errors.v1Error = await describeError(err);
+	}
+	try {
+		const signedUrl = await attachments.getDownloadLink(att.id);
+		if (!signedUrl) {
+			errors.v2Error = "Réponse v2 sans downloadLink.";
+			return errors;
+		}
+		const buffer = await attachments.downloadV2(signedUrl);
+		return {
+			data: Buffer.from(buffer),
+			via: "v2",
+			bytes: buffer.byteLength
+		};
+	} catch (err) {
+		errors.v2Error = await describeError(err);
+		return errors;
+	}
+}
+async function fetchAttachmentText(attachments, pageId, filename) {
+	const att = await attachments.find(pageId, filename);
+	if (!att) return void 0;
+	try {
+		return await attachments.downloadTextV1(att.downloadPath);
+	} catch {
+		return;
+	}
+}
+async function uploadAttachmentBlob(attachments, pageId, filename, blob) {
+	await attachments.upload(pageId, filename, blob);
+}
+async function uploadAttachmentBuffer(attachments, pageId, filename, buffer, mimeType = "application/octet-stream") {
+	await uploadAttachmentBlob(attachments, pageId, filename, new Blob([new Uint8Array(buffer)], { type: mimeType }));
+}
+async function uploadAttachmentFile(attachments, pageId, filePath, mimeType = "application/octet-stream") {
+	const buffer = await readFile(filePath);
+	await uploadAttachmentBuffer(attachments, pageId, basename(filePath), buffer, mimeType);
+}
+//#endregion
+export { fetchAttachmentBinary, fetchAttachmentText, uploadAttachmentBlob, uploadAttachmentBuffer, uploadAttachmentFile };

package/dist/services/confluence/folders.js

@@ -0,0 +1,42 @@
+import { log } from "../log/logger.js";
+import { createPageOrThrowConflict } from "./pages.js";
+//#region src/services/confluence/folders.ts
+async function createOrEnsureFolder(client, title, parentId, existingId) {
+	if (existingId && await resourceExists(client, existingId)) return { id: existingId };
+	if (parentId) {
+		const already = await client.folders.findByTitleUnderParent(String(parentId), title);
+		if (already) return { id: already.id };
+	}
+	if (!client.foldersV2Unavailable) try {
+		const spaceId = await client.folders.getSpaceId(client.configuration.spaceKey);
+		return { id: (await client.folders.create(title, spaceId, parentId)).id };
+	} catch (err) {
+		client.foldersV2Unavailable = true;
+		const status = err.response?.status;
+		log.warning2(`API v2 dossiers indisponible (HTTP ${status ?? "réseau"}) - repli sur des pages de type dossier.`);
+	}
+	return { id: (await createPageOrThrowConflict(client, title, "<p></p>", parentId)).id };
+}
+async function resourceExists(client, id) {
+	return await client.folders.exists(id) || await client.pages.exists(id);
+}
+async function getFolderRef(client, id) {
+	const folder = await client.folders.get(id);
+	if (folder) return {
+		...folder,
+		type: "folder"
+	};
+	try {
+		const page = await client.pages.fetchPage(id);
+		return {
+			id: page.id,
+			title: page.title,
+			parentId: page.parentId,
+			type: "page"
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { createOrEnsureFolder, getFolderRef };

package/dist/services/confluence/labels.js

@@ -0,0 +1,17 @@
+import { log } from "../log/logger.js";
+//#region src/services/confluence/labels.ts
+const COMBINING_MARKS_RE = new RegExp(`[${String.fromCharCode(768)}-${String.fromCharCode(879)}]`, "g");
+function toConfluenceLabel(keyword) {
+	return keyword.normalize("NFD").replace(COMBINING_MARKS_RE, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function pushKeywordLabels(client, pageId, keywords) {
+	const labels = [...new Set((keywords ?? []).map(toConfluenceLabel).filter(Boolean))];
+	if (!labels.length) return;
+	try {
+		await client.pages.addLabels(pageId, labels);
+	} catch (err) {
+		log.warning4(`Labels Confluence non appliqués (${labels.join(", ")}) : ${err.message}`);
+	}
+}
+//#endregion
+export { pushKeywordLabels, toConfluenceLabel };

package/dist/services/confluence/pages.js

@@ -0,0 +1,28 @@
+import { pageUrl } from "../../clients/confluence/utils/confluence-url.js";
+//#region src/services/confluence/pages.ts
+async function createPageOrThrowConflict(client, title, storageContent, parentId, onTitleConflict) {
+	try {
+		return await client.pages.create(title, storageContent, parentId);
+	} catch (err) {
+		const message = await err.response?.text?.();
+		if (err.response?.status !== 400 || !message?.includes("already exists")) throw err;
+		const found = await client.pages.findByTitle(title);
+		if (found && onTitleConflict) {
+			const url = pageUrl(client.configuration.baseUrl, client.configuration.spaceKey, found.id);
+			if (await onTitleConflict(found.id, url)) return client.pages.update(found.id, title, storageContent, parentId);
+		}
+		const where = found ? `elle a été retrouvée ici : ${pageUrl(client.configuration.baseUrl, client.configuration.spaceKey, found.id)}` : `elle n'a pas pu être retrouvée par titre (peut-être à la corbeille) - vérifie manuellement dans l'espace "${client.configuration.spaceKey}".`;
+		throw new Error(`Impossible de créer la page "${title}" : une page portant ce titre existe déjà quelque part dans Confluence, ${where}\nVérifie s'il ne s'agit pas de la même doc mal référencée (codocId/parentPageId à corriger dans codoc.yaml), ou renomme l'une des deux pages pour lever le conflit.`);
+	}
+}
+async function createOrUpdatePage(client, title, storageContent, parentId, existingPageId, onTitleConflict) {
+	if (!existingPageId) return createPageOrThrowConflict(client, title, storageContent, parentId, onTitleConflict);
+	try {
+		return await client.pages.update(existingPageId, title, storageContent, parentId);
+	} catch (err) {
+		if (err.response?.status === 404) return createPageOrThrowConflict(client, title, storageContent, parentId, onTitleConflict);
+		throw err;
+	}
+}
+//#endregion
+export { createOrUpdatePage, createPageOrThrowConflict };

package/dist/services/conversion/confluenceToMarkdown/diagrams/drawio-diagrams.js

@@ -0,0 +1,77 @@
+import { ensureDir, writeBinaryFile } from "../../../files-service.js";
+import { log } from "../../../log/logger.js";
+import { escapeXml } from "../../shared/xml-escaping.js";
+import { sanitizeAttachmentFilename } from "../../shared/image-attachments.js";
+import { macroParam, macroRegex } from "../../shared/read-storage-format.js";
+import { extractGraphModel, renderDrawioToPng } from "./drawio-to-image.js";
+import path from "path";
+//#region src/services/conversion/confluenceToMarkdown/diagrams/drawio-diagrams.ts
+/** Repère les blocs draw.io (macro classique + extension ADF), avec nom de pièce jointe. */
+function findDrawioBlocks(xml) {
+	const out = [];
+	for (const m of xml.matchAll(macroRegex("drawio"))) {
+		const block = m[0];
+		const name = macroParam(block, "attachment") ?? macroParam(block, "diagramName");
+		if (name) out.push({
+			full: block,
+			fileName: name,
+			start: m.index ?? 0
+		});
+	}
+	for (const m of xml.matchAll(/<ac:adf-extension>[\s\S]*?<\/ac:adf-extension>/g)) {
+		const block = m[0];
+		if (!/drawio/i.test(block)) continue;
+		const name = block.match(/key="diagram-name">([^<]+)<\/ac:adf-parameter>/)?.[1];
+		if (name) out.push({
+			full: block,
+			fileName: name.trim(),
+			start: m.index ?? 0
+		});
+	}
+	return out.sort((a, b) => a.start - b.start);
+}
+/** Nom de pièce jointe draw.io → nom de fichier .png local stable (même diagramme = même nom au fil des pulls). */
+function pngFilenameFor(fileName) {
+	const withoutExt = fileName.replace(/\.drawio$/i, "");
+	return `${sanitizeAttachmentFilename(withoutExt)}.png`;
+}
+function imgTag(fileName, localFilename, imgRelPath) {
+	return `<img src="${imgRelPath ? `${imgRelPath}/${localFilename}` : localFilename}" alt="${escapeXml(fileName)}">`;
+}
+/**
+* Blocs draw.io → image PNG rendue par le vrai moteur draw.io (fidèle, icônes/pochoirs inclus),
+* enregistrée dans `imagesDir` et référencée par un `<img>` classique dans le xml (repris ensuite
+* par le pipeline HTML → Markdown, comme n'importe quelle autre image Confluence).
+*
+* Sans `imagesDir` configuré : aucune conversion (mêmes conventions que pour les autres images -
+* pas de dossier, pas de téléchargement local). Les blocs non convertis (échec, pas d'imagesDir)
+* retombent sur `preserveDrawioMacros` (préservés tels quels dans le markdown final).
+*/
+async function convertDrawioBlocksToImages(xml, fetchAttachment, imagesDir, imgRelPath) {
+	const blocks = findDrawioBlocks(xml);
+	if (!blocks.length || !imagesDir) return xml;
+	log.step1(`${blocks.length} diagramme(s) draw.io détecté(s) - conversion en image`);
+	ensureDir(imagesDir);
+	const parts = [];
+	let last = 0;
+	for (const { full, fileName, start } of blocks) try {
+		const drawioXml = await fetchAttachment(fileName);
+		if (!drawioXml) {
+			log.warning3(`"${fileName}" : pièce jointe introuvable - bloc draw.io conservé tel quel`);
+			continue;
+		}
+		const png = await renderDrawioToPng(extractGraphModel(drawioXml));
+		const localFilename = pngFilenameFor(fileName);
+		writeBinaryFile(path.resolve(imagesDir, localFilename), png);
+		parts.push(xml.slice(last, start), imgTag(fileName, localFilename, imgRelPath));
+		last = start + full.length;
+		log.success3(`"${fileName}" → ${localFilename}`);
+	} catch (err) {
+		const why = err?.response?.status ?? err?.message ?? "erreur";
+		log.warning3(`"${fileName}" : téléchargement/rendu impossible (${why}) - bloc conservé`);
+	}
+	parts.push(xml.slice(last));
+	return parts.join("");
+}
+//#endregion
+export { convertDrawioBlocksToImages };

package/dist/services/conversion/confluenceToMarkdown/diagrams/drawio-to-image.js

@@ -0,0 +1,131 @@
+import { log } from "../../../log/logger.js";
+import path from "path";
+import { exec, execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import { promisify } from "util";
+import zlib from "zlib";
+import { fileURLToPath } from "url";
+//#region src/services/conversion/confluenceToMarkdown/diagrams/drawio-to-image.ts
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const VIEWER_SCRIPT_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../../../assets/drawio-viewer/viewer-static.min.js");
+let viewerScriptCache;
+function viewerScript() {
+	viewerScriptCache ??= fs.readFileSync(VIEWER_SCRIPT_PATH, "utf-8").replace(/<\/script/gi, "<\\/script");
+	return viewerScriptCache;
+}
+let browserPromise;
+const CHROME_MISSING = /Could not find (Chrome|Browser)/i;
+const CHROME_VERSION = /ver\. ([\d.]+)/;
+function chromeInstallHelpMessage(cause) {
+	const detail = cause instanceof Error ? cause.message : String(cause);
+	const version = detail.match(CHROME_VERSION)?.[1];
+	const cacheDir = "%USERPROFILE%\\.cache\\puppeteer\\chrome";
+	return `Échec de l'installation automatique de Chrome, nécessaire pour convertir les diagrammes draw.io en image.
+Cause connue sur Windows : un antivirus interfère avec l'extraction automatique des fichiers, alors que le téléchargement du .zip, lui, réussit toujours entièrement.
+Contournement (fiable, déjà vérifié sur ce projet) - depuis PowerShell :
+  Expand-Archive -Path "${cacheDir}\\${version ? `${version}-chrome-win64.zip` : "<version>-chrome-win64.zip"}" -DestinationPath "${cacheDir}\\${version ? `win64-${version}` : "win64-<version>"}" -Force\n` + (version ? "" : "  (remplacez <version> par le numéro présent dans le nom du fichier .zip du dossier ci-dessus)\n") + `Détail technique : ${detail}`;
+}
+function puppeteerCliPath() {
+	const pkgPath = fileURLToPath(import.meta.resolve("puppeteer/package.json"));
+	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	return path.resolve(path.dirname(pkgPath), pkg.bin);
+}
+async function installChromeOnWindows(version) {
+	const { getDownloadUrl, Cache, Browser: PuppeteerBrowser, BrowserPlatform } = await import("@puppeteer/browsers");
+	const installDir = new Cache(path.join(os.homedir(), ".cache", "puppeteer")).installationDir(PuppeteerBrowser.CHROME, BrowserPlatform.WIN64, version);
+	const url = getDownloadUrl(PuppeteerBrowser.CHROME, BrowserPlatform.WIN64, version).toString();
+	const tmpZip = path.join(os.tmpdir(), `codoc-chrome-${version}-${Date.now()}.zip`);
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return false;
+		fs.writeFileSync(tmpZip, Buffer.from(await res.arrayBuffer()));
+		await execFileAsync("powershell", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`Remove-Item -LiteralPath '${installDir}' -Recurse -Force -ErrorAction SilentlyContinue; Expand-Archive -LiteralPath '${tmpZip}' -DestinationPath '${installDir}' -Force`
+		], { timeout: 18e4 });
+		return fs.existsSync(path.join(installDir, "chrome-win64", "chrome.exe"));
+	} catch {
+		return false;
+	} finally {
+		fs.rmSync(tmpZip, { force: true });
+	}
+}
+async function ensureChromeInstalled(version) {
+	log.info1("Chrome (nécessaire pour convertir les diagrammes draw.io) introuvable - installation en cours…");
+	if (process.platform === "win32" && version && await installChromeOnWindows(version)) return;
+	await execAsync(`node "${puppeteerCliPath()}" browsers install chrome`, { timeout: 3e5 });
+}
+async function getBrowser() {
+	browserPromise ??= (async () => {
+		const { launch } = await import("puppeteer");
+		try {
+			return await launch({ headless: true });
+		} catch (err) {
+			if (!(err instanceof Error) || !CHROME_MISSING.test(err.message)) throw err;
+			try {
+				await ensureChromeInstalled(err.message.match(CHROME_VERSION)?.[1]);
+				return await launch({ headless: true });
+			} catch (retryErr) {
+				throw new Error(chromeInstallHelpMessage(retryErr));
+			}
+		}
+	})();
+	return browserPromise;
+}
+/** À appeler en fin de commande (pull/sync) pour fermer proprement le navigateur headless. */
+async function closeDrawioRenderer() {
+	if (!browserPromise) return;
+	const promise = browserPromise;
+	browserPromise = void 0;
+	try {
+		await (await promise).close();
+	} catch {}
+}
+function extractGraphModel(drawio) {
+	if (drawio.includes("<mxGraphModel")) {
+		const start = drawio.indexOf("<mxGraphModel");
+		const end = drawio.indexOf("</mxGraphModel>");
+		if (end !== -1) return drawio.slice(start, end + 15);
+	}
+	const payload = drawio.match(/<diagram[^>]*>([\s\S]*?)<\/diagram>/)?.[1]?.trim();
+	if (payload) try {
+		const inflated = zlib.inflateRawSync(Buffer.from(payload, "base64")).toString("utf-8");
+		return decodeURIComponent(inflated);
+	} catch {}
+	throw new Error("Impossible d'extraire le mxGraphModel (ni XML en clair, ni payload compressé reconnu).");
+}
+function viewerHtml(graphModelXml) {
+	return `<!DOCTYPE html><html><head><meta charset="utf-8"><style>body{margin:0;background:#fff}</style></head><body><div class="mxgraph" data-mxgraph="${JSON.stringify({
+		toolbar: "",
+		resize: true,
+		xml: graphModelXml
+	}).replace(/&/g, "&amp;").replace(/"/g, "&quot;")}"></div><script>${viewerScript()}<\/script></body></html>`;
+}
+/** mxGraphModel XML → PNG rendu par le vrai moteur draw.io (icônes/pochoirs inclus). */
+async function renderDrawioToPng(graphModelXml) {
+	const page = await (await getBrowser()).newPage();
+	try {
+		await page.setViewport({
+			width: 4e3,
+			height: 4e3,
+			deviceScaleFactor: 2
+		});
+		await page.setContent(viewerHtml(graphModelXml), { waitUntil: "load" });
+		await page.waitForFunction(() => document.querySelector(".mxgraph svg") !== null, { timeout: 15e3 });
+		await new Promise((r) => setTimeout(r, 200));
+		const el = await page.$(".mxgraph");
+		if (!el) throw new Error("Élément .mxgraph introuvable après rendu.");
+		return await el.screenshot({
+			type: "png",
+			omitBackground: false
+		});
+	} finally {
+		await page.close();
+	}
+}
+//#endregion
+export { closeDrawioRenderer, extractGraphModel, renderDrawioToPng };

package/dist/services/conversion/confluenceToMarkdown/index.js

@@ -0,0 +1,17 @@
+import { convertDrawioBlocksToImages } from "./diagrams/drawio-diagrams.js";
+import { preprocessStorage } from "./preprocess/preprocess.js";
+import { buildTurndown } from "./turndown.js";
+//#region src/services/conversion/confluenceToMarkdown/index.ts
+function formatTableBlocks(md) {
+	return md.replace(/<table[\s\S]*?<\/table>/g, (table) => table.replace(/(<table[^>]*>)\s*(<colgroup>|<thead>|<tbody>)/g, "$1\n$2").replace(/<\/colgroup>\s*(<thead>|<tbody>)/g, "</colgroup>\n$1").replace(/(<thead>|<tbody>)\s*<tr>/g, "$1\n<tr>").replace(/<\/tr>\s*<tr>/g, "</tr>\n<tr>").replace(/<\/tr>\s*(<\/thead>|<\/tbody>)/g, "</tr>\n$1").replace(/<\/thead>\s*<tbody>/g, "</thead>\n<tbody>").replace(/<\/(thead|tbody)>\s*<\/table>/g, "</$1>\n</table>"));
+}
+function confluenceStorageToMarkdown(storageXml, imgRelPath, baseUrl) {
+	const html = preprocessStorage(storageXml, imgRelPath, baseUrl);
+	return formatTableBlocks(buildTurndown().turndown(html).trim());
+}
+/** Sens pull : page Confluence (Storage Format + pièces jointes) → Markdown. */
+async function renderMarkdown(storageXml, options) {
+	return confluenceStorageToMarkdown(await convertDrawioBlocksToImages(storageXml, options.fetchAttachment, options.imagesDir, options.imgRelPath), options.imgRelPath, options.baseUrl);
+}
+//#endregion
+export { confluenceStorageToMarkdown, preprocessStorage, renderMarkdown };