cntx-ui 3.1.3 → 3.1.6

package/dist/bin/cntx-ui.js

@@ -14,7 +14,12 @@ const command = args[0] || 'help';
 const isVerbose = args.includes('--verbose');
 // Graceful shutdown
 process.on('SIGINT', () => {
-    console.log('\n👋 Shutting down cntx-ui...');
+    if (command === 'mcp') {
+        process.stderr.write('\n👋 Shutting down cntx-ui...\n');
+    }
+    else {
+        console.log('\n👋 Shutting down cntx-ui...');
+    }
     process.exit(0);
 });
 async function main() {
@@ -32,7 +37,7 @@ async function main() {
                 await initConfig();
                 break;
             case 'mcp':
-                await startServer({ withMcp: true, skipFileWatcher: true });
+                await startServer({ withMcp: true, skipFileWatcher: true, isMcp: true });
                 break;
             case 'bundle':
                 const bundleName = args[1] || 'master';

package/dist/lib/api-router.js

@@ -81,6 +81,9 @@ export default class APIRouter {
             if (pathname === '/api/vector-db/search' && method === 'POST') {
                 return await this.handlePostVectorDbSearch(req, res);
             }
+            if (pathname === '/api/vector-db/projection' && method === 'GET') {
+                return await this.handleGetVectorDbProjection(req, res);
+            }
             if (pathname === '/api/vector-db/network' && method === 'GET') {
                 return await this.handleGetVectorDbNetwork(req, res);
             }
@@ -283,8 +286,12 @@ export default class APIRouter {
     }
     async handlePostSemanticSearch(req, res) {
         const body = await this.getRequestBody(req);
-        const { query, limit = 20 } = JSON.parse(body);
-        const results = await this.vectorStore.search(query, { limit });
+        const { query, question, limit = 20 } = JSON.parse(body);
+        const searchTerm = query || question;
+        if (!searchTerm) {
+            return this.sendError(res, 400, 'Missing search term (query or question)');
+        }
+        const results = await this.vectorStore.search(searchTerm, { limit });
         this.sendResponse(res, 200, { results });
     }
     async handleGetVectorDbStatus(req, res) {
@@ -311,6 +318,103 @@ export default class APIRouter {
         const results = await this.vectorStore.search(query, { limit });
         this.sendResponse(res, 200, results);
     }
+    async handleGetVectorDbProjection(req, res) {
+        const dbManager = this.configManager.dbManager;
+        const embeddingCountRow = dbManager.db.prepare('SELECT COUNT(*) as count FROM vector_embeddings').get();
+        const currentEmbeddingCount = embeddingCountRow.count;
+        if (currentEmbeddingCount === 0) {
+            return this.sendResponse(res, 200, {
+                points: [],
+                meta: { totalPoints: 0, embeddingCount: 0, computedAt: null, cached: false }
+            });
+        }
+        // Check cache freshness
+        const cachedCount = dbManager.getProjectionEmbeddingCount();
+        if (cachedCount === currentEmbeddingCount) {
+            const cached = dbManager.getProjections();
+            if (cached) {
+                // Join with chunk metadata
+                const chunkMap = new Map();
+                const chunks = dbManager.db.prepare('SELECT * FROM semantic_chunks').all();
+                for (const c of chunks) {
+                    const mapped = dbManager.mapChunkRow(c);
+                    chunkMap.set(mapped.id, mapped);
+                }
+                const points = cached.map(p => {
+                    const chunk = chunkMap.get(p.chunkId);
+                    return {
+                        id: p.chunkId,
+                        x: p.x,
+                        y: p.y,
+                        name: chunk?.name || 'unknown',
+                        filePath: chunk?.filePath || '',
+                        purpose: chunk?.purpose || 'unknown',
+                        semanticType: chunk?.subtype || chunk?.type || 'unknown',
+                        complexity: chunk?.complexity?.score || 0,
+                        directory: chunk?.filePath ? chunk.filePath.split('/').slice(0, -1).join('/') || '.' : '.'
+                    };
+                });
+                return this.sendResponse(res, 200, {
+                    points,
+                    meta: { totalPoints: points.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: true }
+                });
+            }
+        }
+        // Compute fresh UMAP projection
+        const rows = dbManager.db.prepare(`
+      SELECT ve.chunk_id, ve.embedding, sc.name, sc.file_path, sc.type, sc.subtype, sc.complexity_score, sc.purpose
+      FROM vector_embeddings ve
+      JOIN semantic_chunks sc ON ve.chunk_id = sc.id
+    `).all();
+        if (rows.length < 2) {
+            return this.sendResponse(res, 200, {
+                points: rows.map((r) => ({
+                    id: r.chunk_id, x: 0, y: 0,
+                    name: r.name, filePath: r.file_path, purpose: r.purpose || 'unknown',
+                    semanticType: r.subtype || r.type || 'unknown', complexity: r.complexity_score || 0,
+                    directory: r.file_path ? r.file_path.split('/').slice(0, -1).join('/') || '.' : '.'
+                })),
+                meta: { totalPoints: rows.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: false }
+            });
+        }
+        // Extract embeddings as number[][]
+        const embeddings = rows.map((r) => {
+            const buf = r.embedding;
+            const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+            return Array.from(floats);
+        });
+        // Run UMAP
+        const { UMAP } = await import('umap-js');
+        const umap = new UMAP({
+            nNeighbors: Math.min(15, rows.length - 1),
+            minDist: 0.1,
+            nComponents: 2
+        });
+        const projected = umap.fit(embeddings);
+        // Save to cache
+        const projections = rows.map((r, i) => ({
+            chunkId: r.chunk_id,
+            x: projected[i][0],
+            y: projected[i][1]
+        }));
+        dbManager.saveProjections(projections, currentEmbeddingCount);
+        // Build response
+        const points = rows.map((r, i) => ({
+            id: r.chunk_id,
+            x: projected[i][0],
+            y: projected[i][1],
+            name: r.name,
+            filePath: r.file_path,
+            purpose: r.purpose || 'unknown',
+            semanticType: r.subtype || r.type || 'unknown',
+            complexity: r.complexity_score || 0,
+            directory: r.file_path ? r.file_path.split('/').slice(0, -1).join('/') || '.' : '.'
+        }));
+        this.sendResponse(res, 200, {
+            points,
+            meta: { totalPoints: points.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: false }
+        });
+    }
     async handleGetVectorDbNetwork(req, res) {
         const chunks = this.configManager.dbManager.db.prepare('SELECT * FROM semantic_chunks').all();
         const embeddings = this.configManager.dbManager.db.prepare('SELECT * FROM vector_embeddings').all();

package/dist/lib/database-manager.js

@@ -79,6 +79,16 @@ export default class DatabaseManager {
         FOREIGN KEY(session_id) REFERENCES agent_sessions(id) ON DELETE CASCADE
       );
       
+      -- UMAP Projection Cache
+      CREATE TABLE IF NOT EXISTS umap_projections (
+        chunk_id TEXT PRIMARY KEY,
+        x REAL NOT NULL,
+        y REAL NOT NULL,
+        computed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        embedding_count INTEGER NOT NULL,
+        FOREIGN KEY(chunk_id) REFERENCES semantic_chunks(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);
@@ -265,6 +275,44 @@ export default class DatabaseManager {
             return [];
         }
     }
+    // UMAP Projection Cache
+    saveProjections(projections, embeddingCount) {
+        const transaction = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM umap_projections').run();
+            const stmt = this.db.prepare('INSERT INTO umap_projections (chunk_id, x, y, embedding_count) VALUES (?, ?, ?, ?)');
+            for (const p of projections) {
+                stmt.run(p.chunkId, p.x, p.y, embeddingCount);
+            }
+        });
+        try {
+            transaction();
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to save projections:', error.message);
+            return false;
+        }
+    }
+    getProjections() {
+        try {
+            const rows = this.db.prepare('SELECT chunk_id, x, y, embedding_count FROM umap_projections').all();
+            if (rows.length === 0)
+                return null;
+            return rows.map(r => ({ chunkId: r.chunk_id, x: r.x, y: r.y, embeddingCount: r.embedding_count }));
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getProjectionEmbeddingCount() {
+        try {
+            const row = this.db.prepare('SELECT embedding_count FROM umap_projections LIMIT 1').get();
+            return row?.embedding_count ?? 0;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
     // Close database connection
     close() {
         if (this.db) {

package/dist/lib/mcp-server.js

@@ -6,8 +6,10 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 export class MCPServer {
     cntxServer;
-    constructor(cntxServer) {
+    version;
+    constructor(cntxServer, version = '3.0.0') {
         this.cntxServer = cntxServer;
+        this.version = version;
         // Listen for MCP requests on stdin
         process.stdin.on('data', (data) => {
             this.handleInput(data.toString());
@@ -36,7 +38,7 @@ export class MCPServer {
                         resources: {},
                         prompts: {}
                     },
-                    serverInfo: { name: 'cntx-ui', version: '3.0.0' }
+                    serverInfo: { name: 'cntx-ui', version: this.version }
                 }));
             case 'tools/list':
                 return this.sendResponse(this.handleListTools(id));

package/dist/lib/semantic-splitter.js

@@ -28,6 +28,7 @@ export default class SemanticSplitter {
             includeContext: true, // Include imports/types needed
             minFunctionSize: 40, // Skip tiny functions
             minStructureSize: 20, // Skip tiny structures
+            verbose: options.verbose || false,
             ...options
         };
         // Initialize tree-sitter parsers
@@ -88,7 +89,10 @@ export default class SemanticSplitter {
                 allChunks.push(...fileChunks);
             }
             catch (error) {
-                console.warn(`Failed to process ${filePath}: ${error.message}`);
+                console.warn(`⚠️ Failed to process ${filePath}: ${error.message}`);
+                if (this.options.verbose) {
+                    console.error(error.stack);
+                }
             }
         }
         console.log(`🧩 Created ${allChunks.length} semantic chunks across project`);
@@ -112,39 +116,48 @@ export default class SemanticSplitter {
             return [];
         }
         const parser = this.getParser(relativePath);
-        const tree = parser.parse(content);
-        const root = tree.rootNode;
-        const ext = extname(relativePath).toLowerCase();
-        const elements = {
-            functions: [],
-            types: [],
-            imports: []
-        };
-        if (['.js', '.jsx', '.ts', '.tsx', '.rs'].includes(ext)) {
-            elements.imports = this.extractImports(root, content, relativePath);
-            // Traverse AST for functions and types
-            this.traverse(root, content, relativePath, elements);
-        }
-        else if (ext === '.json') {
-            this.extractJsonStructures(root, content, relativePath, elements);
-        }
-        else if (ext === '.css' || ext === '.scss') {
-            this.extractCssStructures(root, content, relativePath, elements);
-        }
-        else if (ext === '.html') {
-            this.extractHtmlStructures(root, content, relativePath, elements);
-        }
-        else if (ext === '.sql') {
-            this.extractSqlStructures(root, content, relativePath, elements);
-        }
-        else if (ext === '.md') {
-            this.extractMarkdownStructures(root, content, relativePath, elements);
+        try {
+            const tree = parser.parse(content);
+            const root = tree.rootNode;
+            const ext = extname(relativePath).toLowerCase();
+            const elements = {
+                functions: [],
+                types: [],
+                imports: []
+            };
+            if (['.js', '.jsx', '.ts', '.tsx', '.rs'].includes(ext)) {
+                elements.imports = this.extractImports(root, content, relativePath);
+                // Traverse AST for functions and types
+                this.traverse(root, content, relativePath, elements);
+            }
+            else if (ext === '.json') {
+                this.extractJsonStructures(root, content, relativePath, elements);
+            }
+            else if (ext === '.css' || ext === '.scss') {
+                this.extractCssStructures(root, content, relativePath, elements);
+            }
+            else if (ext === '.html') {
+                this.extractHtmlStructures(root, content, relativePath, elements);
+            }
+            else if (ext === '.sql') {
+                this.extractSqlStructures(root, content, relativePath, elements);
+            }
+            else if (ext === '.md') {
+                this.extractMarkdownStructures(root, content, relativePath, elements);
+            }
+            else if (ext === '.toml') {
+                this.extractTomlStructures(root, content, relativePath, elements);
+            }
+            // Create chunks from elements
+            return this.createChunks(elements, content, relativePath);
         }
-        else if (ext === '.toml') {
-            this.extractTomlStructures(root, content, relativePath, elements);
+        catch (error) {
+            console.warn(`⚠️ Parser failed for ${relativePath}: ${error.message}`);
+            if (this.options.verbose) {
+                console.error(error.stack);
+            }
+            return [];
         }
-        // Create chunks from elements
-        return this.createChunks(elements, content, relativePath);
     }
     traverse(node, content, filePath, elements) {
         // Detect Function Declarations (JS/TS)

package/dist/lib/simple-vector-store.js

@@ -9,19 +9,29 @@ export default class SimpleVectorStore {
     modelName;
     pipe;
     initialized;
+    isMcp;
     constructor(databaseManager, options = {}) {
         this.db = databaseManager;
         this.modelName = options.modelName || 'Xenova/all-MiniLM-L6-v2';
         this.pipe = null;
         this.initialized = false;
+        this.isMcp = options.isMcp || false;
+    }
+    log(message) {
+        if (this.isMcp) {
+            process.stderr.write(message + '\n');
+        }
+        else {
+            console.log(message);
+        }
     }
     async init() {
         if (this.initialized)
             return;
-        console.log(`🤖 Initializing local RAG engine (${this.modelName})...`);
+        this.log(`🤖 Initializing local RAG engine (${this.modelName})...`);
         this.pipe = await pipeline('feature-extraction', this.modelName);
         this.initialized = true;
-        console.log('✅ Local RAG engine ready');
+        this.log('✅ Local RAG engine ready');
     }
     async generateEmbedding(text) {
         await this.init();

package/dist/server.js

@@ -38,7 +38,9 @@ function getProjectName(cwd) {
 export class CntxServer {
     CWD;
     CNTX_DIR;
+    version;
     verbose;
+    isMcp;
     mcpServerStarted;
     mcpServer;
     initMessages;
@@ -61,9 +63,24 @@ export class CntxServer {
         this.CWD = cwd;
         this.CNTX_DIR = join(cwd, '.cntx');
         this.verbose = options.verbose || false;
+        this.isMcp = options.isMcp || false;
         this.mcpServerStarted = false;
         this.mcpServer = null;
         this.initMessages = [];
+        // Read package version
+        try {
+            let pkgDir = __dirname;
+            let pkgPath = join(pkgDir, 'package.json');
+            if (!existsSync(pkgPath)) {
+                pkgDir = join(__dirname, '..');
+                pkgPath = join(pkgDir, 'package.json');
+            }
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            this.version = pkg.version;
+        }
+        catch {
+            this.version = '3.1.5';
+        }
         // Ensure directory exists
         if (!existsSync(this.CNTX_DIR))
             mkdirSync(this.CNTX_DIR, { recursive: true });
@@ -78,10 +95,12 @@ export class CntxServer {
         this.semanticSplitter = new SemanticSplitter({
             maxChunkSize: 2000,
             includeContext: true,
-            minFunctionSize: 50
+            minFunctionSize: 50,
+            verbose: this.verbose
         });
         this.vectorStore = new SimpleVectorStore(this.databaseManager, {
-            modelName: 'Xenova/all-MiniLM-L6-v2'
+            modelName: 'Xenova/all-MiniLM-L6-v2',
+            isMcp: this.isMcp
         });
         this.semanticCache = null;
         this.lastSemanticAnalysis = null;
@@ -96,6 +115,14 @@ export class CntxServer {
         this.bundleManager.fileSystemManager = this.fileSystemManager;
         this.bundleManager.webSocketManager = this.webSocketManager;
     }
+    log(message) {
+        if (this.isMcp) {
+            process.stderr.write(message + '\n');
+        }
+        else {
+            console.log(message);
+        }
+    }
     async init(options = {}) {
         const { skipFileWatcher = false, skipBundleGeneration = false } = options;
         // Load configs
@@ -190,11 +217,15 @@ export class CntxServer {
     }
     startMCPServer() {
         if (!this.mcpServer) {
-            this.mcpServer = new MCPServer(this);
+            this.mcpServer = new MCPServer(this, this.version);
             this.mcpServerStarted = true;
         }
     }
     async listen(port = 3333, host = 'localhost') {
+        if (this.isMcp) {
+            this.log('Mode: MCP (stdio) - Skipping HTTP server start');
+            return null;
+        }
         const server = createServer((req, res) => {
             const url = parse(req.url || '/', true);
             // Serve static files from web/dist
@@ -207,7 +238,7 @@ export class CntxServer {
         this.webSocketManager.initialize(server);
         return new Promise((resolve) => {
             server.listen(port, host, () => {
-                console.log(`🚀 cntx-ui server running at http://${host}:${port}`);
+                this.log(`🚀 cntx-ui server running at http://${host}:${port}`);
                 resolve(server);
             });
         });
@@ -264,7 +295,7 @@ export async function initConfig(cwd = process.cwd()) {
     // 1. Initialize directory structure
     if (!existsSync(server.CNTX_DIR)) {
         mkdirSync(server.CNTX_DIR, { recursive: true });
-        console.log('📁 Created .cntx directory');
+        server.log('📁 Created .cntx directory');
     }
     // 2. Create .mcp.json for Claude Code discovery
     const mcpConfigPath = join(cwd, '.mcp.json');
@@ -278,7 +309,7 @@ export async function initConfig(cwd = process.cwd()) {
         }
     };
     writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf8');
-    console.log('📄 Created .mcp.json for agent auto-discovery');
+    server.log('📄 Created .mcp.json for agent auto-discovery');
     // 3. Initialize basic configuration with better defaults and auto-suggestions
     server.configManager.loadConfig();
     const suggestedBundles = {
@@ -296,7 +327,7 @@ export async function initConfig(cwd = process.cwd()) {
     commonDirs.forEach(d => {
         if (existsSync(join(cwd, d.dir))) {
             suggestedBundles[d.name] = [`${d.dir}/**`];
-            console.log(`💡 Suggested bundle: ${d.name} (${d.dir}/**)`);
+            server.log(`💡 Suggested bundle: ${d.name} (${d.dir}/**)`);
         }
     });
     server.configManager.saveConfig({
@@ -330,9 +361,9 @@ export async function initConfig(cwd = process.cwd()) {
 .mcp.json
 `;
         writeFileSync(ignorePath, defaultIgnore, 'utf8');
-        console.log('📄 Created .cntxignore with smart defaults');
+        server.log('📄 Created .cntxignore with smart defaults');
     }
-    console.log('⚙️ Basic configuration initialized');
+    server.log('⚙️ Basic configuration initialized');
     let templateDir = join(__dirname, 'templates');
     if (!existsSync(templateDir)) {
         // Fallback for dist/ context
@@ -356,7 +387,7 @@ export async function initConfig(cwd = process.cwd()) {
             else {
                 copyFileSync(sourcePath, destPath);
             }
-            console.log(`📄 Created ${file}`);
+            server.log(`📄 Created ${file}`);
         }
     }
     // Copy agent-rules directory structure
@@ -364,7 +395,7 @@ export async function initConfig(cwd = process.cwd()) {
     const agentRulesDest = join(server.CNTX_DIR, 'agent-rules');
     if (existsSync(agentRulesSource) && !existsSync(agentRulesDest)) {
         cpSync(agentRulesSource, agentRulesDest, { recursive: true });
-        console.log('📁 Created agent-rules directory with templates');
+        server.log('📁 Created agent-rules directory with templates');
     }
     return server.initMessages;
 }
@@ -387,13 +418,13 @@ export async function getStatus() {
         }
         return bundle;
     }));
-    console.log('📊 cntx-ui Status');
-    console.log('================');
-    console.log(`Total files: ${totalFiles}`);
-    console.log(`Bundles: ${bundlesWithCounts.length}`);
+    server.log('📊 cntx-ui Status');
+    server.log('================');
+    server.log(`Total files: ${totalFiles}`);
+    server.log(`Bundles: ${bundlesWithCounts.length}`);
     bundlesWithCounts.forEach(bundle => {
         const sizeStr = bundle.size > 0 ? ` (${Math.round(bundle.size / 1024)}KB)` : '';
-        console.log(`  • ${bundle.name}: ${bundle.fileCount} files${sizeStr}`);
+        server.log(`  • ${bundle.name}: ${bundle.fileCount} files${sizeStr}`);
     });
     return {
         totalFiles,
@@ -404,9 +435,10 @@ export async function getStatus() {
 export function setupMCP() {
     const configPath = join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
     const projectPath = process.cwd();
-    console.log('🔧 Setting up MCP integration...');
-    console.log(`Project: ${projectPath}`);
-    console.log(`Claude config: ${configPath}`);
+    const server = new CntxServer(projectPath);
+    server.log('🔧 Setting up MCP integration...');
+    server.log(`Project: ${projectPath}`);
+    server.log(`Claude config: ${configPath}`);
     try {
         let config = {};
         if (existsSync(configPath)) {
@@ -423,19 +455,19 @@ export function setupMCP() {
         // Ensure directory exists
         mkdirSync(dirname(configPath), { recursive: true });
         writeFileSync(configPath, JSON.stringify(config, null, 2));
-        console.log('✅ MCP integration configured');
-        console.log('💡 Restart Claude Desktop to apply changes');
+        server.log('✅ MCP integration configured');
+        server.log('💡 Restart Claude Desktop to apply changes');
     }
     catch (error) {
         console.error('❌ Failed to setup MCP:', error.message);
-        console.log('💡 You may need to manually add the configuration to Claude Desktop');
+        server.log('💡 You may need to manually add the configuration to Claude Desktop');
     }
 }
 // Auto-start server when run directly
 const isMainModule = import.meta.url === `file://${process.argv[1]}`;
 if (isMainModule) {
-    console.log('🚀 Starting cntx-ui server...');
     const server = new CntxServer();
+    server.log('🚀 Starting cntx-ui server...');
     server.init();
     server.listen(3333, 'localhost');
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cntx-ui",
   "type": "module",
-  "version": "3.1.3",
+  "version": "3.1.6",
   "description": "Autonomous Repository Intelligence engine with web UI and MCP server. Unified semantic code understanding, local RAG, and agent working memory.",
   "keywords": [
     "repository-intelligence",
@@ -59,6 +59,7 @@
     "tree-sitter-sql": "^0.1.0",
     "tree-sitter-toml": "^0.5.1",
     "tree-sitter-typescript": "^0.23.2",
+    "umap-js": "^1.4.0",
     "ws": "^8.13.0"
   },
   "devDependencies": {