cntx-ui 2.0.15 → 3.0.1

package/lib/configuration-manager.js

@@ -5,6 +5,7 @@
 
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { join, relative } from 'path';
+import DatabaseManager from './database-manager.js';
 
 export default class ConfigurationManager {
   constructor(cwd = process.cwd(), options = {}) {
@@ -32,45 +33,34 @@ export default class ConfigurationManager {
     };
     this.ignorePatterns = [];
 
+    // Initialize database manager
+    this.dbManager = new DatabaseManager(this.CNTX_DIR, { verbose: this.verbose });
+    
     // Load initial configuration
     this.loadConfig();
+    
+    // Load bundles (try SQLite first, fallback to JSON)
+    this.loadBundleStates();
   }
 
   // === Bundle Configuration ===
 
   loadConfig() {
-    // Clear existing bundles to ensure deleted ones are removed
-    this.bundleStates.clear();
-
     if (existsSync(this.CONFIG_FILE)) {
       const config = JSON.parse(readFileSync(this.CONFIG_FILE, 'utf8'));
 
-      // Load editor setting
+      // Load non-bundle settings only
       this.editor = config.editor || 'code';
-
-      Object.entries(config.bundles || {}).forEach(([name, patterns]) => {
-        this.bundleStates.set(name, {
-          patterns: Array.isArray(patterns) ? patterns : [patterns],
-          files: [],
-          content: '',
-          changed: false,
-          size: 0,
-          generated: null
-        });
-      });
+      
+      // Store full config for other non-bundle settings
+      this.config = config;
+    } else {
+      // Set defaults
+      this.editor = 'code';
+      this.config = {};
     }
 
-    // Ensure 'master' bundle exists
-    if (!this.bundleStates.has('master')) {
-      this.bundleStates.set('master', {
-        patterns: ['**/*'],
-        files: [],
-        content: '',
-        changed: false,
-        size: 0,
-        generated: null
-      });
-    }
+    // Bundle loading is now handled by loadBundleStates()
   }
 
   saveConfig(config) {
@@ -80,56 +70,88 @@ export default class ConfigurationManager {
   // === Bundle States Persistence ===
 
   loadBundleStates() {
+    // Try loading from SQLite first
+    try {
+      this.bundleStates = this.dbManager.loadBundles();
+      
+      if (this.bundleStates.size > 0) {
+        if (this.verbose) {
+          console.log('✅ Loaded bundles from SQLite database');
+        }
+        return;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.log('⚠️ SQLite load failed, trying JSON fallback:', error.message);
+      }
+    }
+
+    // Fallback to JSON file
+    this.bundleStates.clear();
+    
     if (existsSync(this.BUNDLE_STATES_FILE)) {
       try {
         const bundleStates = JSON.parse(readFileSync(this.BUNDLE_STATES_FILE, 'utf8'));
 
         bundleStates.forEach(state => {
-          if (this.bundleStates.has(state.name)) {
-            const bundle = this.bundleStates.get(state.name);
-            bundle.content = state.content || '';
-            bundle.size = state.size || 0;
-            bundle.generated = state.generated || null;
-            bundle.changed = false;
-            if (state.files) {
-              // Migrate absolute paths to relative paths for portability
-              bundle.files = state.files.map(file => {
-                if (file.startsWith('/')) {
-                  // Convert absolute to relative
-                  const relativePath = require('path').relative(this.CWD, file);
-                  return relativePath;
-                } else {
-                  // Already relative
-                  return file;
-                }
-              });
-            }
-          }
+          this.bundleStates.set(state.name, {
+            patterns: state.patterns || [],
+            files: (state.files || []).map(file => {
+              if (file.startsWith('/')) {
+                const relativePath = relative(this.CWD, file);
+                return relativePath;
+              } else {
+                return file;
+              }
+            }),
+            content: state.content || '',
+            size: state.size || 0,
+            generated: state.generated || null,
+            changed: false
+          });
         });
+        
+        // Migrate JSON data to SQLite
+        this.dbManager.saveBundles(this.bundleStates);
+        if (this.verbose) {
+          console.log('📦 Migrated bundle data from JSON to SQLite');
+        }
       } catch (error) {
-        console.error('Failed to load bundle states:', error.message);
+        console.error('Failed to load bundle states from JSON:', error.message);
       }
     }
+
+    // Ensure 'master' bundle exists
+    if (!this.bundleStates.has('master')) {
+      this.bundleStates.set('master', {
+        patterns: ['**/*'],
+        files: [],
+        content: '',
+        changed: false,
+        size: 0,
+        generated: null
+      });
+    }
   }
 
   saveBundleStates() {
     try {
+      // Save to SQLite database (primary)
+      this.dbManager.saveBundles(this.bundleStates);
+      
+      // Also save to JSON for compatibility/backup
       const bundleStates = Array.from(this.bundleStates.entries()).map(([name, bundle]) => ({
         name,
-        // Don't save the full content - it's too large and can cause RangeError
         contentPreview: bundle.content ? bundle.content.substring(0, 200) + '...' : '',
         size: bundle.size,
         fileCount: bundle.files ? bundle.files.length : 0,
         generated: bundle.generated,
         changed: bundle.changed,
         patterns: bundle.patterns,
-        // Always save relative paths for portability
         files: (bundle.files || []).map(file => {
           if (file.startsWith('/')) {
-            // Convert absolute to relative
             return relative(this.CWD, file);
           } else {
-            // Already relative
             return file;
           }
         })
@@ -137,7 +159,7 @@ export default class ConfigurationManager {
 
       writeFileSync(this.BUNDLE_STATES_FILE, JSON.stringify(bundleStates, null, 2));
       if (this.verbose) {
-        console.log(`💾 Saved bundle states for ${bundleStates.length} bundles`);
+        console.log(`💾 Saved ${bundleStates.length} bundles to SQLite + JSON`);
       }
     } catch (error) {
       if (this.verbose) {
@@ -694,19 +716,32 @@ When working on this project, please:
       generated: null
     });
 
-    // Save to config file
-    const config = { bundles: {} };
-    this.bundleStates.forEach((bundle, name) => {
-      config.bundles[name] = bundle.patterns;
-    });
-
-    this.saveConfig(config);
+    // Save to bundle-states.json (single source of truth)
+    this.saveBundleStates();
 
     return bundleName;
   }
 
   // === Getters ===
 
+  // === Ignore File Management ===
+
+  saveCntxignore(content) {
+    try {
+      writeFileSync(this.IGNORE_FILE, content, 'utf8');
+      
+      // Update ignore patterns in memory immediately
+      this.ignorePatterns = content.split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'));
+        
+      return true;
+    } catch (error) {
+      console.error('Failed to save .cntxignore:', error.message);
+      return false;
+    }
+  }
+
   getBundles() {
     return this.bundleStates;
   }

package/lib/database-manager.js

@@ -0,0 +1,397 @@
+/**
+ * Database Manager for cntx-ui
+ * Handles SQLite operations for bundle and file data
+ */
+
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { statSync } from 'fs';
+
+export default class DatabaseManager {
+  constructor(cntxDir, options = {}) {
+    this.cntxDir = cntxDir;
+    this.verbose = options.verbose || false;
+    this.dbPath = join(cntxDir, 'bundles.db');
+    
+    try {
+      this.db = new Database(this.dbPath);
+      this.initSchema();
+      if (this.verbose) {
+        console.log(`📊 SQLite database initialized: ${this.dbPath}`);
+      }
+    } catch (error) {
+      console.error('Failed to initialize SQLite database:', error.message);
+      throw error;
+    }
+  }
+
+  initSchema() {
+    this.db.exec(`
+      -- Existing bundles table
+      CREATE TABLE IF NOT EXISTS bundles (
+        name TEXT PRIMARY KEY,
+        patterns TEXT NOT NULL,
+        files TEXT NOT NULL,
+        size INTEGER DEFAULT 0,
+        file_count INTEGER DEFAULT 0,
+        generated_at TEXT,
+        changed BOOLEAN DEFAULT FALSE
+      );
+
+      -- Persistent Semantic Chunks
+      CREATE TABLE IF NOT EXISTS semantic_chunks (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        type TEXT,
+        subtype TEXT,
+        content TEXT NOT NULL,
+        start_line INTEGER,
+        complexity_score INTEGER,
+        purpose TEXT,
+        metadata TEXT, -- JSON string for tags, imports, types, etc.
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      -- Vector Embeddings (Persistence for RAG)
+      CREATE TABLE IF NOT EXISTS vector_embeddings (
+        chunk_id TEXT PRIMARY KEY,
+        embedding BLOB NOT NULL, -- Stored as Float32Array blob
+        model_name TEXT NOT NULL,
+        FOREIGN KEY(chunk_id) REFERENCES semantic_chunks(id) ON DELETE CASCADE
+      );
+
+      -- Agent Working Memory & Sessions
+      CREATE TABLE IF NOT EXISTS agent_sessions (
+        id TEXT PRIMARY KEY,
+        title TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_active_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        context_summary TEXT -- High-level summary of what was being worked on
+      );
+
+      CREATE TABLE IF NOT EXISTS agent_memory (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL, -- 'user' or 'agent'
+        content TEXT NOT NULL,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+        metadata TEXT, -- JSON for tools used, files referenced, etc.
+        FOREIGN KEY(session_id) REFERENCES agent_sessions(id) ON DELETE CASCADE
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_bundles_changed ON bundles(changed);
+      CREATE INDEX IF NOT EXISTS idx_chunks_file ON semantic_chunks(file_path);
+      CREATE INDEX IF NOT EXISTS idx_chunks_purpose ON semantic_chunks(purpose);
+      CREATE INDEX IF NOT EXISTS idx_memory_session ON agent_memory(session_id);
+    `);
+  }
+
+  // Save all bundles from bundleStates Map
+  saveBundles(bundleStates) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO bundles (name, patterns, files, size, file_count, generated_at, changed) 
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const transaction = this.db.transaction(() => {
+      for (const [name, bundle] of bundleStates) {
+        stmt.run(
+          name,
+          JSON.stringify(bundle.patterns || []),
+          JSON.stringify(bundle.files || []),
+          bundle.size || 0,
+          bundle.files ? bundle.files.length : 0,
+          bundle.generated || null,
+          bundle.changed ? 1 : 0
+        );
+      }
+    });
+
+    try {
+      transaction();
+      if (this.verbose) {
+        console.log(`💾 Saved ${bundleStates.size} bundles to SQLite`);
+      }
+    } catch (error) {
+      console.error('Failed to save bundles to SQLite:', error.message);
+      throw error;
+    }
+  }
+
+  // Load all bundles and return as Map
+  loadBundles() {
+    try {
+      const rows = this.db.prepare('SELECT * FROM bundles').all();
+      const bundleStates = new Map();
+
+      rows.forEach(row => {
+        bundleStates.set(row.name, {
+          patterns: JSON.parse(row.patterns),
+          files: JSON.parse(row.files),
+          size: row.size,
+          generated: row.generated_at,
+          changed: Boolean(row.changed)
+        });
+      });
+
+      if (this.verbose) {
+        console.log(`📊 Loaded ${bundleStates.size} bundles from SQLite`);
+      }
+
+      return bundleStates;
+    } catch (error) {
+      console.error('Failed to load bundles from SQLite:', error.message);
+      return new Map();
+    }
+  }
+
+  // Get single bundle by name
+  getBundle(name) {
+    try {
+      const row = this.db.prepare('SELECT * FROM bundles WHERE name = ?').get(name);
+      if (!row) return null;
+
+      return {
+        patterns: JSON.parse(row.patterns),
+        files: JSON.parse(row.files),
+        size: row.size,
+        generated: row.generated_at,
+        changed: Boolean(row.changed)
+      };
+    } catch (error) {
+      console.error(`Failed to get bundle ${name}:`, error.message);
+      return null;
+    }
+  }
+
+  // Delete bundle
+  deleteBundle(name) {
+    try {
+      const stmt = this.db.prepare('DELETE FROM bundles WHERE name = ?');
+      const result = stmt.run(name);
+      
+      if (this.verbose && result.changes > 0) {
+        console.log(`🗑️ Deleted bundle: ${name}`);
+      }
+      
+      return result.changes > 0;
+    } catch (error) {
+      console.error(`Failed to delete bundle ${name}:`, error.message);
+      return false;
+    }
+  }
+
+  // Get all bundle names
+  getBundleNames() {
+    try {
+      const rows = this.db.prepare('SELECT name FROM bundles ORDER BY name').all();
+      return rows.map(row => row.name);
+    } catch (error) {
+      console.error('Failed to get bundle names:', error.message);
+      return [];
+    }
+  }
+
+  // Query interface for database tab
+  query(sql) {
+    try {
+      // Safety: only allow SELECT statements for now
+      if (!sql.trim().toLowerCase().startsWith('select')) {
+        throw new Error('Only SELECT queries are allowed');
+      }
+      
+      const stmt = this.db.prepare(sql);
+      return stmt.all();
+    } catch (error) {
+      console.error('Query failed:', error.message);
+      throw error;
+    }
+  }
+
+  // Get database info for debugging
+  getInfo() {
+    try {
+      const bundleCount = this.db.prepare('SELECT COUNT(*) as count FROM bundles').get().count;
+      const chunkCount = this.db.prepare('SELECT COUNT(*) as count FROM semantic_chunks').get().count;
+      const embeddingCount = this.db.prepare('SELECT COUNT(*) as count FROM vector_embeddings').get().count;
+      const sessionCount = this.db.prepare('SELECT COUNT(*) as count FROM agent_sessions').get().count;
+      const dbSize = statSync(this.dbPath).size;
+      
+      return {
+        path: this.dbPath,
+        bundleCount,
+        chunkCount,
+        embeddingCount,
+        sessionCount,
+        sizeBytes: dbSize,
+        sizeFormatted: (dbSize / 1024).toFixed(1) + ' KB',
+        tables: ['bundles', 'semantic_chunks', 'vector_embeddings', 'agent_sessions', 'agent_memory']
+      };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+
+  // Save semantic chunks
+  saveChunks(chunks) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO semantic_chunks (id, name, file_path, type, subtype, content, start_line, complexity_score, purpose, metadata) 
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const transaction = this.db.transaction(() => {
+      for (const chunk of chunks) {
+        // Generate a stable ID if not provided (org/repo:path:name)
+        const id = chunk.id || `${chunk.filePath}:${chunk.name}:${chunk.startLine}`;
+        stmt.run(
+          id,
+          chunk.name,
+          chunk.filePath,
+          chunk.type || 'unknown',
+          chunk.subtype || 'unknown',
+          chunk.code || chunk.content || '',
+          chunk.startLine || 0,
+          chunk.complexity?.score || 0,
+          chunk.purpose || 'Utility function',
+          JSON.stringify({
+            tags: chunk.tags || [],
+            businessDomain: chunk.businessDomain || [],
+            technicalPatterns: chunk.technicalPatterns || [],
+            imports: chunk.includes?.imports || [],
+            types: chunk.includes?.types || [],
+            bundles: chunk.bundles || []
+          })
+        );
+      }
+    });
+
+    try {
+      transaction();
+      return true;
+    } catch (error) {
+      console.error('Failed to save chunks to SQLite:', error.message);
+      return false;
+    }
+  }
+
+  // Get chunks for a specific file
+  getChunksByFile(filePath) {
+    try {
+      const rows = this.db.prepare('SELECT * FROM semantic_chunks WHERE file_path = ?').all(filePath);
+      return rows.map(row => this.mapChunkRow(row));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  // Search chunks by name or purpose
+  searchChunks(query) {
+    try {
+      const rows = this.db.prepare(`
+        SELECT * FROM semantic_chunks 
+        WHERE name LIKE ? OR purpose LIKE ? 
+        LIMIT 50
+      `).all(`%${query}%`, `%${query}%`);
+      return rows.map(row => this.mapChunkRow(row));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  mapChunkRow(row) {
+    const metadata = JSON.parse(row.metadata || '{}');
+    return {
+      id: row.id,
+      name: row.name,
+      filePath: row.file_path,
+      type: row.type,
+      subtype: row.subtype,
+      code: row.content,
+      startLine: row.start_line,
+      complexity: { score: row.complexity_score },
+      purpose: row.purpose,
+      tags: metadata.tags || [],
+      businessDomain: metadata.businessDomain || [],
+      technicalPatterns: metadata.technicalPatterns || [],
+      includes: {
+        imports: metadata.imports || [],
+        types: metadata.types || []
+      },
+      bundles: metadata.bundles || []
+    };
+  }
+
+  // Vector Embedding Persistence
+  saveEmbedding(chunkId, embedding, modelName) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO vector_embeddings (chunk_id, embedding, model_name) 
+        VALUES (?, ?, ?)
+      `);
+      // Convert Float32Array to Buffer for SQLite BLOB
+      const buffer = Buffer.from(embedding.buffer);
+      stmt.run(chunkId, buffer, modelName);
+      return true;
+    } catch (error) {
+      console.error(`Failed to save embedding for ${chunkId}:`, error.message);
+      return false;
+    }
+  }
+
+  getEmbedding(chunkId) {
+    try {
+      const row = this.db.prepare('SELECT embedding FROM vector_embeddings WHERE chunk_id = ?').get(chunkId);
+      if (!row) return null;
+      // Convert Buffer back to Float32Array
+      return new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Agent Memory Methods
+  createSession(id, title) {
+    try {
+      const stmt = this.db.prepare('INSERT OR REPLACE INTO agent_sessions (id, title) VALUES (?, ?)');
+      stmt.run(id, title);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  addMessage(sessionId, role, content, metadata = {}) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO agent_memory (session_id, role, content, metadata) 
+        VALUES (?, ?, ?, ?)
+      `);
+      stmt.run(sessionId, role, content, JSON.stringify(metadata));
+      
+      // Update session last_active_at
+      this.db.prepare('UPDATE agent_sessions SET last_active_at = CURRENT_TIMESTAMP WHERE id = ?').run(sessionId);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  getSessionHistory(sessionId) {
+    try {
+      return this.db.prepare('SELECT * FROM agent_memory WHERE session_id = ? ORDER BY timestamp ASC').all(sessionId);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  // Close database connection
+  close() {
+    if (this.db) {
+      this.db.close();
+      if (this.verbose) {
+        console.log('📊 SQLite database connection closed');
+      }
+    }
+  }
+}

package/lib/file-system-manager.js

@@ -12,6 +12,23 @@ export default class FileSystemManager {
     this.verbose = options.verbose || false;
     this.watchers = [];
     this.ignorePatterns = [];
+    this.loadIgnorePatterns();
+  }
+
+  loadIgnorePatterns() {
+    const ignorePath = join(this.CWD, '.cntxignore');
+    if (existsSync(ignorePath)) {
+      try {
+        const content = readFileSync(ignorePath, 'utf8');
+        const patterns = content.split('\n')
+          .map(line => line.trim())
+          .filter(line => line && !line.startsWith('#'));
+        this.ignorePatterns = patterns;
+        if (this.verbose) console.log(`📋 Loaded ${patterns.length} patterns from .cntxignore`);
+      } catch (e) {
+        console.error('Failed to load .cntxignore:', e.message);
+      }
+    }
   }
 
   // === File Traversal ===