cntx-ui 3.0.7 → 3.0.9

package/dist/server.js

@@ -0,0 +1,225 @@
+/**
+ * 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 } from 'fs';
+// 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);
+}
+export async function initConfig(cwd = process.cwd()) {
+    const server = new CntxServer(cwd);
+    // Implementation matches previous init logic
+    return [];
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cntx-ui",
   "type": "module",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "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.0.8.tgz"
   },
   "dependencies": {
     "@xenova/transformers": "^2.17.2",
@@ -49,7 +50,16 @@
     "glob": "^9.0.0",
     "tree-sitter": "^0.21.1",
     "tree-sitter-javascript": "^0.23.1",
+    "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);