@girardmedia/bootspring 2.0.36 → 2.0.38

package/cli/analyze.js

@@ -21,6 +21,32 @@ function getContinuousAnalyzer() {
   return ContinuousAnalyzer;
 }
 
+// Lazy load Phase 3 modules
+let DeepArchitectureAnalyzer = null;
+let ContinuousSecurityAnalyzer = null;
+let SemanticDocumentAnalyzer = null;
+
+function getDeepArchitectureAnalyzer() {
+  if (!DeepArchitectureAnalyzer) {
+    DeepArchitectureAnalyzer = require('../analyzers').DeepArchitectureAnalyzer;
+  }
+  return DeepArchitectureAnalyzer;
+}
+
+function getContinuousSecurityAnalyzer() {
+  if (!ContinuousSecurityAnalyzer) {
+    ContinuousSecurityAnalyzer = require('../analyzers').ContinuousSecurityAnalyzer;
+  }
+  return ContinuousSecurityAnalyzer;
+}
+
+function getSemanticDocumentAnalyzer() {
+  if (!SemanticDocumentAnalyzer) {
+    SemanticDocumentAnalyzer = require('../core/coherence').SemanticDocumentAnalyzer;
+  }
+  return SemanticDocumentAnalyzer;
+}
+
 // Get project root
 const projectRoot = process.cwd();
 
@@ -39,12 +65,16 @@ ${utils.COLORS.bold}Usage:${utils.COLORS.reset}
   bootspring analyze reset        Reset workflow
   bootspring analyze watch        Watch mode - continuous analysis
   bootspring analyze drift        Detect documentation drift
+  bootspring analyze deep         Deep architecture analysis
+  bootspring analyze security     Continuous security analysis
+  bootspring analyze semantic     Semantic document analysis
 
 ${utils.COLORS.bold}Options:${utils.COLORS.reset}
   --depth=<level>                 Analysis depth: shallow, standard, deep
   --phase=<phase>                 Run specific phase only
   --include=<glob>                Include pattern (e.g., "src/**")
   --exclude=<glob>                Exclude pattern
+  --json                          Output results as JSON
 
 ${utils.COLORS.bold}Watch Mode:${utils.COLORS.reset}
   --watch                         Start file watcher for continuous analysis
@@ -55,6 +85,14 @@ ${utils.COLORS.bold}Depth Levels:${utils.COLORS.reset}
   standard    Standard analysis with patterns and dependencies
   deep        Comprehensive with flow tracing and components
 
+${utils.COLORS.bold}Advanced Analysis (Phase 3):${utils.COLORS.reset}
+  deep        Comprehensive architecture analysis with data flow,
+              dependencies, components, and quality indicators
+  security    Continuous security analysis with auth, data protection,
+              compliance, and vulnerability scanning
+  semantic    AI-powered document understanding with concept extraction,
+              terminology analysis, and contradiction detection
+
 ${utils.COLORS.bold}Notes:${utils.COLORS.reset}
   Large codebases (500+ files) automatically skip heavy dependency
   analysis for performance. Use --depth=deep to force full analysis.
@@ -66,6 +104,9 @@ ${utils.COLORS.bold}Examples:${utils.COLORS.reset}
   bootspring analyze status
   bootspring analyze watch        Continuous file watching
   bootspring analyze drift        Check documentation alignment
