aifastdb-devplan 1.6.1 → 1.6.3

package/dist/visualize/server.js

@@ -276,12 +276,15 @@ function startServer(projectName, basePath, port) {
                     const includeModules = url.searchParams.get('includeModules') !== 'false';
                     const includeNodeDegree = url.searchParams.get('includeNodeDegree') !== 'false';
                     const enableBackendDegreeFallback = url.searchParams.get('enableBackendDegreeFallback') !== 'false';
+                    // 可视化页面默认不渲染 Prompt 节点（通过顶部统计栏点击查看 Prompt 列表）
+                    const includePrompts = url.searchParams.get('includePrompts') === 'true';
                     if (store.exportGraph) {
                         const graph = store.exportGraph({
                             includeDocuments,
                             includeModules,
                             includeNodeDegree,
                             enableBackendDegreeFallback,
+                            includePrompts,
                         });
                         res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                         res.end(JSON.stringify(graph));
@@ -296,8 +299,40 @@ function startServer(projectName, basePath, port) {
                     // 每次请求重新创建 store，确保读取最新数据
                     const store = createFreshStore(projectName, basePath);
                     const progress = store.getProgress();
+                    // 附加模块和文档计数（分层加载模式下 graph.nodes 不含全部类型，需从此处获取真实数量）
+                    const sections = store.listSections();
+                    const modules = store.listModules();
+                    // 附加 Prompt 计数
+                    let promptCount = 0;
+                    try {
+                        if (typeof store.listPrompts === 'function') {
+                            promptCount = store.listPrompts().length;
+                        }
+                    }
+                    catch (e) { /* listPrompts 不支持时忽略 */ }
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({
+                        ...progress,
+                        moduleCount: modules.length,
+                        docCount: sections.length,
+                        promptCount,
+                    }));
+                    break;
+                }
+                case '/api/prompts': {
+                    // 列出所有 Prompt 日志
+                    const store = createFreshStore(projectName, basePath);
+                    let prompts = [];
+                    try {
+                        if (typeof store.listPrompts === 'function') {
+                            prompts = store.listPrompts();
+                        }
+                    }
+                    catch (e) {
+                        prompts = [];
+                    }
                     res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-                    res.end(JSON.stringify(progress));
+                    res.end(JSON.stringify({ prompts, count: prompts.length }));
                     break;
                 }
                 case '/api/stats': {
@@ -400,6 +435,228 @@ function startServer(projectName, basePath, port) {
                     res.end(JSON.stringify(stats));
                     break;
                 }
+                case '/api/memories': {
+                    // 列出所有记忆（用于记忆浏览页面）
+                    const memStore = createFreshStore(projectName, basePath);
+                    let memories = [];
+                    if (typeof memStore.listMemories === 'function') {
+                        const memoryType = url.searchParams.get('memoryType') || undefined;
+                        memories = memStore.listMemories({
+                            memoryType,
+                        });
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ memories }));
+                    break;
+                }
+                case '/api/memories/generate': {
+                    // 从文档/任务中生成记忆候选项
+                    const genStore = createFreshStore(projectName, basePath);
+                    if (typeof genStore.generateMemoryCandidates !== 'function') {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'generateMemoryCandidates not supported (requires graph engine)' }));
+                        break;
+                    }
+                    const genSource = url.searchParams.get('source') || 'both';
+                    const genTaskId = url.searchParams.get('taskId') || undefined;
+                    const genSection = url.searchParams.get('section') || undefined;
+                    const rawLimit = url.searchParams.get('limit') ? parseInt(url.searchParams.get('limit'), 10) : 50;
+                    const genLimit = rawLimit <= 0 ? 99999 : rawLimit;
+                    const result = genStore.generateMemoryCandidates({
+                        source: genSource,
+                        taskId: genTaskId,
+                        section: genSection,
+                        limit: genLimit,
+                    });
+                    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify(result));
+                    break;
+                }
+                case '/api/memories/save': {
+                    // 保存一条记忆（POST）
+                    if (req.method !== 'POST') {
+                        res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'Method Not Allowed. Use POST.' }));
+                        break;
+                    }
+                    const saveBody = await readRequestBody(req);
+                    const saveStore = createFreshStore(projectName, basePath);
+                    if (typeof saveStore.saveMemory !== 'function') {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'saveMemory not supported (requires graph engine)' }));
+                        break;
+                    }
+                    try {
+                        const saved = saveStore.saveMemory({
+                            projectName,
+                            memoryType: saveBody.memoryType || 'insight',
+                            content: saveBody.content || '',
+                            tags: saveBody.tags || [],
+                            relatedTaskId: saveBody.relatedTaskId || undefined,
+                            sourceId: saveBody.sourceId || undefined,
+                            importance: saveBody.importance ?? 0.5,
+                        });
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ status: 'saved', memory: saved }));
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: e.message || String(e) }));
+                    }
+                    break;
+                }
+                case '/api/memories/relate': {
+                    // Phase-44: 建立记忆间关系（POST）
+                    if (req.method !== 'POST') {
+                        res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'Method Not Allowed. Use POST.' }));
+                        break;
+                    }
+                    const relBody = await readRequestBody(req);
+                    const relStore = createFreshStore(projectName, basePath);
+                    try {
+                        // 使用 graph 的 put_relation 或 applyMutations 建立关系
+                        const graph = relStore.graph;
+                        if (!graph) {
+                            res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'Graph engine not available' }));
+                            break;
+                        }
+                        const fromId = relBody.fromId;
+                        const toId = relBody.toId;
+                        const relationType = relBody.relationType || 'MEMORY_RELATES';
+                        const weight = relBody.weight ?? 0.5;
+                        // 尝试使用 applyMutations (Phase-44)，回退到 putRelation
+                        if (typeof graph.applyMutations === 'function') {
+                            graph.applyMutations([{
+                                    type: 'PutRelation',
+                                    relation: {
+                                        source_id: fromId,
+                                        target_id: toId,
+                                        relation_type: relationType,
+                                        weight: weight,
+                                    }
+                                }]);
+                        }
+                        else if (typeof graph.putRelation === 'function') {
+                            graph.putRelation({
+                                source_id: fromId,
+                                target_id: toId,
+                                relation_type: relationType,
+                                weight: weight,
+                            });
+                        }
+                        else {
+                            res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'No relation creation method available' }));
+                            break;
+                        }
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ status: 'created', from: fromId, to: toId, relationType, weight }));
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: e.message || String(e) }));
+                    }
+                    break;
+                }
+                case '/api/memories/clear': {
+                    // 批量清除所有记忆（POST）
+                    if (req.method !== 'POST') {
+                        res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'Method Not Allowed. Use POST.' }));
+                        break;
+                    }
+                    const clearBody = await readRequestBody(req);
+                    if (clearBody.confirm !== true) {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'Safety guard: confirm must be true' }));
+                        break;
+                    }
+                    const clearStore = createFreshStore(projectName, basePath);
+                    if (typeof clearStore.clearAllMemories !== 'function') {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'clearAllMemories not supported (requires graph engine)' }));
+                        break;
+                    }
+                    try {
+                        const clearResult = clearStore.clearAllMemories(clearBody.memoryType || undefined);
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ status: 'cleared', ...clearResult, memoryType: clearBody.memoryType || 'all' }));
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: e.message || String(e) }));
+                    }
+                    break;
+                }
+                case '/api/memories/graph': {
+                    // 导出仅记忆相关的图数据（用于记忆页面 3D 可视化）
+                    const memGraphStore = createFreshStore(projectName, basePath);
+                    if (!memGraphStore.exportGraph) {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: 'exportGraph not supported (requires graph engine)' }));
+                        break;
+                    }
+                    try {
+                        // 导出完整图（含记忆），然后过滤出记忆相关节点和边
+                        const fullGraph = memGraphStore.exportGraph({
+                            includeDocuments: true,
+                            includeModules: true,
+                            includeNodeDegree: false,
+                            enableBackendDegreeFallback: false,
+                            includePrompts: false,
+                        });
+                        if (!fullGraph) {
+                            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: 'exportGraph returned null' }));
+                            break;
+                        }
+                        // 收集记忆节点 ID
+                        const memoryNodeIds = new Set();
+                        const memoryNodes = [];
+                        const contextNodes = [];
+                        const contextNodeIds = new Set();
+                        for (const node of fullGraph.nodes) {
+                            if (node.type === 'memory') {
+                                memoryNodeIds.add(node.id);
+                                memoryNodes.push(node);
+                            }
+                        }
+                        // 收集与记忆相关的边和上下文节点（任务、文档、模块）
+                        const memEdges = [];
+                        for (const edge of fullGraph.edges) {
+                            const fromIsMem = memoryNodeIds.has(edge.from);
+                            const toIsMem = memoryNodeIds.has(edge.to);
+                            if (fromIsMem || toIsMem) {
+                                memEdges.push(edge);
+                                // 添加非记忆端的上下文节点
+                                const otherId = fromIsMem ? edge.to : edge.from;
+                                if (!memoryNodeIds.has(otherId) && !contextNodeIds.has(otherId)) {
+                                    contextNodeIds.add(otherId);
+                                    const ctxNode = fullGraph.nodes.find((n) => n.id === otherId);
+                                    if (ctxNode)
+                                        contextNodes.push(ctxNode);
+                                }
+                            }
+                        }
+                        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({
+                            nodes: [...memoryNodes, ...contextNodes],
+                            edges: memEdges,
+                            stats: {
+                                memoryCount: memoryNodes.length,
+                                contextCount: contextNodes.length,
+                                edgeCount: memEdges.length,
+                            },
+                        }));
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: e.message || String(e) }));
+                    }
+                    break;
+                }
                 case '/api/docs': {
                     // 列出所有文档片段（不含内容，用于文档浏览页面左侧列表）
                     const store = createFreshStore(projectName, basePath);
@@ -855,19 +1112,48 @@ function startServer(projectName, basePath, port) {
                     break;
                 }
                 case '/api/graph/paged': {
-                    // ── Phase-8C T8C.3: Paginated graph data API ──
-                    // GET /api/graph/paged?offset=0&limit=5000&sortBy=center
-                    // Returns a page of { nodes, edges, total, hasMore }
-                    // sortBy=center: viewport-priority (nodes sorted by distance to center)
-                    // sortBy=default: natural order
-                    const store = createFreshStore(projectName, basePath);
+                    // ── Phase-9 T9.2: True pagination push-down to Rust layer ──
+                    // GET /api/graph/paged?offset=0&limit=5000
+                    // Returns a page of { nodes, edges, totalNodes, totalEdges, hasMore }
+                    // Now calls Rust SocialGraphV2.exportGraphPaginated() via NAPI
+                    // instead of full-loading + in-memory slicing.
+                    const pagedStore = createFreshStore(projectName, basePath);
                     const offset = parseInt(url.searchParams.get('offset') || '0', 10);
                     const limit = parseInt(url.searchParams.get('limit') || '5000', 10);
-                    const sortBy = url.searchParams.get('sortBy') || 'default';
                     const includeDocuments = url.searchParams.get('includeDocuments') !== 'false';
                     const includeModules = url.searchParams.get('includeModules') !== 'false';
-                    if (store.exportGraph) {
-                        const fullGraph = store.exportGraph({
+                    // Phase-10 T10.1: Support entityTypes query param for tiered loading
+                    const entityTypesParam = url.searchParams.get('entityTypes');
+                    const entityTypes = entityTypesParam ? entityTypesParam.split(',').map(t => t.trim()).filter(Boolean) : undefined;
+                    // Use the new pagination push-down method if available
+                    if (pagedStore.exportGraphPaginated) {
+                        try {
+                            const result = pagedStore.exportGraphPaginated(offset, limit, {
+                                includeDocuments,
+                                includeModules,
+                                includeNodeDegree: true,
+                                entityTypes,
+                            });
+                            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({
+                                nodes: result.nodes,
+                                edges: result.edges,
+                                total: result.totalNodes,
+                                totalEdges: result.totalEdges,
+                                offset: result.offset,
+                                limit: result.limit,
+                                hasMore: result.hasMore,
+                                nextOffset: Math.min(offset + limit, result.totalNodes),
+                            }));
+                        }
+                        catch (err) {
+                            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: `分页导出失败: ${err?.message || err}` }));
+                        }
+                    }
+                    else if (pagedStore.exportGraph) {
+                        // Fallback: full load + in-memory slicing (pre-Phase-9 behavior)
+                        const fullGraph = pagedStore.exportGraph({
                             includeDocuments,
                             includeModules,
                             includeNodeDegree: true,
@@ -878,31 +1164,10 @@ function startServer(projectName, basePath, port) {
                             res.end(JSON.stringify({ error: '图数据导出失败' }));
                             break;
                         }
-                        let allNodes = fullGraph.nodes || [];
+                        const allNodes = fullGraph.nodes || [];
                         const allEdges = fullGraph.edges || [];
-                        // T8C.4: Viewport-priority sorting — sort by distance from center
-                        if (sortBy === 'center') {
-                            // Calculate centroid of all nodes
-                            let cx = 0, cy = 0;
-                            for (const n of allNodes) {
-                                cx += (n.x || 0);
-                                cy += (n.y || 0);
-                            }
-                            if (allNodes.length > 0) {
-                                cx /= allNodes.length;
-                                cy /= allNodes.length;
-                            }
-                            // Sort by distance to centroid (closest first)
-                            allNodes = [...allNodes].sort((a, b) => {
-                                const da = (a.x - cx) ** 2 + (a.y - cy) ** 2;
-                                const db = (b.x - cx) ** 2 + (b.y - cy) ** 2;
-                                return da - db;
-                            });
-                        }
-                        // Slice the page
                         const pageNodes = allNodes.slice(offset, offset + limit);
                         const pageNodeIds = new Set(pageNodes.map((n) => n.id));
-                        // Include only edges where both endpoints are in this page
                         const pageEdges = allEdges.filter((e) => pageNodeIds.has(e.from) && pageNodeIds.has(e.to));
                         res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                         res.end(JSON.stringify({
@@ -922,6 +1187,80 @@ function startServer(projectName, basePath, port) {
                     }
                     break;
                 }
+                case '/api/graph/binary': {
+                    // ── Phase-9 T9.3: Binary compact export endpoint ──
+                    // GET /api/graph/binary
+                    // Returns ArrayBuffer with compact binary format (5x smaller than JSON)
+                    // Client can parse directly as TypedArray, no JSON.parse needed.
+                    const binaryStore = createFreshStore(projectName, basePath);
+                    if (binaryStore.exportGraphCompact) {
+                        try {
+                            const buf = binaryStore.exportGraphCompact();
+                            if (buf && buf.length > 0) {
+                                res.writeHead(200, {
+                                    'Content-Type': 'application/octet-stream',
+                                    'Content-Length': String(buf.length),
+                                    'X-Node-Count': String(new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(8, true)),
+                                    'X-Edge-Count': String(new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(12, true)),
+                                });
+                                res.end(buf);
+                            }
+                            else {
+                                // Fallback: return empty binary
+                                const emptyBuf = Buffer.alloc(16);
+                                emptyBuf.writeUInt32LE(0x41494647, 0); // magic
+                                emptyBuf.writeUInt32LE(1, 4); // version
+                                emptyBuf.writeUInt32LE(0, 8); // node_count
+                                emptyBuf.writeUInt32LE(0, 12); // edge_count
+                                res.writeHead(200, {
+                                    'Content-Type': 'application/octet-stream',
+                                    'Content-Length': '16',
+                                    'X-Node-Count': '0',
+                                    'X-Edge-Count': '0',
+                                });
+                                res.end(emptyBuf);
+                            }
+                        }
+                        catch (err) {
+                            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: `二进制导出失败: ${err?.message || err}` }));
+                        }
+                    }
+                    else {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: '当前引擎不支持二进制导出' }));
+                    }
+                    break;
+                }
+                case '/api/graph/clusters': {
+                    // ── Phase-9 T9.4: Server-side aggregation endpoint ──
+                    // GET /api/graph/clusters
+                    // Returns pre-aggregated entity group summaries.
+                    // Ideal for low-zoom cluster views — no need to transfer all nodes.
+                    const clusterStore = createFreshStore(projectName, basePath);
+                    if (clusterStore.getEntityGroupSummary) {
+                        try {
+                            const agg = clusterStore.getEntityGroupSummary();
+                            if (agg) {
+                                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                                res.end(JSON.stringify(agg));
+                            }
+                            else {
+                                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                                res.end(JSON.stringify({ groups: [], totalEntities: 0, totalRelations: 0 }));
+                            }
+                        }
+                        catch (err) {
+                            res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                            res.end(JSON.stringify({ error: `聚合查询失败: ${err?.message || err}` }));
+                        }
+                    }
+                    else {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: '当前引擎不支持聚合查询' }));
+                    }
+                    break;
+                }
                 case '/graph-canvas.js': {
                     // Serve the GraphCanvas engine as a JavaScript file
                     res.writeHead(200, {