cntx-ui 2.0.15 → 3.0.1

package/lib/bundle-manager.js

@@ -1,6 +1,6 @@
 /**
  * Bundle Manager for cntx-ui
- * Handles bundle generation, XML creation, and file organization
+ * Handles Smart Dynamic Bundles and traditional XML generation
  */
 
 import { readFileSync, statSync } from 'fs';
@@ -10,462 +10,227 @@ export default class BundleManager {
   constructor(configManager, fileSystemManager, verbose = false) {
     this.configManager = configManager;
     this.fileSystemManager = fileSystemManager;
+    this.db = configManager.dbManager;
     this.verbose = verbose;
     this._isScanning = false;
   }
 
-  // === Bundle Generation ===
-
-  async generateAllBundles() {
-    this._isScanning = true;
-
-    try {
-      const bundles = this.configManager.getBundles();
-
-      const totalBundles = bundles.size;
-      let processedBundles = 0;
-
-      for (const [name] of bundles) {
-        if (this.verbose) {
-          processedBundles++;
-          const progress = `📊 Generating bundles: ${processedBundles}/${totalBundles} (${name})`;
-          process.stdout.write(`\r${progress.padEnd(80)}`); // Pad to clear previous longer messages
-        }
-        await this.generateBundle(name);
-      }
-
-      if (this.verbose) {
-        process.stdout.write('\r' + ''.padEnd(80) + '\r'); // Clear the line
-      }
-      this.configManager.saveBundleStates();
-    } finally {
-      this._isScanning = false;
-    }
-  }
-
-  async generateBundle(name) {
-    const bundles = this.configManager.getBundles();
-    const bundle = bundles.get(name);
-
-    if (!bundle) {
-      throw new Error(`Bundle "${name}" not found`);
-    }
+  /**
+   * Get all bundle information, including Smart Dynamic Bundles
+   */
+  getAllBundleInfo() {
+    if (this.verbose) console.log('📦 Getting all bundle info...');
+    const manualBundles = Array.from(this.configManager.getBundles().entries()).map(([name, bundle]) => ({
+      name,
+      fileCount: bundle.files?.length || 0,
+      size: bundle.size || 0,
+      generated: bundle.generated,
+      changed: bundle.changed,
+      patterns: bundle.patterns,
+      type: 'manual'
+    }));
 
-    // Only regenerate from patterns if no manual files exist
-    // This preserves manual file management while allowing pattern-based initialization
-    if (!bundle.files || bundle.files.length === 0) {
-      // Get all files matching bundle patterns
-      const allFiles = this.fileSystemManager.getAllFiles();
-      const bundleFiles = allFiles.filter(file =>
-        bundle.patterns.some(pattern =>
-          this.fileSystemManager.matchesPattern(file, pattern)
-        )
-      );
+    if (this.verbose) console.log(`📦 Found ${manualBundles.length} manual bundles`);
 
-      // Convert to relative paths for storage (portable across environments)
-      bundle.files = bundleFiles.map(file => this.fileSystemManager.relativePath(file));
-    }
-    // If bundle.files already exists, preserve manual file management
+    const smartBundles = this.generateSmartBundleDefinitions();
+    if (this.verbose) console.log(`📦 Found ${smartBundles.length} smart bundle definitions`);
 
-    // Ensure bundle.files always contains relative paths for storage consistency
-    bundle.files = bundle.files.map(file =>
-      file.startsWith('/') ? this.fileSystemManager.relativePath(file) : file
-    );
+    // Filter out smart bundles that have no files
+    const activeSmartBundles = smartBundles.map(b => {
+      const files = this.resolveSmartBundle(b.name);
+      return {
+        ...b,
+        fileCount: files.length,
+        files
+      };
+    }).filter(b => b.fileCount > 0);
 
-    // Convert relative paths to absolute for XML generation
-    const absoluteFiles = bundle.files.map(file =>
-      this.fileSystemManager.absolutePath(file)
-    );
-    bundle.content = this.generateBundleXML(name, absoluteFiles);
-    bundle.size = Buffer.byteLength(bundle.content, 'utf8');
-    bundle.generated = new Date().toISOString();
-    bundle.changed = false;
+    if (this.verbose) console.log(`📦 Active smart bundles: ${activeSmartBundles.length}`);
 
-    return bundle;
+    return [...manualBundles, ...activeSmartBundles];
   }
 
-  generateBundleXML(bundleName, files) {
-    const projectInfo = this.getProjectInfo();
-    const categorizedFiles = this.categorizeFiles(files);
-    const entryPoints = this.identifyEntryPoints(files);
-    const bundlePurpose = this.getBundlePurpose(bundleName);
-
-    let xml = `<?xml version="1.0" encoding="UTF-8"?>
-<codebase>
-  <project_info>
-    <name>${this.escapeXml(projectInfo.name)}</name>
-    <bundle_name>${this.escapeXml(bundleName)}</bundle_name>
-    <bundle_purpose>${this.escapeXml(bundlePurpose)}</bundle_purpose>
-    <total_files>${files.length}</total_files>
-    <generated_at>${new Date().toISOString()}</generated_at>
-  </project_info>
-  
-  <overview>
-    <description>
-      This bundle contains ${files.length} files organized into different categories.
-      ${bundlePurpose}
-    </description>
-    <entry_points>
-${entryPoints.map(file => `      <file>${this.escapeXml(file)}</file>`).join('\n')}
-    </entry_points>
-  </overview>
-  
-  <file_structure>`;
-
-    // Add categorized files
-    Object.entries(categorizedFiles).forEach(([category, categoryFiles]) => {
-      if (categoryFiles.length > 0) {
-        xml += `
-    <group name="${category}" description="${this.getTypeDescription(category)}">`;
-
-        categoryFiles.forEach(file => {
-          xml += `
-      ${this.generateFileXML(file)}`;
+  /**
+   * Generate Smart Bundle definitions from indexed semantic data
+   */
+  generateSmartBundleDefinitions() {
+    const smartBundles = [];
+    try {
+      // 1. Group by Purpose (Heuristics)
+      const purposeRows = this.db.db.prepare('SELECT DISTINCT purpose, COUNT(*) as count FROM semantic_chunks GROUP BY purpose').all();
+      purposeRows.forEach(row => {
+        if (!row.purpose) return;
+        const name = `smart:${row.purpose.toLowerCase().replace(/\s+/g, '-')}`;
+        smartBundles.push({
+          name,
+          purpose: row.purpose,
+          fileCount: row.count,
+          type: 'smart',
+          description: `Automatically grouped by purpose: ${row.purpose}`
         });
+      });
 
-        xml += `
-    </group>`;
-      }
-    });
-
-    xml += `
-  </file_structure>
-</codebase>`;
-
-    return xml;
-  }
-
-  // === File Organization ===
-
-  categorizeFiles(files) {
-    const categories = {
-      'entry_points': [],
-      'components': [],
-      'hooks': [],
-      'utilities': [],
-      'types': [],
-      'styles': [],
-      'tests': [],
-      'configuration': [],
-      'documentation': [],
-      'other': []
-    };
-
-    files.forEach(file => {
-      const ext = extname(file).toLowerCase();
-      const fileName = basename(file).toLowerCase();
-      const filePath = file.toLowerCase();
-
-      // Entry points
-      if (fileName.match(/^(main|index|app)\.(js|jsx|ts|tsx)$/)) {
-        categories.entry_points.push(file);
-      }
-      // Components
-      else if (ext.match(/\.(jsx|tsx|vue)$/) || filePath.includes('/components/')) {
-        categories.components.push(file);
-      }
-      // Hooks
-      else if (filePath.includes('/hooks/') || fileName.startsWith('use') && ext.match(/\.(js|ts)$/)) {
-        categories.hooks.push(file);
-      }
-      // Utilities
-      else if (filePath.includes('/utils/') || filePath.includes('/helpers/') || filePath.includes('/lib/')) {
-        categories.utilities.push(file);
-      }
-      // Types
-      else if (fileName.includes('.d.ts') || filePath.includes('/types/') || fileName.includes('types')) {
-        categories.types.push(file);
-      }
-      // Styles
-      else if (ext.match(/\.(css|scss|sass|less|styl)$/)) {
-        categories.styles.push(file);
-      }
-      // Tests
-      else if (fileName.includes('.test.') || fileName.includes('.spec.') || filePath.includes('/test/') || filePath.includes('/__tests__/')) {
-        categories.tests.push(file);
-      }
-      // Configuration
-      else if (ext.match(/\.(json|yaml|yml|toml|ini)$/) || fileName.includes('config')) {
-        categories.configuration.push(file);
-      }
-      // Documentation
-      else if (ext.match(/\.(md|txt|rst)$/)) {
-        categories.documentation.push(file);
-      }
-      // Other
-      else {
-        categories.other.push(file);
-      }
-    });
-
-    return categories;
+      // 2. Group by Component Types (Subtypes)
+      const subtypeRows = this.db.db.prepare('SELECT DISTINCT subtype, COUNT(*) as count FROM semantic_chunks GROUP BY subtype').all();
+      subtypeRows.forEach(row => {
+        if (!row.subtype) return;
+        const name = `smart:type-${row.subtype.toLowerCase().replace(/_/g, '-')}`;
+        smartBundles.push({
+          name,
+          purpose: row.subtype,
+          fileCount: row.count,
+          type: 'smart',
+          description: `All ${row.subtype} elements across the codebase`
+        });
+      });
+    } catch (e) {
+      if (this.verbose) console.warn('Smart bundle discovery failed:', e.message);
+    }
+    return smartBundles;
   }
 
-  identifyEntryPoints(files) {
-    const entryPoints = [];
-    const entryPatterns = [
-      /^(main|index|app)\.(js|jsx|ts|tsx)$/i,
-      /^server\.(js|ts)$/i,
-      /^app\.(js|jsx|ts|tsx)$/i
-    ];
+  /**
+   * Resolve files for a bundle (Manual or Smart)
+   */
+  async resolveBundleFiles(bundleName) {
+    if (bundleName.startsWith('smart:')) {
+      return this.resolveSmartBundle(bundleName);
+    }
 
-    files.forEach(file => {
-      const fileName = basename(file);
-      if (entryPatterns.some(pattern => pattern.test(fileName))) {
-        entryPoints.push(file);
+    const bundle = this.configManager.getBundles().get(bundleName);
+    if (!bundle) return [];
+
+    const allFiles = this.fileSystemManager.getAllFiles();
+    return allFiles.filter(file =>
+      bundle.patterns.some(pattern => this.fileSystemManager.matchesPattern(file, pattern))
+    ).map(f => this.fileSystemManager.relativePath(f));
+  }
+
+  /**
+   * Resolve a Smart Bundle query against SQLite
+   */
+  resolveSmartBundle(bundleName) {
+    const query = bundleName.replace('smart:', '');
+    let rows = [];
+
+    if (query.startsWith('type-')) {
+      const type = query.replace('type-', '').replace(/-/g, '_');
+      rows = this.db.db.prepare('SELECT DISTINCT file_path FROM semantic_chunks WHERE LOWER(subtype) = ?').all(type);
+    } else {
+      const purposeRows = this.db.db.prepare('SELECT DISTINCT purpose FROM semantic_chunks').all();
+      const matched = purposeRows.find(r => r.purpose?.toLowerCase().replace(/\s+/g, '-') === query);
+      if (matched) {
+        rows = this.db.db.prepare('SELECT DISTINCT file_path FROM semantic_chunks WHERE purpose = ?').all(matched.purpose);
       }
-    });
-
-    return entryPoints;
-  }
-
-  getBundlePurpose(bundleName) {
-    const purposes = {
-      'master': 'Complete codebase overview with all project files',
-      'frontend': 'User interface components, styling, and client-side logic',
-      'backend': 'Server-side logic, API endpoints, and business logic',
-      'components': 'Reusable UI components and their associated styles',
-      'utilities': 'Shared utility functions and helper modules',
-      'configuration': 'Project configuration files and environment setup',
-      'tests': 'Test files and testing utilities',
-      'documentation': 'Project documentation and README files',
-      'types': 'TypeScript type definitions and interfaces',
-      'styles': 'CSS, SCSS, and other styling files'
-    };
-
-    return purposes[bundleName] || `Files matching the ${bundleName} bundle patterns`;
-  }
-
-  getTypeDescription(type) {
-    const descriptions = {
-      'entry_points': 'Main application entry points and bootstrap files',
-      'components': 'Reusable UI components and their implementations',
-      'hooks': 'Custom React hooks and composable functions',
-      'utilities': 'Shared utility functions and helper modules',
-      'types': 'TypeScript type definitions and interfaces',
-      'styles': 'CSS, SCSS, and other styling files',
-      'tests': 'Test files and testing utilities',
-      'configuration': 'Configuration files and environment setup',
-      'documentation': 'Documentation, README files, and guides',
-      'other': 'Other project files not fitting specific categories'
-    };
-
-    return descriptions[type] || 'Project files';
+    }
+    return rows.map(r => r.file_path);
   }
 
-  // === File Processing ===
+  // === Bundle Generation ===
 
-  generateFileXML(file) {
+  async generateAllBundles() {
+    this._isScanning = true;
     try {
-      const stats = this.getFileStats(file);
-      const content = readFileSync(file, 'utf8');
-      const role = this.getFileRole(file);
-      const relativePath = relative(this.configManager.CWD, file);
-
-      return `<file path="${this.escapeXml(relativePath)}" role="${this.escapeXml(role)}" size="${stats.size}" modified="${stats.mtime.toISOString()}">
-        <![CDATA[${content}]]>
-      </file>`;
-    } catch (error) {
-      const relativePath = relative(this.configManager.CWD, file);
-      return `<file path="${this.escapeXml(relativePath)}" role="error" error="${this.escapeXml(error.message)}">
-        <!-- File could not be read -->
-      </file>`;
+      const bundles = this.configManager.getBundles();
+      for (const [name] of bundles) {
+        await this.regenerateBundle(name);
+      }
+    } finally {
+      this._isScanning = false;
     }
   }
 
-  getFileRole(file) {
-    const fileName = basename(file).toLowerCase();
-    const filePath = file.toLowerCase();
-    const ext = extname(file).toLowerCase();
+  async regenerateBundle(bundleName) {
+    if (this.verbose) console.log(`🔄 Regenerating bundle: ${bundleName}`);
+    
+    const files = await this.resolveBundleFiles(bundleName);
+    const content = await this.generateBundleXML(bundleName, files);
+    
+    const bundleData = {
+      files,
+      content,
+      size: Buffer.byteLength(content, 'utf8'),
+      generated: new Date().toISOString(),
+      changed: false
+    };
 
-    if (fileName.match(/^(main|index|app)\.(js|jsx|ts|tsx)$/)) {
-      return 'entry_point';
-    }
-    if (fileName.includes('config') || fileName.includes('setup')) {
-      return 'configuration';
-    }
-    if (fileName.includes('readme') || ext === '.md') {
-      return 'documentation';
+    if (!bundleName.startsWith('smart:')) {
+      const existing = this.configManager.getBundles().get(bundleName);
+      this.configManager.getBundles().set(bundleName, { ...existing, ...bundleData });
+      this.configManager.saveBundleStates();
     }
 
-    return 'implementation';
-  }
-
-  getFileStats(filePath) {
-    try {
-      const stats = statSync(filePath);
-      return {
-        size: stats.size,
-        mtime: stats.mtime,
-        ctime: stats.ctime
-      };
-    } catch (error) {
-      return {
-        size: 0,
-        mtime: new Date(0),
-        ctime: new Date(0)
-      };
-    }
+    return bundleData;
   }
 
-  escapeXml(text) {
-    if (typeof text !== 'string') {
-      text = String(text);
+  async generateBundleXML(bundleName, relativeFiles) {
+    const projectInfo = this.getProjectInfo();
+    let xml = `<?xml version="1.0" encoding="UTF-8"?>\n<codebase>\n`;
+    xml += `  <project_info>\n    <name>${this.escapeXml(projectInfo.name)}</name>\n    <bundle>${this.escapeXml(bundleName)}</bundle>\n  </project_info>\n`;
+    
+    for (const relPath of relativeFiles) {
+      xml += await this.generateFileXML(relPath);
     }
-    return text
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&apos;');
-  }
-
-  // === Bundle State Management ===
-
-  markBundlesChanged(filename) {
-    const bundles = this.configManager.getBundles();
-
-    bundles.forEach((bundle, name) => {
-      const matchesBundle = bundle.patterns.some(pattern =>
-        this.fileSystemManager.matchesPattern(filename, pattern)
-      );
-
-      if (matchesBundle) {
-        bundle.changed = true;
-      }
-    });
+    
+    xml += `</codebase>`;
+    return xml;
   }
 
-  getFileListWithVisibility(bundleName) {
+  async generateFileXML(relativePath) {
     try {
-      const allFiles = this.fileSystemManager.getAllFiles();
-      const bundle = this.configManager.getBundles().get(bundleName);
-
-      if (!bundle) {
-        return [];
+      const fullPath = this.fileSystemManager.fullPath(relativePath);
+      const content = readFileSync(fullPath, 'utf8');
+      const chunks = this.db.getChunksByFile(relativePath);
+      
+      let xml = `  <file path="${this.escapeXml(relativePath)}">\n`;
+      if (chunks.length > 0) {
+        xml += `    <semantic_context>\n`;
+        chunks.forEach(c => {
+          xml += `      <chunk name="${this.escapeXml(c.name)}" purpose="${this.escapeXml(c.purpose)}" complexity="${c.complexity?.score || 0}" />\n`;
+        });
+        xml += `    </semantic_context>\n`;
       }
-
-      return allFiles.map(file => {
-        const matchesBundle = bundle.patterns.some(pattern =>
-          this.fileSystemManager.matchesPattern(file, pattern)
-        );
-
-        const isHidden = this.configManager.isFileHidden(file, bundleName);
-        const relativePath = relative(this.configManager.CWD, file);
-
-        return {
-          path: relativePath,
-          fullPath: file,
-          included: matchesBundle && !isHidden,
-          hidden: isHidden,
-          matchesPattern: matchesBundle
-        };
-      });
-    } catch (error) {
-      console.error('Failed to get file list with visibility:', error.message);
-      return [];
+      xml += `    <content><![CDATA[${content}]]></content>\n  </file>\n`;
+      return xml;
+    } catch (e) {
+      return `  <file path="${this.escapeXml(relativePath)}" error="${this.escapeXml(e.message)}" />\n`;
     }
   }
 
-  // === Project Information ===
-
   getProjectInfo() {
     try {
-      const packagePath = this.configManager.CWD + '/package.json';
-      const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
-      return {
-        name: pkg.name || 'Unknown Project',
-        version: pkg.version || '1.0.0',
-        description: pkg.description || 'No description available'
-      };
-    } catch (error) {
-      return {
-        name: 'Unknown Project',
-        version: '1.0.0',
-        description: 'No description available'
-      };
-    }
-  }
-
-  // === Bundle Operations ===
-
-  async regenerateBundle(bundleName) {
-    // Notify WebSocket clients that sync has started
-    if (this.webSocketManager) {
-      this.webSocketManager.onBundleSyncStarted(bundleName);
-    }
-
-    try {
-      const bundle = await this.generateBundle(bundleName);
-      this.configManager.saveBundleStates();
-
-      // Notify WebSocket clients that sync completed successfully
-      if (this.webSocketManager) {
-        this.webSocketManager.onBundleSyncCompleted(bundleName);
-      }
-
-      return bundle;
-    } catch (error) {
-      // Notify WebSocket clients that sync failed
-      if (this.webSocketManager) {
-        this.webSocketManager.onBundleSyncFailed(bundleName, error);
-      }
-      throw error;
+      const pkg = JSON.parse(readFileSync(this.fileSystemManager.fullPath('package.json'), 'utf8'));
+      return { name: pkg.name || 'Unknown', version: pkg.version || '1.0.0' };
+    } catch {
+      return { name: 'Unknown', version: '1.0.0' };
     }
   }
 
-  async regenerateChangedBundles() {
-    const bundles = this.configManager.getBundles();
-    const changedBundles = [];
-
-    for (const [name, bundle] of bundles) {
-      if (bundle.changed) {
-        await this.generateBundle(name);
-        changedBundles.push(name);
-      }
-    }
-
-    if (changedBundles.length > 0) {
-      this.configManager.saveBundleStates();
-    }
-
-    return changedBundles;
+  escapeXml(text) {
+    return String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
   }
 
   getBundleContent(bundleName) {
+    if (bundleName.startsWith('smart:')) {
+      // For smart bundles, we generate on the fly if not cached
+      return this.regenerateBundle(bundleName).then(data => data.content);
+    }
     const bundle = this.configManager.getBundles().get(bundleName);
     return bundle ? bundle.content : null;
   }
 
-  getBundleInfo(bundleName) {
-    const bundle = this.configManager.getBundles().get(bundleName);
-    if (!bundle) return null;
-
-    return {
-      name: bundleName,
-      fileCount: bundle.files.length,
-      size: bundle.size,
-      generated: bundle.generated,
-      changed: bundle.changed,
-      patterns: bundle.patterns
-    };
-  }
-
-  getAllBundleInfo() {
-    const bundles = this.configManager.getBundles();
-    return Array.from(bundles.entries()).map(([name, bundle]) => ({
-      name,
-      fileCount: bundle.files.length,
-      size: bundle.size,
-      generated: bundle.generated,
-      changed: bundle.changed,
-      patterns: bundle.patterns
-    }));
+  markBundlesChanged(filename) {
+    this.configManager.getBundles().forEach((bundle, name) => {
+      if (bundle.patterns?.some(p => this.fileSystemManager.matchesPattern(filename, p))) {
+        bundle.changed = true;
+      }
+    });
   }
 
-  // === Getters ===
-
-  get isScanning() {
-    return this._isScanning;
+  getBundleInfo(bundleName) {
+    if (bundleName.startsWith('smart:')) {
+      return this.generateSmartBundleDefinitions().find(b => b.name === bundleName);
+    }
+    return this.configManager.getBundles().get(bundleName);
   }
 }