cntx-ui 3.1.2 → 3.1.4

package/README.md

@@ -40,6 +40,10 @@ Agents interact through MCP tools or the HTTP API:
 | `agent/query` | Semantic search — "where is auth handled?" |
 | `agent/investigate` | Find integration points for a new feature |
 | `agent/organize` | Audit and optimize bundle structure |
+| `artifacts/list` | List normalized project artifacts (OpenAPI + Navigation) |
+| `artifacts/get_openapi` | Return OpenAPI artifact summary and payload |
+| `artifacts/get_navigation` | Return Navigation artifact summary and payload |
+| `artifacts/summarize` | Compact cross-artifact summary for agents |
 | `list_bundles` | List all bundles with metadata |
 | `get_bundle` | Get full bundle content as XML |
 | `get_semantic_chunks` | Get all analyzed code chunks |
@@ -47,6 +51,11 @@ Agents interact through MCP tools or the HTTP API:
 
 Full tool reference with parameters is generated in `.cntx/AGENT.md` and `.cntx/TOOLS.md`.
 
+Artifact HTTP endpoints:
+- `GET /api/artifacts`
+- `GET /api/artifacts/openapi`
+- `GET /api/artifacts/navigation`
+
 ## How it works
 
 1. **tree-sitter** parses source files into AST, extracts functions/types/interfaces

package/dist/bin/cntx-ui.js

