cntx-ui 3.0.3 → 3.0.5

package/lib/bundle-manager.js

@@ -51,38 +51,87 @@ export default class BundleManager {
   }
 
   /**
-   * Generate Smart Bundle definitions from indexed semantic data
+   * Generate Smart Bundle definitions from indexed semantic data.
+   * Uses business domain, directory structure, and technical patterns
+   * instead of raw AST node types.
    */
   generateSmartBundleDefinitions() {
     const smartBundles = [];
+    const MIN_CHUNKS = 3; // Skip bundles with fewer than this many chunks
+
     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, '-')}`;
+      // 1. Group by business domain (from metadata JSON)
+      const allRows = this.db.db.prepare('SELECT metadata FROM semantic_chunks WHERE metadata IS NOT NULL').all();
+      const domainCounts = new Map();
+      for (const row of allRows) {
+        try {
+          const meta = JSON.parse(row.metadata);
+          for (const domain of (meta.businessDomain || [])) {
+            domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
+          }
+        } catch { /* skip malformed */ }
+      }
+      for (const [domain, count] of domainCounts) {
+        if (count < MIN_CHUNKS) continue;
         smartBundles.push({
-          name,
-          purpose: row.purpose,
-          fileCount: row.count,
+          name: `smart:${domain}`,
+          purpose: domain,
+          fileCount: count,
           type: 'smart',
-          description: `Automatically grouped by purpose: ${row.purpose}`
+          description: `${count} chunks in the ${domain} domain`
         });
-      });
+      }
 
-      // 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, '-')}`;
+      // 2. Group by directory structure (components, hooks, pages, api, etc.)
+      const dirRows = this.db.db.prepare(`
+        SELECT
+          CASE
+            WHEN file_path LIKE '%/hooks/%' THEN 'hooks'
+            WHEN file_path LIKE '%/components/%' THEN 'components'
+            WHEN file_path LIKE '%/api/%' OR file_path LIKE '%/services/%' THEN 'api-services'
+            WHEN file_path LIKE '%/pages/%' OR file_path LIKE '%/routes/%' THEN 'pages'
+            WHEN file_path LIKE '%/stores/%' OR file_path LIKE '%/store/%' THEN 'state'
+            WHEN file_path LIKE '%/lib/%' OR file_path LIKE '%/utils/%' THEN 'lib-utils'
+            WHEN file_path LIKE '%/types/%' THEN 'types'
+            ELSE NULL
+          END as dir_group,
+          COUNT(DISTINCT file_path) as file_cnt
+        FROM semantic_chunks
+        GROUP BY dir_group
+        HAVING dir_group IS NOT NULL
+      `).all();
+      for (const row of dirRows) {
+        if (row.file_cnt < 2) continue;
         smartBundles.push({
-          name,
-          purpose: row.subtype,
-          fileCount: row.count,
+          name: `smart:dir-${row.dir_group}`,
+          purpose: row.dir_group,
+          fileCount: row.file_cnt,
           type: 'smart',
-          description: `All ${row.subtype} elements across the codebase`
+          description: `${row.file_cnt} files in ${row.dir_group} directories`
         });
-      });
+      }
+
+      // 3. Group by technical pattern (react-hooks, async-io, event-driven)
+      const patternCounts = new Map();
+      for (const row of allRows) {
+        try {
+          const meta = JSON.parse(row.metadata);
+          for (const pattern of (meta.technicalPatterns || [])) {
+            if (pattern === 'public-api') continue; // Too generic
+            patternCounts.set(pattern, (patternCounts.get(pattern) || 0) + 1);
+          }
+        } catch { /* skip */ }
+      }
+      for (const [pattern, count] of patternCounts) {
+        if (count < MIN_CHUNKS) continue;
+        smartBundles.push({
+          name: `smart:pattern-${pattern}`,
+          purpose: pattern,
+          fileCount: count,
+          type: 'smart',
+          description: `${count} chunks using ${pattern} patterns`
+        });
+      }
     } catch (e) {
       if (this.verbose) console.warn('Smart bundle discovery failed:', e.message);
     }
@@ -113,15 +162,56 @@ export default class BundleManager {
     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);