+  bootspring analyze deep         Deep architecture analysis
+  bootspring analyze security     Security posture analysis
+  bootspring analyze semantic     Document semantic analysis
 `);
 }
 
@@ -626,6 +667,268 @@ async function analyzeDrift() {
   }
 }
 
+/**
+ * Run deep architecture analysis
+ */
+async function analyzeDeepArchitecture(args) {
+  const Analyzer = getDeepArchitectureAnalyzer();
+  const analyzer = new Analyzer(projectRoot);
+
+  utils.print.header('Deep Architecture Analysis');
+  console.log('');
+
+  const spinner = utils.createSpinner('Analyzing architecture in depth...').start();
+
+  try {
+    const result = await analyzer.analyze();
+
+    spinner.succeed('Deep architecture analysis complete');
+    console.log('');
+
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // Display results
+    if (result.structure) {
+      console.log(`${utils.COLORS.cyan}Structure:${utils.COLORS.reset}`);
+      console.log(`  Layers: ${result.structure.layers?.length || 0}`);
+      console.log(`  Modules: ${result.structure.modules?.length || 0}`);
+      console.log(`  Entry Points: ${result.structure.entryPoints?.length || 0}`);
+      console.log('');
+    }
+
+    if (result.dataFlow) {
+      console.log(`${utils.COLORS.cyan}Data Flow:${utils.COLORS.reset}`);
+      console.log(`  Sources: ${result.dataFlow.sources?.length || 0}`);
+      console.log(`  Processors: ${result.dataFlow.processors?.length || 0}`);
+      console.log(`  Outputs: ${result.dataFlow.outputs?.length || 0}`);
+      console.log('');
+    }
+
+    if (result.dependencies) {
+      console.log(`${utils.COLORS.cyan}Dependencies:${utils.COLORS.reset}`);
+      console.log(`  External: ${result.dependencies.external?.length || 0}`);
+      console.log(`  Internal: ${result.dependencies.internal?.length || 0}`);
+      if (result.dependencies.circular?.length > 0) {
+        console.log(`  ${utils.COLORS.yellow}Circular: ${result.dependencies.circular.length}${utils.COLORS.reset}`);
+      }
+      console.log('');
+    }
+
+    if (result.quality) {
+      console.log(`${utils.COLORS.cyan}Quality Indicators:${utils.COLORS.reset}`);
+      console.log(`  Modularity: ${result.quality.modularity || 'N/A'}`);
+      console.log(`  Coupling: ${result.quality.coupling || 'N/A'}`);
+      console.log(`  Cohesion: ${result.quality.cohesion || 'N/A'}`);
+      console.log('');
+    }
+
+    if (result.recommendations?.length > 0) {
+      console.log(`${utils.COLORS.cyan}Recommendations:${utils.COLORS.reset}`);
+      for (const rec of result.recommendations.slice(0, 5)) {
+        console.log(`  ${utils.COLORS.yellow}→${utils.COLORS.reset} ${rec.message || rec}`);
+      }
+    }
+
+  } catch (error) {
+    spinner.fail(`Analysis failed: ${error.message}`);
+  }
+}
+
+/**
+ * Run continuous security analysis
+ */
+async function analyzeSecurityContinuous(args) {
+  const Analyzer = getContinuousSecurityAnalyzer();
+  const analyzer = new Analyzer(projectRoot);
+
+  utils.print.header('Continuous Security Analysis');
+  console.log('');
+
+  const spinner = utils.createSpinner('Analyzing security posture...').start();
+
+  try {
+    const result = await analyzer.analyze();
+
+    spinner.succeed('Security analysis complete');
+    console.log('');
+
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // Risk score
+    const scoreColor = result.riskScore < 30 ? utils.COLORS.green :
+                       result.riskScore < 60 ? utils.COLORS.yellow :
+                       utils.COLORS.red;
+    console.log(`Risk Score: ${scoreColor}${result.riskScore || 0}${utils.COLORS.reset}/100`);
+    console.log('');
+
+    // Authentication
+    if (result.authentication) {
+      console.log(`${utils.COLORS.cyan}Authentication:${utils.COLORS.reset}`);
+      console.log(`  Mechanisms: ${result.authentication.mechanisms?.join(', ') || 'None detected'}`);
+      console.log(`  Issues: ${result.authentication.issues?.length || 0}`);
+      console.log('');
+    }
+
+    // Authorization
+    if (result.authorization) {
+      console.log(`${utils.COLORS.cyan}Authorization:${utils.COLORS.reset}`);
+      console.log(`  Patterns: ${result.authorization.patterns?.join(', ') || 'None detected'}`);
+      console.log(`  Issues: ${result.authorization.issues?.length || 0}`);
+      console.log('');
+    }
+
+    // Data Protection
+    if (result.dataProtection) {
+      console.log(`${utils.COLORS.cyan}Data Protection:${utils.COLORS.reset}`);
+      console.log(`  Encryption: ${result.dataProtection.encryption ? 'Detected' : 'Not detected'}`);
+      console.log(`  PII Handling: ${result.dataProtection.piiDetected ? 'Detected' : 'Not detected'}`);
+      console.log('');
+    }
+
+    // Compliance
+    if (result.compliance) {
+      console.log(`${utils.COLORS.cyan}Compliance:${utils.COLORS.reset}`);
+      for (const [standard, status] of Object.entries(result.compliance)) {
+        const icon = status.compliant ? `${utils.COLORS.green}✓${utils.COLORS.reset}` : `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+        console.log(`  ${icon} ${standard}: ${status.compliant ? 'Compliant' : 'Needs review'}`);
+      }
+      console.log('');
+    }
+
+    // Recommendations
+    if (result.recommendations?.length > 0) {
+      console.log(`${utils.COLORS.cyan}Recommendations:${utils.COLORS.reset}`);
+      for (const rec of result.recommendations.slice(0, 5)) {
+        const priority = rec.priority || 'medium';
+        const icon = priority === 'high' ? `${utils.COLORS.red}!${utils.COLORS.reset}` :
+                     priority === 'medium' ? `${utils.COLORS.yellow}→${utils.COLORS.reset}` :
+                     `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+        console.log(`  ${icon} ${rec.message || rec}`);
+      }
+    }
+
+  } catch (error) {
+    spinner.fail(`Analysis failed: ${error.message}`);
+  }
+}
+
+/**
+ * Run semantic document analysis
+ */
+async function analyzeSemanticDocuments(args) {
+  const Analyzer = getSemanticDocumentAnalyzer();
+  const analyzer = new Analyzer();
+
+  utils.print.header('Semantic Document Analysis');
+  console.log('');
+
+  // Collect documents to analyze
+  const fs = require('fs');
+  const documents = [];
+
+  const docFiles = [
+    path.join(projectRoot, 'CLAUDE.md'),
+    path.join(projectRoot, 'README.md'),
+    path.join(projectRoot, 'docs', 'README.md'),
+    path.join(projectRoot, 'docs', 'architecture.md'),
+    path.join(projectRoot, 'docs', 'api.md')
+  ];
+
+  for (const file of docFiles) {
+    if (fs.existsSync(file)) {
+      const content = fs.readFileSync(file, 'utf-8');
+      documents.push({
+        path: file,
+        name: path.basename(file),
+        content
+      });
+    }
+  }
+
+  if (documents.length === 0) {
+    utils.print.warn('No documentation files found to analyze');
+    return;
+  }
+
+  const spinner = utils.createSpinner(`Analyzing ${documents.length} documents...`).start();
+
+  try {
+    const result = await analyzer.analyze(documents);
+
+    spinner.succeed('Semantic analysis complete');
+    console.log('');
+
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // Concepts
+    if (result.concepts) {
+      console.log(`${utils.COLORS.cyan}Concepts Extracted:${utils.COLORS.reset}`);
+      const topConcepts = Object.entries(result.concepts)
+        .sort((a, b) => b[1].frequency - a[1].frequency)
+        .slice(0, 10);
+      for (const [concept, data] of topConcepts) {
+        console.log(`  ${concept}: ${data.frequency} occurrences`);
+      }
+      console.log('');
+    }
+
+    // Terminology
+    if (result.terminology) {
+      console.log(`${utils.COLORS.cyan}Terminology:${utils.COLORS.reset}`);
+      console.log(`  Unique terms: ${result.terminology.uniqueTerms || 0}`);
+      console.log(`  Technical density: ${result.terminology.technicalDensity || 'N/A'}`);
+      if (result.terminology.inconsistencies?.length > 0) {
+        console.log(`  ${utils.COLORS.yellow}Inconsistencies: ${result.terminology.inconsistencies.length}${utils.COLORS.reset}`);
+      }
+      console.log('');
+    }
+
+    // Contradictions
+    if (result.contradictions?.length > 0) {
+      console.log(`${utils.COLORS.cyan}Potential Contradictions:${utils.COLORS.reset}`);
+      for (const contradiction of result.contradictions.slice(0, 3)) {
+        console.log(`  ${utils.COLORS.yellow}!${utils.COLORS.reset} ${contradiction.description || contradiction}`);
+      }
+      console.log('');
+    }
+
+    // Specificity
+    if (result.specificity) {
+      console.log(`${utils.COLORS.cyan}Specificity:${utils.COLORS.reset}`);
+      console.log(`  Overall: ${result.specificity.overall || 'N/A'}`);
+      console.log(`  Vague sections: ${result.specificity.vagueSections?.length || 0}`);
+      console.log('');
+    }
+
+    // Gaps
+    if (result.gaps?.length > 0) {
+      console.log(`${utils.COLORS.cyan}Documentation Gaps:${utils.COLORS.reset}`);
+      for (const gap of result.gaps.slice(0, 5)) {
+        console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} ${gap.description || gap}`);
+      }
+    }
+
+    // Summary
+    if (result.summary) {
+      console.log('');
+      console.log(`${utils.COLORS.cyan}Summary:${utils.COLORS.reset}`);
+      console.log(`  ${result.summary.overview || 'Analysis complete'}`);
+    }
+
+  } catch (error) {
+    spinner.fail(`Analysis failed: ${error.message}`);
+  }
+}
+
 /**
  * Main entry point
  */
