noteconnection 1.8.0 → 1.9.0

package/dist/src/frontend/mobile_semantic_comparator.js

@@ -0,0 +1,264 @@
+(function attachMobileSemanticComparator(root, factory) {
+    const api = factory();
+    if (typeof module === 'object' && module.exports) {
+        module.exports = api;
+    }
+    if (root) {
+        root.NoteConnectionMobileSemanticComparator = api;
+    }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function createMobileSemanticComparator() {
+    'use strict';
+
+    const SOURCE_URI_PREFIX = 'note://workspace/v1/';
+    const MAX_DIAGNOSTICS = 64;
+
+    function normalizeText(value) {
+        const text = String(value || '').trim();
+        return typeof text.normalize === 'function' ? text.normalize('NFC') : text;
+    }
+
+    function normalizePath(value) {
+        const text = normalizeText(value)
+            .replace(/\\/g, '/')
+            .replace(/^\/+/, '')
+            .replace(/^knowledge_base\//i, '');
+        const segments = [];
+        for (const segment of text.split('/')) {
+            if (!segment || segment === '.') {
+                continue;
+            }
+            if (segment === '..') {
+                if (segments.length === 0) {
+                    return '';
+                }
+                segments.pop();
+                continue;
+            }
+            segments.push(segment);
+        }
+        return segments.join('/').replace(/\.(?:md|markdown)$/i, '').toLowerCase();
+    }
+
+    function canonicalIdFromSourceUri(sourceUri) {
+        const normalized = normalizeText(sourceUri);
+        if (!normalized.startsWith(SOURCE_URI_PREFIX)) {
+            return '';
+        }
+        try {
+            const decoded = normalized.slice(SOURCE_URI_PREFIX.length)
+                .split('/')
+                .map((segment) => decodeURIComponent(segment))
+                .join('/');
+            return normalizePath(decoded);
+        } catch (_error) {
+            return '';
+        }
+    }
+
+    function normalizeSourceUri(sourceUri) {
+        const normalized = normalizeText(sourceUri);
+        if (!normalized) {
+            return '';
+        }
+        const canonicalId = canonicalIdFromSourceUri(normalized);
+        return canonicalId ? `${SOURCE_URI_PREFIX}${canonicalId.split('/').map(encodeURIComponent).join('/')}.md` : normalized;
+    }
+
+    function nodeCanonicalId(node) {
+        return normalizePath(node && node.canonicalId)
+            || canonicalIdFromSourceUri(node && node.sourceUri)
+            || normalizePath(node && node.id);
+    }
+
+    function nodeIdentity(node) {
+        const canonicalId = nodeCanonicalId(node);
+        if (canonicalId) {
+            return `canonical:${canonicalId}`;
+        }
+        const sourceUri = normalizeSourceUri(node && node.sourceUri);
+        if (sourceUri) {
+            return `uri:${sourceUri}`;
+        }
+        const legacyId = normalizeText(node && node.id).toLowerCase();
+        if (legacyId) {
+            return `legacy:${legacyId}`;
+        }
+        throw new Error('Semantic parity requires every node to expose an identity.');
+    }
+
+    function nodeSignature(node) {
+        return {
+            canonicalId: nodeCanonicalId(node),
+            sourceUri: normalizeSourceUri(node && node.sourceUri),
+        };
+    }
+
+    function endpointIdentity(rawEndpoint, rawUri, nodeById) {
+        const endpointId = rawEndpoint && typeof rawEndpoint === 'object'
+            ? normalizeText(rawEndpoint.id)
+            : normalizeText(rawEndpoint);
+        const node = nodeById.get(endpointId) || nodeById.get(endpointId.toLowerCase());
+        const endpointUri = normalizeSourceUri(rawUri) || normalizeSourceUri(node && node.sourceUri);
+        const canonicalId = nodeCanonicalId(node) || canonicalIdFromSourceUri(rawUri);
+        if (canonicalId) {
+            return {
+                identity: `canonical:${canonicalId}`,
+                sourceUri: endpointUri,
+            };
+        }
+        if (endpointUri) {
+            return {
+                identity: `uri:${endpointUri}`,
+                sourceUri: endpointUri,
+            };
+        }
+        if (endpointId) {
+            return {
+                identity: `legacy:${endpointId.toLowerCase()}`,
+                sourceUri: '',
+            };
+        }
+        throw new Error('Semantic parity requires every edge endpoint to resolve.');
+    }
+
+    function semanticEdge(rawEdge, nodeById) {
+        if (!rawEdge || typeof rawEdge !== 'object') {
+            throw new Error('Semantic parity requires every edge to be an object.');
+        }
+        const source = endpointIdentity(rawEdge.source || rawEdge.from, rawEdge.sourceUri, nodeById);
+        const target = endpointIdentity(rawEdge.target || rawEdge.to, rawEdge.targetUri, nodeById);
+        const type = normalizeText(rawEdge.type) || 'association';
+        const kind = normalizeText(rawEdge.kind).toLowerCase() || 'explicit';
+        const provenance = normalizeText(rawEdge.provenance) || type;
+        return {
+            source: source.identity,
+            target: target.identity,
+            sourceUri: source.sourceUri,
+            targetUri: target.sourceUri,
+            type,
+            kind,
+            provenance,
+        };
+    }
+
+    function edgeKey(edge) {
+        return [
+            edge.source,
+            edge.target,
+            edge.sourceUri,
+            edge.targetUri,
+            edge.type,
+            edge.kind,
+            edge.provenance,
+        ].join('|');
+    }
+
+    function buildIndex(projection, side) {
+        if (!projection || typeof projection !== 'object') {
+            throw new Error(`${side} projection must be an object.`);
+        }
+        const nodes = Array.isArray(projection.nodes) ? projection.nodes : [];
+        const edges = Array.isArray(projection.edges) ? projection.edges : [];
+        const nodeByIdentity = new Map();
+        const nodeById = new Map();
+        nodes.forEach((node) => {
+            const identity = nodeIdentity(node);
+            if (nodeByIdentity.has(identity)) {
+                throw new Error(`${side} projection contains duplicate semantic node identity: ${identity}.`);
+            }
+            const id = normalizeText(node && node.id);
+            if (!id) {
+                throw new Error(`${side} projection contains a node without an id.`);
+            }
+            nodeByIdentity.set(identity, {
+                identity,
+                signature: nodeSignature(node),
+            });
+            nodeById.set(id, node);
+            nodeById.set(id.toLowerCase(), node);
+        });
+
+        const edgeByKey = new Map();
+        edges.forEach((edge) => {
+            const semantic = semanticEdge(edge, nodeById);
+            const key = edgeKey(semantic);
+            if (edgeByKey.has(key)) {
+                throw new Error(`${side} projection contains duplicate semantic edge: ${key}.`);
+            }
+            edgeByKey.set(key, semantic);
+        });
+        return { nodeByIdentity, edgeByKey };
+    }
+
+    function boundedDiagnostics(values) {
+        return values.sort().slice(0, MAX_DIAGNOSTICS);
+    }
+
+    function compareSemanticProjections(leftProjection, rightProjection) {
+        const left = buildIndex(leftProjection, 'left');
+        const right = buildIndex(rightProjection, 'right');
+        const missingNodes = [];
+        const extraNodes = [];
+        const nodeMismatches = [];
+        left.nodeByIdentity.forEach((leftNode, identity) => {
+            const rightNode = right.nodeByIdentity.get(identity);
+            if (!rightNode) {
+                missingNodes.push(identity);
+                return;
+            }
+            if (JSON.stringify(leftNode.signature) !== JSON.stringify(rightNode.signature)) {
+                nodeMismatches.push({ identity, left: leftNode.signature, right: rightNode.signature });
+            }
+        });
+        right.nodeByIdentity.forEach((_rightNode, identity) => {
+            if (!left.nodeByIdentity.has(identity)) {
+                extraNodes.push(identity);
+            }
+        });
+
+        const missingEdges = [];
+        const extraEdges = [];
+        left.edgeByKey.forEach((_edge, key) => {
+            if (!right.edgeByKey.has(key)) {
+                missingEdges.push(key);
+            }
+        });
+        right.edgeByKey.forEach((_edge, key) => {
+            if (!left.edgeByKey.has(key)) {
+                extraEdges.push(key);
+            }
+        });
+
+        return {
+            equal: missingNodes.length === 0
+                && extraNodes.length === 0
+                && nodeMismatches.length === 0
+                && missingEdges.length === 0
+                && extraEdges.length === 0,
+            left: { nodeCount: left.nodeByIdentity.size, edgeCount: left.edgeByKey.size },
+            right: { nodeCount: right.nodeByIdentity.size, edgeCount: right.edgeByKey.size },
+            missingNodes: boundedDiagnostics(missingNodes),
+            extraNodes: boundedDiagnostics(extraNodes),
+            nodeMismatches: nodeMismatches.slice(0, MAX_DIAGNOSTICS),
+            missingEdges: boundedDiagnostics(missingEdges),
+            extraEdges: boundedDiagnostics(extraEdges),
+        };
+    }
+
+    function assertSemanticParity(leftProjection, rightProjection, label) {
+        const comparison = compareSemanticProjections(leftProjection, rightProjection);
+        if (!comparison.equal) {
+            const prefix = label ? `${label}: ` : '';
+            const error = new Error(`${prefix}semantic projection parity failed: ${JSON.stringify(comparison)}`);
+            error.comparison = comparison;
+            throw error;
+        }
+        return comparison;
+    }
+
+    return Object.freeze({
+        canonicalIdFromSourceUri,
+        compareSemanticProjections,
+        assertSemanticParity,
+    });
+}));

package/dist/src/frontend/path.html

@@ -171,8 +171,12 @@
     <script src="libs/katex/katex.min.js"></script>
     <script src="libs/katex/contrib/auto-render.min.js"></script>
     <script src="libs/mermaid.min.js"></script>
-    <script src="runtime_bridge.js"></script>
-    <script src="storage_provider.js"></script>
+     <script src="runtime_bridge.js"></script>
+     <script src="knowledge_projection_contract.js"></script>
+     <script src="knowledge_projection_store.js"></script>
+     <script src="mobile_exact_analyzer.js"></script>
+     <script src="mobile_identity_contract.js"></script>
+     <script src="storage_provider.js"></script>
     <script src="reader.js"></script>
 
     <!-- Reading Window -->

package/dist/src/frontend/simulationWorker.js

@@ -1,4 +1,4 @@
-importScripts("https://d3js.org/d3.v6.min.js", "libs/gpu-browser.min.js", "layout_gpu.js");
+importScripts("libs/d3.v7.min.js", "libs/gpu-browser.min.js", "layout_gpu.js");
 
 let simulation;
 let nodes = [];

package/dist/src/frontend/source_manager.js

@@ -46,12 +46,23 @@ document.addEventListener('DOMContentLoaded', () => {
         return /^https?:\/\/(?:127\.0\.0\.1|localhost):3000$/.test(origin);
     };
 
+    const isTauriRuntime = typeof window !== 'undefined' && Boolean(window.__TAURI__);
+    const initialBrowserRuntimeBackend = canUseBrowserRuntimeBackend();
     let runtimeCaps = {
         platform: 'web',
-        supports_sidecar: canUseBrowserRuntimeBackend(),
-        supports_build: canUseBrowserRuntimeBackend(),
-        supports_content_api: canUseBrowserRuntimeBackend(),
+        supports_sidecar: initialBrowserRuntimeBackend,
+        supports_build: initialBrowserRuntimeBackend,
+        supports_content_api: initialBrowserRuntimeBackend,
         supports_kb_runtime_change: false,
+        supports_kb_import: false,
+        kb_import_mode: 'none',
+        supports_projection_store: true,
+        storage_requested_provider: isTauriRuntime || initialBrowserRuntimeBackend ? 'sqlite' : 'projection',
+        storage_resolved_provider: isTauriRuntime || initialBrowserRuntimeBackend ? 'unknown' : 'projection',
+        storage_fallback_reason: isTauriRuntime
+            ? 'runtime_capability_unavailable'
+            : initialBrowserRuntimeBackend ? '' : 'runtime_backend_unavailable',
+        supports_sqlite: initialBrowserRuntimeBackend,
         supports_native_pathmode: false,
         supports_mobile_wasm_compute: false,
         mobile_wasm_reason: 'non-mobile-runtime'
@@ -217,6 +228,25 @@ document.addEventListener('DOMContentLoaded', () => {
         return window.NoteConnectionStorage.createProvider({ runtimeCaps });
     };
 
+    const refreshStorageResolution = async () => {
+        const provider = getStorageProvider();
+        if (!provider || typeof provider.refreshStorageResolution !== 'function') {
+            return;
+        }
+        const resolution = await provider.refreshStorageResolution();
+        if (!resolution || typeof resolution !== 'object') {
+            return;
+        }
+        runtimeCaps = {
+            ...runtimeCaps,
+            storage_requested_provider: resolution.requestedProvider,
+            storage_resolved_provider: resolution.resolvedProvider,
+            storage_fallback_reason: resolution.fallbackReason || '',
+            supports_sqlite: resolution.supportsSqlite === true,
+        };
+        exposeRuntimeCaps();
+    };
+
     const resolveRuntimeCapabilities = async () => {
         if (!window.__TAURI__) {
             const capacitorPlatform = resolveCapacitorPlatform();
@@ -231,6 +261,13 @@ document.addEventListener('DOMContentLoaded', () => {
                     supports_build: canBuildGraph,
                     supports_content_api: canReadContent,
                     supports_kb_runtime_change: false,
+                    supports_kb_import: false,
+                    kb_import_mode: 'app-local-only',
+                    supports_projection_store: true,
+                    storage_requested_provider: 'projection',
+                    storage_resolved_provider: 'projection',
+                    storage_fallback_reason: 'native_sqlite_runtime_unavailable',
+                    supports_sqlite: false,
                     supports_native_pathmode: false,
                     supports_mobile_wasm_compute: mobileWasm.supported,
                     mobile_wasm_reason: mobileWasm.reason,
@@ -251,6 +288,13 @@ document.addEventListener('DOMContentLoaded', () => {
                     supports_build: browserRuntimeBackend,
                     supports_content_api: browserRuntimeBackend,
                     supports_kb_runtime_change: false,
+                    supports_kb_import: false,
+                    kb_import_mode: 'none',
+                    supports_projection_store: true,
+                    storage_requested_provider: browserRuntimeBackend ? 'sqlite' : 'projection',
+                    storage_resolved_provider: browserRuntimeBackend ? 'unknown' : 'projection',
+                    storage_fallback_reason: browserRuntimeBackend ? '' : 'runtime_backend_unavailable',
+                    supports_sqlite: browserRuntimeBackend,
                     supports_native_pathmode: false
                 };
                 if (!browserRuntimeBackend) {
@@ -313,6 +357,26 @@ document.addEventListener('DOMContentLoaded', () => {
     // 动态脚本加载器（缓存破坏与顺序保证）
     const loadGraphDataFromSidecar = async (src) => {
         const parseGraphDataPayload = (text) => {
+            const mobileRuntime = window.NoteConnectionMobileBudget && window.NoteConnectionMobileBudget.runtime;
+            if (mobileRuntime && Number.isInteger(mobileRuntime.maxProjectionBytes)) {
+                const payloadText = String(text || '');
+                const byteCounter = window.NoteConnectionStorage
+                    && typeof window.NoteConnectionStorage.measureUtf8Bytes === 'function'
+                    ? window.NoteConnectionStorage.measureUtf8Bytes
+                    : null;
+                const payloadBytes = byteCounter
+                    ? byteCounter(payloadText)
+                    : (typeof TextEncoder === 'function'
+                        ? new TextEncoder().encode(payloadText).length
+                        : (typeof Buffer !== 'undefined' && typeof Buffer.byteLength === 'function'
+                            ? Buffer.byteLength(payloadText, 'utf8')
+                            : payloadText.length));
+                if (payloadBytes > mobileRuntime.maxProjectionBytes) {
+                    throw new Error(
+                        `Mobile graph projection exceeds ${mobileRuntime.maxProjectionBytes} bytes.`
+                    );
+                }
+            }
             const trimmed = text.trim();
             let parsed = null;
             const extractAssignedJson = (sourceText, equalsIndex) => {
@@ -1081,6 +1145,7 @@ document.addEventListener('DOMContentLoaded', () => {
         if (window.__TAURI__ && runtimeCaps.supports_sidecar) {
             await waitForSidecarReady();
         }
+        await refreshStorageResolution();
         bootstrapScriptLoad();
 
         if (window.i18n && window.i18n.isInitialized) {
@@ -1125,6 +1190,47 @@ document.addEventListener('DOMContentLoaded', () => {
         });
     }
 
+    const requestKnowledgeBasePathChange = async () => {
+        try {
+            const request = await window.__TAURI__.core.invoke('request_kb_path_change');
+            if (typeof request === 'string') {
+                return request;
+            }
+            const status = String(request && request.status || '').trim().toLowerCase();
+            if (status === 'completed') {
+                return String(request.path || '').trim();
+            }
+            if (status !== 'pending') {
+                return '';
+            }
+
+            const deadline = Date.now() + 120000;
+            while (Date.now() < deadline) {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                const result = await window.__TAURI__.core.invoke('poll_kb_path_change');
+                const resultStatus = String(result && result.status || '').trim().toLowerCase();
+                if (resultStatus === 'completed') {
+                    return String(result.path || '').trim();
+                }
+                if (resultStatus === 'cancelled') {
+                    return '';
+                }
+                if (resultStatus === 'failed' || resultStatus === 'unavailable') {
+                    const detail = String(result && result.detail || '').trim();
+                    throw new Error(detail || `Knowledge base picker ${resultStatus}.`);
+                }
+            }
+            throw new Error('Timed out waiting for Android knowledge base import.');
+        } catch (error) {
+            // Older Tauri builds do not expose the additive request/poll commands.
+            // Preserve their synchronous desktop picker contract as a fallback.
+            if (/unknown command|not found|invalid command/i.test(String(error && error.message || error))) {
+                return await window.__TAURI__.core.invoke('choose_kb_path');
+            }
+            throw error;
+        }
+    };
+
     if (changeKbPathBtn && window.__TAURI__) {
         changeKbPathBtn.addEventListener('click', async () => {
             if (!runtimeCaps.supports_kb_runtime_change) {
@@ -1136,7 +1242,7 @@ document.addEventListener('DOMContentLoaded', () => {
             if (resetKbPathBtn) resetKbPathBtn.disabled = true;
 
             try {
-                const selectedPath = await window.__TAURI__.core.invoke('choose_kb_path');
+                const selectedPath = await requestKnowledgeBasePathChange();
                 if (!selectedPath) {
                     return;
                 }