@limo-labs/limo-cli 0.1.0-alpha.0

package/dist/report/diagrams.js

@@ -0,0 +1,74 @@
+/**
+ * Diagram rendering utilities for CLI reports
+ */
+/**
+ * Embeds a diagram in Markdown format
+ *
+ * For SVG diagrams, embeds as base64 data URI image for universal compatibility.
+ * For DOT/Mermaid format, embeds as code blocks for external rendering.
+ */
+export function embedDiagramInMarkdown(diagram) {
+    let markdown = '';
+    // Add title and description
+    if (diagram.title) {
+        markdown += `### ${diagram.title}\n\n`;
+    }
+    if (diagram.description) {
+        markdown += `${diagram.description}\n\n`;
+    }
+    // Embed diagram based on format
+    if (diagram.format === 'svg') {
+        // Convert SVG to base64 data URI and embed as image
+        const base64Svg = Buffer.from(diagram.source, 'utf-8').toString('base64');
+        const dataUri = `data:image/svg+xml;base64,${base64Svg}`;
+        const altText = diagram.title || 'Architecture Diagram';
+        markdown += `![${altText}](${dataUri})\n\n`;
+    }
+    else if (diagram.format === 'dot') {
+        // DOT as code block (requires external renderer)
+        markdown += `\`\`\`dot\n${diagram.source}\n\`\`\`\n\n`;
+    }
+    else if (diagram.format === 'mermaid') {
+        // Mermaid as code block
+        markdown += `\`\`\`mermaid\n${diagram.source}\n\`\`\`\n\n`;
+    }
+    else {
+        // Fallback for unknown formats
+        markdown += `\`\`\`${diagram.format}\n${diagram.source}\n\`\`\`\n\n`;
+    }
+    // Add metadata if present
+    if (diagram.metadata) {
+        if (diagram.metadata.nodeCount !== undefined || diagram.metadata.edgeCount !== undefined) {
+            markdown += `*Complexity: `;
+            const parts = [];
+            if (diagram.metadata.nodeCount !== undefined) {
+                parts.push(`${diagram.metadata.nodeCount} nodes`);
+            }
+            if (diagram.metadata.edgeCount !== undefined) {
+                parts.push(`${diagram.metadata.edgeCount} edges`);
+            }
+            markdown += parts.join(', ') + '*\n\n';
+        }
+    }
+    // Add related files if present
+    if (diagram.relatedFiles && diagram.relatedFiles.length > 0) {
+        markdown += `**Related files:**\n`;
+        for (const file of diagram.relatedFiles) {
+            // Use proper file path encoding
+            const encodedPath = encodeFilePathForMarkdown(file);
+            markdown += `- [\`${file}\`](${encodedPath})\n`;
+        }
+        markdown += '\n';
+    }
+    return markdown;
+}
+/**
+ * Encode file path for use in markdown links
+ * Preserves forward slashes for VS Code compatibility
+ */
+function encodeFilePathForMarkdown(filePath) {
+    return filePath
+        .split('/')
+        .map(segment => encodeURIComponent(segment))
+        .join('/');
+}

package/dist/report/graphCompiler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Graph Semantics to SVG Compiler
+ *
+ * Converts graph semantic structure (IR) to SVG directly via DOT.
+ * This compiler uses ONLY explicit semantic fields from the IR.
+ * NO natural language inference, NO layout guessing.
+ *
+ * CRITICAL: LLM never sees this code. This is a pure code-side responsibility.
+ */
+import type { GraphSemantics } from '../types/graphSemantics.js';
+/**
+ * Compile graph semantics to DOT language
+ */
+export declare function compileGraphToDot(semantics: GraphSemantics): string;
+/**
+ * Generate DOT with validation
+ */
+export declare function compileGraphToDotSafe(semantics: GraphSemantics): {
+    success: boolean;
+    dot?: string;
+    error?: string;
+};
+/**
+ * Compile graph semantics directly to SVG
+ *
+ * This is the primary function for diagram generation.
+ * It compiles semantic IR to DOT, then uses Viz.js to render SVG.
+ */
+export declare function compileGraphToSvg(semantics: GraphSemantics): Promise<string>;
+/**
+ * Compile graph semantics to SVG with validation
+ */
+export declare function compileGraphToSvgSafe(semantics: GraphSemantics): Promise<{
+    success: boolean;
+    svg?: string;
+    error?: string;
+}>;

