cntx-ui 2.0.15 → 3.0.1

package/lib/heuristics-manager.js

@@ -102,18 +102,66 @@ export default class HeuristicsManager {
    * Determine function purpose using configured heuristics
    */
   determinePurpose(func) {
-    const config = this.getConfig()
-    const name = func.name.toLowerCase()
+    const config = this.getConfig();
+    const name = func.name.toLowerCase();
+    const pathParts = func.pathParts || [];
     
+    // console.log(`🔍 Determining purpose for: ${func.name} in ${pathParts.join('/')}`);
+
     // Check each purpose pattern
     for (const [patternName, pattern] of Object.entries(config.purposeHeuristics.patterns)) {
-      if (this.evaluateConditions(pattern.conditions, { func, name })) {
-        return pattern.purpose
+      if (this.evaluateConditions(pattern.conditions, { func, name, pathParts })) {
+        // console.log(`  ✅ Matched pattern: ${patternName} -> ${pattern.purpose}`);
+        return pattern.purpose;
       }
     }
     
     // Return fallback
-    return config.purposeHeuristics.fallback.purpose
+    return config.purposeHeuristics.fallback.purpose;
+  }
+
+  /**
+   * Infer business domains (e.g. auth, editing, file-mgmt)
+   */
+  inferBusinessDomains(func) {
+    const domains = new Set();
+    const name = func.name.toLowerCase();
+    const path = (func.pathParts || []).join('/').toLowerCase();
+    const imports = func.includes?.imports || [];
+
+    // Path-based domains
+    if (path.includes('auth')) domains.add('authentication');
+    if (path.includes('component') || path.includes('ui')) domains.add('ui-layer');
+    if (path.includes('service') || path.includes('api')) domains.add('api-integration');
+    if (path.includes('test') || path.includes('spec')) domains.add('testing');
+
+    // Import-based domains
+    if (imports.some(i => i.includes('tauri'))) domains.add('desktop-runtime');
+    if (imports.some(i => i.includes('tiptap') || i.includes('prosemirror'))) domains.add('text-editing');
+    if (imports.some(i => i.includes('react'))) domains.add('frontend-ui');
+
+    // Name-based domains
+    if (/file|save|export|read|write/i.test(name)) domains.add('file-management');
+    if (/login|user|session/i.test(name)) domains.add('authentication');
+
+    return Array.from(domains);
+  }
+
+  /**
+   * Infer technical patterns (e.g. hooks, async-io, event-handlers)
+   */
+  inferTechnicalPatterns(func) {
+    const patterns = new Set();
+    const name = func.name.toLowerCase();
+    const code = func.code || '';
+
+    if (name.startsWith('use')) patterns.add('react-hooks');
+    if (code.includes('async') || code.includes('await')) patterns.add('async-io');
+    if (code.includes('on(') || code.includes('addListener') || name.startsWith('handle')) patterns.add('event-driven');
+    if (code.includes('new ') || code.includes('class ')) patterns.add('object-oriented');
+    if (func.isExported) patterns.add('public-api');
+
+    return Array.from(patterns);
   }
 
   /**
@@ -179,9 +227,9 @@ export default class HeuristicsManager {
       conditions = [conditions]
     }
     
-    // For React hook pattern, we need AND logic (all conditions must be true)
-    // For other patterns, we use OR logic (any condition can be true)
-    const needsAndLogic = this.requiresAndLogic(conditions)
+    // For purpose heuristics, we generally want high precision, so use AND logic 
+    // if there are multiple conditions
+    const needsAndLogic = conditions.length > 1 || this.requiresAndLogic(conditions)
     
     if (needsAndLogic) {
       return conditions.every(condition => {
@@ -277,6 +325,22 @@ export default class HeuristicsManager {
         return pathParts.includes(includesMatch[1])
       }
     }
+
+    // New: Check imports in the chunk context
+    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]))
+      }
+    }
+
+    // New: Check for specific naming patterns (case-insensitive)
+    if (condition.includes('name.matches(')) {
+      const regexMatch = condition.match(/name\.matches\(['"]([^'"]+)['"]\)/)
+      if (regexMatch && name) {
+        return new RegExp(regexMatch[1], 'i').test(name)
+      }
+    }
     
     return false
   }
@@ -299,6 +363,36 @@ export default class HeuristicsManager {
             purpose: "React hook",
             confidence: 0.9
           },
+          serviceLayer: {
+            conditions: ["pathParts.includes('services')"],
+            purpose: "Service layer logic",
+            confidence: 0.7
+          },
+          componentLayer: {
+            conditions: ["pathParts.includes('components')"],
+            purpose: "UI component logic",
+            confidence: 0.7
+          },
+          tauriCommand: {
+            conditions: ["name.matches('command')", "chunk.imports.includes('tauri')"],
+            purpose: "Tauri backend command",
+            confidence: 0.9
+          },
+          textEditing: {
+            conditions: ["chunk.imports.includes('tiptap')", "chunk.imports.includes('prosemirror')"],
+            purpose: "Rich text editing logic",
+            confidence: 0.95
+          },
+          fileManagement: {
+            conditions: ["pathParts.includes('services')", "name.matches('file|export|save')"],
+            purpose: "File system service",
+            confidence: 0.85
+          },
+          uiComponent: {
+            conditions: ["pathParts.includes('components')", "name.matches('modal|button|menu|bar')"],
+            purpose: "UI component logic",
+            confidence: 0.85
+          },
           apiHandler: {
             conditions: ["name.includes('api')", "name.includes('endpoint')"],
             purpose: "API handler",
@@ -398,17 +492,25 @@ export default class HeuristicsManager {
   }
 
   /**
-   * Update configuration (for API endpoints)
+   * Update configuration (for API endpoints) and persist to disk
    */
   async updateConfig(newConfig) {
-    this.validateConfig(newConfig)
-    
-    // TODO: Implement file writing when API endpoints are created
-    // For now, just update in-memory config
-    this.config = newConfig
-    this.cache.clear()
-    
-    return true
+    try {
+      this.validateConfig(newConfig)
+      
+      // Write to disk
+      writeFileSync(this.configPath, JSON.stringify(newConfig, null, 2), 'utf8')
+      
+      this.config = newConfig
+      this.cache.clear()
+      this.lastLoaded = Date.now()
+      
+      console.log('📝 Heuristics configuration updated and saved to disk')
+      return true
+    } catch (error) {
+      console.error('❌ Failed to update heuristics config:', error.message)
+      throw error
+    }
   }
 
   /**

package/lib/mcp-server.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join, relative } from 'path';
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, copyFileSync } from 'fs';
+import { join, relative, dirname } from 'path';
+import fs from 'fs';
 import AgentRuntime from './agent-runtime.js';
 
 export class MCPServer {
@@ -54,6 +55,12 @@ export class MCPServer {
         case 'tools/call':
           return this.handleCallTool(params, id);
         
+        case 'prompts/list':
+          return this.handleListPrompts(id);
+
+        case 'prompts/get':
+          return this.handleGetPrompt(params, id);
+        
         case 'prompts/list':
           return this.createErrorResponse(id, -32601, 'Method not found');
         
@@ -159,6 +166,62 @@ export class MCPServer {
     }
   }
 
+  // List available prompts
+  handleListPrompts(id) {
+    const prompts = [
+      {
+        name: 'onboard-me',
+        description: 'Guided walkthrough of the current codebase architecture.',
+        arguments: []
+      },
+      {
+        name: 'refactor-planner',
+        description: 'Plan a refactor by analyzing semantic dependencies.',
+        arguments: [
+          { name: 'target', description: 'The function or file to refactor', required: true }
+        ]
+      }
+    ];
+    return this.createSuccessResponse(id, { prompts });
+  }
+
+  // Get a specific prompt
+  handleGetPrompt(params, id) {
+    const { name, arguments: args } = params;
+    
+    if (name === 'onboard-me') {
+      return this.createSuccessResponse(id, {
+        description: 'Codebase Onboarding',
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: 'Please perform a comprehensive discovery of this codebase using the `agent/discover` tool. Focus on identifying the primary entry points and the core architectural patterns. Use the results to explain how the project is organized.'
+            }
+          }
+        ]
+      });
+    }
+
+    if (name === 'refactor-planner') {
+      return this.createSuccessResponse(id, {
+        description: 'Refactor Planning',
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `I want to refactor ${args.target}. Use the \`agent/query\` tool to find all semantic chunks related to this target and the \`agent/investigate\` tool to identify potential impact on other modules. Present a step-by-step refactoring plan.`
+            }
+          }
+        ]
+      });
+    }
+
+    return this.createErrorResponse(id, -32602, 'Prompt not found');
+  }
+
   // List available tools
   handleListTools(id) {
     const tools = [
@@ -912,22 +975,20 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
         return this.createErrorResponse(id, -32602, `Bundle '${name}' already exists`);
       }
 
-      // Load current config
-      const configPath = join(this.cntxServer.CNTX_DIR, 'config.json');
-      let config = { bundles: {} };
-      
-      if (existsSync(configPath)) {
-        config = JSON.parse(readFileSync(configPath, 'utf8'));
-      }
-
-      // Add new bundle
-      config.bundles[name] = patterns;
+      // Create bundle in bundle-states.json (single source of truth)
+      this.cntxServer.configManager.bundleStates.set(name, {
+        patterns: patterns,
+        files: [],
+        content: '',
+        changed: false,
+        size: 0,
+        generated: null
+      });
 
-      // Save config
-      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      // Save bundle states
+      this.cntxServer.configManager.saveBundleStates();
 
-      // Reload server config
-      this.cntxServer.loadConfig();
+      // Regenerate bundles
       this.cntxServer.generateAllBundles();
 
       const result = {
@@ -969,18 +1030,15 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
         return this.createErrorResponse(id, -32602, 'Cannot update master bundle');
       }
 
-      // Load current config
-      const configPath = join(this.cntxServer.CNTX_DIR, 'config.json');
-      const config = JSON.parse(readFileSync(configPath, 'utf8'));
-
-      // Update bundle patterns
-      config.bundles[name] = patterns;
+      // Update bundle in bundle-states.json (single source of truth)
+      const bundle = this.cntxServer.configManager.bundleStates.get(name);
+      bundle.patterns = patterns;
+      bundle.changed = true;
 
-      // Save config
-      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      // Save bundle states
+      this.cntxServer.configManager.saveBundleStates();
 
-      // Reload server config
-      this.cntxServer.loadConfig();
+      // Regenerate bundles
       this.cntxServer.generateAllBundles();
 
       const result = {
@@ -1022,18 +1080,13 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
         return this.createErrorResponse(id, -32602, 'Cannot delete master bundle');
       }
 
-      // Load current config
-      const configPath = join(this.cntxServer.CNTX_DIR, 'config.json');
-      const config = JSON.parse(readFileSync(configPath, 'utf8'));
-
-      // Remove bundle
-      delete config.bundles[name];
+      // Remove bundle from bundle-states.json (single source of truth)
+      this.cntxServer.configManager.bundleStates.delete(name);
 
-      // Save config
-      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      // Save bundle states
+      this.cntxServer.configManager.saveBundleStates();
 
-      // Reload server config
-      this.cntxServer.loadConfig();
+      // Regenerate bundles
       this.cntxServer.generateAllBundles();
 
       const result = {
@@ -1188,36 +1241,53 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
 
   // New tool implementations
   async toolReadFile(args, id) {
-    const { path, includeMetadata = true } = args;
+    const { path: filePath, includeMetadata = true } = args;
     
-    if (!path) {
+    if (!filePath) {
       return this.createErrorResponse(id, -32602, 'Path is required');
     }
 
     try {
-      const fullPath = join(this.cntxServer.CWD, path);
+      const fullPath = join(this.cntxServer.CWD, filePath);
       
       if (!existsSync(fullPath)) {
-        return this.createErrorResponse(id, -32602, `File not found: ${path}`);
+        return this.createErrorResponse(id, -32602, `File not found: ${filePath}`);
       }
 
       const content = readFileSync(fullPath, 'utf8');
-      const result = { path, content };
+      
+      // Fetch semantic context for this file
+      const chunks = this.cntxServer.databaseManager.getChunksByFile(filePath);
+      const totalComplexity = chunks.reduce((sum, c) => sum + (c.complexity?.score || 0), 0);
+      const avgComplexity = chunks.length > 0 ? Math.round(totalComplexity / chunks.length) : 0;
+
+      let semanticHeader = `--- SEMANTIC CONTEXT ---\n`;
+      semanticHeader += `File importance: ${chunks.length} semantic chunks found.\n`;
+      semanticHeader += `Aggregate Complexity: ${totalComplexity} (Avg: ${avgComplexity})\n`;
+      if (chunks.length > 0) {
+        semanticHeader += `Primary purposes: ${[...new Set(chunks.map(c => c.purpose))].join(', ')}\n`;
+      }
+      semanticHeader += `------------------------\n\n`;
+
+      const result = { 
+        path: filePath, 
+        content: semanticHeader + content 
+      };
 
       if (includeMetadata) {
-        const stats = require('fs').statSync(fullPath);
+        const stats = fs.statSync(fullPath);
         const bundles = [];
         
         // Find which bundles include this file
         this.cntxServer.bundles.forEach((bundle, name) => {
-          if (bundle.files && bundle.files.includes(fullPath)) {
+          if (bundle.files && bundle.files.includes(filePath)) {
             bundles.push(name);
           }
         });
 
         result.metadata = {
           size: stats.size,
-          mimeType: this.getMimeType(path),
+          mimeType: this.getMimeType(filePath),
           modified: stats.mtime.toISOString(),
           lines: content.split('\n').length,
           bundles: bundles
@@ -1225,7 +1295,7 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
       }
 
       return this.createSuccessResponse(id, {
-        contents: [{
+        content: [{
           type: 'text',
           text: JSON.stringify(result, null, 2)
         }]
@@ -1236,25 +1306,25 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
   }
 
   async toolWriteFile(args, id) {
-    const { path, content, backup = true, createDirs = true } = args;
+    const { path: filePath, content, backup = true, createDirs = true } = args;
     
-    if (!path || content === undefined) {
+    if (!filePath || content === undefined) {
       return this.createErrorResponse(id, -32602, 'Path and content are required');
     }
 
     try {
-      const fullPath = join(this.cntxServer.CWD, path);
-      const parentDir = require('path').dirname(fullPath);
+      const fullPath = join(this.cntxServer.CWD, filePath);
+      const parentDir = dirname(fullPath);
       
       // Create parent directories if needed
       if (createDirs && !existsSync(parentDir)) {
-        require('fs').mkdirSync(parentDir, { recursive: true });
+        fs.mkdirSync(parentDir, { recursive: true });
       }
 
       // Create backup if file exists
       if (backup && existsSync(fullPath)) {
         const backupPath = `${fullPath}.backup.${Date.now()}`;
-        require('fs').copyFileSync(fullPath, backupPath);
+        fs.copyFileSync(fullPath, backupPath);
       }
 
       // Write the file
@@ -1269,13 +1339,13 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
         }
       });
 
-      const stats = require('fs').statSync(fullPath);
+      const stats = fs.statSync(fullPath);
       
       return this.createSuccessResponse(id, {
-        contents: [{
+        content: [{
           type: 'text',
           text: JSON.stringify({
-            path,
+            path: filePath,
             written: true,
             size: stats.size,
             modified: stats.mtime.toISOString()
@@ -1390,7 +1460,7 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
       }
 
       return this.createSuccessResponse(id, {
-        contents: [{
+        content: [{
           type: 'text',
           text: JSON.stringify(result, null, 2)
         }]