cntx-ui 3.0.8 → 3.1.0

package/dist/server.js

@@ -0,0 +1,413 @@
+/**
+ * Refactored cntx-ui Server
+ * Lean orchestration layer using modular architecture
+ */
+import { createServer } from 'http';
+import { join, dirname, extname } from 'path';
+import { fileURLToPath, parse } from 'url';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, cpSync } from 'fs';
+import { homedir } from 'os';
+// Import our modular components
+import ConfigurationManager from './lib/configuration-manager.js';
+import FileSystemManager from './lib/file-system-manager.js';
+import BundleManager from './lib/bundle-manager.js';
+import APIRouter from './lib/api-router.js';
+import WebSocketManager from './lib/websocket-manager.js';
+// Import existing lib modules
+import SemanticSplitter from './lib/semantic-splitter.js';
+import SimpleVectorStore from './lib/simple-vector-store.js';
+import { MCPServer } from './lib/mcp-server.js';
+import AgentRuntime from './lib/agent-runtime.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class CntxServer {
+    CWD;
+    CNTX_DIR;
+    verbose;
+    mcpServerStarted;
+    mcpServer;
+    initMessages;
+    configManager;
+    databaseManager;
+    fileSystemManager;
+    bundleManager;
+    webSocketManager;
+    apiRouter;
+    semanticSplitter;
+    vectorStore;
+    agentRuntime;
+    semanticCache;
+    lastSemanticAnalysis;
+    vectorStoreInitialized;
+    semanticAnalysisManager;
+    activityManager;
+    constructor(cwd = process.cwd(), options = {}) {
+        this.CWD = cwd;
+        this.CNTX_DIR = join(cwd, '.cntx');
+        this.verbose = options.verbose || false;
+        this.mcpServerStarted = false;
+        this.mcpServer = null;
+        this.initMessages = [];
+        // Ensure directory exists
+        if (!existsSync(this.CNTX_DIR))
+            mkdirSync(this.CNTX_DIR, { recursive: true });
+        // Initialize modular components
+        this.configManager = new ConfigurationManager(cwd, { verbose: this.verbose });
+        this.databaseManager = this.configManager.dbManager;
+        this.fileSystemManager = new FileSystemManager(cwd, { verbose: this.verbose });
+        this.bundleManager = new BundleManager(this.configManager, this.fileSystemManager, this.verbose);
+        this.webSocketManager = new WebSocketManager(this.bundleManager, this.configManager, { verbose: this.verbose });
+        // AI Components
+        this.semanticSplitter = new SemanticSplitter({
+            maxChunkSize: 2000,
+            includeContext: true,
+            minFunctionSize: 50
+        });
+        this.vectorStore = new SimpleVectorStore(this.databaseManager, {
+            modelName: 'Xenova/all-MiniLM-L6-v2'
+        });
+        this.semanticCache = null;
+        this.lastSemanticAnalysis = null;
+        this.vectorStoreInitialized = false;
+        // Initialize Agent Runtime
+        this.agentRuntime = new AgentRuntime(this);
+        this.semanticAnalysisManager = this; // Self as manager
+        this.activityManager = this; // Simple mock for now
+        // Initialize API router
+        this.apiRouter = new APIRouter(this, this.configManager, this.bundleManager, this.fileSystemManager, this.semanticAnalysisManager, this.vectorStore, this.activityManager);
+        // Cross-module linkage
+        this.bundleManager.fileSystemManager = this.fileSystemManager;
+        this.bundleManager.webSocketManager = this.webSocketManager;
+    }
+    async init(options = {}) {
+        const { skipFileWatcher = false, skipBundleGeneration = false } = options;
+        // Load configs
+        this.configManager.loadConfig();
+        this.configManager.loadHiddenFilesConfig();
+        this.configManager.loadIgnorePatterns();
+        this.configManager.loadBundleStates();
+        if (!skipFileWatcher) {
+            this.startWatching();
+            // Trigger semantic analysis
+            if (!this.semanticCache) {
+                this.getSemanticAnalysis().catch(err => console.error('Initial semantic analysis failed:', err.message));
+            }
+            if (!skipBundleGeneration) {
+                await this.bundleManager.generateAllBundles();
+            }
+        }
+        // Load reasoning/manifest
+        await this.agentRuntime.generateAgentManifest();
+    }
+    startWatching() {
+        this.fileSystemManager.startWatching((eventType, filename) => {
+            this.bundleManager.markBundlesChanged(filename);
+            this.webSocketManager.onFileChanged(filename, eventType);
+        });
+    }
+    async getSemanticAnalysis() {
+        // Try SQLite first
+        try {
+            const dbChunks = this.databaseManager.db.prepare('SELECT * FROM semantic_chunks').all();
+            if (dbChunks.length > 0) {
+                if (!this.semanticCache) {
+                    this.semanticCache = {
+                        chunks: dbChunks.map(row => this.databaseManager.mapChunkRow(row)),
+                        summary: { totalChunks: dbChunks.length }
+                    };
+                }
+                return this.semanticCache;
+            }
+        }
+        catch (e) { }
+        // Fresh analysis
+        const files = this.fileSystemManager.getAllFiles().map(f => this.fileSystemManager.relativePath(f))
+            .filter(f => ['.js', '.jsx', '.ts', '.tsx', '.rs'].includes(extname(f).toLowerCase()));
+        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, files, bundleConfig);
+        this.lastSemanticAnalysis = Date.now();
+        if (this.semanticCache.chunks.length > 0) {
+            this.databaseManager.saveChunks(this.semanticCache.chunks);
+        }
+        this.enhanceSemanticChunksIfNeeded(this.semanticCache);
+        return this.semanticCache;
+    }
+    async enhanceSemanticChunksIfNeeded(analysis) {
+        if (!analysis || !analysis.chunks)
+            return;
+        if (!this.vectorStoreInitialized) {
+            await this.vectorStore.init();
+            this.vectorStoreInitialized = true;
+        }
+        for (const chunk of analysis.chunks) {
+            if (!this.databaseManager.getEmbedding(chunk.id)) {
+                await this.vectorStore.upsertChunk(chunk);
+            }
+        }
+    }
+    async refreshSemanticAnalysis() {
+        this.databaseManager.db.prepare('DELETE FROM semantic_chunks').run();
+        this.databaseManager.db.prepare('DELETE FROM vector_embeddings').run();
+        this.semanticCache = null;
+        return this.getSemanticAnalysis();
+    }
+    startMCPServer() {
+        if (!this.mcpServer) {
+            this.mcpServer = new MCPServer(this);
+            this.mcpServerStarted = true;
+        }
+    }
+    async listen(port = 3333, host = 'localhost') {
+        const server = createServer((req, res) => {
+            const url = parse(req.url || '/', true);
+            // Serve static files from web/dist
+            if (!url.pathname?.startsWith('/api/')) {
+                return this.handleStaticFile(req, res, url);
+            }
+            // Route API requests
+            this.apiRouter.handleRequest(req, res, url);
+        });
+        this.webSocketManager.initialize(server);
+        return new Promise((resolve) => {
+            server.listen(port, host, () => {
+                console.log(`🚀 cntx-ui server running at http://${host}:${port}`);
+                resolve(server);
+            });
+        });
+    }
+    handleStaticFile(req, res, url) {
+        const webDir = join(__dirname, 'web/dist');
+        let filePath = join(webDir, url.pathname === '/' ? 'index.html' : url.pathname);
+        if (!existsSync(filePath)) {
+            filePath = join(webDir, 'index.html');
+        }
+        try {
+            const content = readFileSync(filePath);
+            const ext = extname(filePath).toLowerCase();
+            const contentType = this.getContentType(ext);
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+        catch (e) {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    }
+    getContentType(ext) {
+        const types = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.svg': 'image/svg+xml'
+        };
+        return types[ext] || 'text/plain';
+    }
+    // Activity Manager Mock
+    async loadActivities() {
+        return [];
+    }
+}
+export async function startServer(options = {}) {
+    const server = new CntxServer(options.cwd, options);
+    await server.init(options);
+    if (options.withMcp !== false)
+        server.startMCPServer();
+    return await server.listen(options.port, options.host);
+}
+// Initialize project configuration
+export async function initConfig(cwd = process.cwd()) {
+    const server = new CntxServer(cwd);
+    // 1. Initialize directory structure
+    if (!existsSync(server.CNTX_DIR)) {
+        mkdirSync(server.CNTX_DIR, { recursive: true });
+        console.log('📁 Created .cntx directory');
+    }
+    // 2. Create .mcp.json for Claude Code discovery
+    const mcpConfigPath = join(cwd, '.mcp.json');
+    const mcpConfig = {
+        mcpServers: {
+            "cntx-ui": {
+                command: "cntx-ui",
+                args: ["mcp"],
+                cwd: "."
+            }
+        }
+    };
+    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf8');
+    console.log('📄 Created .mcp.json for agent auto-discovery');
+    // 3. Initialize basic configuration with better defaults and auto-suggestions
+    server.configManager.loadConfig();
+    const suggestedBundles = {
+        master: ['**/*']
+    };
+    // Directory-based auto-suggestions
+    const commonDirs = [
+        { dir: 'src/components', name: 'ui-components' },
+        { dir: 'src/services', name: 'services' },
+        { dir: 'src/lib', name: 'libraries' },
+        { dir: 'src/hooks', name: 'react-hooks' },
+        { dir: 'server', name: 'backend-api' },
+        { dir: 'tests', name: 'test-suite' }
+    ];
+    commonDirs.forEach(d => {
+        if (existsSync(join(cwd, d.dir))) {
+            suggestedBundles[d.name] = [`${d.dir}/**`];
+            console.log(`💡 Suggested bundle: ${d.name} (${d.dir}/**)`);
+        }
+    });
+    server.configManager.saveConfig({
+        bundles: suggestedBundles
+    });
+    // 4. Create robust default .cntxignore
+    const ignorePath = join(cwd, '.cntxignore');
+    if (!existsSync(ignorePath)) {
+        const defaultIgnore = `# Binary files
+*.db
+*.db-journal
+*.png
+*.jpg
+*.jpeg
+*.ico
+*.icns
+*.gif
+*.zip
+*.tar.gz
+
+# Generated files
+**/gen/**
+**/dist/**
+**/build/**
+**/node_modules/**
+**/.next/**
+**/.cache/**
+
+# cntx-ui internals
+.cntx/**
+.mcp.json
+`;
+        writeFileSync(ignorePath, defaultIgnore, 'utf8');
+        console.log('📄 Created .cntxignore with smart defaults');
+    }
+    console.log('⚙️ Basic configuration initialized');
+    const templateDir = join(__dirname, 'templates');
+    // Copy agent configuration files
+    const agentFiles = [
+        'agent-config.yaml',
+        'agent-instructions.md'
+    ];
+    for (const file of agentFiles) {
+        const sourcePath = join(templateDir, file);
+        const destPath = join(server.CNTX_DIR, file);
+        if (existsSync(sourcePath) && !existsSync(destPath)) {
+            copyFileSync(sourcePath, destPath);
+            console.log(`📄 Created ${file}`);
+        }
+    }
+    // Copy agent-rules directory structure
+    const agentRulesSource = join(templateDir, 'agent-rules');
+    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');
+    }
+    // Copy activities framework
+    const activitiesDir = join(server.CNTX_DIR, 'activities');
+    if (!existsSync(activitiesDir)) {
+        mkdirSync(activitiesDir, { recursive: true });
+    }
+    // Copy activities README
+    const activitiesReadmeSource = join(templateDir, 'activities', 'README.md');
+    const activitiesReadmeDest = join(activitiesDir, 'README.md');
+    if (existsSync(activitiesReadmeSource) && !existsSync(activitiesReadmeDest)) {
+        copyFileSync(activitiesReadmeSource, activitiesReadmeDest);
+        console.log('📄 Created activities/README.md');
+    }
+    // Copy activities lib directory (MDC templates)
+    const activitiesLibSource = join(templateDir, 'activities', 'lib');
+    const activitiesLibDest = join(activitiesDir, 'lib');
+    if (existsSync(activitiesLibSource) && !existsSync(activitiesLibDest)) {
+        cpSync(activitiesLibSource, activitiesLibDest, { recursive: true });
+        console.log('📁 Created activities/lib with MDC templates');
+    }
+    // Copy activities.json from templates
+    const activitiesJsonPath = join(activitiesDir, 'activities.json');
+    const templateActivitiesJsonPath = join(templateDir, 'activities', 'activities.json');
+    if (!existsSync(activitiesJsonPath) && existsSync(templateActivitiesJsonPath)) {
+        copyFileSync(templateActivitiesJsonPath, activitiesJsonPath);
+        console.log('📄 Created activities.json with bundle example activity');
+    }
+    // Copy example activity from templates
+    const activitiesDestDir = join(activitiesDir, 'activities');
+    const templateActivitiesDir = join(templateDir, 'activities', 'activities');
+    if (!existsSync(activitiesDestDir) && existsSync(templateActivitiesDir)) {
+        cpSync(templateActivitiesDir, activitiesDestDir, { recursive: true });
+        console.log('📁 Created example activity with templates');
+    }
+    return server.initMessages;
+}
+export async function generateBundle(name) {
+    const server = new CntxServer(process.cwd());
+    await server.init({ skipFileWatcher: true });
+    return await server.bundleManager.regenerateBundle(name);
+}
+export async function getStatus() {
+    const server = new CntxServer(process.cwd());
+    await server.init({ skipFileWatcher: true });
+    const bundles = server.bundleManager.getAllBundleInfo();
+    const totalFiles = server.fileSystemManager.getAllFiles().length;
+    console.log('📊 cntx-ui Status');
+    console.log('================');
+    console.log(`Total files: ${totalFiles}`);
+    console.log(`Bundles: ${bundles.length}`);
+    bundles.forEach(bundle => {
+        console.log(`  • ${bundle.name}: ${bundle.fileCount} files (${Math.round(bundle.size / 1024)}KB)`);
+    });
+    return {
+        totalFiles,
+        bundles: bundles.length,
+        bundleDetails: bundles
+    };
+}
+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}`);
+    try {
+        let config = {};
+        if (existsSync(configPath)) {
+            config = JSON.parse(readFileSync(configPath, 'utf8'));
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers['cntx-ui'] = {
+            command: 'npx',
+            args: ['cntx-ui', 'mcp'],
+            cwd: projectPath
+        };
+        // 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');
+    }
+    catch (error) {
+        console.error('❌ Failed to setup MCP:', error.message);
+        console.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.init();
+    server.listen(3333, 'localhost');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cntx-ui",
   "type": "module",
-  "version": "3.0.8",
+  "version": "3.1.0",
   "description": "Autonomous Repository Intelligence engine with web UI and MCP server. Unified semantic code understanding, local RAG, and agent working memory.",
   "keywords": [
     "repository-intelligence",
@@ -20,13 +20,12 @@
   },
   "author": "whaleen",
   "license": "MIT",
+  "main": "dist/server.js",
   "bin": {
-    "cntx-ui": "./bin/cntx-ui.js"
+    "cntx-ui": "./dist/bin/cntx-ui.js"
   },
   "files": [
-    "bin/",
-    "server.js",
-    "lib/",
+    "dist/",
     "templates/",
     "web/dist/",
     "README.md",
@@ -36,12 +35,14 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "dev": "node server.js",
-    "build": "cd web && npm install && npm run build",
+    "dev": "ts-node --esm bin/cntx-ui.ts",
+    "build:backend": "tsc && chmod +x dist/bin/cntx-ui.js",
+    "build:web": "cd web && npm install && npm run build",
+    "build": "npm run build:backend && npm run build:web",
     "check:version-sync": "node scripts/check-version-sync.mjs",
     "release:ci": "node scripts/release-from-package.mjs",
     "prepublishOnly": "npm run build",
-    "test:local": "npm pack && npm install -g ./cntx-ui-3.0.0.tgz"
+    "test:local": "npm pack && npm install -g ./cntx-ui-3.1.0.tgz"
   },
   "dependencies": {
     "@xenova/transformers": "^2.17.2",
@@ -52,5 +53,13 @@
     "tree-sitter-rust": "^0.21.0",
     "tree-sitter-typescript": "^0.23.2",
     "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/glob": "^8.1.0",
+    "@types/node": "^25.3.2",
+    "@types/ws": "^8.18.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
   }
 }

package/bin/cntx-ui-mcp.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-# Wrapper script to run cntx-ui MCP server in current directory
-cd "$(pwd)" && npx cntx-ui mcp

package/bin/cntx-ui.js

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-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] || 'start';
-const isVerbose = args.includes('--verbose');
-
-// Graceful shutdown
-process.on('SIGINT', () => {
-  console.log('\n Shutting down cntx-ui...');
-  process.exit(0);
-});
-
-function showHelp() {
-  console.log(`cntx-ui v${packageJson.version}
-
-${packageJson.description}
-
-Usage:
-  cntx-ui [command] [options]
-
-Commands:
-  (default)                   Auto-init if needed, then start web server
-  init                        Initialize configuration in current directory
-  mcp                         Start MCP server (stdio transport)
-  bundle [name]               Generate specific bundle (default: master)
-  status                      Show current project status
-
-Options:
-  --verbose                   Enable detailed logging
-  --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 mcp                 Start MCP server on stdio
-  cntx-ui bundle api          Generate 'api' bundle
-  cntx-ui status              Show project status
-
-MCP Integration:
-  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}
-License: ${packageJson.license}`);
-}
-
-function showVersion() {
-  console.log(`cntx-ui v${packageJson.version}`);
-}
-
-async function main() {
-  // Handle version flags
-  if (args.includes('--version') || args.includes('-v')) {
-    return showVersion();
-  }
-
-  // Handle help flags
-  if (args.includes('--help') || args.includes('-h') || command === 'help') {
-    return showHelp();
-  }
-
-  try {
-    switch (command) {
-      case 'start':
-      case 'watch':
-      case 'w':
-        const port = parseInt(args[1]) || 3333;
-        await autoInitAndStart({ port, verbose: isVerbose });
-        break;
-
-      case 'mcp':
-        // MCP server mode - runs on stdio
-        await startMCPServer({ cwd: process.cwd(), verbose: isVerbose });
-        break;
-
-      case 'bundle':
-      case 'b':
-        const bundleName = args[1] || 'master';
-        try {
-          await generateBundle(bundleName);
-          console.log(`Bundle '${bundleName}' generated successfully`);
-        } catch (error) {
-          console.error(`Failed to generate bundle '${bundleName}': ${error.message}`);
-          process.exit(1);
-        }
-        break;
-
-      case 'init':
-      case 'i':
-        await initConfig();
-        break;
-
-      case 'status':
-      case 's':
-        await getStatus();
-        break;
-
-      default:
-        console.error(`Unknown command: ${command}`);
-        console.log('Run "cntx-ui --help" for usage information.');
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(`Error: ${error.message}`);
-    if (isVerbose) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
-}
-
-main().catch(console.error);