noteconnection 1.7.0 → 1.9.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/copy.assets.contract.test.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+class TempDir {
+    constructor(prefix) {
+        this.path = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `${prefix}-`));
+    }
+    child(relative) {
+        return path.join(this.path, relative);
+    }
+    mkdir(relative) {
+        const target = this.child(relative);
+        fs.mkdirSync(target, { recursive: true });
+        return target;
+    }
+    file(relative, content) {
+        const target = this.child(relative);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, content, 'utf8');
+        return target;
+    }
+    cleanup() {
+        fs.rmSync(this.path, { recursive: true, force: true });
+    }
+}
+describe('copy-assets runtime-first contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const copyAssetsPath = path.join(repoRoot, 'scripts', 'copy-assets.js');
+    let temp;
+    let srcDir;
+    let destDir;
+    let copyProjectAssets;
+    beforeAll(() => {
+        ({ copyProjectAssets } = require(copyAssetsPath));
+    });
+    beforeEach(() => {
+        temp = new TempDir('noteconnection-copy-assets');
+        srcDir = temp.mkdir('src');
+        destDir = temp.mkdir('dest');
+    });
+    afterEach(() => {
+        temp.cleanup();
+    });
+    test('excludes generated graph payloads by default', () => {
+        temp.file(path.join('src', 'app.js'), 'console.log("app");');
+        temp.file(path.join('src', 'data.js'), 'const graphData = {"nodes":[{"id":"A"}],"edges":[]}');
+        temp.file(path.join('src', 'graph_data.json'), '{"nodes":[{"id":"A"}],"edges":[]}');
+        copyProjectAssets({
+            src: srcDir,
+            dest: destDir,
+            logger: console
+        });
+        expect(fs.existsSync(path.join(destDir, 'app.js'))).toBe(true);
+        expect(fs.existsSync(path.join(destDir, 'data.js'))).toBe(false);
+        expect(fs.existsSync(path.join(destDir, 'graph_data.json'))).toBe(false);
+    });
+    test('copies generated graph payloads only when explicitly requested', () => {
+        temp.file(path.join('src', 'data.js'), 'const graphData = {"nodes":[{"id":"A"}],"edges":[]}');
+        temp.file(path.join('src', 'graph_data.json'), '{"nodes":[{"id":"A"}],"edges":[]}');
+        copyProjectAssets({
+            src: srcDir,
+            dest: destDir,
+            includeGeneratedGraphAssets: true,
+            logger: console
+        });
+        expect(fs.existsSync(path.join(destDir, 'data.js'))).toBe(true);
+        expect(fs.existsSync(path.join(destDir, 'graph_data.json'))).toBe(true);
+    });
+    test('full mode remains valid when repository head no longer ships bundled graph payload files', () => {
+        temp.file(path.join('src', 'app.js'), 'console.log("app");');
+        expect(() => copyProjectAssets({
+            src: srcDir,
+            dest: destDir,
+            includeGeneratedGraphAssets: true,
+            logger: console
+        })).not.toThrow();
+        expect(fs.existsSync(path.join(destDir, 'app.js'))).toBe(true);
+        expect(fs.existsSync(path.join(destDir, 'data.js'))).toBe(false);
+        expect(fs.existsSync(path.join(destDir, 'graph_data.json'))).toBe(false);
+    });
+    test('does not copy LFS pointer placeholders even in explicit full mode', () => {
+        temp.file(path.join('src', 'data.js'), [
+            'version https://git-lfs.github.com/spec/v1',
+            'oid sha256:abc123',
+            'size 177419264'
+        ].join('\n'));
+        copyProjectAssets({
+            src: srcDir,
+            dest: destDir,
+            includeGeneratedGraphAssets: true,
+            logger: console
+        });
+        expect(fs.existsSync(path.join(destDir, 'data.js'))).toBe(false);
+    });
+});

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,