cntx-ui 3.0.7 → 3.0.9

package/dist/lib/configuration-manager.js

@@ -0,0 +1,230 @@
+/**
+ * Configuration Manager for cntx-ui
+ * Handles all configuration files, settings, and persistence
+ */
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { join, relative } from 'path';
+import DatabaseManager from './database-manager.js';
+export default class ConfigurationManager {
+    CWD;
+    CNTX_DIR;
+    CONFIG_FILE;
+    IGNORE_FILE;
+    BUNDLE_STATES_FILE;
+    HIDDEN_FILES_FILE;
+    SEMANTIC_CACHE_FILE;
+    bundleStates;
+    ignorePatterns;
+    hiddenFilesConfig;
+    editor;
+    verbose;
+    dbManager;
+    constructor(cwd, options = {}) {
+        this.CWD = cwd;
+        this.CNTX_DIR = join(cwd, '.cntx');
+        this.CONFIG_FILE = join(this.CNTX_DIR, 'config.json');
+        this.IGNORE_FILE = join(cwd, '.cntxignore');
+        this.BUNDLE_STATES_FILE = join(this.CNTX_DIR, 'bundle-states.json');
+        this.HIDDEN_FILES_FILE = join(this.CNTX_DIR, 'hidden-files.json');
+        this.SEMANTIC_CACHE_FILE = join(this.CNTX_DIR, 'semantic-cache.json');
+        this.bundleStates = new Map();
+        this.ignorePatterns = [];
+        this.hiddenFilesConfig = { hiddenFiles: [] };
+        this.editor = process.env.EDITOR || 'code';
+        this.verbose = options.verbose || false;
+        this.dbManager = new DatabaseManager(this.CNTX_DIR, { verbose: this.verbose });
+        // Load bundles (try SQLite first, fallback to JSON)
+        this.loadBundleStates();
+    }
+    // === Bundle Configuration ===
+    loadConfig() {
+        if (existsSync(this.CONFIG_FILE)) {
+            const config = JSON.parse(readFileSync(this.CONFIG_FILE, 'utf8'));
+            // Update in-memory bundle states from config patterns
+            if (config.bundles) {
+                Object.entries(config.bundles).forEach(([name, patterns]) => {
+                    const existing = this.bundleStates.get(name) || { files: [], patterns: [] };
+                    this.bundleStates.set(name, {
+                        ...existing,
+                        patterns: patterns
+                    });
+                });
+            }
+            return config;
+        }
+        return { bundles: { master: ['**/*'] } };
+    }
+    saveConfig(config) {
+        writeFileSync(this.CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+    }
+    // === 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;
+    }
+    getIgnorePatterns() {
+        return this.ignorePatterns;
+    }
+    getHiddenFilesConfig() {
+        return this.hiddenFilesConfig;
+    }
+    getEditor() {
+        return this.editor;
+    }
+    // === Persistence ===
+    loadBundleStates() {
+        // 1. Try to load from SQLite first
+        try {
+            const rows = this.dbManager.db.prepare('SELECT * FROM bundles').all();
+            if (rows.length > 0) {
+                rows.forEach(row => {
+                    this.bundleStates.set(row.name, {
+                        patterns: JSON.parse(row.patterns),
+                        files: JSON.parse(row.files),
+                        size: row.size,
+                        fileCount: row.file_count,
+                        generated: row.generated_at,
+                        changed: row.changed === 1
+                    });
+                });
+                if (this.verbose)
+                    console.log('✅ Loaded bundles from SQLite database');
+                return;
+            }
+        }
+        catch (e) {
+            // Fallback to JSON
+        }
+        // 2. Fallback to legacy JSON file
+        if (existsSync(this.BUNDLE_STATES_FILE)) {
+            try {
+                const data = readFileSync(this.BUNDLE_STATES_FILE, 'utf8');
+                const bundleStates = JSON.parse(data);
+                bundleStates.forEach(state => {
+                    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;
+                            }
+                        }),
+                        size: state.size || 0,
+                        fileCount: (state.files || []).length,
+                        generated: state.generated,
+                        changed: state.changed || false
+                    });
+                });
+            }
+            catch (error) {
+                console.error('Error loading bundle states:', error);
+            }
+        }
+    }
+    saveBundleStates() {
+        // 1. Save to SQLite
+        const stmt = this.dbManager.db.prepare(`
+      INSERT OR REPLACE INTO bundles (name, patterns, files, size, file_count, generated_at, changed)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        const transaction = this.dbManager.db.transaction(() => {
+            for (const [name, bundle] of this.bundleStates.entries()) {
+                stmt.run(name, JSON.stringify(bundle.patterns), JSON.stringify(bundle.files), bundle.size || 0, bundle.files.length, bundle.generated || '', bundle.changed ? 1 : 0);
+            }
+        });
+        try {
+            transaction();
+            if (this.verbose)
+                console.log('💾 Saved bundles to SQLite');
+        }
+        catch (e) {
+            console.error('Failed to save bundles to SQLite:', e.message);
+        }
+        // 2. Also save to JSON for backup/legacy compatibility
+        try {
+            const data = Array.from(this.bundleStates.entries()).map(([name, bundle]) => ({
+                name,
+                ...bundle
+            }));
+            writeFileSync(this.BUNDLE_STATES_FILE, JSON.stringify(data, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error('Error saving bundle states:', error);
+        }
+    }
+    loadHiddenFilesConfig() {
+        if (existsSync(this.HIDDEN_FILES_FILE)) {
+            try {
+                const data = readFileSync(this.HIDDEN_FILES_FILE, 'utf8');
+                this.hiddenFilesConfig = JSON.parse(data);
+            }
+            catch (error) {
+                console.error('Error loading hidden files config:', error);
+            }
+        }
+    }
+    isFileHidden(filePath, bundleName) {
+        const bundleHidden = this.hiddenFilesConfig[bundleName] || [];
+        return bundleHidden.includes(filePath);
+    }
+    loadIgnorePatterns() {
+        const ignorePath = join(this.CWD, '.cntxignore');
+        if (existsSync(ignorePath)) {
+            try {
+                const content = readFileSync(ignorePath, 'utf8');
+                this.ignorePatterns = content.split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line && !line.startsWith('#'));
+            }
+            catch (error) {
+                console.error('Error loading ignore patterns:', error);
+            }
+        }
+    }
+    // === Semantic Cache ===
+    saveSemanticCache(analysis) {
+        try {
+            const data = {
+                timestamp: Date.now(),
+                analysis
+            };
+            writeFileSync(this.SEMANTIC_CACHE_FILE, JSON.stringify(data), 'utf8');
+        }
+        catch (error) {
+            console.error('Error saving semantic cache:', error);
+        }
+    }
+    loadSemanticCache() {
+        if (existsSync(this.SEMANTIC_CACHE_FILE)) {
+            try {
+                const data = readFileSync(this.SEMANTIC_CACHE_FILE, 'utf8');
+                return JSON.parse(data);
+            }
+            catch (error) {
+                return null;
+            }
+        }
+        return null;
+    }
+    invalidateSemanticCache() {
+        if (existsSync(this.SEMANTIC_CACHE_FILE)) {
+            unlinkSync(this.SEMANTIC_CACHE_FILE);
+        }
+    }
+}

package/dist/lib/database-manager.js

@@ -0,0 +1,277 @@
+/**
+ * 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 {
+    dbPath;
+    db;
+    verbose;
+    constructor(dbDir, options = {}) {
+        this.dbPath = join(dbDir, 'bundles.db');
+        this.verbose = options.verbose || false;
+        try {
+            this.db = new Database(this.dbPath);
+            if (this.verbose) {
+                console.log(`📊 SQLite database initialized: ${this.dbPath}`);
+            }
+            this.initSchema();
+        }
+        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);
+    `);
+    }
+    /**
+     * Run a raw SELECT query against the database
+     */
+    query(sql) {
+        try {
+            if (!sql.trim().toUpperCase().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 bundleCountRow = this.db.prepare('SELECT COUNT(*) as count FROM bundles').get();
+            const chunkCountRow = this.db.prepare('SELECT COUNT(*) as count FROM semantic_chunks').get();
+            const embeddingCountRow = this.db.prepare('SELECT COUNT(*) as count FROM vector_embeddings').get();
+            const sessionCountRow = this.db.prepare('SELECT COUNT(*) as count FROM agent_sessions').get();
+            const dbSize = statSync(this.dbPath).size;
+            return {
+                path: this.dbPath,
+                bundleCount: bundleCountRow.count,
+                chunkCount: chunkCountRow.count,
+                embeddingCount: embeddingCountRow.count,
+                sessionCount: sessionCountRow.count,
+                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,
+                level: row.complexity_score < 5 ? 'low' : row.complexity_score < 15 ? 'medium' : 'high'
+            },
+            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');
+            }
+        }
+    }
+}