cntx-ui 3.0.7 → 3.0.9

package/dist/lib/treesitter-semantic-chunker.js

@@ -0,0 +1,277 @@
+/**
+ * Treesitter-based Semantic Chunker for JavaScript/TypeScript and Rust Files
+ * Uses tree-sitter for true AST-based code analysis and semantic chunking
+ * Supports JS/TS/JSX/TSX and Rust with equal treatment
+ */
+import { readFileSync, existsSync } from 'fs';
+import { extname, basename, dirname, join } from 'path';
+import { glob } from 'glob';
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+import TypeScript from 'tree-sitter-typescript';
+import Rust from 'tree-sitter-rust';
+class TreesitterSemanticChunker {
+    options;
+    parsers;
+    semanticPatterns;
+    constructor(options = {}) {
+        this.options = {
+            includeImports: true,
+            includeExports: true,
+            detectComponentTypes: true,
+            groupRelatedFiles: true,
+            minChunkSize: 100,
+            maxChunkSize: 50000,
+            namingStrategy: 'domain-based',
+            ...options
+        };
+        this.parsers = {};
+        this.initializeParsers();
+        this.semanticPatterns = {
+            reactComponent: this.isReactComponent.bind(this),
+            reactHook: this.isReactHook.bind(this),
+            expressRoute: this.isExpressRoute.bind(this),
+            expressMiddleware: this.isExpressMiddleware.bind(this),
+            cliCommand: this.isCliCommand.bind(this),
+            utilityFunction: this.isUtilityFunction.bind(this),
+            apiHandler: this.isApiHandler.bind(this),
+            typeDefinition: this.isTypeDefinition.bind(this),
+            configModule: this.isConfigModule.bind(this)
+        };
+    }
+    initializeParsers() {
+        this.parsers.javascript = new Parser();
+        this.parsers.javascript.setLanguage(JavaScript);
+        this.parsers.typescript = new Parser();
+        this.parsers.typescript.setLanguage(TypeScript.typescript);
+        this.parsers.tsx = new Parser();
+        this.parsers.tsx.setLanguage(TypeScript.tsx);
+        this.parsers.rust = new Parser();
+        this.parsers.rust.setLanguage(Rust);
+    }
+    getParser(filePath) {
+        const ext = extname(filePath);
+        switch (ext) {
+            case '.ts': return this.parsers.typescript;
+            case '.tsx': return this.parsers.tsx;
+            case '.rs': return this.parsers.rust;
+            case '.js':
+            case '.jsx':
+            default: return this.parsers.javascript;
+        }
+    }
+    async analyzeProject(projectPath, patterns = ['**/*.{js,jsx,ts,tsx,rs}']) {
+        console.log('🔍 Starting treesitter-based semantic analysis...');
+        const files = await this.findFiles(projectPath, patterns);
+        console.log(`📁 Found ${files.length} files to analyze`);
+        const analysis = await this.analyzeFiles(files, projectPath);
+        const successfulFiles = Object.keys(analysis).filter(f => !analysis[f].error);
+        const relationshipGraph = this.buildRelationshipGraph(analysis);
+        const chunks = await this.createSmartChunks(analysis, relationshipGraph);
+        return {
+            summary: this.generateSummary(analysis, chunks),
+            files: analysis,
+            chunks: chunks,
+            relationshipGraph,
+            recommendations: this.generateRecommendations(analysis, chunks)
+        };
+    }
+    async findFiles(projectPath, patterns) {
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: projectPath,
+                ignore: ['node_modules/**', 'dist/**', 'build/**', '.git/**']
+            });
+            files.push(...matches);
+        }
+        return [...new Set(files)];
+    }
+    async analyzeFiles(filePaths, projectPath) {
+        const analysis = {};
+        for (const relativePath of filePaths) {
+            const fullPath = join(projectPath, relativePath);
+            if (!existsSync(fullPath))
+                continue;
+            try {
+                const content = readFileSync(fullPath, 'utf8');
+                const fileAnalysis = await this.analyzeFile(fullPath, content);
+                fileAnalysis.path = relativePath;
+                analysis[relativePath] = fileAnalysis;
+            }
+            catch (error) {
+                analysis[relativePath] = { error: error.message, path: relativePath };
+            }
+        }
+        return analysis;
+    }
+    async analyzeFile(filePath, content) {
+        const parser = this.getParser(filePath);
+        let tree, rootNode;
+        try {
+            tree = parser.parse(content);
+            rootNode = tree.rootNode;
+        }
+        catch (error) {
+            throw new Error(`Tree-sitter parse failed: ${error.message}`);
+        }
+        const analysis = {
+            path: filePath,
+            fileName: basename(filePath),
+            dirName: basename(dirname(filePath)),
+            extension: extname(filePath),
+            size: content.length,
+            lines: content.split('\n').length,
+            ast: {
+                functions: this.extractFunctions(rootNode, content),
+                classes: this.extractClasses(rootNode, content),
+                imports: this.extractImports(rootNode, content),
+                exports: this.extractExports(rootNode, content),
+                variables: this.extractVariables(rootNode, content),
+                jsxElements: this.extractJsxElements(rootNode, content),
+                typeDefinitions: this.extractTypeDefinitions(rootNode, content)
+            },
+            semanticType: this.classifyFileSemantics(rootNode, content, filePath),
+            businessDomain: this.extractBusinessDomain(rootNode, content, filePath),
+            technicalPatterns: this.identifyTechnicalPatterns(rootNode, content),
+            dependencies: this.analyzeDependencies(rootNode, content),
+            complexity: this.calculateAstComplexity(rootNode),
+            codeSignature: this.generateCodeSignature(rootNode, content),
+            semanticTags: []
+        };
+        analysis.semanticTags = this.generateSemanticTags(analysis);
+        return analysis;
+    }
+    extractFunctions(rootNode, content) {
+        const functions = [];
+        const functionDeclarations = this.queryNode(rootNode, ['function_declaration']);
+        functions.push(...functionDeclarations.map(capture => ({
+            name: this.getNodeText(capture.node, content),
+            type: 'function_declaration',
+            startPosition: capture.node.startPosition,
+            isExported: this.isNodeExported(capture.node)
+        })));
+        const rustFunctions = this.queryNode(rootNode, ['function_item']);
+        functions.push(...rustFunctions.map(capture => ({
+            name: this.getNodeText(capture.node, content),
+            type: 'function_item',
+            startPosition: capture.node.startPosition,
+            isExported: this.isNodeExported(capture.node)
+        })));
+        return functions;
+    }
+    extractClasses(rootNode, content) {
+        return [];
+    }
+    extractImports(rootNode, content) {
+        return [];
+    }
+    extractExports(rootNode, content) {
+        return [];
+    }
+    extractVariables(rootNode, content) {
+        return [];
+    }
+    extractJsxElements(rootNode, content) {
+        return [];
+    }
+    extractTypeDefinitions(rootNode, content) {
+        return [];
+    }
+    classifyFileSemantics(rootNode, content, filePath) {
+        return 'module';
+    }
+    isReactComponent(rootNode, content, filePath) {
+        return false;
+    }
+    isReactHook(rootNode, content, filePath) {
+        return false;
+    }
+    isExpressRoute(rootNode, content, filePath) {
+        return false;
+    }
+    isExpressMiddleware(rootNode, content, filePath) {
+        return false;
+    }
+    isCliCommand(rootNode, content, filePath) {
+        return false;
+    }
+    isUtilityFunction(rootNode, content, filePath) {
+        return false;
+    }
+    isApiHandler(rootNode, content, filePath) {
+        return false;
+    }
+    isTypeDefinition(rootNode, content, filePath) {
+        return false;
+    }
+    isConfigModule(rootNode, content, filePath) {
+        return false;
+    }
+    extractBusinessDomain(rootNode, content, filePath) {
+        return [];
+    }
+    identifyTechnicalPatterns(rootNode, content) {
+        return [];
+    }
+    buildRelationshipGraph(analysis) {
+        return {};
+    }
+    async createSmartChunks(analysis, relationshipGraph) {
+        return [];
+    }
+    generateSummary(analysis, chunks) {
+        return {};
+    }
+    generateRecommendations(analysis, chunks) {
+        return [];
+    }
+    queryNode(node, types) {
+        const results = [];
+        const traverse = (currentNode) => {
+            if (types.includes(currentNode.type)) {
+                results.push({ node: currentNode });
+            }
+            for (let i = 0; i < currentNode.namedChildCount; i++) {
+                const child = currentNode.namedChild(i);
+                if (child)
+                    traverse(child);
+            }
+        };
+        traverse(node);
+        return results;
+    }
+    getNodeText(node, content) {
+        return content.slice(node.startIndex, node.endIndex);
+    }
+    isNodeExported(node) {
+        let parent = node.parent;
+        while (parent) {
+            if (parent.type === 'export_statement' || parent.type === 'export_declaration' || parent.type === 'visibility_modifier') {
+                return true;
+            }
+            parent = parent.parent;
+        }
+        return false;
+    }
+    calculateOverlap(arrayA, arrayB) {
+        const setA = new Set(arrayA);
+        const setB = new Set(arrayB);
+        const intersection = new Set([...setA].filter(x => setB.has(x)));
+        const union = new Set([...setA, ...setB]);
+        return union.size === 0 ? 0 : intersection.size / union.size;
+    }
+    generateSemanticTags(analysis) {
+        return [];
+    }
+    calculateAstComplexity(rootNode) {
+        return { score: 1, level: 'low' };
+    }
+    analyzeDependencies(rootNode, content) {
+        return { internal: [], external: [], relative: [] };
+    }
+    generateCodeSignature(rootNode, content) {
+        return {};
+    }
+}
+export default TreesitterSemanticChunker;

