noteconnection 1.8.0 → 1.9.1

package/dist/src/backend/algorithms/CycleDetection.js

@@ -105,7 +105,6 @@ class CycleDetector {
                     stack.pop();
                     continue;
                 }
-                // Get next neighbor
                 const neighborId = frame.neighbors[frame.index];
                 frame.index++; // Advance for next time
                 if (onPath.has(neighborId)) {

package/dist/src/backend/algorithms/HybridEngine.js

@@ -29,12 +29,10 @@ class HybridEngine {
                 if (checkedPairs.has(pairKey))
                     return;
                 checkedPairs.add(pairKey);
-                // Get Reverse Metrics
                 const rowB = matrix.get(nodeB);
                 const metricsBtoA = rowB ? rowB.get(nodeA) : null;
                 if (!metricsBtoA)
                     return;
-                // 1. Check Vector Similarity
                 const vecA = vectorSpace.getVector(nodeA);
                 const vecB = vectorSpace.getVector(nodeB);
                 if (!vecA || !vecB)
@@ -43,7 +41,6 @@ class HybridEngine {
                 const similarity = vectorSpace.cosineSimilarity(vecA, vecB);
                 if (similarity < vectorThreshold)
                     return;
-                // 2. Check Asymmetry
                 // P(B|A) = metricsAtoB.conditionalProb
                 // P(A|B) = metricsBtoA.conditionalProb
                 const p_A_given_B = metricsBtoA.conditionalProb;

package/dist/src/backend/algorithms/LayoutEngine.js

@@ -136,7 +136,6 @@ class LayoutEngine {
                 execArgv: isTsNode ? ['-r', require.resolve('ts-node/register')] : undefined
             });
             worker.on('message', (positions) => {
-                // Update graph nodes with computed positions
                 positions.forEach((pos, id) => {
                     const node = graph.getNode(id);
                     if (node) {

package/dist/src/backend/algorithms/StatisticalAnalyzer.js

@@ -45,7 +45,6 @@ class StatisticalAnalyzer {
      */
     static async analyzeAsync(files, terms) {
         const termDocCounts = new Map();
-        // Initialize counts
         terms.forEach(term => termDocCounts.set(term, 0));
         // 1. Parallel Term Extraction
         // 1. 并行术语提取
@@ -155,14 +154,11 @@ class StatisticalAnalyzer {
         // Temporary storage for intersection counts: Source -> Target -> Count
         // 临时存储交集计数：源 -> 目标 -> 计数
         const intersectionCounts = new Map();
-        // Iterate over files to find co-occurring pairs
-        // 遍历文件以查找共现对
         for (const termsInFile of Object.values(fileTermsMap)) {
             // Ensure unique terms per file to avoid self-loops or double counting within same file
             const uniqueTerms = Array.from(new Set(termsInFile));
             for (let i = 0; i < uniqueTerms.length; i++) {
                 const source = uniqueTerms[i];
-                // Initialize row if needed
                 if (!intersectionCounts.has(source)) {
                     intersectionCounts.set(source, new Map());
                 }

package/dist/src/backend/algorithms/TopologicalSort.js

@@ -105,12 +105,10 @@ class TopologicalSort {
             const uRank = ranks.get(uId);
             const neighbors = graph.getNeighbors(uId);
             for (const vId of neighbors) {
-                // Update rank of v
                 const currentVRank = ranks.get(vId) || 0;
                 if (uRank + 1 > currentVRank) {
                     ranks.set(vId, uRank + 1);
                 }
-                // Decrement in-degree
                 const d = inDegrees.get(vId) - 1;
                 inDegrees.set(vId, d);
                 if (d === 0) {

package/dist/src/backend/build_dag.js

@@ -111,7 +111,6 @@ class StructureGenerator {
         // Calculate degrees
         const inDegreeMap = new Map();
         const outDegreeMap = new Map();
-        // Initialize maps
         notes.forEach(n => {
             inDegreeMap.set(n.id, 0);
             outDegreeMap.set(n.id, 0);

package/dist/src/capacitor.bridge.serialization.contract.test.js

@@ -42,11 +42,14 @@ describe('capacitor bridge serialization contract', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
         expect(source).toContain('CAPACITOR_BRIDGE_MAX_CHUNK_BYTES');
         expect(source).toContain('CAPACITOR_GRAPH_SERIALIZATION_MAX_BYTES');
+        expect(source).toContain('getMobileRuntimeBudget().maxProjectionBytes');
+        expect(source).toContain('Math.min(\n            CAPACITOR_GRAPH_SERIALIZATION_MAX_BYTES,');
         expect(source).toContain('splitCapacitorPayloadIntoChunks');
         expect(source).toContain('writeCapacitorChunkSequenceToDirectory');
         expect(source).toContain('appendFile');
         expect(source).toContain('createCapacitorGraphDataJsonChunks');
         expect(source).toContain("serializationMode: 'chunked-bridge-json-stream'");
+        expect(source).toContain('maxPayloadBytes: graphSerializationMaxBytes');
         expect(source).not.toContain('JSON.stringify(graphData, null, 2)');
     });
 });

package/dist/src/capacitor.runtime.contract.test.js

@@ -69,7 +69,16 @@ describe('capacitor runtime parity closure contract', () => {
     });
     test('storage provider keeps capacitor local build fallback path', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
-        expect(source).toContain('CAPACITOR_GRAPH_BUILD_MAX_FILES');
+        expect(source).toContain('getMobileRuntimeBudget');
+        expect(source).toContain('measureUtf8Bytes');
+        expect(source).toContain('maxBytes: getMobileRuntimeBudget().maxDocumentBytes');
+        expect(source).toContain('maxBytes: getMobileRuntimeBudget().maxProjectionBytes');
+        expect(source).toContain('maxDocuments');
+        expect(source).toContain('maxBytes: budget.maxDocumentBytes');
+        expect(source).toContain('maxTotalInputBytes');
+        expect(source).toContain('maxDepth');
+        expect(source).toContain('const entryDepth = currentDepth + 1;');
+        expect(source).toContain("MOBILE_BUDGET_EXCEEDED");
         expect(source).toContain('collectCapacitorMarkdownFiles');
         expect(source).toContain('buildCapacitorGraphData');
         expect(source).toContain('buildCapacitorGraphDataWithWorkerFallback');
@@ -82,7 +91,7 @@ describe('capacitor runtime parity closure contract', () => {
         expect(source).toContain('supportsMobileWasmCompute');
         expect(source).toContain('mobileWasmReason');
         expect(source).toContain('capacitorBuildGraph');
-        expect(source).toContain("return await capacitorReadText(normalized);");
+        expect(source).toContain("return await capacitorReadText(normalized, {");
     });
     test('source panel no longer hard-blocks capacitor load action before cache/build flow', () => {
         const source = fs.readFileSync(sourceManagerPath, 'utf8');

package/dist/src/core/Graph.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graph = void 0;
+const ResourceReference_1 = require("./ResourceReference");
 /**
  * Directed Graph implementation for managing notes and dependencies.
  * 用于管理笔记和依赖关系的有向图实现。
@@ -10,6 +11,7 @@ class Graph {
         this.nodes = new Map();
         this.adjacencyList = new Map();
         this.reverseAdjacencyList = new Map();
+        this.aliases = new Map();
     }
     /**
      * Adds a node to the graph.
@@ -17,11 +19,90 @@ class Graph {
      * @param node The node to add | 要添加的节点
      */
     addNode(node) {
-        if (!this.nodes.has(node.id)) {
-            this.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
-            this.adjacencyList.set(node.id, []);
-            this.reverseAdjacencyList.set(node.id, []);
+        if (this.nodes.has(node.id)) {
+            return;
         }
+        const aliases = [node.id, node.sourceUri, ...(node.identityAliases ?? [])]
+            .filter((alias) => typeof alias === 'string' && alias.length > 0);
+        const normalizedAliases = new Set(aliases.map(alias => (0, ResourceReference_1.normalizeResourceReference)(alias)));
+        normalizedAliases.forEach(alias => {
+            const existingNodeId = this.aliases.get(alias);
+            if (existingNodeId && existingNodeId !== node.id) {
+                throw new Error(`Resource identity alias collision: "${alias}" is claimed by both "${existingNodeId}" and "${node.id}"`);
+            }
+        });
+        this.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
+        this.adjacencyList.set(node.id, []);
+        this.reverseAdjacencyList.set(node.id, []);
+        normalizedAliases.forEach(alias => {
+            this.aliases.set(alias, node.id);
+        });
+    }
+    /**
+     * Rehydrates a graph from either a current or legacy JSON snapshot.
+     *
+     * The snapshot is validated before mutating the returned graph. Edges must
+     * reference declared nodes so a corrupt or partially-written snapshot cannot
+     * silently create synthetic nodes and change graph semantics during replay.
+     */
+    static fromJSON(data) {
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            throw new Error('Graph snapshot must be an object.');
+        }
+        const snapshot = data;
+        if (!Array.isArray(snapshot.nodes) || !Array.isArray(snapshot.edges)) {
+            throw new Error('Graph snapshot must contain nodes and edges arrays.');
+        }
+        const graph = new Graph();
+        const nodeIds = new Set();
+        snapshot.nodes.forEach((rawNode, index) => {
+            if (!rawNode || typeof rawNode !== 'object' || Array.isArray(rawNode)) {
+                throw new Error(`Graph snapshot node at index ${index} must be an object.`);
+            }
+            const node = rawNode;
+            if (typeof node.id !== 'string' || node.id.trim().length === 0) {
+                throw new Error(`Graph snapshot node at index ${index} requires a non-empty id.`);
+            }
+            if (nodeIds.has(node.id)) {
+                throw new Error(`Graph snapshot contains duplicate node id: ${node.id}.`);
+            }
+            nodeIds.add(node.id);
+            graph.addNode({
+                ...node,
+                id: node.id,
+                label: typeof node.label === 'string' && node.label.length > 0 ? node.label : node.id,
+                inDegree: 0,
+                outDegree: 0,
+            });
+        });
+        snapshot.edges.forEach((rawEdge, index) => {
+            if (!rawEdge || typeof rawEdge !== 'object' || Array.isArray(rawEdge)) {
+                throw new Error(`Graph snapshot edge at index ${index} must be an object.`);
+            }
+            const edge = rawEdge;
+            if (typeof edge.source !== 'string' || typeof edge.target !== 'string') {
+                throw new Error(`Graph snapshot edge at index ${index} requires source and target ids.`);
+            }
+            if (!graph.hasNode(edge.source) || !graph.hasNode(edge.target)) {
+                throw new Error(`Graph snapshot edge at index ${index} references an undeclared node: ${edge.source} -> ${edge.target}.`);
+            }
+            graph.addEdge(edge.source, edge.target, edge.type, edge.weight);
+        });
+        return graph;
+    }
+    /** Restore this instance atomically from a legacy or current JSON snapshot. */
+    restore(data) {
+        const restored = Graph.fromJSON(data);
+        this.nodes = restored.nodes;
+        this.adjacencyList = restored.adjacencyList;
+        this.reverseAdjacencyList = restored.reverseAdjacencyList;
+        this.aliases = restored.aliases;
+    }
+    resolveNodeId(reference) {
+        if (this.nodes.has(reference)) {
+            return reference;
+        }
+        return this.aliases.get((0, ResourceReference_1.normalizeResourceReference)(reference));
     }
     /**
      * Retrieves a node by its ID.
@@ -29,16 +110,17 @@ class Graph {
      * @param id The node ID | 节点 ID
      * @returns The node or undefined if not found | 节点，如果未找到则返回 undefined
      */
-    getNode(id) {
-        return this.nodes.get(id);
+    getNode(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? this.nodes.get(nodeId) : undefined;
     }
     /**
      * Checks if a node exists in the graph.
      * 检查图中是否存在该节点。
      * @param id The node ID | 节点 ID
      */
-    hasNode(id) {
-        return this.nodes.has(id);
+    hasNode(reference) {
+        return this.resolveNodeId(reference) !== undefined;
     }
     /**
      * Adds a directed edge between two nodes.
@@ -49,30 +131,32 @@ class Graph {
      * @param weight Edge weight (confidence) | 边权重 (置信度)
      */
     addEdge(source, target, type = 'dependency', weight = 1) {
-        if (!this.nodes.has(source)) {
-            this.addNode({ id: source, label: source, inDegree: 0, outDegree: 0 });
+        const sourceId = this.resolveNodeId(source) ?? source;
+        const targetId = this.resolveNodeId(target) ?? target;
+        if (!this.nodes.has(sourceId)) {
+            this.addNode({ id: sourceId, label: sourceId, inDegree: 0, outDegree: 0 });
         }
-        if (!this.nodes.has(target)) {
-            this.addNode({ id: target, label: target, inDegree: 0, outDegree: 0 });
+        if (!this.nodes.has(targetId)) {
+            this.addNode({ id: targetId, label: targetId, inDegree: 0, outDegree: 0 });
         }
-        const edge = { source, target, type, weight };
+        const edge = { source: sourceId, target: targetId, type, weight };
         // Add to adjacency list (outgoing)
-        const outgoing = this.adjacencyList.get(source) || [];
+        const outgoing = this.adjacencyList.get(sourceId) || [];
         // Prevent duplicate edges
-        if (!outgoing.some(e => e.target === target && e.type === type)) {
+        if (!outgoing.some(e => e.target === targetId && e.type === type)) {
             outgoing.push(edge);
-            this.adjacencyList.set(source, outgoing);
+            this.adjacencyList.set(sourceId, outgoing);
             // Update out-degree
-            const sourceNode = this.nodes.get(source);
+            const sourceNode = this.nodes.get(sourceId);
             sourceNode.outDegree++;
         }
         // Add to reverse adjacency list (incoming)
-        const incoming = this.reverseAdjacencyList.get(target) || [];
-        if (!incoming.some(e => e.source === source && e.type === type)) {
+        const incoming = this.reverseAdjacencyList.get(targetId) || [];
+        if (!incoming.some(e => e.source === sourceId && e.type === type)) {
             incoming.push(edge);
-            this.reverseAdjacencyList.set(target, incoming);
+            this.reverseAdjacencyList.set(targetId, incoming);
             // Update in-degree
-            const targetNode = this.nodes.get(target);
+            const targetNode = this.nodes.get(targetId);
             targetNode.inDegree++;
         }
     }
@@ -81,16 +165,17 @@ class Graph {
      * 获取节点的所有出边。
      * @param id Node ID | 节点 ID
      */
-    getOutgoingEdges(id) {
-        return this.adjacencyList.get(id) || [];
+    getOutgoingEdges(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? (this.adjacencyList.get(nodeId) || []) : [];
     }
     /**
      * Gets all outgoing neighbor IDs for a node.
      * 获取节点的所有出度邻居 ID。
      * @param id Node ID | 节点 ID
      */
-    getNeighbors(id) {
-        return (this.adjacencyList.get(id) || []).map(edge => edge.target);
+    getNeighbors(reference) {
+        return this.getOutgoingEdges(reference).map(edge => edge.target);
     }
     /**
      * Gets all nodes in the graph.
@@ -111,8 +196,9 @@ class Graph {
      * 获取节点的所有入边。
      * @param id Node ID | 节点 ID
      */
-    getIncomingEdges(id) {
-        return this.reverseAdjacencyList.get(id) || [];
+    getIncomingEdges(reference) {
+        const nodeId = this.resolveNodeId(reference);
+        return nodeId ? (this.reverseAdjacencyList.get(nodeId) || []) : [];
     }
     /**
      * Returns the graph data in a serializable format.
@@ -129,11 +215,14 @@ class Graph {
      * 获取所有前驱节点（入边的传递闭包）。
      * @param id Target node ID
      */
-    getPredecessors(id) {
+    getPredecessors(reference) {
         const predecessors = new Set();
-        const queue = [id];
+        const nodeId = this.resolveNodeId(reference);
+        if (!nodeId)
+            return predecessors;
+        const queue = [nodeId];
         const visited = new Set();
-        visited.add(id);
+        visited.add(nodeId);
         while (queue.length > 0) {
             const current = queue.shift();
             const incoming = this.getIncomingEdges(current);
@@ -152,11 +241,14 @@ class Graph {
      * 获取所有后继节点（出边的传递闭包）。
      * @param id Source node ID
      */
-    getSuccessors(id) {
+    getSuccessors(reference) {
         const successors = new Set();
-        const queue = [id];
+        const nodeId = this.resolveNodeId(reference);
+        if (!nodeId)
+            return successors;
+        const queue = [nodeId];
         const visited = new Set();
-        visited.add(id);
+        visited.add(nodeId);
         while (queue.length > 0) {
             const current = queue.shift();
             const outgoing = this.getOutgoingEdges(current);
@@ -178,15 +270,19 @@ class Graph {
      * @returns Array of node IDs representing the path, or empty if no path found
      */
     getShortestPath(source, target) {
-        if (source === target)
-            return [source];
-        const queue = [source];
+        const sourceId = this.resolveNodeId(source);
+        const targetId = this.resolveNodeId(target);
+        if (!sourceId || !targetId)
+            return [];
+        if (sourceId === targetId)
+            return [sourceId];
+        const queue = [sourceId];
         const visited = new Set();
         const parent = new Map();
-        visited.add(source);
+        visited.add(sourceId);
         while (queue.length > 0) {
             const current = queue.shift();
-            if (current === target)
+            if (current === targetId)
                 break;
             const neighbors = this.getNeighbors(current);
             for (const neighbor of neighbors) {
@@ -197,12 +293,12 @@ class Graph {
                 }
             }
         }
-        if (!visited.has(target))
+        if (!visited.has(targetId))
             return [];
         // Reconstruct path
-        const path = [target];
-        let curr = target;
-        while (curr !== source) {
+        const path = [targetId];
+        let curr = targetId;
+        while (curr !== sourceId) {
             curr = parent.get(curr);
             path.unshift(curr);
         }

package/dist/src/core/Graph.test.js

@@ -34,4 +34,78 @@ describe('Graph Core', () => {
         expect(nodeA?.outDegree).toBe(1);
         expect(graph.getOutgoingEdges('A')).toHaveLength(1);
     });
+    test('resolves source URI and relative path aliases without changing the public node ID', () => {
+        graph.addNode({
+            id: 'Index',
+            label: 'Index',
+            inDegree: 0,
+            outDegree: 0,
+            sourceUri: 'note://workspace/v1/algebra/index.md',
+            revision: 'sha256:revision',
+            identityAliases: ['algebra/index.md', 'Index'],
+        });
+        graph.addNode({ id: 'Limits', label: 'Limits', inDegree: 0, outDegree: 0 });
+        expect(graph.getNode('note://workspace/v1/algebra/index.md')?.id).toBe('Index');
+        expect(graph.getNode('algebra\\index.md')?.id).toBe('Index');
+        expect(graph.hasNode('INDEX')).toBe(true);
+        graph.addEdge('algebra/index.md', 'Limits', 'explicit-next');
+        expect(graph.getOutgoingEdges('Index')[0]).toEqual(expect.objectContaining({
+            source: 'Index',
+            target: 'Limits',
+            type: 'explicit-next',
+        }));
+    });
+    test('rejects an alias claimed by two different nodes', () => {
+        graph.addNode({
+            id: 'A',
+            label: 'A',
+            inDegree: 0,
+            outDegree: 0,
+            identityAliases: ['shared/path.md'],
+        });
+        expect(() => graph.addNode({
+            id: 'B',
+            label: 'B',
+            inDegree: 0,
+            outDegree: 0,
+            identityAliases: ['shared/path.md'],
+        })).toThrow(/alias/i);
+    });
+    test('replays legacy snapshots without identity metadata and preserves alias-aware edges', () => {
+        const restored = Graph_1.Graph.fromJSON({
+            nodes: [
+                { id: 'A', label: 'A', inDegree: 0, outDegree: 1 },
+                { id: 'B', label: 'B', inDegree: 1, outDegree: 0 },
+            ],
+            edges: [{ source: 'A', target: 'B', type: 'legacy-link', weight: 0.5 }],
+        });
+        expect(restored.getNode('A')).toEqual(expect.objectContaining({ id: 'A', inDegree: 0, outDegree: 1 }));
+        expect(restored.getOutgoingEdges('A')).toEqual([
+            { source: 'A', target: 'B', type: 'legacy-link', weight: 0.5 },
+        ]);
+    });
+    test('rejects an edge that references a missing node before restoring', () => {
+        expect(() => Graph_1.Graph.fromJSON({
+            nodes: [{ id: 'A', label: 'A' }],
+            edges: [{ source: 'A', target: 'missing' }],
+        })).toThrow(/undeclared node/i);
+    });
+    test('restores an existing instance atomically', () => {
+        graph.addNode({ id: 'old', label: 'old', inDegree: 0, outDegree: 0 });
+        expect(() => graph.restore({
+            nodes: [{ id: 'new', label: 'new' }],
+            edges: [],
+        })).not.toThrow();
+        expect(graph.hasNode('old')).toBe(false);
+        expect(graph.hasNode('new')).toBe(true);
+    });
+    test('keeps the previous graph when an incoming snapshot fails validation', () => {
+        graph.addNode({ id: 'stable', label: 'stable', inDegree: 0, outDegree: 0 });
+        expect(() => graph.restore({
+            nodes: [{ id: 'candidate', label: 'candidate' }],
+            edges: [{ source: 'candidate', target: 'missing' }],
+        })).toThrow(/undeclared node/i);
+        expect(graph.hasNode('stable')).toBe(true);
+        expect(graph.hasNode('candidate')).toBe(false);
+    });
 });

package/dist/src/core/NoteConnection.js

@@ -79,7 +79,7 @@ class NoteConnection {
         }
         // 2. Resolve Directory
         const projectRoot = options.projectRoot || path.resolve(__dirname, '..', '..');
-        const kbRoot = path.join(projectRoot, 'Knowledge_Base');
+        const kbRoot = path.resolve(options.knowledgeBaseRoot || path.join(projectRoot, 'Knowledge_Base'));
         let conceptDir;
         if (options.targetPath) {
             if (path.isAbsolute(options.targetPath)) {
@@ -97,7 +97,7 @@ class NoteConnection {
         }
         // 3. Load Files
         log(`Loading files from: ${conceptDir}`);
-        const files = await FileLoader_1.FileLoader.loadFiles(conceptDir);
+        const files = await FileLoader_1.FileLoader.loadFiles(conceptDir, ['.md'], kbRoot);
         log(`Loaded ${files.length} files.`);
         // 4. Load Layout (Optional)
         // Note: Layout logic is slightly coupled to file system here,