@@ -14,7 +14,12 @@ const command = args[0] || 'help';
 const isVerbose = args.includes('--verbose');
 // Graceful shutdown
 process.on('SIGINT', () => {
-    console.log('\n👋 Shutting down cntx-ui...');
+    if (command === 'mcp') {
+        process.stderr.write('\n👋 Shutting down cntx-ui...\n');
+    }
+    else {
+        console.log('\n👋 Shutting down cntx-ui...');
+    }
     process.exit(0);
 });
 async function main() {
@@ -32,7 +37,7 @@ async function main() {
                 await initConfig();
                 break;
             case 'mcp':
-                await startServer({ withMcp: true, skipFileWatcher: true, skipBundleGeneration: true });
+                await startServer({ withMcp: true, skipFileWatcher: true, isMcp: true });
                 break;
             case 'bundle':
                 const bundleName = args[1] || 'master';

package/dist/lib/api-router.js

@@ -81,6 +81,9 @@ export default class APIRouter {
             if (pathname === '/api/vector-db/search' && method === 'POST') {
                 return await this.handlePostVectorDbSearch(req, res);
             }
+            if (pathname === '/api/vector-db/projection' && method === 'GET') {
+                return await this.handleGetVectorDbProjection(req, res);
+            }
             if (pathname === '/api/vector-db/network' && method === 'GET') {
                 return await this.handleGetVectorDbNetwork(req, res);
             }
@@ -106,6 +109,16 @@ export default class APIRouter {
             if (pathname === '/api/mcp-status' && method === 'GET') {
                 return await this.handleGetMcpStatus(req, res);
             }
+            // === Artifact Endpoints ===
+            if (pathname === '/api/artifacts' && method === 'GET') {
+                return await this.handleGetArtifacts(req, res);
+            }
+            if (pathname === '/api/artifacts/openapi' && method === 'GET') {
+                return await this.handleGetArtifact(req, res, 'openapi');
+            }
+            if (pathname === '/api/artifacts/navigation' && method === 'GET') {
+                return await this.handleGetArtifact(req, res, 'navigation');
+            }
             // === Rule Management ===
             if (pathname === '/api/cursor-rules' && method === 'GET') {
                 return await this.handleGetCursorRules(req, res);
@@ -301,6 +314,103 @@ export default class APIRouter {
         const results = await this.vectorStore.search(query, { limit });
         this.sendResponse(res, 200, results);
     }
+    async handleGetVectorDbProjection(req, res) {
+        const dbManager = this.configManager.dbManager;
+        const embeddingCountRow = dbManager.db.prepare('SELECT COUNT(*) as count FROM vector_embeddings').get();
+        const currentEmbeddingCount = embeddingCountRow.count;
+        if (currentEmbeddingCount === 0) {
+            return this.sendResponse(res, 200, {
+                points: [],
+                meta: { totalPoints: 0, embeddingCount: 0, computedAt: null, cached: false }
+            });
+        }
+        // Check cache freshness
+        const cachedCount = dbManager.getProjectionEmbeddingCount();
+        if (cachedCount === currentEmbeddingCount) {
+            const cached = dbManager.getProjections();
+            if (cached) {
+                // Join with chunk metadata
+                const chunkMap = new Map();
+                const chunks = dbManager.db.prepare('SELECT * FROM semantic_chunks').all();
+                for (const c of chunks) {
+                    const mapped = dbManager.mapChunkRow(c);
+                    chunkMap.set(mapped.id, mapped);
+                }
+                const points = cached.map(p => {
+                    const chunk = chunkMap.get(p.chunkId);
+                    return {
+                        id: p.chunkId,
+                        x: p.x,
+                        y: p.y,
+                        name: chunk?.name || 'unknown',
+                        filePath: chunk?.filePath || '',
+                        purpose: chunk?.purpose || 'unknown',
+                        semanticType: chunk?.subtype || chunk?.type || 'unknown',
+                        complexity: chunk?.complexity?.score || 0,
+                        directory: chunk?.filePath ? chunk.filePath.split('/').slice(0, -1).join('/') || '.' : '.'
+                    };
+                });
+                return this.sendResponse(res, 200, {
+                    points,
+                    meta: { totalPoints: points.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: true }
+                });
+            }
+        }
+        // Compute fresh UMAP projection
+        const rows = dbManager.db.prepare(`
+      SELECT ve.chunk_id, ve.embedding, sc.name, sc.file_path, sc.type, sc.subtype, sc.complexity_score, sc.purpose
+      FROM vector_embeddings ve
+      JOIN semantic_chunks sc ON ve.chunk_id = sc.id
+    `).all();
+        if (rows.length < 2) {
+            return this.sendResponse(res, 200, {
+                points: rows.map((r) => ({
+                    id: r.chunk_id, x: 0, y: 0,
+                    name: r.name, filePath: r.file_path, purpose: r.purpose || 'unknown',
+                    semanticType: r.subtype || r.type || 'unknown', complexity: r.complexity_score || 0,
+                    directory: r.file_path ? r.file_path.split('/').slice(0, -1).join('/') || '.' : '.'
+                })),
+                meta: { totalPoints: rows.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: false }
+            });
+        }
+        // Extract embeddings as number[][]
+        const embeddings = rows.map((r) => {
+            const buf = r.embedding;
+            const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+            return Array.from(floats);
+        });
+        // Run UMAP
+        const { UMAP } = await import('umap-js');
+        const umap = new UMAP({
+            nNeighbors: Math.min(15, rows.length - 1),
+            minDist: 0.1,
+            nComponents: 2
+        });
+        const projected = umap.fit(embeddings);
+        // Save to cache
+        const projections = rows.map((r, i) => ({
+            chunkId: r.chunk_id,
+            x: projected[i][0],
+            y: projected[i][1]
+        }));
+        dbManager.saveProjections(projections, currentEmbeddingCount);
+        // Build response
+        const points = rows.map((r, i) => ({
+            id: r.chunk_id,
+            x: projected[i][0],
+            y: projected[i][1],
+            name: r.name,
+            filePath: r.file_path,
+            purpose: r.purpose || 'unknown',
+            semanticType: r.subtype || r.type || 'unknown',
+            complexity: r.complexity_score || 0,
+            directory: r.file_path ? r.file_path.split('/').slice(0, -1).join('/') || '.' : '.'
+        }));
+        this.sendResponse(res, 200, {
+            points,
+            meta: { totalPoints: points.length, embeddingCount: currentEmbeddingCount, computedAt: new Date().toISOString(), cached: false }
+        });
+    }
     async handleGetVectorDbNetwork(req, res) {
         const chunks = this.configManager.dbManager.db.prepare('SELECT * FROM semantic_chunks').all();
         const embeddings = this.configManager.dbManager.db.prepare('SELECT * FROM vector_embeddings').all();
@@ -350,6 +460,15 @@ export default class APIRouter {
             message: isRunning ? 'MCP server is running' : 'MCP server integration available'
         });
     }
+    async handleGetArtifacts(req, res) {
+        const artifacts = this.cntxServer.artifactManager.refresh();
+        this.sendResponse(res, 200, { artifacts });
+    }
+    async handleGetArtifact(req, res, type) {
+        this.cntxServer.artifactManager.refresh();
+        const payload = this.cntxServer.artifactManager.getPayload(type);
+        this.sendResponse(res, 200, payload);
+    }
     async handleGetCursorRules(req, res) {
         const filePath = join(this.configManager.CWD, '.cursorrules');
         if (existsSync(filePath)) {

package/dist/lib/artifact-manager.js

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+export default class ArtifactManager {
+    cwd;
+    records;
+    constructor(cwd) {
+        this.cwd = cwd;
+        this.records = new Map();
+    }
+    refresh() {
+        const openapi = this.resolveOpenApiArtifact();
+        const navigation = this.resolveNavigationArtifact();
+        this.records.set('openapi', openapi);
+        this.records.set('navigation', navigation);
+        return this.list();
+    }
+    list() {
+        if (this.records.size === 0) {
+            this.refresh();
+        }
+        return Array.from(this.records.values());
+    }
+    get(type) {
+        if (!this.records.has(type)) {
+            this.refresh();
+        }
+        return this.records.get(type);
+    }
+    getPayload(type) {
+        const record = this.get(type);
+        if (!record) {
+            return {
+                type,
+                filePath: '',
+                format: 'json',
+                exists: false,
+                summary: {}
+            };
+        }
+        if (!record.exists) {
+            return { ...record };
+        }
+        try {
+            const absolutePath = join(this.cwd, record.filePath);
+            const raw = readFileSync(absolutePath, 'utf8');
+            if (record.format === 'json') {
+                return { ...record, parsed: JSON.parse(raw), raw };
+            }
+            return { ...record, raw };
+        }
+        catch {
+            return { ...record };
+        }
+    }
+    resolveOpenApiArtifact() {
+        const candidates = [
+            { path: 'openapi.json', format: 'json' },
+            { path: 'openapi.yaml', format: 'yaml' },
+            { path: 'openapi.yml', format: 'yaml' }
+        ];
+        for (const candidate of candidates) {
+            const absolutePath = join(this.cwd, candidate.path);
+            if (!existsSync(absolutePath))
+                continue;
+            const summary = this.summarizeOpenApi(absolutePath, candidate.format);
+            return {
+                type: 'openapi',
+                filePath: candidate.path,
+                format: candidate.format,
+                exists: true,
+                summary
+            };
+        }
+        return {
+            type: 'openapi',
+            filePath: 'openapi.json',
+            format: 'json',
+            exists: false,
+            summary: {}
+        };
+    }
+    resolveNavigationArtifact() {
+        const candidates = [
+            { path: 'navigation.manifest.json', format: 'json' },
+            { path: 'navigation.json', format: 'json' }
+        ];
+        for (const candidate of candidates) {
+            const absolutePath = join(this.cwd, candidate.path);
+            if (!existsSync(absolutePath))
+                continue;
+            const summary = this.summarizeNavigation(absolutePath);
+            return {
+                type: 'navigation',
+                filePath: candidate.path,
+                format: candidate.format,
+                exists: true,
+                summary
+            };
+        }
+        return {
+            type: 'navigation',
+            filePath: 'navigation.manifest.json',
+            format: 'json',
+            exists: false,
+            summary: {}
+        };
+    }
+    summarizeOpenApi(absolutePath, format) {
+        try {
+            const raw = readFileSync(absolutePath, 'utf8');
+            if (format === 'json') {
+                const parsed = JSON.parse(raw);
+                const endpointCount = parsed.paths ? Object.keys(parsed.paths).length : 0;
+                return {
+                    title: parsed.info?.title,
+                    version: parsed.info?.version,
+                    endpointCount
+                };
+            }
+            const titleMatch = raw.match(/^\s*title:\s*["']?(.+?)["']?\s*$/m);
+            const versionMatch = raw.match(/^\s*version:\s*["']?(.+?)["']?\s*$/m);
+            return {
+                title: titleMatch?.[1],
+                version: versionMatch?.[1]
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    summarizeNavigation(absolutePath) {
+        try {
+            const parsed = JSON.parse(readFileSync(absolutePath, 'utf8'));
+            return {
+                title: parsed.project?.name || parsed.name,
+                version: parsed.version ? String(parsed.version) : undefined,
+                routeCount: Array.isArray(parsed.routes) ? parsed.routes.length : 0,
+                stateCount: Array.isArray(parsed.states) ? parsed.states.length : 0,
+                flowCount: Array.isArray(parsed.flows) ? parsed.flows.length : 0,
+                viewportCount: Array.isArray(parsed.viewports) ? parsed.viewports.length : 0
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/lib/bundle-manager.js

@@ -170,6 +170,10 @@ export default class BundleManager {
         try {
             const fullPath = this.fileSystemManager.fullPath(relativePath);
             const content = readFileSync(fullPath, 'utf8');
+            // Skip files over 100KB in bundle XML to prevent string length crashes
+            if (content.length > 100_000) {
+                return `  <file path="${this.escapeXml(relativePath)}" skipped="too-large" size="${content.length}" />\n`;
+            }
             const chunks = this.db.getChunksByFile(relativePath);
             let xml = `  <file path="${this.escapeXml(relativePath)}">\n`;
             if (chunks.length > 0) {

package/dist/lib/database-manager.js

@@ -79,6 +79,16 @@ export default class DatabaseManager {
         FOREIGN KEY(session_id) REFERENCES agent_sessions(id) ON DELETE CASCADE
       );
       
+      -- UMAP Projection Cache
+      CREATE TABLE IF NOT EXISTS umap_projections (
+        chunk_id TEXT PRIMARY KEY,
+        x REAL NOT NULL,
+        y REAL NOT NULL,
+        computed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        embedding_count INTEGER NOT NULL,
+        FOREIGN KEY(chunk_id) REFERENCES semantic_chunks(id) ON DELETE CASCADE
+      );
+
       CREATE INDEX IF NOT EXISTS idx_bundles_changed ON bundles(changed);
       CREATE INDEX IF NOT EXISTS idx_chunks_file ON semantic_chunks(file_path);
       CREATE INDEX IF NOT EXISTS idx_chunks_purpose ON semantic_chunks(purpose);
@@ -265,6 +275,44 @@ export default class DatabaseManager {
             return [];
         }
     }
+    // UMAP Projection Cache
+    saveProjections(projections, embeddingCount) {
+        const transaction = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM umap_projections').run();
+            const stmt = this.db.prepare('INSERT INTO umap_projections (chunk_id, x, y, embedding_count) VALUES (?, ?, ?, ?)');
+            for (const p of projections) {
+                stmt.run(p.chunkId, p.x, p.y, embeddingCount);
+            }
+        });
+        try {
+            transaction();
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to save projections:', error.message);
+            return false;
+        }
+    }
+    getProjections() {
+        try {
+            const rows = this.db.prepare('SELECT chunk_id, x, y, embedding_count FROM umap_projections').all();
+            if (rows.length === 0)
+                return null;
+            return rows.map(r => ({ chunkId: r.chunk_id, x: r.x, y: r.y, embeddingCount: r.embedding_count }));
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getProjectionEmbeddingCount() {
+        try {
+            const row = this.db.prepare('SELECT embedding_count FROM umap_projections LIMIT 1').get();
+            return row?.embedding_count ?? 0;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
     // Close database connection
     close() {
         if (this.db) {

package/dist/lib/mcp-server.js

@@ -92,6 +92,28 @@ export class MCPServer {
             }
             // Legacy tools mapping
             switch (name) {
+                case 'artifacts/list': {
+                    const artifacts = this.cntxServer.artifactManager.refresh();
+                    return this.createSuccessResponse(id, { content: [{ type: 'text', text: JSON.stringify({ artifacts }, null, 2) }] });
+                }
+                case 'artifacts/get_openapi': {
+                    this.cntxServer.artifactManager.refresh();
+                    const payload = this.cntxServer.artifactManager.getPayload('openapi');
+                    return this.createSuccessResponse(id, { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] });
+                }
+                case 'artifacts/get_navigation': {
+                    this.cntxServer.artifactManager.refresh();
+                    const payload = this.cntxServer.artifactManager.getPayload('navigation');
+                    return this.createSuccessResponse(id, { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] });
+                }
+                case 'artifacts/summarize': {
+                    const artifacts = this.cntxServer.artifactManager.refresh();
+                    const summary = {
+                        openapi: artifacts.find((a) => a.type === 'openapi')?.summary ?? {},
+                        navigation: artifacts.find((a) => a.type === 'navigation')?.summary ?? {}
+                    };
+                    return this.createSuccessResponse(id, { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] });
+                }
                 case 'list_bundles':
                     const bundles = this.cntxServer.bundleManager.getAllBundleInfo();
                     return this.createSuccessResponse(id, { content: [{ type: 'text', text: JSON.stringify(bundles, null, 2) }] });
@@ -144,6 +166,26 @@ export class MCPServer {
                 description: 'Investigation Mode: Suggest integration points.',
                 inputSchema: { type: 'object', properties: { feature: { type: 'string' } }, required: ['feature'] }
             },
+            {
+                name: 'artifacts/list',
+                description: 'List normalized project artifacts (OpenAPI and Navigation manifests).',
+                inputSchema: { type: 'object', properties: {} }
+            },
+            {
+                name: 'artifacts/get_openapi',
+                description: 'Get OpenAPI artifact payload (summary + parsed content when JSON).',
+                inputSchema: { type: 'object', properties: {} }
+            },
+            {
+                name: 'artifacts/get_navigation',
+                description: 'Get Navigation artifact payload (summary + parsed manifest).',
+                inputSchema: { type: 'object', properties: {} }
+            },
+            {
+                name: 'artifacts/summarize',
+                description: 'Get compact summaries for OpenAPI and Navigation artifacts.',
+                inputSchema: { type: 'object', properties: {} }
+            },
             {
                 name: 'list_bundles',
                 description: 'List all project bundles.',

package/dist/lib/semantic-splitter.js

@@ -106,6 +106,11 @@ export default class SemanticSplitter {
         if (!existsSync(fullPath))
             return [];
         const content = readFileSync(fullPath, 'utf8');
+        // Skip files larger than 200KB — tree-sitter and embeddings can't handle them well
+        if (content.length > 200_000) {
+            console.warn(`Skipping ${relativePath}: file too large (${Math.round(content.length / 1024)}KB)`);
+            return [];
+        }
         const parser = this.getParser(relativePath);
         const tree = parser.parse(content);
         const root = tree.rootNode;
@@ -394,7 +399,10 @@ export default class SemanticSplitter {
             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);
+                // Legacy parser uses namedChild instead of childForFieldName
+                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) {

package/dist/lib/simple-vector-store.js

@@ -9,19 +9,29 @@ export default class SimpleVectorStore {
     modelName;
     pipe;
     initialized;
+    isMcp;
     constructor(databaseManager, options = {}) {
         this.db = databaseManager;
         this.modelName = options.modelName || 'Xenova/all-MiniLM-L6-v2';
         this.pipe = null;
         this.initialized = false;
+        this.isMcp = options.isMcp || false;
+    }
+    log(message) {
+        if (this.isMcp) {
+            process.stderr.write(message + '\n');
+        }
+        else {
+            console.log(message);
+        }
     }
     async init() {
         if (this.initialized)
             return;
-        console.log(`🤖 Initializing local RAG engine (${this.modelName})...`);
+        this.log(`🤖 Initializing local RAG engine (${this.modelName})...`);
         this.pipe = await pipeline('feature-extraction', this.modelName);
         this.initialized = true;
-        console.log('✅ Local RAG engine ready');
+        this.log('✅ Local RAG engine ready');
     }
     async generateEmbedding(text) {
         await this.init();
@@ -37,8 +47,9 @@ export default class SimpleVectorStore {
         const existing = this.db.getEmbedding(chunkId);
         if (existing)
             return existing;
-        // Generate new embedding
-        const textToEmbed = `${chunk.name} ${chunk.purpose} ${chunk.code}`;
+        // Generate new embedding — truncate to 8KB to stay within model limits
+        const rawText = `${chunk.name} ${chunk.purpose} ${chunk.code}`;
+        const textToEmbed = rawText.length > 8192 ? rawText.slice(0, 8192) : rawText;
         const embedding = await this.generateEmbedding(textToEmbed);
         // Save to SQLite
         this.db.saveEmbedding(chunkId, embedding, this.modelName);