package/dist/lib/websocket-manager.js

@@ -0,0 +1,268 @@
+/**
+ * WebSocket Manager for cntx-ui
+ * Handles real-time communication between server and dashboard
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+export default class WebSocketManager {
+    bundleManager;
+    configManager;
+    verbose;
+    clients;
+    wss;
+    constructor(bundleManager, configManager, options = {}) {
+        this.bundleManager = bundleManager;
+        this.configManager = configManager;
+        this.verbose = options.verbose || false;
+        this.clients = new Set();
+        this.wss = null;
+    }
+    initialize(httpServer) {
+        this.wss = new WebSocketServer({ server: httpServer });
+        this.wss.on('connection', (ws) => {
+            this.handleConnection(ws);
+        });
+        if (this.verbose) {
+            console.log('🔌 WebSocket server initialized');
+        }
+    }
+    handleConnection(ws) {
+        this.clients.add(ws);
+        if (this.verbose) {
+            console.log(`📱 WebSocket client connected (${this.clients.size} total clients)`);
+        }
+        // Send initial status
+        this.sendUpdate(ws);
+        ws.on('close', () => {
+            this.clients.delete(ws);
+            if (this.verbose) {
+                console.log(`📱 WebSocket client disconnected (${this.clients.size} total clients)`);
+            }
+        });
+        ws.on('error', (error) => {
+            if (this.verbose) {
+                console.error('WebSocket client error:', error.message);
+            }
+            this.clients.delete(ws);
+        });
+        ws.on('message', (message) => {
+            try {
+                const data = JSON.parse(message.toString());
+                this.handleClientMessage(ws, data);
+            }
+            catch (error) {
+                if (this.verbose) {
+                    console.error('Invalid WebSocket message:', error.message);
+                }
+            }
+        });
+    }
+    handleClientMessage(ws, data) {
+        if (this.verbose) {
+            console.log('📩 Received client message:', data.type);
+        }
+        switch (data.type) {
+            case 'ping':
+                ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
+                break;
+            case 'get_status':
+                this.sendUpdate(ws);
+                break;
+            default:
+                if (this.verbose) {
+                    console.warn('Unknown message type:', data.type);
+                }
+        }
+    }
+    get connectedClientsCount() {
+        return this.clients.size;
+    }
+    broadcast(type, payload) {
+        const data = JSON.stringify({ type, payload, timestamp: Date.now() });
+        this.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+                try {
+                    client.send(data);
+                }
+                catch (error) {
+                    this.clients.delete(client);
+                }
+            }
+        });
+    }
+    /**
+     * Broadcast a general status update
+     */
+    broadcastUpdate() {
+        if (this.verbose) {
+            console.log('📢 Broadcasting status update to all clients');
+        }
+        this.clients.forEach(client => {
+            this.sendUpdate(client);
+        });
+    }
+    sendUpdate(client) {
+        if (client.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            const bundles = this.configManager.getBundles();
+            const bundleData = Array.from(bundles.entries()).map(([name, bundle]) => ({
+                name,
+                changed: bundle.changed,
+                fileCount: bundle.files.length,
+                content: bundle.content ? bundle.content.substring(0, 200) + '...' : '',
+                files: bundle.files,
+                lastGenerated: bundle.generated,
+                size: bundle.size,
+                patterns: bundle.patterns
+            }));
+            const updateData = {
+                type: 'status_update',
+                payload: {
+                    bundles: bundleData,
+                    scanning: this.bundleManager.isScanning || false,
+                    totalFiles: this.bundleManager.fileSystemManager?.getAllFiles()?.length || 0
+                },
+                timestamp: Date.now()
+            };
+            client.send(JSON.stringify(updateData));
+        }
+        catch (error) {
+            if (this.verbose) {
+                console.error('Failed to send WebSocket update:', error.message);
+            }
+            this.clients.delete(client);
+        }
+    }
+    broadcastBundleUpdate(bundleName) {
+        if (this.verbose) {
+            console.log(`📢 Broadcasting update for bundle: ${bundleName}`);
+        }
+        const bundle = this.configManager.getBundles().get(bundleName);
+        if (!bundle)
+            return;
+        const updateData = {
+            type: 'bundle_update',
+            payload: {
+                name: bundleName,
+                changed: bundle.changed,
+                fileCount: bundle.files.length,
+                size: bundle.size,
+                generated: bundle.generated
+            },
+            timestamp: Date.now()
+        };
+        this.broadcastToActiveClients(updateData);
+    }
+    broadcastFileChange(filename, eventType) {
+        const updateData = {
+            type: 'file_change',
+            payload: {
+                filename,
+                eventType
+            },
+            timestamp: Date.now()
+        };
+        this.broadcastToActiveClients(updateData);
+    }
+    broadcastStatusUpdate(status) {
+        const updateData = {
+            type: 'status',
+            payload: status,
+            timestamp: Date.now()
+        };
+        this.broadcastToActiveClients(updateData);
+    }
+    ping() {
+        const pingData = { type: 'ping', timestamp: Date.now() };
+        this.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify(pingData));
+            }
+            else {
+                this.clients.delete(client);
+            }
+        });
+    }
+    close() {
+        if (this.wss) {
+            if (this.verbose) {
+                console.log('🔌 Closing WebSocket server');
+            }
+            this.clients.forEach(client => {
+                try {
+                    client.terminate();
+                }
+                catch (error) {
+                    if (this.verbose) {
+                        console.error('Error closing WebSocket client:', error.message);
+                    }
+                }
+            });
+            this.wss.close(() => {
+                if (this.verbose) {
+                    console.log('🔌 WebSocket server closed');
+                }
+            });
+            this.clients.clear();
+        }
+    }
+    getStatus() {
+        return {
+            connected: this.clients.size,
+            server: this.wss ? 'running' : 'stopped'
+        };
+    }
+    onBundleGenerated(bundleName) {
+        this.broadcastBundleUpdate(bundleName);
+    }
+    onFileChanged(filename, eventType) {
+        this.broadcastFileChange(filename, eventType);
+        // Also broadcast bundle changes if needed
+        const affectedBundles = this.getAffectedBundles(filename);
+        affectedBundles.forEach(bundleName => {
+            this.broadcastBundleUpdate(bundleName);
+        });
+    }
+    onBundleSyncStarted(bundleName) {
+        this.broadcast('bundle_sync_started', { name: bundleName });
+    }
+    onBundleSyncCompleted(bundleName) {
+        this.broadcast('bundle_sync_completed', { name: bundleName });
+    }
+    onBundleSyncFailed(bundleName, error) {
+        this.broadcast('bundle_sync_failed', { name: bundleName, error: error.message });
+    }
+    broadcastBundleFileChanged(bundleName, filename) {
+        this.broadcast('bundle_file_changed', { bundleName, filename });
+    }
+    broadcastBundleSyncCompleted(bundleName) {
+        this.broadcast('bundle_sync_completed', { bundleName });
+    }
+    broadcastToActiveClients(data) {
+        const message = JSON.stringify(data);
+        this.clients.forEach(client => {
+            if (client.readyState === WebSocket.OPEN) {
+                try {
+                    client.send(message);
+                }
+                catch (error) {
+                    if (this.verbose) {
+                        console.error('Failed to send WebSocket update:', error.message);
+                    }
+                    this.clients.delete(client);
+                }
+            }
+        });
+    }
+    getAffectedBundles(filename) {
+        const bundles = this.configManager.getBundles();
+        const affectedBundles = [];
+        bundles.forEach((bundle, name) => {
+            const matchesBundle = bundle.patterns.some(pattern => this.bundleManager.fileSystemManager.matchesPattern(filename, pattern));
+            if (matchesBundle) {
+                affectedBundles.push(name);
+            }
+        });
+        return affectedBundles;
+    }
+}