package/dist/report/graphCompiler.js

@@ -0,0 +1,277 @@
+/**
+ * Graph Semantics to SVG Compiler
+ *
+ * Converts graph semantic structure (IR) to SVG directly via DOT.
+ * This compiler uses ONLY explicit semantic fields from the IR.
+ * NO natural language inference, NO layout guessing.
+ *
+ * CRITICAL: LLM never sees this code. This is a pure code-side responsibility.
+ */
+import { instance } from '@viz-js/viz';
+/**
+ * Cached Viz.js instance for performance
+ */
+let vizInstance = null;
+/**
+ * Get or initialize Viz.js instance
+ */
+async function getVizInstance() {
+    if (!vizInstance) {
+        vizInstance = await instance();
+    }
+    return vizInstance;
+}
+/**
+ * Node shape mapping based on semantic type
+ */
+const NODE_SHAPES = {
+    'component': 'box',
+    'layer': 'folder',
+    'system': 'hexagon',
+    'data': 'cylinder',
+    'process': 'ellipse',
+    'actor': 'house'
+};
+/**
+ * Node color mapping based on semantic type
+ */
+const NODE_COLORS = {
+    'component': { fillcolor: '#E3F2FD', fontcolor: '#0D47A1' },
+    'layer': { fillcolor: '#F3E5F5', fontcolor: '#4A148C' },
+    'system': { fillcolor: '#FFF9C4', fontcolor: '#F57F17' },
+    'data': { fillcolor: '#E0F2F1', fontcolor: '#004D40' },
+    'process': { fillcolor: '#FCE4EC', fontcolor: '#880E4F' },
+    'actor': { fillcolor: '#E8F5E9', fontcolor: '#1B5E20' }
+};
+/**
+ * Edge style mapping based on semantic type
+ */
+const EDGE_STYLES = {
+    'depends_on': { style: 'solid', arrowhead: 'normal', color: '#424242' },
+    'calls': { style: 'solid', arrowhead: 'vee', color: '#1976D2' },
+    'uses': { style: 'dashed', arrowhead: 'open', color: '#424242' },
+    'contains': { style: 'solid', arrowhead: 'diamond', color: '#4CAF50' },
+    'inherits': { style: 'solid', arrowhead: 'empty', color: '#9C27B0' },
+    'implements': { style: 'dashed', arrowhead: 'empty', color: '#9C27B0' },
+    'data_flow': { style: 'bold', arrowhead: 'normal', color: '#FF9800' },
+    'control_flow': { style: 'bold', arrowhead: 'normal', color: '#F44336' }
+};
+/**
+ * Compile graph semantics to DOT language
+ */
+export function compileGraphToDot(semantics) {
+    const lines = [];
+    const indent = '  ';
+    // Start digraph
+    lines.push(`digraph ${quote(sanitizeId(semantics.id))} {`);
+    // Graph attributes
+    const direction = semantics.metadata?.direction || 'TB';
+    lines.push(`${indent}rankdir="${direction}";`);
+    lines.push(`${indent}bgcolor="transparent";`);
+    lines.push(`${indent}fontname="Arial";`);
+    lines.push(`${indent}fontsize=12;`);
+    lines.push(`${indent}nodesep=0.5;`);
+    lines.push(`${indent}ranksep=0.75;`);
+    lines.push('');
+    // Default node attributes
+    lines.push(`${indent}node [style=filled, fontname="Arial", fontsize=11, margin="0.2,0.1"];`);
+    lines.push('');
+    // Default edge attributes
+    lines.push(`${indent}edge [fontname="Arial", fontsize=9];`);
+    lines.push('');
+    // Build group structure
+    const groups = semantics.groups || [];
+    const groupsByParent = organizeGroupsByParent(groups);
+    const nodesInGroups = new Set();
+    // Add groups and their nodes
+    if (groups.length > 0) {
+        addGroupsRecursive(lines, indent, groups, groupsByParent, semantics.nodes, nodesInGroups, semantics.metadata?.focusNodes);
+    }
+    // Add ungrouped nodes
+    for (const node of semantics.nodes) {
+        if (!node.group || !nodesInGroups.has(node.id)) {
+            addNodeDef(lines, indent, node, semantics.metadata?.focusNodes);
+        }
+    }
+    // Add edges
+    if (semantics.edges.length > 0) {
+        lines.push('');
+        for (const edge of semantics.edges) {
+            addEdgeDef(lines, indent, edge);
+        }
+    }
+    // Close digraph
+    lines.push('}');
+    return lines.join('\n');
+}
+/**
+ * Organize groups by parent
+ */
+function organizeGroupsByParent(groups) {
+    const map = new Map();
+    for (const group of groups) {
+        const parent = group.parent;
+        if (!map.has(parent)) {
+            map.set(parent, []);
+        }
+        map.get(parent).push(group);
+    }
+    return map;
+}
+/**
+ * Add groups recursively with their nodes
+ */
+function addGroupsRecursive(lines, baseIndent, allGroups, groupsByParent, nodes, nodesInGroups, focusNodes, parentId, currentDepth = 0) {
+    const children = groupsByParent.get(parentId) || [];
+    const indent = baseIndent.repeat(currentDepth + 1);
+    for (const group of children) {
+        // Start subgraph
+        lines.push('');
+        lines.push(`${indent}subgraph cluster_${sanitizeId(group.id)} {`);
+        lines.push(`${indent}  label=${quote(group.label)};`);
+        lines.push(`${indent}  style="rounded,filled";`);
+        lines.push(`${indent}  fillcolor="#F5F5F5";`);
+        lines.push(`${indent}  color="#BDBDBD";`);
+        lines.push(`${indent}  fontsize=12;`);
+        lines.push(`${indent}  fontname="Arial Bold";`);
+        if (group.description) {
+            lines.push(`${indent}  tooltip=${quote(group.description)};`);
+        }
+        // Add nodes in this group
+        for (const node of nodes) {
+            if (node.group === group.id) {
+                addNodeDef(lines, indent + '  ', node, focusNodes);
+                nodesInGroups.add(node.id);
+            }
+        }
+        // Recursively add child groups
+        addGroupsRecursive(lines, baseIndent, allGroups, groupsByParent, nodes, nodesInGroups, focusNodes, group.id, currentDepth + 1);
+        // End subgraph
+        lines.push(`${indent}}`);
+    }
+}
+/**
+ * Add node definition
+ */
+function addNodeDef(lines, indent, node, focusNodes) {
+    const shape = NODE_SHAPES[node.type] || 'box';
+    const colors = NODE_COLORS[node.type] || { fillcolor: '#FFFFFF', fontcolor: '#000000' };
+    const isFocused = focusNodes?.includes(node.id);
+    const attrs = [
+        `label=${quote(node.label)}`,
+        `shape=${shape}`,
+        `fillcolor="${colors.fillcolor}"`,
+        `fontcolor="${colors.fontcolor}"`,
+        `style="${isFocused ? 'filled,bold' : 'filled'}"`,
+        `penwidth=${isFocused ? '2' : '1'}`,
+        `tooltip=${quote(node.description || node.label)}`
+    ];
+    lines.push(`${indent}${sanitizeId(node.id)} [${attrs.join(', ')}];`);
+}
+/**
+ * Add edge definition
+ */
+function addEdgeDef(lines, indent, edge) {
+    const style = EDGE_STYLES[edge.type] || { style: 'solid', arrowhead: 'normal', color: '#424242' };
+    const attrs = [
+        `style=${style.style}`,
+        `arrowhead=${style.arrowhead}`,
+        `color="${style.color}"`
+    ];
+    if (edge.label) {
+        attrs.push(`label=${quote(edge.label)}`);
+    }
+    if (edge.metadata?.weight) {
+        const penwidth = Math.max(1, Math.min(5, edge.metadata.weight / 2));
+        attrs.push(`penwidth=${penwidth}`);
+    }
+    if (edge.bidirectional) {
+        attrs.push('dir=both');
+    }
+    const arrow = edge.bidirectional ? '--' : '->';
+    lines.push(`${indent}${sanitizeId(edge.from)} ${arrow} ${sanitizeId(edge.to)} [${attrs.join(', ')}];`);
+}
+/**
+ * DOT reserved keywords that cannot be used as node IDs
+ */
+const DOT_KEYWORDS = new Set([
+    'node', 'edge', 'graph', 'digraph', 'subgraph', 'strict',
+    // Also include common DOT attribute names to avoid confusion
+    'label', 'shape', 'color', 'style', 'rank'
+]);
+/**
+ * Sanitize ID to be valid DOT identifier
+ *
+ * Handles:
+ * - Special characters (replaced with underscores)
+ * - IDs starting with digits (prefixed with 'n_')
+ * - DOT reserved keywords (prefixed with 'n_')
+ * - Empty IDs (replaced with random ID)
+ */
+function sanitizeId(id) {
+    // 1. Replace invalid characters with underscores
+    let cleaned = id.replace(/[^a-zA-Z0-9_]/g, '_');
+    // 2. Handle IDs starting with digits (DOT doesn't allow this)
+    if (/^[0-9]/.test(cleaned)) {
+        cleaned = 'n_' + cleaned;
+    }
+    // 3. Handle DOT reserved keywords (case-insensitive)
+    if (DOT_KEYWORDS.has(cleaned.toLowerCase())) {
+        cleaned = 'n_' + cleaned;
+    }
+    // 4. Ensure non-empty ID
+    if (cleaned === '' || cleaned === '_') {
+        cleaned = 'node_' + Math.random().toString(36).substring(7);
+    }
+    return cleaned;
+}
+/**
+ * Quote string for DOT
+ */
+function quote(str) {
+    return '"' + str.replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"';
+}
+/**
+ * Generate DOT with validation
+ */
+export function compileGraphToDotSafe(semantics) {
+    try {
+        const dot = compileGraphToDot(semantics);
+        return { success: true, dot };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to compile graph to DOT: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+/**
+ * Compile graph semantics directly to SVG
+ *
+ * This is the primary function for diagram generation.
+ * It compiles semantic IR to DOT, then uses Viz.js to render SVG.
+ */
+export async function compileGraphToSvg(semantics) {
+    // Step 1: Compile semantic structure to DOT
+    const dot = compileGraphToDot(semantics);
+    // Step 2: Render DOT to SVG using Viz.js
+    const viz = await getVizInstance();
+    const svg = viz.renderString(dot, { format: 'svg', engine: 'dot' });
+    return svg;
+}
+/**
+ * Compile graph semantics to SVG with validation
+ */
+export async function compileGraphToSvgSafe(semantics) {
+    try {
+        const svg = await compileGraphToSvg(semantics);
+        return { success: true, svg };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to compile graph to SVG: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}

package/dist/report/markdownGenerator.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Markdown Report Generator
+ *
+ * Generates professional markdown reports with embedded diagrams,
+ * rich metadata, and statistics - matching VSCode report quality.
+ */
+import type { DiagramDefinition } from './diagrams.js';
+export interface ReportMetadata {
+    id: string;
+    title: string;
+    generatedAt: Date;
+    projectPath: string;
+    aiModel?: string;
+    modules: string[];
+    statistics?: {
+        totalSections?: number;
+        totalDiagrams?: number;
+        totalFindings?: number;
+        filesAnalyzed?: number;
+    };
+}
+export interface ReportSection {
+    id: string;
+    title: string;
+    content: string;
+    diagrams?: DiagramDefinition[];
+}
+export interface Report {
+    metadata: ReportMetadata;
+    executiveSummary?: string;
+    sections: ReportSection[];
+}
+export declare class MarkdownGenerator {
+    /**
+     * Generate a complete markdown report
+     */
+    generate(report: Report): string;
+    /**
+     * Generate report header with rich metadata
+     */
+    private generateHeader;
+    /**
+     * Generate executive summary section
+     */
+    private generateExecutiveSummary;
+    /**
+     * Generate a single section with embedded diagrams
+     */
+    private generateSection;
+    /**
+     * Embed a single diagram
+     */
+    private embedDiagram;
+    /**
+     * Format date in a human-readable way
+     */
+    private formatDate;
+}
+/**
+ * Helper function to extract title from markdown content
+ */
+export declare function extractTitle(content: string): string;
+/**
+ * Helper function to count findings in content
+ * Counts bullet points, numbered items, and sections
+ */
+export declare function countFindings(content: string): number;
+/**
+ * Helper function to count findings across all sections
+ */
+export declare function countAllFindings(sections: ReportSection[]): number;

package/dist/report/markdownGenerator.js

@@ -0,0 +1,148 @@
+/**
+ * Markdown Report Generator
+ *
+ * Generates professional markdown reports with embedded diagrams,
+ * rich metadata, and statistics - matching VSCode report quality.
+ */
+import { embedDiagramInMarkdown } from './diagrams.js';
+export class MarkdownGenerator {
+    /**
+     * Generate a complete markdown report
+     */
+    generate(report) {
+        const parts = [];
+        // 1. Header with metadata
+        parts.push(this.generateHeader(report.metadata));
+        // 2. Executive Summary (if available)
+        if (report.executiveSummary) {
+            parts.push(this.generateExecutiveSummary(report.executiveSummary));
+        }
+        // 3. Sections with embedded diagrams
+        for (const section of report.sections) {
+            parts.push(this.generateSection(section));
+        }
+        return parts.join('\n\n');
+    }
+    /**
+     * Generate report header with rich metadata
+     */
+    generateHeader(metadata) {
+        let header = `# ${metadata.title}\n\n`;
+        // Basic metadata
+        header += `**Generated**: ${this.formatDate(metadata.generatedAt)}\n`;
+        header += `**Project**: ${metadata.projectPath}\n`;
+        // AI Model (if available)
+        if (metadata.aiModel) {
+            header += `**AI Model**: ${metadata.aiModel}\n`;
+        }
+        // Analysis Modules
+        if (metadata.modules.length > 0) {
+            header += `**Analysis Modules**: ${metadata.modules.join(', ')}\n`;
+        }
+        // Statistics (if available)
+        if (metadata.statistics) {
+            header += '\n**Statistics**:\n';
+            const stats = metadata.statistics;
+            if (stats.totalSections !== undefined) {
+                header += `- Report Sections: ${stats.totalSections}\n`;
+            }
+            if (stats.totalDiagrams !== undefined) {
+                header += `- Diagrams: ${stats.totalDiagrams}\n`;
+            }
+            if (stats.totalFindings !== undefined) {
+                header += `- Key Findings: ${stats.totalFindings}\n`;
+            }
+            if (stats.filesAnalyzed !== undefined) {
+                header += `- Files Analyzed: ${stats.filesAnalyzed}\n`;
+            }
+        }
+        header += '\n---';
+        return header;
+    }
+    /**
+     * Generate executive summary section
+     */
+    generateExecutiveSummary(summary) {
+        // Check if summary already has markdown formatting
+        // If it already starts with "##", use it as-is
+        if (summary.trim().startsWith('##')) {
+            return `${summary}\n\n---`;
+        }
+        // Otherwise, wrap it with a heading
+        return `## 📊 Executive Summary\n\n${summary}\n\n---`;
+    }
+    /**
+     * Generate a single section with embedded diagrams
+     */
+    generateSection(section) {
+        let markdown = section.content;
+        // Embed diagrams within the section (not at the end!)
+        if (section.diagrams && section.diagrams.length > 0) {
+            // Add diagrams at the end of the section content
+            markdown += '\n\n';
+            for (const diagram of section.diagrams) {
+                markdown += this.embedDiagram(diagram) + '\n\n';
+            }
+        }
+        return markdown.trim();
+    }
+    /**
+     * Embed a single diagram
+     */
+    embedDiagram(diagram) {
+        return embedDiagramInMarkdown(diagram);
+    }
+    /**
+     * Format date in a human-readable way
+     */
+    formatDate(date) {
+        return date.toLocaleString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false
+        });
+    }
+}
+/**
+ * Helper function to extract title from markdown content
+ */
+export function extractTitle(content) {
+    // Find first ## heading
+    const match = content.match(/^##\s+(.+)$/m);
+    if (match) {
+        return match[1].trim();
+    }
+    // Fallback: use first non-empty line
+    const firstLine = content.split('\n').find(line => line.trim().length > 0);
+    return firstLine?.trim() || 'Untitled Section';
+}
+/**
+ * Helper function to count findings in content
+ * Counts bullet points, numbered items, and sections
+ */
+export function countFindings(content) {
+    let count = 0;
+    // Count bullet points (- or *)
+    const bulletPoints = content.match(/^[\s]*[-*]\s+/gm);
+    if (bulletPoints) {
+        count += bulletPoints.length;
+    }
+    // Count numbered items (1., 2., etc.)
+    const numberedItems = content.match(/^[\s]*\d+\.\s+/gm);
+    if (numberedItems) {
+        count += numberedItems.length;
+    }
+    return count;
+}
+/**
+ * Helper function to count findings across all sections
+ */
+export function countAllFindings(sections) {
+    return sections.reduce((total, section) => {
+        return total + countFindings(section.content);
+    }, 0);
+}