cntx-ui 3.0.9 → 3.1.2

package/dist/bin/cntx-ui.js

@@ -2,7 +2,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { startServer, initConfig } from '../server.js';
+import { startServer, initConfig, getStatus, setupMCP, generateBundle } from '../server.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let packagePath = join(__dirname, '..', 'package.json');
 if (!existsSync(packagePath)) {
@@ -30,11 +30,27 @@ async function main() {
             case 'init':
                 console.log('🚀 Initializing cntx-ui...');
                 await initConfig();
-                console.log('🎉 cntx-ui initialized with full scaffolding!');
                 break;
             case 'mcp':
                 await startServer({ withMcp: true, skipFileWatcher: true, skipBundleGeneration: true });
                 break;
+            case 'bundle':
+                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 'status':
+                await getStatus();
+                break;
+            case 'setup-mcp':
+                setupMCP();
+                break;
             case 'version':
             case '-v':
             case '--version':
@@ -49,6 +65,9 @@ Usage:
   cntx-ui watch [port]    Start the visual dashboard and intelligence engine (default: 3333)
   cntx-ui init            Initialize cntx-ui configuration in the current directory
   cntx-ui mcp             Start the Model Context Protocol (MCP) server on stdio
+  cntx-ui bundle [name]   Generate specific bundle (default: master)
+  cntx-ui status          Show current project status
+  cntx-ui setup-mcp       Add this project to Claude Desktop MCP config
   cntx-ui version         Show current version
   cntx-ui help            Show this help information
 

package/dist/lib/agent-runtime.js

@@ -39,7 +39,9 @@ export class AgentRuntime {
         let toolsReference = '';
         if (this.cntxServer.mcpServer) {
             const tools = this.cntxServer.mcpServer.getToolDefinitions();
-            toolsReference = tools.map(t => {
+            toolsReference = tools
+                .filter(t => !t.name?.includes('activities'))
+                .map(t => {
                 let params = [];
                 if (t.inputSchema?.properties) {
                     params = Object.entries(t.inputSchema.properties).map(([name, prop]) => {
@@ -50,6 +52,12 @@ export class AgentRuntime {
                 return `### \`${t.name}\`\n${t.description}\n${params.length > 0 ? '**Parameters:**\n- ' + params.join('\n- ') : '*No parameters required*'}\n`;
             }).join('\n');
         }
+        // Find TOOLS.md template
+        let toolsMdPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../templates/TOOLS.md');
+        if (!fs.existsSync(toolsMdPath)) {
+            // Fallback for dist/lib/ context
+            toolsMdPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../templates/TOOLS.md');
+        }
         const manifest = `# 🤖 Agent Handshake: ${overview.projectPath.split('/').pop()}
 
 ## Project Overview
@@ -70,7 +78,7 @@ ${toolsReference || '*(MCP Server not yet initialized, tools will appear here)*'
 ## 🛠 Complete Tool & API Reference
 Refer to the dynamic reference below for full parameter schemas and HTTP fallback endpoints.
 
-${fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '../templates/TOOLS.md'), 'utf8')}
+${fs.existsSync(toolsMdPath) ? fs.readFileSync(toolsMdPath, 'utf8') : '*(Tools documentation missing)*'}
 
 ## Working Memory
 This agent is **stateful**. All interactions in this directory are logged to a persistent SQLite database (\`.cntx/bundles.db\`), allowing for context retention across sessions.

package/dist/lib/semantic-splitter.js

@@ -9,6 +9,13 @@ import Parser from 'tree-sitter';
 import JavaScript from 'tree-sitter-javascript';
 import TypeScript from 'tree-sitter-typescript';
 import Rust from 'tree-sitter-rust';
+import Json from 'tree-sitter-json';
+import Css from 'tree-sitter-css';
+import Html from 'tree-sitter-html';
+import Sql from 'tree-sitter-sql';
+import Markdown from 'tree-sitter-markdown';
+import Toml from 'tree-sitter-toml';
+import LegacyParser from 'tree-sitter-legacy';
 import HeuristicsManager from './heuristics-manager.js';
 export default class SemanticSplitter {
     options;
@@ -20,6 +27,7 @@ export default class SemanticSplitter {
             maxChunkSize: 3000, // Max chars per chunk
             includeContext: true, // Include imports/types needed
             minFunctionSize: 40, // Skip tiny functions
+            minStructureSize: 20, // Skip tiny structures
             ...options
         };
         // Initialize tree-sitter parsers
@@ -27,17 +35,37 @@ export default class SemanticSplitter {
             javascript: new Parser(),
             typescript: new Parser(),
             tsx: new Parser(),
-            rust: new Parser()
+            rust: new Parser(),
+            json: new Parser(),
+            css: new Parser(),
+            html: new Parser(),
+            sql: new LegacyParser(),
+            markdown: new LegacyParser(),
+            toml: new LegacyParser()
         };
         this.parsers.javascript.setLanguage(JavaScript);
         this.parsers.typescript.setLanguage(TypeScript.typescript);
         this.parsers.tsx.setLanguage(TypeScript.tsx);
         this.parsers.rust.setLanguage(Rust);
+        this.parsers.json.setLanguage(Json);
+        this.parsers.css.setLanguage(Css);
+        this.parsers.html.setLanguage(Html);
+        this.parsers.sql.setLanguage(Sql);
+        this.parsers.markdown.setLanguage(Markdown);
+        this.parsers.toml.setLanguage(Toml);
         this.heuristicsManager = new HeuristicsManager();
     }
     getParser(filePath) {
         const ext = extname(filePath);
         switch (ext) {
+            case '.json': return this.parsers.json;
+            case '.css': return this.parsers.css;
+            case '.scss': return this.parsers.css;
+            case '.html': return this.parsers.html;
+            case '.sql': return this.parsers.sql;
+            case '.md': return this.parsers.markdown;
+            case '.toml': return this.parsers.toml;
+            case '.jsx': return this.parsers.javascript;
             case '.ts': return this.parsers.typescript;
             case '.tsx': return this.parsers.tsx;
             case '.rs': return this.parsers.rust;
@@ -81,13 +109,35 @@ export default class SemanticSplitter {
         const parser = this.getParser(relativePath);
         const tree = parser.parse(content);
         const root = tree.rootNode;
+        const ext = extname(relativePath).toLowerCase();
         const elements = {
             functions: [],
             types: [],
-            imports: this.extractImports(root, content, relativePath)
+            imports: []
         };
-        // Traverse AST for functions and types
-        this.traverse(root, content, relativePath, elements);
+        if (['.js', '.jsx', '.ts', '.tsx', '.rs'].includes(ext)) {
+            elements.imports = this.extractImports(root, content, relativePath);
+            // Traverse AST for functions and types
+            this.traverse(root, content, relativePath, elements);
+        }
+        else if (ext === '.json') {
+            this.extractJsonStructures(root, content, relativePath, elements);
+        }
+        else if (ext === '.css' || ext === '.scss') {
+            this.extractCssStructures(root, content, relativePath, elements);
+        }
+        else if (ext === '.html') {
+            this.extractHtmlStructures(root, content, relativePath, elements);
+        }
+        else if (ext === '.sql') {
+            this.extractSqlStructures(root, content, relativePath, elements);
+        }
+        else if (ext === '.md') {
+            this.extractMarkdownStructures(root, content, relativePath, elements);
+        }
+        else if (ext === '.toml') {
+            this.extractTomlStructures(root, content, relativePath, elements);
+        }
         // Create chunks from elements
         return this.createChunks(elements, content, relativePath);
     }
@@ -176,9 +226,183 @@ export default class SemanticSplitter {
             startLine: node.startPosition.row + 1,
             code,
             isExported: this.isExported(node),
-            isAsync: code.includes('async')
+            isAsync: code.includes('async'),
+            category: 'function'
+        };
+    }
+    mapStructureNode(name, node, content, filePath) {
+        return {
+            name,
+            type: node.type,
+            filePath,
+            startLine: node.startPosition.row + 1,
+            code: content.slice(node.startIndex, node.endIndex),
+            isExported: false,
+            isAsync: false,
+            category: 'structure'
         };
     }
+    extractJsonStructures(root, content, filePath, elements) {
+        const rootNode = root.namedChild(0);
+        if (!rootNode)
+            return;
+        if (rootNode.type === 'object') {
+            for (let i = 0; i < rootNode.namedChildCount; i++) {
+                const child = rootNode.namedChild(i);
+                if (child && child.type === 'pair') {
+                    const keyNode = child.childForFieldName('key') || child.namedChild(0);
+                    const name = keyNode ? content.slice(keyNode.startIndex, keyNode.endIndex).replace(/['"]/g, '') : 'pair';
+                    const structure = this.mapStructureNode(name, child, content, filePath);
+                    if (structure.code.length >= this.options.minStructureSize) {
+                        elements.functions.push(structure);
+                    }
+                }
+            }
+        }
+        else if (rootNode.type === 'array') {
+            for (let i = 0; i < rootNode.namedChildCount; i++) {
+                const child = rootNode.namedChild(i);
+                if (child) {
+                    const structure = this.mapStructureNode(`item_${i + 1}`, child, content, filePath);
+                    if (structure.code.length >= this.options.minStructureSize) {
+                        elements.functions.push(structure);
+                    }
+                }
+            }
+        }
+    }
+    extractCssStructures(root, content, filePath, elements) {
+        for (let i = 0; i < root.namedChildCount; i++) {
+            const node = root.namedChild(i);
+            if (!node)
+                continue;
+            if (node.type === 'rule_set' || node.type === 'at_rule') {
+                const name = this.getCssRuleName(node, content);
+                const structure = this.mapStructureNode(name, node, content, filePath);
+                if (structure.code.length >= this.options.minStructureSize) {
+                    elements.functions.push(structure);
+                }
+            }
+        }
+    }
+    getCssRuleName(node, content) {
+        const selectorsNode = node.childForFieldName('selectors') || node.namedChild(0);
+        if (selectorsNode) {
+            return content.slice(selectorsNode.startIndex, selectorsNode.endIndex).trim();
+        }
+        const code = content.slice(node.startIndex, node.endIndex);
+        return code.split('{')[0].trim() || 'rule';
+    }
+    extractHtmlStructures(root, content, filePath, elements) {
+        for (let i = 0; i < root.namedChildCount; i++) {
+            const node = root.namedChild(i);
+            if (!node)
+                continue;
+            if (node.type === 'element' || node.type === 'script_element' || node.type === 'style_element') {
+                const name = this.getHtmlElementName(node, content);
+                const structure = this.mapStructureNode(name, node, content, filePath);
+                if (structure.code.length >= this.options.minStructureSize) {
+                    elements.functions.push(structure);
+                }
+            }
+        }
+    }
+    getHtmlElementName(node, content) {
+        const startTag = node.childForFieldName('start_tag') || node.namedChild(0);
+        const tagNameNode = startTag?.childForFieldName('tag_name') || startTag?.namedChild(0);
+        if (tagNameNode) {
+            return content.slice(tagNameNode.startIndex, tagNameNode.endIndex);
+        }
+        return node.type;
+    }
+    extractSqlStructures(root, content, filePath, elements) {
+        for (let i = 0; i < root.namedChildCount; i++) {
+            const node = root.namedChild(i);
+            if (!node)
+                continue;
+            const name = this.getSqlStatementName(node, content);
+            const structure = this.mapStructureNode(name, node, content, filePath);
+            if (structure.code.length >= this.options.minStructureSize) {
+                elements.functions.push(structure);
+            }
+        }
+    }
+    getSqlStatementName(node, content) {
+        const code = content.slice(node.startIndex, node.endIndex).trim();
+        if (!code)
+            return node.type;
+        const firstLine = code.split('\n')[0];
+        const match = firstLine.match(/^\s*([A-Za-z_]+)/);
+        if (match)
+            return match[1].toUpperCase();
+        return node.type;
+    }
+    extractMarkdownStructures(root, content, filePath, elements) {
+        for (let i = 0; i < root.namedChildCount; i++) {
+            const node = root.namedChild(i);
+            if (!node)
+                continue;
+            if (this.isMarkdownStructureNode(node.type)) {
+                const name = this.getMarkdownNodeName(node, content);
+                const structure = this.mapStructureNode(name, node, content, filePath);
+                if (structure.code.length >= this.options.minStructureSize) {
+                    elements.functions.push(structure);
+                }
+            }
+        }
+    }
+    isMarkdownStructureNode(type) {
+        return [
+            'atx_heading',
+            'setext_heading',
+            'fenced_code_block',
+            'indented_code_block',
+            'tight_list',
+            'loose_list',
+            'list',
+            'block_quote',
+            'thematic_break'
+        ].includes(type);
+    }
+    getMarkdownNodeName(node, content) {
+        const text = content.slice(node.startIndex, node.endIndex).trim();
+        if (node.type === 'atx_heading') {
+            const withoutHashes = text.replace(/^#{1,6}\s*/, '').replace(/\s*#+\s*$/, '').trim();
+            return withoutHashes || 'heading';
+        }
+        if (node.type === 'setext_heading') {
+            const firstLine = text.split('\n')[0]?.trim();
+            return firstLine || 'heading';
+        }
+        if (node.type === 'fenced_code_block' || node.type === 'indented_code_block') {
+            return 'code_block';
+        }
+        if (node.type.includes('list')) {
+            return 'list';
+        }
+        if (node.type === 'block_quote') {
+            return 'blockquote';
+        }
+        if (node.type === 'thematic_break') {
+            return 'break';
+        }
+        return node.type;
+    }
+    extractTomlStructures(root, content, filePath, elements) {
+        for (let i = 0; i < root.namedChildCount; i++) {
+            const node = root.namedChild(i);
+            if (!node)
+                continue;
+            if (node.type === 'table' || node.type === 'table_array_element' || node.type === 'pair') {
+                const keyNode = node.childForFieldName('name') || node.childForFieldName('key') || node.namedChild(0);
+                const name = keyNode ? content.slice(keyNode.startIndex, keyNode.endIndex) : node.type;
+                const structure = this.mapStructureNode(name, node, content, filePath);
+                if (structure.code.length >= this.options.minStructureSize) {
+                    elements.functions.push(structure);
+                }
+            }
+        }
+    }
     mapTypeNode(node, content, filePath) {
         const nameNode = node.childForFieldName('name');
         if (!nameNode)
@@ -251,7 +475,7 @@ export default class SemanticSplitter {
                 id: `${filePath}:${func.name}:${func.startLine}`,
                 name: func.name,
                 filePath,
-                type: 'function',
+                type: func.category === 'structure' ? 'structure' : 'function',
                 subtype: func.type,
                 code: chunkCode,
                 startLine: func.startLine,

package/dist/server.js

@@ -3,9 +3,10 @@
  * Lean orchestration layer using modular architecture
  */
 import { createServer } from 'http';
-import { join, dirname, extname } from 'path';
+import { join, dirname, extname, basename } from 'path';
 import { fileURLToPath, parse } from 'url';
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+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';
@@ -18,6 +19,21 @@ 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));
+function getProjectName(cwd) {
+    const packageJsonPath = join(cwd, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+            if (typeof packageJson?.name === 'string' && packageJson.name.trim()) {
+                return packageJson.name.trim();
+            }
+        }
+        catch {
+            // Fall through to directory name
+        }
+    }
+    return basename(cwd);
+}
 export class CntxServer {
     CWD;
     CNTX_DIR;
@@ -120,7 +136,7 @@ export class CntxServer {
         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()));
+            .filter(f => ['.js', '.jsx', '.ts', '.tsx', '.rs', '.json', '.css', '.scss', '.html', '.sql', '.md', '.toml'].includes(extname(f).toLowerCase()));
         let bundleConfig = null;
         if (existsSync(this.configManager.CONFIG_FILE)) {
             bundleConfig = JSON.parse(readFileSync(this.configManager.CONFIG_FILE, 'utf8'));
@@ -218,8 +234,184 @@ export async function startServer(options = {}) {
         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);
-    // Implementation matches previous init logic
-    return [];
+    // 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');
+    let templateDir = join(__dirname, 'templates');
+    if (!existsSync(templateDir)) {
+        // Fallback for dist/ context
+        templateDir = join(__dirname, '..', 'templates');
+    }
+    const projectName = getProjectName(cwd);
+    // 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)) {
+            if (file === 'agent-config.yaml') {
+                const template = readFileSync(sourcePath, 'utf8');
+                const updated = template.replace(/^project:\s*["'].*?["']\s*$/m, `project: "${projectName}"`);
+                writeFileSync(destPath, updated, 'utf8');
+            }
+            else {
+                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');
+    }
+    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;
+    // Resolve actual file counts from glob patterns (getAllBundleInfo only
+    // returns stored counts which are 0 until bundles are generated)
+    const bundlesWithCounts = await Promise.all(bundles.map(async (bundle) => {
+        if (bundle.fileCount === 0 && bundle.patterns?.length) {
+            const files = await server.bundleManager.resolveBundleFiles(bundle.name);
+            return { ...bundle, fileCount: files.length };
+        }
+        return bundle;
+    }));
+    console.log('📊 cntx-ui Status');
+    console.log('================');
+    console.log(`Total files: ${totalFiles}`);
+    console.log(`Bundles: ${bundlesWithCounts.length}`);
+    bundlesWithCounts.forEach(bundle => {
+        const sizeStr = bundle.size > 0 ? ` (${Math.round(bundle.size / 1024)}KB)` : '';
+        console.log(`  • ${bundle.name}: ${bundle.fileCount} files${sizeStr}`);
+    });
+    return {
+        totalFiles,
+        bundles: bundlesWithCounts.length,
+        bundleDetails: bundlesWithCounts
+    };
+}
+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.9",
+  "version": "3.1.2",
   "description": "Autonomous Repository Intelligence engine with web UI and MCP server. Unified semantic code understanding, local RAG, and agent working memory.",
   "keywords": [
     "repository-intelligence",
@@ -42,15 +42,22 @@
     "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.8.tgz"
+    "test:local": "npm pack && npm install -g ./cntx-ui-3.1.0.tgz"
   },
   "dependencies": {
     "@xenova/transformers": "^2.17.2",
     "better-sqlite3": "^12.2.0",
     "glob": "^9.0.0",
     "tree-sitter": "^0.21.1",
+    "tree-sitter-css": "^0.21.1",
+    "tree-sitter-html": "^0.20.4",
     "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-json": "^0.21.0",
+    "tree-sitter-legacy": "npm:tree-sitter@^0.20.4",
+    "tree-sitter-markdown": "^0.7.1",
     "tree-sitter-rust": "^0.21.0",
+    "tree-sitter-sql": "^0.1.0",
+    "tree-sitter-toml": "^0.5.1",
     "tree-sitter-typescript": "^0.23.2",
     "ws": "^8.13.0"
   },