cntx-ui 3.0.4 → 3.0.6

package/bin/cntx-ui.js

@@ -3,19 +3,19 @@
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { startServer, startMCPServer, generateBundle, initConfig, getStatus, setupMCP } from '../server.js';
+import { autoInitAndStart, startMCPServer, generateBundle, initConfig, getStatus } from '../server.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packagePath = join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
 
 const args = process.argv.slice(2);
-const command = args[0] || 'help';
+const command = args[0] || 'start';
 const isVerbose = args.includes('--verbose');
 
 // Graceful shutdown
 process.on('SIGINT', () => {
-  console.log('\n👋 Shutting down cntx-ui...');
+  console.log('\n Shutting down cntx-ui...');
   process.exit(0);
 });
 
@@ -25,55 +25,30 @@ function showHelp() {
 ${packageJson.description}
 
 Usage:
-  cntx-ui <command> [options]
+  cntx-ui [command] [options]
 
 Commands:
+  (default)                   Auto-init if needed, then start web server
   init                        Initialize configuration in current directory
-  watch [port]                Start web server (default port: 3333)
   mcp                         Start MCP server (stdio transport)
   bundle [name]               Generate specific bundle (default: master)
   status                      Show current project status
-  setup-mcp                   Add this project to Claude Desktop MCP config
 
 Options:
   --verbose                   Enable detailed logging
-  --with-mcp                  Start web server with MCP status tracking
   --version, -v               Show version number
   --help, -h                  Show this help message
 
 Examples:
+  cntx-ui                     Start server (auto-inits if needed)
   cntx-ui init                Initialize a new project
-  cntx-ui watch               Start web server on port 3333
-  cntx-ui watch 8080          Start web server on port 8080
-  cntx-ui watch --verbose     Start with detailed logs
-  cntx-ui watch --with-mcp    Start with MCP integration
+  cntx-ui mcp                 Start MCP server on stdio
   cntx-ui bundle api          Generate 'api' bundle
   cntx-ui status              Show project status
-  cntx-ui setup-mcp           Configure Claude Desktop integration
 
 MCP Integration:
-  The MCP server provides AI-accessible bundle management for Claude Desktop
-  and other MCP-compatible clients. Use 'setup-mcp' to configure automatic
-  integration with Claude Desktop.
-
-Agent Collaboration:
-  To get an external agent up to speed with your project, use this prompt:
-
-  "I'm working in a project that uses cntx-ui for file organization and AI 
-  collaboration. Please read these files to understand the project structure 
-  and help me with activities:
-
-  @.cntx/agent-instructions.md
-  @.cntx/activities/README.md  
-  @.cntx/activities/activities.json
-
-  After reading those, please also examine:
-  @.cntx/activities/lib/create-activity.mdc
-  @.cntx/activities/lib/generate-tasks.mdc
-  @.cntx/activities/lib/process-task-list.mdc
-
-  These files contain the complete workflow for creating and managing 
-  activities with agent assistance."
+  Running 'cntx-ui init' creates a .mcp.json file so Claude Code
+  can auto-discover the MCP server. Run 'cntx-ui mcp' for stdio mode.
 
 Repository: ${packageJson.repository.url}
 Author: ${packageJson.author}
@@ -95,17 +70,13 @@ async function main() {
     return showHelp();
   }
 
-  // Handle default command (watch if no command provided and no flags)
-  const actualCommand = command === 'help' ? 'watch' : command;
-
   try {
-    switch (actualCommand) {
+    switch (command) {
+      case 'start':
       case 'watch':
       case 'w':
         const port = parseInt(args[1]) || 3333;
-        // Enable MCP status tracking by default for the web dashboard
-        const withMcp = !args.includes('--no-mcp');
-        await startServer({ port, withMcp, verbose: isVerbose });
+        await autoInitAndStart({ port, verbose: isVerbose });
         break;
 
       case 'mcp':
@@ -118,9 +89,9 @@ async function main() {
         const bundleName = args[1] || 'master';
         try {
           await generateBundle(bundleName);
-          console.log(`✅ Bundle '${bundleName}' generated successfully`);
+          console.log(`Bundle '${bundleName}' generated successfully`);
         } catch (error) {
-          console.error(`❌ Failed to generate bundle '${bundleName}': ${error.message}`);
+          console.error(`Failed to generate bundle '${bundleName}': ${error.message}`);
           process.exit(1);
         }
         break;
@@ -135,17 +106,13 @@ async function main() {
         await getStatus();
         break;
 
-      case 'setup-mcp':
-        setupMCP();
-        break;
-
       default:
-        console.error(`❌ Unknown command: ${command}`);
+        console.error(`Unknown command: ${command}`);
         console.log('Run "cntx-ui --help" for usage information.');
         process.exit(1);
     }
   } catch (error) {
-    console.error(`❌ Error: ${error.message}`);
+    console.error(`Error: ${error.message}`);
     if (isVerbose) {
       console.error(error.stack);
     }

package/lib/agent-runtime.js

@@ -281,6 +281,76 @@ This agent is **stateful**. All interactions in this directory are logged to a p
     return { strategy: 'TBD', description: 'Ready to plan' };
   }
 
+  /**
+   * Discussion Mode: Engage in architectural discussion about the codebase
+   */
+  async discussAndPlan(userInput, context = {}) {
+    try {
+      await this.logInteraction('user', userInput);
+
+      const overview = await this.getCodebaseOverview();
+      const searchResults = await this.cntxServer.vectorStore.search(userInput, { limit: 5 });
+
+      const response = {
+        input: userInput,
+        context,
+        overview,
+        relevantCode: searchResults.map(r => ({
+          name: r.name,
+          filePath: r.filePath,
+          purpose: r.purpose,
+          type: r.type
+        })),
+        suggestions: [
+          'Review the relevant code sections listed above.',
+          'Consider how changes would affect dependent bundles.',
+          'Use semantic search to explore related patterns.'
+        ]
+      };
+
+      await this.logInteraction('agent', `Discussion: ${userInput}`, { response });
+
+      return response;
+    } catch (error) {
+      throw new Error(`Discussion failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Organize Mode: Setup and maintenance of project organization
+   */
+  async organizeProject(options = {}) {
+    const { activity = 'detect', autoDetect = true, force = false } = options;
+
+    try {
+      await this.logInteraction('agent', `Organizing project: ${activity}`);
+
+      const overview = await this.getCodebaseOverview();
+      const bundles = await this.analyzeBundles('all');
+
+      const response = {
+        activity,
+        overview,
+        bundles: bundles.map(b => ({
+          name: b.name,
+          fileCount: b.fileCount,
+          purpose: b.purpose
+        })),
+        recommendations: [
+          'Review bundle organization for coverage gaps.',
+          'Check .cntxignore for missing exclusion patterns.',
+          'Run semantic analysis to identify uncategorized code.'
+        ]
+      };
+
+      await this.logInteraction('agent', `Organization complete for activity: ${activity}`, { response });
+
+      return response;
+    } catch (error) {
+      throw new Error(`Organization failed: ${error.message}`);
+    }
+  }
+
   async generateContextualAnswer(question, results, includeCode) {
     let response = `Based on the codebase analysis:\n\n`;
     if (results.chunks.length > 0) {

package/lib/api-router.js

@@ -8,26 +8,19 @@ import fs from 'fs';
 import path from 'path';
 
 export default class APIRouter {
-  constructor(cntxServer, configManager, bundleManager, fileSystemManager, semanticAnalysisManager, vectorStore, activityManager) {
+  constructor(cntxServer, configManager, bundleManager, fileSystemManager, semanticAnalysisManager, vectorStore) {
     this.cntxServer = cntxServer;
     this.configManager = configManager;
     this.bundleManager = bundleManager;
     this.fileSystemManager = fileSystemManager;
     this.semanticAnalysisManager = semanticAnalysisManager;
     this.vectorStore = vectorStore;
-    this.activityManager = activityManager;
   }
 
   async handleRequest(req, res, url) {
     const method = req.method;
     const pathname = url.pathname;
 
-    // DEBUG: Log all incoming API requests
-    console.log('[API REQUEST]', method, pathname);
-    if (pathname.includes('database')) {
-      console.log('[DATABASE] Route requested:', pathname, method);
-    }
-
     try {
       // Route to appropriate handler
       if (pathname === '/api/bundles' && method === 'GET') {
@@ -73,26 +66,6 @@ export default class APIRouter {
         return await this.handleGetFiles(req, res);
       }
 
-      if (pathname === '/api/cursor-rules' && method === 'GET') {
-        return await this.handleGetCursorRules(req, res);
-      }
-
-      if (pathname === '/api/cursor-rules' && method === 'POST') {
-        return await this.handlePostCursorRules(req, res);
-      }
-
-      if (pathname === '/api/cursor-rules/templates' && method === 'GET') {
-        return await this.handleGetCursorRulesTemplates(req, res);
-      }
-
-      if (pathname === '/api/claude-md' && method === 'GET') {
-        return await this.handleGetClaudeMd(req, res);
-      }
-
-      if (pathname === '/api/claude-md' && method === 'POST') {
-        return await this.handlePostClaudeMd(req, res);
-      }
-
       if (pathname === '/api/heuristics/config' && method === 'GET') {
         return await this.handleGetHeuristicsConfig(req, res);
       }
@@ -190,25 +163,6 @@ export default class APIRouter {
         return await this.handlePostVectorDbSearchByDomain(req, res);
       }
 
-      if (pathname === '/api/activities' && method === 'GET') {
-        return await this.handleGetActivities(req, res);
-      }
-
-      if (pathname.startsWith('/api/activities/') && pathname.endsWith('/reasoning') && method === 'GET') {
-        const activityId = pathname.split('/')[3];
-        return await this.handleGetActivityReasoning(req, res, activityId);
-      }
-
-      if (pathname.startsWith('/api/activities/') && pathname.endsWith('/execute') && method === 'POST') {
-        const activityId = pathname.split('/')[3];
-        return await this.handlePostActivityExecute(req, res, activityId);
-      }
-
-      if (pathname.startsWith('/api/activities/') && pathname.endsWith('/stop') && method === 'POST') {
-        const activityId = pathname.split('/')[3];
-        return await this.handlePostActivityStop(req, res, activityId);
-      }
-
       if (pathname === '/api/open-file' && method === 'POST') {
         return await this.handleOpenFile(req, res);
       }
@@ -429,49 +383,6 @@ export default class APIRouter {
     res.end(JSON.stringify({ success: true }));
   }
 
-  async handleGetCursorRules(req, res) {
-    const content = this.configManager.loadCursorRules();
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end(content);
-  }
-
-  async handlePostCursorRules(req, res) {
-    const body = await this.getRequestBody(req);
-    const { content } = JSON.parse(body);
-
-    this.configManager.saveCursorRules(content);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true }));
-  }
-
-  async handleGetCursorRulesTemplates(req, res) {
-    const templates = {
-      react: this.configManager.generateCursorRulesTemplate({ projectType: 'react', name: 'React Project' }),
-      vue: this.configManager.generateCursorRulesTemplate({ projectType: 'vue', name: 'Vue Project' }),
-      angular: this.configManager.generateCursorRulesTemplate({ projectType: 'angular', name: 'Angular Project' }),
-      'node-backend': this.configManager.generateCursorRulesTemplate({ projectType: 'node-backend', name: 'Node.js Backend' }),
-      javascript: this.configManager.generateCursorRulesTemplate({ projectType: 'javascript', name: 'JavaScript Project' })
-    };
-
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(templates));
-  }
-
-  async handleGetClaudeMd(req, res) {
-    const content = this.configManager.loadClaudeMd();
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end(content);
-  }
-
-  async handlePostClaudeMd(req, res) {
-    const body = await this.getRequestBody(req);
-    const { content } = JSON.parse(body);
-
-    this.configManager.saveClaudeMd(content);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true }));
-  }
-
   async handleGetHeuristicsConfig(req, res) {
     const config = this.configManager.loadHeuristicsConfig();
     res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -907,52 +818,6 @@ export default class APIRouter {
     }
   }
 
-  // === Activities ===
-
-  async handleGetActivities(req, res) {
-    try {
-      const activities = await this.activityManager.loadActivities();
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(activities));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: error.message }));
-    }
-  }
-
-  async handleGetActivityReasoning(req, res, activityId) {
-    try {
-      const history = this.configManager.dbManager.getSessionHistory(activityId);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ history }));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: error.message }));
-    }
-  }
-
-  async handlePostActivityExecute(req, res, activityId) {
-    try {
-      const result = await this.activityManager.executeActivity(activityId);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: error.message }));
-    }
-  }
-
-  async handlePostActivityStop(req, res, activityId) {
-    try {
-      const result = await this.activityManager.stopActivity(activityId);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: error.message }));
-    }
-  }
-
   async handleOpenFile(req, res) {
     try {
       const body = await this.getRequestBody(req);

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);
   }