cntx-ui 3.0.5 → 3.0.7

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/mcp-server.js

@@ -578,36 +578,6 @@ export class MCPServer {
           required: ['path', 'content']
         }
       },
-      {
-        name: 'manage_activities',
-        description: 'CRUD operations for project activities',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            action: {
-              type: 'string',
-              enum: ['list', 'get', 'create', 'update', 'delete'],
-              description: 'Action to perform on activities'
-            },
-            activityId: {
-              type: 'string',
-              description: 'Activity ID (required for get, update, delete)'
-            },
-            activity: {
-              type: 'object',
-              description: 'Activity data (required for create, update)',
-              properties: {
-                title: { type: 'string' },
-                description: { type: 'string' },
-                status: { type: 'string', enum: ['todo', 'in_progress', 'completed', 'blocked'] },
-                tags: { type: 'array', items: { type: 'string' } },
-                tasks: { type: 'array', items: { type: 'object' } }
-              }
-            }
-          },
-          required: ['action']
-        }
-      }
     ];
 
     return this.createSuccessResponse(id, { tools });
@@ -676,9 +646,6 @@ export class MCPServer {
         case 'write_file':
           return this.toolWriteFile(args, id);
         
-        case 'manage_activities':
-          return this.toolManageActivities(args, id);
-        
         default:
           return this.createErrorResponse(id, -32602, 'Unknown tool');
       }
@@ -1369,119 +1336,6 @@ ${Array.from(this.cntxServer.bundles.entries()).map(([name, bundle]) =>
     }
   }
 
-  async toolManageActivities(args, id) {
-    const { action, activityId, activity } = args;
-    
-    if (!action) {
-      return this.createErrorResponse(id, -32602, 'Action is required');
-    }
-
-    try {
-      const activitiesPath = join(this.cntxServer.CWD, '.cntx', 'activities');
-      const activitiesJsonPath = join(activitiesPath, 'activities.json');
-      
-      let activities = [];
-      if (existsSync(activitiesJsonPath)) {
-        activities = JSON.parse(readFileSync(activitiesJsonPath, 'utf8'));
-      }
-
-      let result;
-      
-      switch (action) {
-        case 'list':
-          result = { activities: activities.map(a => ({ 
-            id: a.title.toLowerCase().replace(/[^a-z0-9]/g, '-'),
-            title: a.title, 
-            description: a.description, 
-            status: a.status, 
-            tags: a.tags 
-          })) };
-          break;
-          
-        case 'get':
-          if (!activityId) {
-            return this.createErrorResponse(id, -32602, 'Activity ID is required for get action');
-          }
-          const found = activities.find(a => 
-            a.title.toLowerCase().replace(/[^a-z0-9]/g, '-') === activityId
-          );
-          if (!found) {
-            return this.createErrorResponse(id, -32602, `Activity not found: ${activityId}`);
-          }
-          
-          // Load markdown files
-          const activityDir = join(activitiesPath, 'activities', activityId);
-          const files = {};
-          ['README.md', 'progress.md', 'tasks.md', 'notes.md'].forEach(file => {
-            const filePath = join(activityDir, file);
-            files[file.replace('.md', '')] = existsSync(filePath) 
-              ? readFileSync(filePath, 'utf8') 
-              : 'No content available';
-          });
-          
-          result = { ...found, files };
-          break;
-          
-        case 'create':
-          if (!activity || !activity.title) {
-            return this.createErrorResponse(id, -32602, 'Activity with title is required for create action');
-          }
-          activities.push({
-            title: activity.title,
-            description: activity.description || '',
-            status: activity.status || 'todo',
-            tags: activity.tags || ['general'],
-            tasks: activity.tasks || []
-          });
-          writeFileSync(activitiesJsonPath, JSON.stringify(activities, null, 2));
-          result = { created: true, activityId: activity.title.toLowerCase().replace(/[^a-z0-9]/g, '-') };
-          break;
-          
-        case 'update':
-          if (!activityId || !activity) {
-            return this.createErrorResponse(id, -32602, 'Activity ID and activity data are required for update action');
-          }
-          const updateIndex = activities.findIndex(a => 
-            a.title.toLowerCase().replace(/[^a-z0-9]/g, '-') === activityId
-          );
-          if (updateIndex === -1) {
-            return this.createErrorResponse(id, -32602, `Activity not found: ${activityId}`);
-          }
-          activities[updateIndex] = { ...activities[updateIndex], ...activity };
-          writeFileSync(activitiesJsonPath, JSON.stringify(activities, null, 2));
-          result = { updated: true };
-          break;
-          
-        case 'delete':
-          if (!activityId) {
-            return this.createErrorResponse(id, -32602, 'Activity ID is required for delete action');
-          }
-          const deleteIndex = activities.findIndex(a => 
-            a.title.toLowerCase().replace(/[^a-z0-9]/g, '-') === activityId
-          );
-          if (deleteIndex === -1) {
-            return this.createErrorResponse(id, -32602, `Activity not found: ${activityId}`);
-          }
-          activities.splice(deleteIndex, 1);
-          writeFileSync(activitiesJsonPath, JSON.stringify(activities, null, 2));
-          result = { deleted: true };
-          break;
-          
-        default:
-          return this.createErrorResponse(id, -32602, `Unknown action: ${action}`);
-      }
-
-      return this.createSuccessResponse(id, {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(result, null, 2)
-        }]
-      });
-    } catch (error) {
-      return this.createErrorResponse(id, -32603, 'Failed to manage activities', error.message);
-    }
-  }
-
   // Helper methods
   getMimeType(filePath) {
     const ext = filePath.split('.').pop()?.toLowerCase();

package/package.json

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