cntx-ui 3.1.0 → 3.1.3

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

@@ -32,7 +32,7 @@ async function main() {
                 await initConfig();
                 break;
             case 'mcp':
-                await startServer({ withMcp: true, skipFileWatcher: true, skipBundleGeneration: true });
+                await startServer({ withMcp: true, skipFileWatcher: true });
                 break;
             case 'bundle':
                 const bundleName = args[1] || 'master';

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/api-router.js

@@ -106,6 +106,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);
@@ -350,6 +360,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/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

@@ -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;
@@ -78,16 +106,43 @@ 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;
+        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 +231,186 @@ 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') {
+                // 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) {
+                    elements.functions.push(structure);
+                }
+            }
+        }
+    }
     mapTypeNode(node, content, filePath) {
         const nameNode = node.childForFieldName('name');
         if (!nameNode)
@@ -251,7 +483,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/lib/simple-vector-store.js

@@ -37,8 +37,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);