@yalehwang/archguard 0.1.0

package/dist/cli/processors/diagram-processor.js

@@ -0,0 +1,610 @@
+import { FileDiscoveryService } from '../utils/file-discovery-service.js';
+import { ParallelParser } from '../../parser/parallel-parser.js';
+import { ArchJSONAggregator } from '../../parser/archjson-aggregator.js';
+import { MetricsCalculator } from '../../parser/metrics-calculator.js';
+import { OutputPathResolver } from '../utils/output-path-resolver.js';
+import { MermaidDiagramGenerator } from '../../mermaid/diagram-generator.js';
+import { ParallelProgressReporter } from '../progress/parallel-progress.js';
+import { MermaidRenderWorkerPool } from '../../mermaid/render-worker-pool.js';
+import { ArchJsonDiskCache } from '../cache/arch-json-disk-cache.js';
+import fs from 'fs-extra';
+import pMap from 'p-map';
+import os from 'os';
+import { createHash } from 'crypto';
+import path from 'path';
+export function deriveSubModuleArchJSON(parent, subPath, workspaceRoot) {
+    const normSub = subPath.replace(/\\/g, '/').replace(/\/$/, '');
+    let relSub = null;
+    if (workspaceRoot) {
+        const normRoot = workspaceRoot.replace(/\\/g, '/').replace(/\/$/, '');
+        if (normSub.startsWith(normRoot + '/')) {
+            relSub = normSub.slice(normRoot.length + 1);
+        }
+        else if (normSub === normRoot) {
+            relSub = '';
+        }
+    }
+    const entities = parent.entities.filter((e) => {
+        let fp = (e.filePath ?? '').replace(/\\/g, '/');
+        if (!fp && e.name && e.id.endsWith('.' + e.name)) {
+            fp = e.id.slice(0, e.id.length - e.name.length - 1).replace(/\\/g, '/');
+        }
+        if (e.sourceLocation?.file && (!fp || (!fp.includes('/') && !fp.includes('.')))) {
+            fp = e.sourceLocation.file.replace(/\\/g, '/');
+        }
+        if (!fp)
+            return false;
+        if (fp.startsWith(normSub + '/') || fp === normSub)
+            return true;
+        if (relSub !== null) {
+            if (relSub === '')
+                return true;
+            if (fp.startsWith(relSub + '/') || fp === relSub)
+                return true;
+        }
+        return false;
+    });
+    const ids = new Set(entities.map((e) => e.id));
+    const outgoingRelations = (parent.relations ?? []).filter((r) => ids.has(r.source));
+    const crossModuleTargetIds = new Set(outgoingRelations
+        .filter((r) => !ids.has(r.target))
+        .map((r) => r.target));
+    const stubEntities = parent.entities
+        .filter((e) => crossModuleTargetIds.has(e.id))
+        .map((e) => ({ ...e, members: [] }));
+    const allModuleEntities = [...entities, ...stubEntities];
+    const relations = outgoingRelations;
+    let extensions = parent.extensions;
+    const mg = parent.extensions?.tsAnalysis?.moduleGraph;
+    if (mg) {
+        const parts = normSub.split('/').filter(Boolean);
+        const relPrefix = parts.length >= 2 ? parts.slice(-2).join('/') : parts[parts.length - 1] ?? normSub;
+        const filteredNodes = mg.nodes.filter((n) => n.id === relPrefix || n.id.startsWith(relPrefix + '/'));
+        const filteredNodeIds = new Set(filteredNodes.map((n) => n.id));
+        const filteredEdges = mg.edges.filter((e) => filteredNodeIds.has(e.from) && filteredNodeIds.has(e.to));
+        const filteredCycles = (mg.cycles ?? []).filter((c) => c.modules.every((m) => filteredNodeIds.has(m)));
+        extensions = {
+            ...parent.extensions,
+            tsAnalysis: {
+                ...parent.extensions.tsAnalysis,
+                moduleGraph: {
+                    nodes: filteredNodes,
+                    edges: filteredEdges,
+                    cycles: filteredCycles,
+                },
+            },
+        };
+    }
+    return { ...parent, entities: allModuleEntities, relations, extensions };
+}
+export class DiagramProcessor {
+    diagrams;
+    globalConfig;
+    progress;
+    fileDiscovery;
+    aggregator;
+    metricsCalculator;
+    parallelProgress;
+    parseCache;
+    registry;
+    archJsonDiskCache;
+    constructor(options) {
+        if (options.diagrams.length === 0) {
+            throw new Error('At least one diagram configuration is required');
+        }
+        this.diagrams = options.diagrams;
+        this.globalConfig = options.globalConfig;
+        this.progress = options.progress;
+        this.fileDiscovery = new FileDiscoveryService();
+        this.aggregator = new ArchJSONAggregator();
+        this.metricsCalculator = new MetricsCalculator();
+        this.parseCache = options.parseCache;
+        this.registry = options.registry;
+        const diskCacheDir = path.join(os.homedir(), '.archguard', 'cache', 'archjson');
+        this.archJsonDiskCache = new ArchJsonDiskCache(diskCacheDir);
+    }
+    async processAll() {
+        const concurrency = this.globalConfig.concurrency || os.cpus().length;
+        if (this.diagrams.length > 1) {
+            const diagramNames = this.diagrams.map((d) => d.name);
+            this.parallelProgress = new ParallelProgressReporter(diagramNames);
+        }
+        const diagramCount = this.diagrams.length;
+        const isGoAtlas = diagramCount === 1 && this.diagrams[0].language === 'go';
+        const atlasLayerCount = isGoAtlas
+            ? (this.diagrams[0].languageSpecific?.atlas
+                ?.layers?.length ?? 4)
+            : 0;
+        const effectiveDiagramCount = Math.max(diagramCount, atlasLayerCount);
+        const poolSize = effectiveDiagramCount >= 2 ? Math.min(os.cpus().length, effectiveDiagramCount, 4) : 0;
+        const poolTheme = typeof this.globalConfig.mermaid?.theme === 'string'
+            ? this.globalConfig.mermaid.theme
+            : this.globalConfig.mermaid?.theme?.name ?? 'default';
+        const pool = poolSize > 0
+            ? new MermaidRenderWorkerPool(poolSize, {
+                theme: poolTheme,
+                backgroundColor: this.globalConfig.mermaid?.transparentBackground ? 'transparent' : 'white',
+            })
+            : null;
+        if (pool)
+            await pool.start();
+        try {
+            const sourceGroups = this.groupDiagramsBySource();
+            const groupResults = await pMap(Array.from(sourceGroups.entries()), async ([sourceKey, diagrams]) => {
+                return await this.processSourceGroup(sourceKey, diagrams, pool);
+            }, { concurrency: Math.min(concurrency, sourceGroups.size) });
+            const results = groupResults.flat();
+            if (process.env.ArchGuardDebug === 'true') {
+                console.debug(`📊 Cache stats: ${this.archJsonCache.size} entries`);
+            }
+            return results;
+        }
+        finally {
+            await pool?.terminate();
+            if (this.parallelProgress) {
+                this.parallelProgress.stop();
+            }
+        }
+    }
+    groupDiagramsBySource() {
+        const sourceGroups = new Map();
+        for (const diagram of this.diagrams) {
+            const key = this.hashSources(diagram.sources);
+            if (!sourceGroups.has(key)) {
+                sourceGroups.set(key, []);
+            }
+            sourceGroups.get(key).push(diagram);
+        }
+        return sourceGroups;
+    }
+    hashSources(sources) {
+        const normalized = sources
+            .map((s) => s.replace(/\\/g, '/'))
+            .sort()
+            .join('|');
+        return createHash('sha256').update(normalized).digest('hex').slice(0, 8);
+    }
+    cacheArchJson(sources, archJson) {
+        const key = this.hashSources(sources);
+        this.archJsonCache.set(key, archJson);
+        for (const s of sources) {
+            this.archJsonPathIndex.set(s.replace(/\\/g, '/'), key);
+        }
+    }
+    registerDeferred(sources, parsePromise) {
+        const key = this.hashSources(sources);
+        const withCaching = parsePromise.then((result) => {
+            this.cacheArchJson(sources, result);
+            this.archJsonDeferred.delete(key);
+            return result;
+        });
+        this.archJsonDeferred.set(key, { promise: withCaching, sources });
+        return withCaching;
+    }
+    findParentCoverage(sources) {
+        const normSources = sources.map((s) => s.replace(/\\/g, '/'));
+        for (const [indexedPath] of this.archJsonPathIndex) {
+            if (normSources.every((s) => s.startsWith(indexedPath + '/') || s === indexedPath)) {
+                return { deferred: null, normParentPath: indexedPath };
+            }
+        }
+        for (const [, { promise, sources: parentSources }] of this.archJsonDeferred) {
+            const normParentSources = parentSources.map((ps) => ps.replace(/\\/g, '/'));
+            const matchedParent = normParentSources.find((ps) => normSources.every((s) => s.startsWith(ps + '/') || s === ps));
+            if (matchedParent) {
+                return { deferred: promise, normParentPath: matchedParent };
+            }
+        }
+        return { deferred: null, normParentPath: null };
+    }
+    archJsonCache = new Map();
+    archJsonPathIndex = new Map();
+    archJsonDeferred = new Map();
+    async processSourceGroup(sourceKey, diagrams, pool = null) {
+        if (!this.parallelProgress && diagrams.length === 1) {
+            this.progress.start(`Processing diagram: ${diagrams[0].name}`);
+        }
+        try {
+            const firstDiagram = diagrams[0];
+            if (firstDiagram.language === 'go') {
+                const rawArchJSON = await this.registerDeferred(firstDiagram.sources, this.parseGoProject(firstDiagram));
+                const results = await pMap(diagrams, async (diagram) => this.processDiagramWithArchJSON(diagram, rawArchJSON, pool), { concurrency: this.globalConfig.concurrency || os.cpus().length });
+                return results;
+            }
+            if (firstDiagram.language === 'cpp') {
+                const { deferred, normParentPath } = this.findParentCoverage(firstDiagram.sources);
+                let rawArchJSON;
+                if (deferred) {
+                    const parentArchJSON = await deferred;
+                    rawArchJSON = deriveSubModuleArchJSON(parentArchJSON, firstDiagram.sources[0], normParentPath ?? undefined);
+                }
+                else if (normParentPath) {
+                    const parentCacheKey = this.archJsonPathIndex.get(normParentPath);
+                    const parentArchJSON = this.archJsonCache.get(parentCacheKey);
+                    rawArchJSON = deriveSubModuleArchJSON(parentArchJSON, firstDiagram.sources[0], normParentPath);
+                }
+                else {
+                    rawArchJSON = await this.registerDeferred(firstDiagram.sources, this.parseCppProject(firstDiagram));
+                }
+                const results = await pMap(diagrams, async (diagram) => this.processDiagramWithArchJSON(diagram, rawArchJSON, pool), { concurrency: this.globalConfig.concurrency || os.cpus().length });
+                return results;
+            }
+            const needsModuleGraph = diagrams.some((d) => d.level === 'package');
+            if (needsModuleGraph && (!firstDiagram.language || firstDiagram.language === 'typescript')) {
+                const tsFiles = await this.fileDiscovery.discoverFiles({
+                    sources: firstDiagram.sources,
+                    exclude: firstDiagram.exclude || this.globalConfig.exclude,
+                    skipMissing: false,
+                });
+                const diskCacheEnabled = this.globalConfig.cache?.enabled !== false;
+                const diskKey = diskCacheEnabled && tsFiles.length > 0 ? await this.archJsonDiskCache.computeKey(tsFiles) : null;
+                let cachedArchJSON = null;
+                if (diskKey) {
+                    cachedArchJSON = await this.archJsonDiskCache.get(diskKey);
+                    if (cachedArchJSON && process.env.ArchGuardDebug === 'true') {
+                        console.debug(`💾 Disk cache hit for ts-morph path: ${firstDiagram.sources.join(', ')}`);
+                    }
+                }
+                const rawArchJSON = cachedArchJSON
+                    ? cachedArchJSON
+                    : await this.registerDeferred(firstDiagram.sources, this.parseTsProject(firstDiagram).then(async (result) => {
+                        if (diskKey)
+                            await this.archJsonDiskCache.set(diskKey, result);
+                        return result;
+                    }));
+                const results = await pMap(diagrams, async (diagram) => this.processDiagramWithArchJSON(diagram, rawArchJSON, pool), { concurrency: this.globalConfig.concurrency || os.cpus().length });
+                return results;
+            }
+            const files = await this.fileDiscovery.discoverFiles({
+                sources: diagrams[0].sources,
+                exclude: diagrams[0].exclude || this.globalConfig.exclude,
+                skipMissing: false,
+            });
+            if (files.length === 0) {
+                throw new Error(`No TypeScript files found in sources: ${diagrams[0].sources.join(', ')}`);
+            }
+            let rawArchJSON = this.archJsonCache.get(sourceKey);
+            if (!rawArchJSON) {
+                const { deferred, normParentPath } = this.findParentCoverage(diagrams[0].sources);
+                if (deferred) {
+                    const parentArchJSON = await deferred;
+                    rawArchJSON = deriveSubModuleArchJSON(parentArchJSON, diagrams[0].sources[0], normParentPath ?? undefined);
+                    if (process.env.ArchGuardDebug === 'true') {
+                        console.debug(`🔗 Awaited parent and derived ArchJSON for ${diagrams[0].sources.join(', ')} from ${normParentPath}`);
+                    }
+                }
+                else if (normParentPath) {
+                    const parentCacheKey = this.archJsonPathIndex.get(normParentPath);
+                    const parentArchJSON = this.archJsonCache.get(parentCacheKey);
+                    rawArchJSON = deriveSubModuleArchJSON(parentArchJSON, diagrams[0].sources[0], normParentPath);
+                    if (process.env.ArchGuardDebug === 'true') {
+                        console.debug(`🔗 Derived ArchJSON for ${diagrams[0].sources.join(', ')} from ${normParentPath}`);
+                    }
+                }
+                else {
+                    if (process.env.ArchGuardDebug === 'true') {
+                        console.debug(`🔍 Cache miss for ${sourceKey}: ${diagrams[0].sources.join(', ')}`);
+                    }
+                    const diskCacheEnabled2 = this.globalConfig.cache?.enabled !== false;
+                    const diskKey = diskCacheEnabled2 ? await this.archJsonDiskCache.computeKey(files) : null;
+                    const diskCached = diskKey ? await this.archJsonDiskCache.get(diskKey) : null;
+                    if (diskCached) {
+                        rawArchJSON = diskCached;
+                        if (process.env.ArchGuardDebug === 'true') {
+                            console.debug(`💾 Disk cache hit for ParallelParser path: ${diagrams[0].sources.join(', ')}`);
+                        }
+                    }
+                    else {
+                        const parser = new ParallelParser({
+                            concurrency: this.globalConfig.concurrency,
+                            continueOnError: true,
+                            parseCache: this.parseCache,
+                        });
+                        rawArchJSON = await parser.parseFiles(files);
+                        if (diskKey)
+                            await this.archJsonDiskCache.set(diskKey, rawArchJSON);
+                    }
+                    this.cacheArchJson(diagrams[0].sources, rawArchJSON);
+                }
+            }
+            else if (process.env.ArchGuardDebug === 'true') {
+                console.debug(`📦 Cache hit for ${sourceKey}: ${diagrams[0].sources.join(', ')}`);
+            }
+            const results = await pMap(diagrams, async (diagram) => {
+                return await this.processDiagramWithArchJSON(diagram, rawArchJSON, pool);
+            }, { concurrency: this.globalConfig.concurrency || os.cpus().length });
+            return results;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return diagrams.map((diagram) => ({
+                name: diagram.name,
+                success: false,
+                error: errorMessage,
+            }));
+        }
+    }
+    async processDiagramWithArchJSON(diagram, rawArchJSON, pool = null) {
+        const startTime = Date.now();
+        try {
+            if (!this.parallelProgress) {
+                this.progress.start(`Processing diagram: ${diagram.name}`);
+            }
+            if (this.parallelProgress) {
+                this.parallelProgress.update(diagram.name, 50, 'Aggregating');
+            }
+            const aggregatedJSON = this.aggregator.aggregate(rawArchJSON, diagram.level);
+            if (this.parallelProgress) {
+                this.parallelProgress.update(diagram.name, 60, 'Preparing output');
+            }
+            const pathResolver = new OutputPathResolver({
+                outputDir: this.globalConfig.outputDir,
+                output: undefined,
+            });
+            const paths = pathResolver.resolve({ name: diagram.name });
+            await pathResolver.ensureDirectory({ name: diagram.name });
+            if (this.parallelProgress) {
+                this.parallelProgress.update(diagram.name, 70, 'Generating output');
+            }
+            const format = diagram.format || this.globalConfig.format;
+            const outputJSON = format === 'json'
+                ? { ...aggregatedJSON, metrics: this.metricsCalculator.calculate(aggregatedJSON, diagram.level) }
+                : aggregatedJSON;
+            await this.generateOutput(outputJSON, paths, format, diagram.level, diagram, pool);
+            if (this.parallelProgress) {
+                this.parallelProgress.update(diagram.name, 90, 'Finalizing');
+            }
+            const parseTime = Date.now() - startTime;
+            if (this.parallelProgress) {
+                this.parallelProgress.complete(diagram.name);
+            }
+            else {
+                this.progress.succeed(`Diagram ${diagram.name} completed`);
+            }
+            const resultPaths = {};
+            if (format === 'json') {
+                resultPaths.json = paths.paths.json;
+            }
+            else if (format === 'mermaid') {
+                resultPaths.mmd = paths.paths.mmd;
+                resultPaths.svg = paths.paths.svg;
+                resultPaths.png = paths.paths.png;
+            }
+            const moduleGraph = aggregatedJSON.extensions?.tsAnalysis?.moduleGraph;
+            const usesModuleGraph = diagram.level === 'package' && !!moduleGraph;
+            return {
+                name: diagram.name,
+                success: true,
+                paths: resultPaths,
+                stats: {
+                    entities: usesModuleGraph ? moduleGraph.nodes.length : aggregatedJSON.entities.length,
+                    relations: usesModuleGraph ? moduleGraph.edges.length : aggregatedJSON.relations.length,
+                    parseTime,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (this.parallelProgress) {
+                this.parallelProgress.fail(diagram.name);
+            }
+            else {
+                this.progress.fail(`Diagram ${diagram.name} failed: ${errorMessage}`);
+            }
+            return {
+                name: diagram.name,
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async parseGoProject(diagram) {
+        const workspaceRoot = path.resolve(diagram.sources[0]);
+        const registryPlugin = this.registry?.getByName('golang');
+        const plugin = registryPlugin ?? await (async () => {
+            const { GoAtlasPlugin } = await import('../../plugins/golang/atlas/index.js');
+            return new GoAtlasPlugin();
+        })();
+        await plugin.initialize({ workspaceRoot });
+        return plugin.parseProject(workspaceRoot, {
+            workspaceRoot,
+            excludePatterns: diagram.exclude ?? this.globalConfig.exclude ?? [],
+            languageSpecific: diagram.languageSpecific,
+        });
+    }
+    async parseCppProject(diagram) {
+        const workspaceRoot = path.resolve(diagram.sources[0]);
+        const registryPlugin = this.registry?.getByName('cpp');
+        const plugin = registryPlugin ?? await (async () => {
+            const { CppPlugin } = await import('../../plugins/cpp/index.js');
+            return new CppPlugin();
+        })();
+        await plugin.initialize({ workspaceRoot });
+        return plugin.parseProject(workspaceRoot, {
+            workspaceRoot,
+            excludePatterns: diagram.exclude ?? this.globalConfig.exclude ?? [],
+        });
+    }
+    async parseTsProject(diagram) {
+        const workspaceRoot = path.resolve(diagram.sources[0]);
+        const registryPlugin = this.registry?.getByName('typescript');
+        const plugin = registryPlugin ?? await (async () => {
+            const { TypeScriptPlugin } = await import('../../plugins/typescript/index.js');
+            return new TypeScriptPlugin();
+        })();
+        await plugin.initialize({ workspaceRoot });
+        return plugin.parseProject(workspaceRoot, {
+            workspaceRoot,
+            excludePatterns: diagram.exclude ?? this.globalConfig.exclude ?? [],
+        });
+    }
+    async generateOutput(archJSON, paths, format, level, diagram, pool = null) {
+        switch (format) {
+            case 'json':
+                await fs.writeJson(paths.paths.json, archJSON, { spaces: 2 });
+                break;
+            case 'mermaid':
+                if (archJSON.extensions?.goAtlas) {
+                    await this.generateAtlasOutput(archJSON, paths, diagram, pool);
+                }
+                else if (level === 'package' && archJSON.extensions?.tsAnalysis?.moduleGraph) {
+                    await this.generateTsModuleGraphOutput(archJSON, paths, diagram, pool);
+                }
+                else if (level === 'package' && archJSON.language === 'cpp') {
+                    await this.generateCppPackageOutput(archJSON, paths, pool);
+                }
+                else {
+                    const mermaidGenerator = new MermaidDiagramGenerator(this.globalConfig, this.progress);
+                    await mermaidGenerator.generateAndRender(archJSON, {
+                        outputDir: paths.paths.mmd.replace(/\/[^/]+$/, ''),
+                        baseName: paths.paths.mmd.replace(/^.*\/([^/]+)\.mmd$/, '$1'),
+                        paths: paths.paths,
+                    }, level, diagram);
+                }
+                break;
+            default:
+                const exhaustiveCheck = format;
+                throw new Error(`Unsupported format: ${exhaustiveCheck}`);
+        }
+    }
+    async generateAtlasOutput(archJSON, paths, diagram, pool = null) {
+        const { AtlasRenderer } = await import('../../plugins/golang/atlas/renderers/atlas-renderer.js');
+        const { IsomorphicMermaidRenderer } = await import('../../mermaid/renderer.js');
+        const atlas = archJSON.extensions.goAtlas;
+        const renderer = new AtlasRenderer();
+        const requestedLayers = diagram.languageSpecific?.atlas?.layers ?? ['package', 'capability', 'goroutine', 'flow'];
+        const availableLayers = requestedLayers.filter((layer) => atlas.layers[layer]);
+        const basePath = paths.paths.mmd.replace(/\.mmd$/, '');
+        const rendererOptions = {};
+        if (this.globalConfig.mermaid?.theme) {
+            rendererOptions.theme =
+                typeof this.globalConfig.mermaid.theme === 'string'
+                    ? { name: this.globalConfig.mermaid.theme }
+                    : this.globalConfig.mermaid.theme;
+        }
+        if (this.globalConfig.mermaid?.transparentBackground) {
+            rendererOptions.backgroundColor = 'transparent';
+        }
+        const mermaidRenderer = new IsomorphicMermaidRenderer(rendererOptions);
+        console.log('\n🗺️  Generating Go Architecture Atlas...');
+        await Promise.all(availableLayers.map(async (layer) => {
+            const result = await renderer.render(atlas, layer, 'mermaid');
+            const layerPaths = {
+                mmd: `${basePath}-${layer}.mmd`,
+                svg: `${basePath}-${layer}.svg`,
+                png: `${basePath}-${layer}.png`,
+            };
+            await fs.ensureDir(path.dirname(layerPaths.mmd));
+            await fs.writeFile(layerPaths.mmd, result.content, 'utf-8');
+            let svg;
+            if (pool) {
+                const poolResult = await pool.render({ mermaidCode: result.content });
+                if (!poolResult.success) {
+                    console.warn(`  Worker render failed: ${poolResult.error} — falling back to main thread`);
+                    svg = await mermaidRenderer.renderSVG(result.content);
+                }
+                else {
+                    svg = poolResult.svg;
+                }
+            }
+            else {
+                svg = await mermaidRenderer.renderSVG(result.content);
+            }
+            let pngFailed = false;
+            await Promise.all([
+                fs.writeFile(layerPaths.svg, svg, 'utf-8'),
+                mermaidRenderer.convertSVGToPNG(svg, layerPaths.png).catch((err) => {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.warn(`  ⚠️  ${layer} PNG skipped (${msg}) — MMD + SVG saved`);
+                    pngFailed = true;
+                }),
+            ]);
+            console.log(`  ✅ ${layer}: ${layerPaths.mmd}${pngFailed ? ' (no PNG)' : ''}`);
+        }));
+        const atlasJsonPath = `${basePath}-atlas.json`;
+        await fs.writeJson(atlasJsonPath, atlas, { spaces: 2 });
+        console.log(`  📊 Atlas JSON: ${atlasJsonPath}`);
+        console.log(`\n✨ Atlas layers: ${availableLayers.join(', ')}`);
+    }
+    async generateTsModuleGraphOutput(archJSON, paths, _diagram, pool = null) {
+        const { renderTsModuleGraph } = await import('../../mermaid/ts-module-graph-renderer.js');
+        const { IsomorphicMermaidRenderer } = await import('../../mermaid/renderer.js');
+        const moduleGraph = archJSON.extensions.tsAnalysis.moduleGraph;
+        const mmdContent = renderTsModuleGraph(moduleGraph);
+        const rendererOptions = {};
+        if (this.globalConfig.mermaid?.theme) {
+            rendererOptions.theme =
+                typeof this.globalConfig.mermaid.theme === 'string'
+                    ? { name: this.globalConfig.mermaid.theme }
+                    : this.globalConfig.mermaid.theme;
+        }
+        if (this.globalConfig.mermaid?.transparentBackground) {
+            rendererOptions.backgroundColor = 'transparent';
+        }
+        const mermaidRenderer = new IsomorphicMermaidRenderer(rendererOptions);
+        await fs.ensureDir(path.dirname(paths.paths.mmd));
+        await fs.writeFile(paths.paths.mmd, mmdContent, 'utf-8');
+        let svg;
+        if (pool) {
+            const poolResult = await pool.render({ mermaidCode: mmdContent });
+            if (!poolResult.success) {
+                console.warn(`  Worker render failed: ${poolResult.error} — falling back to main thread`);
+                svg = await mermaidRenderer.renderSVG(mmdContent);
+            }
+            else {
+                svg = poolResult.svg;
+            }
+        }
+        else {
+            svg = await mermaidRenderer.renderSVG(mmdContent);
+        }
+        await Promise.all([
+            fs.writeFile(paths.paths.svg, svg, 'utf-8'),
+            mermaidRenderer.convertSVGToPNG(svg, paths.paths.png).catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`  TS module graph PNG skipped (${msg}) — MMD + SVG saved`);
+            }),
+        ]);
+    }
+    async generateCppPackageOutput(archJSON, paths, pool = null) {
+        const { CppPackageFlowchartGenerator } = await import('../../mermaid/cpp-package-flowchart-generator.js');
+        const { IsomorphicMermaidRenderer } = await import('../../mermaid/renderer.js');
+        const generator = new CppPackageFlowchartGenerator();
+        const mmdContent = generator.generate(archJSON);
+        const rendererOptions = {};
+        if (this.globalConfig.mermaid?.theme) {
+            rendererOptions.theme =
+                typeof this.globalConfig.mermaid.theme === 'string'
+                    ? { name: this.globalConfig.mermaid.theme }
+                    : this.globalConfig.mermaid.theme;
+        }
+        if (this.globalConfig.mermaid?.transparentBackground) {
+            rendererOptions.backgroundColor = 'transparent';
+        }
+        const mermaidRenderer = new IsomorphicMermaidRenderer(rendererOptions);
+        await fs.ensureDir(path.dirname(paths.paths.mmd));
+        await fs.writeFile(paths.paths.mmd, mmdContent, 'utf-8');
+        let svg;
+        if (pool) {
+            const poolResult = await pool.render({ mermaidCode: mmdContent });
+            if (!poolResult.success) {
+                console.warn(`  Worker render failed: ${poolResult.error} — falling back to main thread`);
+                svg = await mermaidRenderer.renderSVG(mmdContent);
+            }
+            else {
+                svg = poolResult.svg;
+            }
+        }
+        else {
+            svg = await mermaidRenderer.renderSVG(mmdContent);
+        }
+        await Promise.all([
+            fs.writeFile(paths.paths.svg, svg, 'utf-8'),
+            mermaidRenderer.convertSVGToPNG(svg, paths.paths.png).catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`  C++ package graph PNG skipped (${msg}) — MMD + SVG saved`);
+            }),
+        ]);
+    }
+}
+//# sourceMappingURL=diagram-processor.js.map