+    if (query.startsWith('dir-')) {
+      // Directory-based bundle
+      const dirGroup = query.replace('dir-', '');
+      const dirPatterns = {
+        'hooks': '%/hooks/%',
+        'components': '%/components/%',
+        'api-services': null, // handled below
+        'pages': null,
+        'state': null,
+        'lib-utils': null,
+        'types': '%/types/%'
+      };
+      if (dirGroup === 'api-services') {
+        rows = this.db.db.prepare("SELECT DISTINCT file_path FROM semantic_chunks WHERE file_path LIKE '%/api/%' OR file_path LIKE '%/services/%'").all();
+      } else if (dirGroup === 'pages') {
+        rows = this.db.db.prepare("SELECT DISTINCT file_path FROM semantic_chunks WHERE file_path LIKE '%/pages/%' OR file_path LIKE '%/routes/%'").all();
+      } else if (dirGroup === 'state') {
+        rows = this.db.db.prepare("SELECT DISTINCT file_path FROM semantic_chunks WHERE file_path LIKE '%/stores/%' OR file_path LIKE '%/store/%'").all();
+      } else if (dirGroup === 'lib-utils') {
+        rows = this.db.db.prepare("SELECT DISTINCT file_path FROM semantic_chunks WHERE file_path LIKE '%/lib/%' OR file_path LIKE '%/utils/%'").all();
+      } else if (dirPatterns[dirGroup]) {
+        rows = this.db.db.prepare('SELECT DISTINCT file_path FROM semantic_chunks WHERE file_path LIKE ?').all(dirPatterns[dirGroup]);
+      }
+    } else if (query.startsWith('pattern-')) {
+      // Technical pattern bundle — search metadata JSON
+      const pattern = query.replace('pattern-', '');
+      const allRows = this.db.db.prepare('SELECT DISTINCT file_path, metadata FROM semantic_chunks WHERE metadata IS NOT NULL').all();
+      const files = new Set();
+      for (const row of allRows) {
+        try {
+          const meta = JSON.parse(row.metadata);
+          if ((meta.technicalPatterns || []).includes(pattern)) {
+            files.add(row.file_path);
+          }
+        } catch { /* skip */ }
+      }
+      return Array.from(files);
     } 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);
+      // Business domain bundle — search metadata JSON
+      const allRows = this.db.db.prepare('SELECT DISTINCT file_path, metadata FROM semantic_chunks WHERE metadata IS NOT NULL').all();
+      const files = new Set();
+      for (const row of allRows) {
+        try {
+          const meta = JSON.parse(row.metadata);
+          if ((meta.businessDomain || []).includes(query)) {
+            files.add(row.file_path);
+          }
+        } catch { /* skip */ }
       }
+      return Array.from(files);
     }
     return rows.map(r => r.file_path);
   }

package/lib/heuristics-manager.js

