@mindexec/cli 0.2.383 → 0.2.385

package/wwwroot/_content/MindExecution.Shared/js/mind-map-node-search-worker.js

@@ -0,0 +1,554 @@
+'use strict';
+
+const MAX_PROMPT_CHARS = 2048;
+const MAX_RESPONSE_CHARS = 16000;
+const MAX_METADATA_TEXT_CHARS = 8192;
+const MAX_SOURCE_PATH_CHARS = 2048;
+const NGRAM_SIZE = 3;
+const SEARCH_VIEWPORT_FOV_DEGREES = 45;
+const SEARCH_VIEWPORT_ASPECT_RATIO_FALLBACK = 1.6;
+const SEARCH_VIEWPORT_IN_VIEW_BONUS = 4;
+const SEARCH_VIEWPORT_CENTER_BOOST_MAX = 8;
+const SEARCH_VIEWPORT_NEAR_MARGIN = 1.35;
+const TOKEN_REGEX = /[\p{L}\p{M}\p{N}]{2,}/gu;
+
+function createState() {
+    return {
+        boardId: '',
+        documents: new Map(),
+        tokenIndex: new Map(),
+        prefixIndex: new Map(),
+        ngramIndex: new Map()
+    };
+}
+
+let runtime = createState();
+
+function normalizeBoardId(boardId) {
+    return String(boardId ?? '').trim();
+}
+
+function limitText(value, maxLength) {
+    const text = String(value ?? '');
+    if (!text) {
+        return '';
+    }
+
+    return text.length <= maxLength
+        ? text
+        : text.slice(0, maxLength);
+}
+
+function shouldIndexResponse(contentType) {
+    return contentType === 'text'
+        || contentType === 'note'
+        || contentType === 'memo'
+        || contentType === 'markdown'
+        || contentType === 'code'
+        || contentType === 'csv-table'
+        || contentType === 'directory';
+}
+
+function buildMetadataText(metadata) {
+    if (!metadata) {
+        return '';
+    }
+
+    if (typeof metadata === 'string') {
+        return limitText(metadata, MAX_METADATA_TEXT_CHARS);
+    }
+
+    const values = [];
+    const entries = Array.isArray(metadata)
+        ? metadata
+        : Object.entries(metadata);
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (Array.isArray(entry)) {
+            const key = limitText(entry[0], 128).trim();
+            const value = limitText(entry[1], 1024).trim();
+            if (key) values.push(key);
+            if (value) values.push(value);
+        } else if (entry) {
+            const value = limitText(entry, 1024).trim();
+            if (value) values.push(value);
+        }
+
+        if (values.join(' ').length >= MAX_METADATA_TEXT_CHARS) {
+            break;
+        }
+    }
+
+    return limitText(values.join(' '), MAX_METADATA_TEXT_CHARS);
+}
+
+function normalizeText(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+
+    let normalized = String(value);
+    if (!normalized.trim()) {
+        return '';
+    }
+
+    try {
+        normalized = normalized.normalize('NFKC');
+    } catch {
+    }
+
+    normalized = normalized.toLowerCase();
+
+    let result = '';
+    let wroteWhitespace = false;
+    for (let i = 0; i < normalized.length; i++) {
+        const ch = normalized[i];
+        if (/\s/u.test(ch)) {
+            if (!wroteWhitespace) {
+                result += ' ';
+                wroteWhitespace = true;
+            }
+            continue;
+        }
+
+        const code = ch.codePointAt(0);
+        if (typeof code === 'number' && code <= 31) {
+            continue;
+        }
+
+        result += ch;
+        wroteWhitespace = false;
+    }
+
+    return result.trim();
+}
+
+function removeWhitespace(value) {
+    return String(value ?? '').replace(/\s+/gu, '');
+}
+
+function extractTokens(normalizedText) {
+    if (!normalizedText) {
+        return [];
+    }
+
+    const matches = normalizedText.match(TOKEN_REGEX);
+    if (!matches || matches.length === 0) {
+        return [];
+    }
+
+    return matches.filter((token) => token.length >= 2);
+}
+
+function buildPrefixes(tokens) {
+    const prefixes = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!token) {
+            continue;
+        }
+
+        const maxLength = Math.min(8, token.length);
+        for (let length = 2; length <= maxLength; length++) {
+            prefixes.push(token.slice(0, length));
+        }
+    }
+
+    return prefixes;
+}
+
+function buildNGrams(normalizedCompactText) {
+    if (!normalizedCompactText) {
+        return [];
+    }
+
+    if (normalizedCompactText.length <= NGRAM_SIZE) {
+        return [normalizedCompactText];
+    }
+
+    const ngrams = [];
+    for (let i = 0; i <= normalizedCompactText.length - NGRAM_SIZE; i++) {
+        ngrams.push(normalizedCompactText.slice(i, i + NGRAM_SIZE));
+    }
+    return ngrams;
+}
+
+function addPosting(index, key, nodeId) {
+    if (!key) {
+        return;
+    }
+
+    let postings = index.get(key);
+    if (!postings) {
+        postings = new Set();
+        index.set(key, postings);
+    }
+    postings.add(nodeId);
+}
+
+function removePosting(index, key, nodeId) {
+    const postings = index.get(key);
+    if (!postings) {
+        return;
+    }
+
+    postings.delete(nodeId);
+    if (postings.size === 0) {
+        index.delete(key);
+    }
+}
+
+function addPostingMatches(index, key, candidateScores, weight) {
+    const postings = index.get(key);
+    if (!postings) {
+        return;
+    }
+
+    postings.forEach((nodeId) => {
+        candidateScores.set(
+            nodeId,
+            Number(candidateScores.get(nodeId) || 0) + weight
+        );
+    });
+}
+
+function clearState(boardId) {
+    runtime = createState();
+    runtime.boardId = normalizeBoardId(boardId);
+}
+
+function normalizeNodeSnapshot(node) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+
+    const nodeId = String(node.id ?? node.Id ?? '').trim();
+    if (!nodeId) {
+        return null;
+    }
+
+    const contentType = String(node.contentType ?? node.ContentType ?? '').trim().toLowerCase();
+
+    return {
+        id: nodeId,
+        contentType,
+        prompt: limitText(node.prompt ?? node.Prompt, MAX_PROMPT_CHARS),
+        response: limitText(node.response ?? node.Response, MAX_RESPONSE_CHARS),
+        metadataText: buildMetadataText(node.metadataText ?? node.MetadataText ?? node.metadata ?? node.Metadata),
+        sourcePath: limitText(node.sourcePath ?? node.SourcePath ?? node.sourceFilePath ?? node.SourceFilePath, MAX_SOURCE_PATH_CHARS),
+        positionX: Number(node.positionX ?? node.PositionX ?? node.x ?? 0),
+        positionY: Number(node.positionY ?? node.PositionY ?? node.y ?? 0),
+        width: Math.max(1, Number(node.width ?? node.Width ?? 1)),
+        height: Math.max(1, Number(node.height ?? node.Height ?? 1))
+    };
+}
+
+function buildDocument(node) {
+    const prompt = normalizeText(node.prompt);
+    const response = normalizeText(shouldIndexResponse(node.contentType) ? node.response : '');
+    const metadataText = normalizeText(node.metadataText);
+    const sourcePath = normalizeText(node.sourcePath);
+    const normalizedContentType = normalizeText(node.contentType);
+
+    const combined = [prompt, metadataText, sourcePath, response, normalizedContentType]
+        .filter(Boolean)
+        .join(' ');
+    const tokens = new Set(extractTokens(combined));
+    const prefixes = new Set(buildPrefixes(Array.from(tokens)));
+    const ngrams = new Set(buildNGrams(removeWhitespace(combined)));
+
+    return {
+        nodeId: node.id,
+        contentType: node.contentType,
+        positionX: node.positionX,
+        positionY: node.positionY,
+        width: node.width,
+        height: node.height,
+        normalizedPrompt: prompt,
+        normalizedResponse: response,
+        normalizedMetadata: metadataText,
+        normalizedSourcePath: sourcePath,
+        normalizedContentType,
+        tokens,
+        prefixes,
+        ngrams
+    };
+}
+
+function removeDocument(nodeId) {
+    const existing = runtime.documents.get(nodeId);
+    if (!existing) {
+        return;
+    }
+
+    existing.tokens.forEach((token) => removePosting(runtime.tokenIndex, token, nodeId));
+    existing.prefixes.forEach((prefix) => removePosting(runtime.prefixIndex, prefix, nodeId));
+    existing.ngrams.forEach((ngram) => removePosting(runtime.ngramIndex, ngram, nodeId));
+    runtime.documents.delete(nodeId);
+}
+
+function upsertNode(node) {
+    const normalizedNode = normalizeNodeSnapshot(node);
+    if (!normalizedNode) {
+        return;
+    }
+
+    removeDocument(normalizedNode.id);
+
+    const document = buildDocument(normalizedNode);
+    runtime.documents.set(document.nodeId, document);
+
+    document.tokens.forEach((token) => addPosting(runtime.tokenIndex, token, document.nodeId));
+    document.prefixes.forEach((prefix) => addPosting(runtime.prefixIndex, prefix, document.nodeId));
+    document.ngrams.forEach((ngram) => addPosting(runtime.ngramIndex, ngram, document.nodeId));
+}
+
+function rebuildBoard(boardId, nodes) {
+    clearState(boardId);
+    const sourceNodes = Array.isArray(nodes) ? nodes : [];
+    for (let i = 0; i < sourceNodes.length; i++) {
+        upsertNode(sourceNodes[i]);
+    }
+}
+
+function scoreDocument(document, normalizedQuery, queryTokens, queryNGrams) {
+    let score = 0;
+
+    if (document.normalizedPrompt === normalizedQuery) {
+        score += 120;
+    } else if (document.normalizedPrompt.includes(normalizedQuery)) {
+        score += 54;
+    }
+
+    if (document.normalizedMetadata.includes(normalizedQuery)) {
+        score += 26;
+    }
+
+    if (document.normalizedSourcePath.includes(normalizedQuery)) {
+        score += 18;
+    }
+
+    if (document.normalizedResponse.includes(normalizedQuery)) {
+        score += 14;
+    }
+
+    if (document.normalizedContentType.includes(normalizedQuery)) {
+        score += 8;
+    }
+
+    for (let i = 0; i < queryTokens.length; i++) {
+        const token = queryTokens[i];
+        if (document.tokens.has(token)) {
+            score += 7;
+        }
+
+        if (document.normalizedPrompt.startsWith(token)) {
+            score += 10;
+        }
+    }
+
+    for (let i = 0; i < queryNGrams.length; i++) {
+        if (document.ngrams.has(queryNGrams[i])) {
+            score += 0.85;
+        }
+    }
+
+    return score;
+}
+
+function calculateViewportBoost(document, camera) {
+    if (!camera) {
+        return 0;
+    }
+
+    const cameraZ = Math.max(400, Number(camera.z || 0) || 1200);
+    const aspect = Math.max(0.1, Number(camera.aspect || SEARCH_VIEWPORT_ASPECT_RATIO_FALLBACK));
+    const halfViewHeight = Math.max(
+        480,
+        cameraZ * Math.tan((SEARCH_VIEWPORT_FOV_DEGREES * Math.PI / 180) / 2)
+    );
+    const halfViewWidth = halfViewHeight * aspect;
+
+    const nodeWidth = Math.max(1, Number(document.width || 1));
+    const nodeHeight = Math.max(1, Number(document.height || 1));
+    const centerX = Number(document.positionX || 0) + (nodeWidth / 2);
+    const centerY = Number(document.positionY || 0) - (nodeHeight / 2);
+    const normalizedX = Math.abs(centerX - Number(camera.x || 0)) / Math.max(1, halfViewWidth);
+    const normalizedY = Math.abs(centerY - Number(camera.y || 0)) / Math.max(1, halfViewHeight);
+    const radialDistance = Math.sqrt((normalizedX * normalizedX) + (normalizedY * normalizedY));
+
+    if (radialDistance <= 1) {
+        return SEARCH_VIEWPORT_IN_VIEW_BONUS + ((1 - radialDistance) * SEARCH_VIEWPORT_CENTER_BOOST_MAX);
+    }
+
+    if (radialDistance <= SEARCH_VIEWPORT_NEAR_MARGIN) {
+        const falloff = 1 - ((radialDistance - 1) / Math.max(0.001, SEARCH_VIEWPORT_NEAR_MARGIN - 1));
+        return Math.max(0, falloff) * (SEARCH_VIEWPORT_IN_VIEW_BONUS * 0.75);
+    }
+
+    return 0;
+}
+
+function handleSearchQuery(message) {
+    const boardId = normalizeBoardId(message.boardId);
+    if (!boardId || boardId !== runtime.boardId) {
+        self.postMessage({
+            type: 'SEARCH_RESULT',
+            boardId,
+            seq: Number(message.seq || 0),
+            query: String(message.query || ''),
+            hits: []
+        });
+        return;
+    }
+
+    const startedAt = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+    const normalizedLimit = Math.max(1, Number(message.limit || 30));
+    const normalizedQuery = normalizeText(message.query);
+    if (!normalizedQuery) {
+        self.postMessage({
+            type: 'SEARCH_RESULT',
+            boardId,
+            seq: Number(message.seq || 0),
+            query: String(message.query || ''),
+            hits: []
+        });
+        return;
+    }
+
+    const allowedContentTypes = Array.isArray(message.contentTypes) && message.contentTypes.length > 0
+        ? new Set(
+            message.contentTypes
+                .map((value) => String(value || '').trim().toLowerCase())
+                .filter(Boolean)
+        )
+        : null;
+    const queryTokens = extractTokens(normalizedQuery);
+    const queryPrefixes = buildPrefixes(queryTokens);
+    const queryNGrams = buildNGrams(removeWhitespace(normalizedQuery));
+    const candidateScores = new Map();
+
+    for (let i = 0; i < queryTokens.length; i++) {
+        addPostingMatches(runtime.tokenIndex, queryTokens[i], candidateScores, 8);
+    }
+
+    for (let i = 0; i < queryPrefixes.length; i++) {
+        const prefix = queryPrefixes[i];
+        addPostingMatches(runtime.prefixIndex, prefix, candidateScores, prefix.length <= 3 ? 4 : 2);
+    }
+
+    for (let i = 0; i < queryNGrams.length; i++) {
+        addPostingMatches(runtime.ngramIndex, queryNGrams[i], candidateScores, 1.15);
+    }
+
+    let candidateIds = [];
+    if (candidateScores.size > 0) {
+        candidateIds = Array.from(candidateScores.entries())
+            .sort((a, b) => {
+                if (b[1] !== a[1]) {
+                    return b[1] - a[1];
+                }
+                return String(a[0]).localeCompare(String(b[0]));
+            })
+            .slice(0, Math.max(normalizedLimit * 16, 256))
+            .map((entry) => entry[0]);
+    } else {
+        candidateIds = Array.from(runtime.documents.keys());
+    }
+
+    const ranked = [];
+    for (let i = 0; i < candidateIds.length; i++) {
+        const document = runtime.documents.get(candidateIds[i]);
+        if (!document) {
+            continue;
+        }
+
+        if (allowedContentTypes && allowedContentTypes.size > 0 && !allowedContentTypes.has(document.contentType)) {
+            continue;
+        }
+
+        const score = scoreDocument(document, normalizedQuery, queryTokens, queryNGrams);
+        if (score <= 0) {
+            continue;
+        }
+
+        ranked.push({
+            nodeId: document.nodeId,
+            score: score + calculateViewportBoost(document, message.camera || null)
+        });
+    }
+
+    ranked.sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score;
+        }
+        return String(a.nodeId).localeCompare(String(b.nodeId));
+    });
+
+    const completedAt = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+
+    self.postMessage({
+        type: 'SEARCH_RESULT',
+        boardId,
+        seq: Number(message.seq || 0),
+        query: String(message.query || ''),
+        hits: ranked.slice(0, normalizedLimit),
+        profile: {
+            durationMs: Number(Math.max(0, completedAt - startedAt).toFixed(2)),
+            candidateCount: candidateIds.length,
+            rankedCount: ranked.length
+        }
+    });
+}
+
+self.onmessage = function (event) {
+    const message = event?.data || null;
+    if (!message || typeof message !== 'object') {
+        return;
+    }
+
+    switch (message.type) {
+        case 'RESET_BOARD':
+            clearState(message.boardId);
+            break;
+        case 'REBUILD_BOARD':
+            rebuildBoard(message.boardId, message.nodes);
+            break;
+        case 'UPSERT_NODE':
+            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+                upsertNode(message.node);
+            }
+            break;
+        case 'REMOVE_NODE':
+            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+                removeDocument(String(message.nodeId || '').trim());
+            }
+            break;
+        case 'BATCH_SYNC':
+            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+                const removedIds = Array.isArray(message.removedIds) ? message.removedIds : [];
+                for (let i = 0; i < removedIds.length; i++) {
+                    removeDocument(String(removedIds[i] || '').trim());
+                }
+
+                const nodes = Array.isArray(message.nodes) ? message.nodes : [];
+                for (let i = 0; i < nodes.length; i++) {
+                    upsertNode(nodes[i]);
+                }
+            }
+            break;
+        case 'SEARCH_QUERY':
+            handleSearchQuery(message);
+            break;
+        default:
+            break;
+    }
+};
+
+self.postMessage({
+    type: 'READY'
+});