@girardmedia/bootspring 2.0.37 → 2.0.38

package/cli/visualize.js

@@ -11,6 +11,15 @@ const path = require('path');
 const config = require('../core/config');
 const utils = require('../core/utils');
 
+// Lazy load Phase 3 module
+let VisualDocGenerator = null;
+function getVisualDocGenerator() {
+  if (!VisualDocGenerator) {
+    VisualDocGenerator = require('../generators/visual-doc-generator').VisualDocGenerator;
+  }
+  return VisualDocGenerator;
+}
+
 // Colors
 const c = {
   reset: '\x1b[0m',
@@ -435,16 +444,157 @@ async function watchMode(projectRoot, interval = 2000) {
   });
 }
 
+/**
+ * Generate Mermaid diagrams
+ */
+async function generateDiagrams(projectRoot, args) {
+  const Generator = getVisualDocGenerator();
+  const outputDir = args.output || path.join(projectRoot, 'docs', 'diagrams');
+
+  const generator = new Generator({
+    projectRoot,
+    outputDir,
+    theme: args.theme || 'default'
+  });
+
+  console.log(`\n${c.cyan}${c.bold}Diagram Generation${c.reset}\n`);
+
+  // Read analysis data if available
+  const analysisPath = path.join(projectRoot, '.bootspring', 'analyze', 'reports', 'analysis.json');
+  let analysis = {};
+
+  if (fs.existsSync(analysisPath)) {
+    try {
+      analysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+    } catch {
+      // Continue with empty analysis
+    }
+  }
+
+  // Build analysis from project structure if no analysis exists
+  if (!analysis.architecture) {
+    console.log(`${c.dim}Building analysis from project structure...${c.reset}`);
+
+    // Detect layers from common directory patterns
+    const layers = { presentation: [], api: [], service: [], data: [] };
+    const scanDirs = ['src', 'lib', 'app', 'pages', 'components', 'api', 'services', 'models'];
+
+    for (const dir of scanDirs) {
+      const dirPath = path.join(projectRoot, dir);
+      if (fs.existsSync(dirPath)) {
+        const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.tsx'));
+        for (const file of files.slice(0, 5)) {
+          const name = file.replace(/\.(js|ts|tsx)$/, '');
+          if (/component|page|view|ui/i.test(dir) || /component|page|view/i.test(file)) {
+            layers.presentation.push({ name });
+          } else if (/api|route|controller/i.test(dir) || /api|route|controller/i.test(file)) {
+            layers.api.push({ name });
+          } else if (/service|handler/i.test(dir) || /service|handler/i.test(file)) {
+            layers.service.push({ name });
+          } else if (/model|schema|repo/i.test(dir) || /model|schema|repo/i.test(file)) {
+            layers.data.push({ name });
+          }
+        }
+      }
+    }
+
+    analysis.architecture = { layers };
+  }
+
+  // Generate specific diagram type or all
+  const diagrams = {};
+  const diagramType = args._[1];
+
+  if (diagramType && diagramType !== 'all') {
+    try {
+      switch (diagramType) {
+        case 'architecture':
+          diagrams.architecture = {
+            type: 'architecture',
+            title: 'System Architecture',
+            code: generator.generateArchitectureDiagram(analysis.architecture || { layers: {} }),
+            filename: 'architecture.mmd'
+          };
+          break;
+        case 'dependencies':
+          diagrams.dependencies = {
+            type: 'dependencies',
+            title: 'Module Dependencies',
+            code: generator.generateDependencyDiagram(analysis.dependencies || { modules: [] }),
+            filename: 'dependencies.mmd'
+          };
+          break;
+        case 'components':
+          diagrams.components = {
+            type: 'components',
+            title: 'Component Hierarchy',
+            code: generator.generateComponentDiagram(analysis.components || { categories: {} }),
+            filename: 'components.mmd'
+          };
+          break;
+        case 'dataflow':
+          diagrams.dataFlow = {
+            type: 'dataFlow',
+            title: 'Data Flow',
+            code: generator.generateDataFlowDiagram(analysis.dataFlow || { sources: [], flows: [] }),
+            filename: 'data-flow.mmd'
+          };
+          break;
+        default:
+          console.log(`${c.yellow}Unknown diagram type: ${diagramType}${c.reset}`);
+          console.log('Available types: architecture, dependencies, components, dataflow, all');
+          return;
+      }
+    } catch (error) {
+      console.log(`${c.red}Failed to generate ${diagramType} diagram: ${error.message}${c.reset}`);
+      return;
+    }
+  } else {
+    // Generate all diagrams
+    Object.assign(diagrams, generator.generateAllDiagrams(analysis));
+  }
+
+  if (Object.keys(diagrams).length === 0) {
+    console.log(`${c.yellow}No diagrams generated. Run 'bootspring analyze' first for better results.${c.reset}`);
+    return;
+  }
+
+  // Save diagrams
+  const saved = generator.saveDiagrams(diagrams);
+
+  console.log(`Generated ${saved.length} diagram(s):\n`);
+  for (const file of saved) {
+    console.log(`  ${c.green}✓${c.reset} ${file.title}`);
+    console.log(`    ${c.dim}${file.filepath}${c.reset}`);
+  }
+
+  // Also generate markdown doc
+  if (args.markdown !== false) {
+    const mdPath = path.join(outputDir, 'DIAGRAMS.md');
+    const mdContent = generator.generateMarkdownDoc(diagrams, {
+      title: 'Visual Documentation'
+    });
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(mdPath, mdContent, 'utf-8');
+    console.log(`\n  ${c.green}✓${c.reset} Markdown documentation`);
+    console.log(`    ${c.dim}${mdPath}${c.reset}`);
+  }
+
+  console.log(`\n${c.dim}View diagrams in any Mermaid-compatible viewer${c.reset}`);
+  console.log(`${c.dim}(GitHub, VSCode, https://mermaid.live, etc.)${c.reset}\n`);
+}
+
 /**
  * Show help
  */
 function showHelp() {
   console.log(`
 ${c.cyan}${c.bold}⚡ Bootspring Visualize${c.reset}
-${c.dim}Terminal-based workflow visualization${c.reset}
+${c.dim}Terminal-based workflow visualization and diagram generation${c.reset}
 
 ${c.bold}Usage:${c.reset}
   bootspring visualize [options]
+  bootspring visualize diagrams [type]     Generate Mermaid diagrams
 
 ${c.bold}Options:${c.reset}
   --watch           Live updating view
@@ -455,11 +605,25 @@ ${c.bold}Options:${c.reset}
   --tasks           Show only task overview
   --json            Output as JSON
 
+${c.bold}Diagram Generation:${c.reset}
+  diagrams                Generate all diagrams
+  diagrams architecture   Architecture diagram only
+  diagrams dependencies   Dependency diagram only
+  diagrams components     Component diagram only
+  diagrams dataflow       Data flow diagram only
+
+${c.bold}Diagram Options:${c.reset}
+  --output <dir>    Output directory (default: docs/diagrams)
+  --theme <theme>   Mermaid theme (default, forest, dark, neutral)
+  --no-markdown     Skip markdown documentation
+
 ${c.bold}Examples:${c.reset}
   bootspring visualize                    # Full visualization
   bootspring visualize --watch            # Live updating view
   bootspring visualize --graph            # Include dependency graph
   bootspring visualize --pipeline         # Pipeline only
+  bootspring visualize diagrams           # Generate all diagrams
+  bootspring visualize diagrams architecture --theme dark
 `);
 }
 