@@ -127,7 +127,7 @@ export default class HeuristicsManager {
     const domains = new Set();
     const name = func.name.toLowerCase();
     const path = (func.pathParts || []).join('/').toLowerCase();
-    const imports = func.includes?.imports || [];
+    const imports = (func.includes?.imports || []).filter(i => typeof i === 'string');
 
     // Path-based domains
     if (path.includes('auth')) domains.add('authentication');
@@ -330,7 +330,9 @@ export default class HeuristicsManager {
     if (condition.includes('chunk.imports.includes(')) {
       const importMatch = condition.match(/chunk\.imports\.includes\(['"]([^'"]+)['"]\)/)
       if (importMatch && func.includes?.imports) {
-        return func.includes.imports.some(imp => imp.includes(importMatch[1]))
+        return func.includes.imports
+          .filter(i => typeof i === 'string')
+          .some(imp => imp.includes(importMatch[1]))
       }
     }
 

package/lib/semantic-splitter.js

@@ -6,7 +6,6 @@
 
 import { readFileSync, existsSync } from 'fs'
 import { join, extname } from 'path'
-import glob from 'glob'
 import Parser from 'tree-sitter'
 import JavaScript from 'tree-sitter-javascript'
 import TypeScript from 'tree-sitter-typescript'
@@ -45,18 +44,14 @@ export default class SemanticSplitter {
 
   /**
    * Main entry point - extract semantic chunks from project
+   * Now accepts a pre-filtered list of files from FileSystemManager
    */
-  async extractSemanticChunks(projectPath, patterns = ['**/*.{js,jsx,ts,tsx,mjs}'], bundleConfig = null) {
-    console.log('🔪 Starting surgical semantic splitting via tree-sitter...');
-    console.log(`📂 Project path: ${projectPath}`);
-    console.log(`📋 Patterns: ${patterns}`);
+  async extractSemanticChunks(projectPath, files = [], bundleConfig = null) {
+    console.log('🔪 Starting surgical semantic splitting via tree-sitter...')
+    console.log(`📂 Project path: ${projectPath}`)
     
-    this.bundleConfig = bundleConfig;
-    const files = this.findFiles(projectPath, patterns);
-    console.log(`📁 Found ${files.length} files to split`);
-    if (files.length > 0) {
-      console.log('📄 Sample files:', files.slice(0, 5));
-    }
+    this.bundleConfig = bundleConfig
+    console.log(`📁 Processing ${files.length} filtered files`)
     
     const allChunks = []
     
@@ -74,48 +69,32 @@ export default class SemanticSplitter {
       summary: {
         totalFiles: files.length,
         totalChunks: allChunks.length,
-        averageSize: allChunks.reduce((sum, c) => sum + c.code.length, 0) / allChunks.length
+        averageSize: allChunks.length > 0 ? allChunks.reduce((sum, c) => sum + c.code.length, 0) / allChunks.length : 0
       },
       chunks: allChunks
     }
   }
 
-  findFiles(projectPath, patterns) {
-    const files = []
-    for (const pattern of patterns) {
-      const matches = glob.sync(pattern, {
-        cwd: projectPath,
-        ignore: ['node_modules/**', 'dist/**', '.git/**', '*.test.*', '*.spec.*']
-      })
-      files.push(...matches)
-    }
-    return [...new Set(files)]
-  }
-
   processFile(relativePath, projectPath) {
-    const fullPath = join(projectPath, relativePath);
-    if (!existsSync(fullPath)) return [];
+    const fullPath = join(projectPath, relativePath)
+    if (!existsSync(fullPath)) return []
     
-    // console.log(`  📄 Processing: ${relativePath}`);
-    const content = readFileSync(fullPath, 'utf8');
-    const parser = this.getParser(relativePath);
-    const tree = parser.parse(content);
-    const root = tree.rootNode;
+    const content = readFileSync(fullPath, 'utf8')
+    const parser = this.getParser(relativePath)
+    const tree = parser.parse(content)
+    const root = tree.rootNode
     
     const elements = {
       functions: [],
       types: [],
       imports: this.extractImports(root, content, relativePath)
-    };
+    }
 
     // Traverse AST for functions and types
-    this.traverse(root, content, relativePath, elements);
+    this.traverse(root, content, relativePath, elements)
 
-    const chunks = this.createChunks(elements, content, relativePath);
-    // if (chunks.length > 0) {
-    //   console.log(`    ✅ Found ${chunks.length} chunks in ${relativePath}`);
-    // }
-    return chunks;
+    // Create chunks from elements
+    return this.createChunks(elements, content, relativePath)
   }
 
   traverse(node, content, filePath, elements) {
@@ -235,10 +214,6 @@ export default class SemanticSplitter {
       const technicalPatterns = this.heuristicsManager.inferTechnicalPatterns(heuristicContext);
       const tags = this.generateTags(func);
 
-      // if (businessDomain.length > 0) {
-      //   console.log(`  💎 ${func.name}: Domains: [${businessDomain}], Patterns: [${technicalPatterns}]`);
-      // }
-
       let chunkCode = '';
       if (this.options.includeContext) {
         const relevantImports = elements.imports

package/lib/simple-vector-store.js

@@ -54,20 +54,30 @@ export default class SimpleVectorStore {
     const queryEmbedding = await this.generateEmbedding(query);
     
     // Load all embeddings from DB
-    // Optimization: In a huge codebase, we'd use a real vector DB or FAISS
-    // For now, SQLite + Manual Cosine Similarity is fine for local repos
     const rows = this.db.db.prepare('SELECT chunk_id, embedding FROM vector_embeddings WHERE model_name = ?').all(this.modelName);
     
     const results = [];
-    for (const row of rows) {
-      const embedding = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
-      const similarity = this.cosineSimilarity(queryEmbedding, embedding);
+    const batchSize = 100;
+    
+    // Process in batches to prevent blocking the event loop
+    for (let i = 0; i < rows.length; i += batchSize) {
+      const batch = rows.slice(i, i + batchSize);
+      
+      for (const row of batch) {
+        const embedding = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+        const similarity = this.cosineSimilarity(queryEmbedding, embedding);
+        
+        if (similarity >= threshold) {
+          results.push({
+            chunkId: row.chunk_id,
+            similarity
+          });
+        }
+      }
       
-      if (similarity >= threshold) {
-        results.push({
-          chunkId: row.chunk_id,
-          similarity
-        });
+      // Give other tasks a chance to run
+      if (i + batchSize < rows.length) {
+        await new Promise(resolve => setImmediate(resolve));
       }
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cntx-ui",
   "type": "module",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "description": "Autonomous Repository Intelligence engine with web UI and MCP server. Unified semantic code understanding, local RAG, and agent working memory.",
   "keywords": [
     "repository-intelligence",

package/server.js

@@ -4,7 +4,7 @@
  */
 
 import { createServer } from 'http';
-import { join, dirname } from 'path';
+import { join, dirname, relative, extname } from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, cpSync } from 'fs';
 import * as fs from 'fs';
@@ -435,13 +435,17 @@ export class CntxServer {
 
     // 2. Perform fresh analysis if DB is empty
     try {
-      const patterns = ['**/*.{js,jsx,ts,tsx,mjs}'];
+      const supportedExtensions = ['.js', '.jsx', '.ts', '.tsx', '.mjs'];
+      const files = this.fileSystemManager.getAllFiles()
+        .filter(f => supportedExtensions.includes(extname(f).toLowerCase()))
+        .map(f => relative(this.CWD, f));
+      
       let bundleConfig = null;
       if (existsSync(this.configManager.CONFIG_FILE)) {
         bundleConfig = JSON.parse(readFileSync(this.configManager.CONFIG_FILE, 'utf8'));
       }
 
-      this.semanticCache = await this.semanticSplitter.extractSemanticChunks(this.CWD, patterns, bundleConfig);
+      this.semanticCache = await this.semanticSplitter.extractSemanticChunks(this.CWD, files, bundleConfig);
       this.lastSemanticAnalysis = Date.now();
 
       // 3. Persist chunks to SQLite immediately