@@ -659,6 +962,15 @@ async function run(args) {
     case 'drift':
       return analyzeDrift();
 
+    case 'deep':
+      return analyzeDeepArchitecture(parsedArgs);
+
+    case 'security':
+      return analyzeSecurityContinuous(parsedArgs);
+
+    case 'semantic':
+      return analyzeSemanticDocuments(parsedArgs);
+
     case 'help':
     case '--help':
     case '-h':

package/cli/generate.js

@@ -7,12 +7,25 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 const config = require('../core/config');
 const context = require('../core/context');
 const utils = require('../core/utils');
 const gitMemory = require('../intelligence/git-memory');
 const agentsTemplate = require('../generators/templates/agents.template');
 
+// Lazy load Phase 3 module
+let ModelContextOptimizer = null;
+let listSupportedModels = null;
+function getModelContextOptimizer() {
+  if (!ModelContextOptimizer) {
+    const module = require('../intelligence/model-context-optimizer');
+    ModelContextOptimizer = module.ModelContextOptimizer;
+    listSupportedModels = module.listSupportedModels;
+  }
+  return { ModelContextOptimizer, listSupportedModels };
+}
+
 /**
  * Generate CLAUDE.md content from config and project state
  */
@@ -186,6 +199,19 @@ ${cfg.customInstructions}
  */
 async function run(args) {
   const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  // Handle help
+  if (subcommand === 'help' || parsedArgs.help || parsedArgs.h) {
+    showHelp();
+    return;
+  }
+
+  // Handle multimodel subcommand
+  if (subcommand === 'multimodel' || subcommand === 'multi') {
+    return generateMultiModel(parsedArgs);
+  }
+
   const full = parsedArgs.full || parsedArgs.f;
 
   console.log(`
@@ -303,4 +329,159 @@ ${utils.COLORS.dim}Tip: Run 'bootspring generate --full' to regenerate all files
 `);
 }
 
-module.exports = { run, generateClaudeMd };
+/**
+ * Generate multi-model context files
+ */
+async function generateMultiModel(args) {
+  const { ModelContextOptimizer, listSupportedModels } = getModelContextOptimizer();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Multi-Model Context Generation${utils.COLORS.reset}
+${utils.COLORS.dim}Generating optimized context for multiple AI models...${utils.COLORS.reset}
+`);
+
+  const cfg = config.load();
+
+  if (!cfg._configPath) {
+    utils.print.error('No bootspring.config.js found');
+    utils.print.dim('Run "bootspring init" first to initialize your project');
+    return;
+  }
+
+  // Check for existing CLAUDE.md
+  const claudePath = path.join(cfg._projectRoot, 'CLAUDE.md');
+  if (!fs.existsSync(claudePath)) {
+    utils.print.error('CLAUDE.md not found');
+    utils.print.dim('Run "bootspring generate" first to create the base context');
+    return;
+  }
+
+  const sourceContent = fs.readFileSync(claudePath, 'utf-8');
+
+  // List models if requested
+  if (args.list) {
+    const models = listSupportedModels();
+    console.log(`${utils.COLORS.bold}Supported Models:${utils.COLORS.reset}\n`);
+    for (const model of models) {
+      console.log(`  ${utils.COLORS.cyan}${model.family}${utils.COLORS.reset} (${model.provider})`);
+      console.log(`    Variants: ${model.variants.join(', ')}`);
+      console.log(`    Context file: ${model.contextFile}`);
+      console.log('');
+    }
+    return;
+  }
+
+  // Determine which models to generate for
+  let targetModels = ['claude', 'openai', 'gemini'];
+  if (args.models) {
+    targetModels = args.models.split(',').map(m => m.trim().toLowerCase());
+  }
+
+  // Compare across models
+  if (args.compare) {
+    const optimizer = new ModelContextOptimizer({ projectRoot: cfg._projectRoot });
+    const comparison = optimizer.compareAcrossModels(sourceContent);
+
+    console.log(`${utils.COLORS.bold}Context Comparison Across Models:${utils.COLORS.reset}\n`);
+    console.log(`Source tokens: ~${optimizer.estimateTokens(sourceContent).toLocaleString()}\n`);
+
+    for (const result of comparison) {
+      const statusIcon = result.fitsWithinBudget
+        ? `${utils.COLORS.green}✓${utils.COLORS.reset}`
+        : `${utils.COLORS.yellow}⚠${utils.COLORS.reset}`;
+
+      console.log(`  ${statusIcon} ${result.model} (${result.variant})`);
+      console.log(`    ${utils.COLORS.dim}Context window: ${result.contextWindow.toLocaleString()} tokens${utils.COLORS.reset}`);
+      console.log(`    ${utils.COLORS.dim}Utilization: ${result.utilizationPercent}%${utils.COLORS.reset}`);
+    }
+    console.log('');
+    return;
+  }
+
+  // Generate context files
+  const generated = [];
+
+  for (const model of targetModels) {
+    try {
+      const optimizer = new ModelContextOptimizer({
+        projectRoot: cfg._projectRoot,
+        model
+      });
+
+      const spinner = utils.createSpinner(`Generating ${optimizer.config.contextFile}`).start();
+
+      const result = optimizer.generateContextFile(sourceContent);
+
+      // Write the file
+      fs.writeFileSync(result.filepath, result.content, 'utf-8');
+
+      const savings = result.optimization.originalTokens - result.optimization.optimizedTokens;
+      const savingsPercent = Math.round((savings / result.optimization.originalTokens) * 100);
+
+      spinner.succeed(`Generated ${result.filename}`);
+
+      if (result.optimization.sectionsDropped > 0) {
+        console.log(`    ${utils.COLORS.dim}Optimized: ${result.optimization.optimizedTokens.toLocaleString()} tokens (${savingsPercent}% reduction)${utils.COLORS.reset}`);
+        console.log(`    ${utils.COLORS.dim}Dropped ${result.optimization.sectionsDropped} low-priority sections${utils.COLORS.reset}`);
+      }
+
+      generated.push({
+        model,
+        filename: result.filename,
+        tokens: result.optimization.optimizedTokens
+      });
+
+    } catch (error) {
+      utils.print.error(`Failed to generate for ${model}: ${error.message}`);
+    }
+  }
+
+  if (generated.length > 0) {
+    console.log(`
+${utils.COLORS.bold}Summary:${utils.COLORS.reset}
+  Generated ${generated.length} context file(s):
+${generated.map(g => `    ${utils.COLORS.green}✓${utils.COLORS.reset} ${g.filename} (~${g.tokens.toLocaleString()} tokens)`).join('\n')}
+
+${utils.COLORS.dim}These files are optimized for each AI model's context window and formatting preferences.${utils.COLORS.reset}
+`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Generate${utils.COLORS.reset}
+${utils.COLORS.dim}Generate AI context files${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring generate                    Generate CLAUDE.md
+  bootspring generate --full             Generate all context files
+  bootspring generate multimodel         Generate for multiple AI models
+  bootspring generate multimodel --list  List supported models
+  bootspring generate multimodel --compare  Compare context across models
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --full, -f            Generate all files (CLAUDE.md, AGENTS.md, .mcp.json)
+  --models <list>       Comma-separated list of models (default: claude,openai,gemini)
+  --list                List all supported AI models
+  --compare             Compare context requirements across models
+
+${utils.COLORS.bold}Supported Models:${utils.COLORS.reset}
+  claude     Claude (Anthropic) - CLAUDE.md
+  openai     GPT (OpenAI) - OPENAI.md
+  gemini     Gemini (Google) - GEMINI.md
+  mistral    Mistral (Mistral AI) - MISTRAL.md
+  llama      Llama (Meta) - LLAMA.md
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring generate                    # Generate CLAUDE.md
+  bootspring generate --full             # Generate all files
+  bootspring generate multimodel         # Generate for all default models
+  bootspring generate multimodel --models claude,openai
+  bootspring generate multimodel --compare
+`);
+}
+
+module.exports = { run, generateClaudeMd, generateMultiModel };