@@ -478,6 +642,12 @@ async function run(args) {
   const cfg = config.load();
   const projectRoot = cfg._projectRoot;
 
+  // Handle diagrams subcommand
+  if (subcommand === 'diagrams' || subcommand === 'diagram') {
+    await generateDiagrams(projectRoot, parsedArgs);
+    return;
+  }
+
   if (parsedArgs.json) {
     const data = {
       workflows: getWorkflowStates(projectRoot),

package/core/coherence/index.js

@@ -14,9 +14,23 @@ const {
   TERMINOLOGY_PATTERNS
 } = require('./document-coherence');
 
+const {
+  SemanticDocumentAnalyzer,
+  CONCEPT_CATEGORIES,
+  SPECIFICITY_THRESHOLDS,
+  GAP_CATEGORIES
+} = require('./semantic-analyzer');
+
 module.exports = {
+  // Engines
   DocumentCoherenceEngine,
+  SemanticDocumentAnalyzer,
+
+  // Constants
   DOCUMENT_RELATIONSHIPS,
   VALIDATION_RULES,
-  TERMINOLOGY_PATTERNS
+  TERMINOLOGY_PATTERNS,
+  CONCEPT_CATEGORIES,
+  SPECIFICITY_THRESHOLDS,
+  GAP_CATEGORIES
 };