noteconnection 1.6.8 → 1.8.0

package/dist/src/routes/markdown.js

@@ -0,0 +1,287 @@
+"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 });
+exports.registerMarkdownRoutes = registerMarkdownRoutes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+const MarkdownGateway_1 = require("../markdown/MarkdownGateway");
+const PROTOCOL_VERSION = '1.0.0';
+const INDEXES = new Map();
+function buildIndexId(filePath) {
+    return `md-idx-${Buffer.from(filePath).toString('base64').slice(0, 16)}-${Date.now()}`;
+}
+function indexMarkdownFile(filePath) {
+    const resolved = path.resolve(filePath);
+    const content = fs.readFileSync(resolved, 'utf8');
+    const lines = content.split('\n');
+    const blocks = [];
+    let currentBlock = [];
+    let currentHeading;
+    let currentHeadingLevel = 0;
+    let blockStartLine = 0;
+    let blockId = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+        if (headingMatch) {
+            // Flush current block
+            if (currentBlock.length > 0 || currentHeading) {
+                blocks.push({
+                    id: blockId++,
+                    text: currentBlock.join('\n').trim(),
+                    heading: currentHeading,
+                    headingLevel: currentHeadingLevel,
+                    startLine: blockStartLine,
+                    endLine: i - 1,
+                });
+            }
+            currentHeading = headingMatch[2].trim();
+            currentHeadingLevel = headingMatch[1].length;
+            currentBlock = [];
+            blockStartLine = i;
+        }
+        else {
+            currentBlock.push(line);
+        }
+    }
+    // Flush final block
+    if (currentBlock.length > 0 || currentHeading) {
+        blocks.push({
+            id: blockId,
+            text: currentBlock.join('\n').trim(),
+            heading: currentHeading,
+            headingLevel: currentHeadingLevel,
+            startLine: blockStartLine,
+            endLine: lines.length - 1,
+        });
+    }
+    // Ensure at least one block for empty files
+    if (blocks.length === 0) {
+        blocks.push({
+            id: 0,
+            text: content.trim() || '(empty)',
+            heading: undefined,
+            headingLevel: 0,
+            startLine: 0,
+            endLine: lines.length - 1,
+        });
+    }
+    const indexId = buildIndexId(filePath);
+    const index = {
+        indexId,
+        filePath,
+        blocks,
+        markdownProtocolVersion: PROTOCOL_VERSION,
+        indexedAt: new Date().toISOString(),
+    };
+    INDEXES.set(indexId, index);
+    return index;
+}
+function resolveNodeFromIndex(index, nodeId) {
+    const block = index.blocks.find(b => b.heading?.toLowerCase() === nodeId.toLowerCase() ||
+        b.text.toLowerCase().includes(nodeId.toLowerCase()));
+    return block ? { targetBlockId: block.id, filePath: index.filePath } : null;
+}
+function resolveWikiFromIndex(index, wikiTarget) {
+    const clean = wikiTarget.replace(/^\[\[|\]\]$/g, '').trim();
+    const exact = index.blocks.find(b => b.heading?.toLowerCase() === clean.toLowerCase());
+    if (exact)
+        return { matchType: 'exact', filePath: index.filePath, targetBlockId: exact.id };
+    const partial = index.blocks.find(b => b.heading?.toLowerCase().includes(clean.toLowerCase()) ||
+        b.text.toLowerCase().includes(clean.toLowerCase()));
+    if (partial)
+        return { matchType: 'alias', filePath: index.filePath, targetBlockId: partial.id };
+    return { matchType: 'fallback', filePath: index.filePath };
+}
+function registerMarkdownRoutes(_ctx) {
+    const ctx = _ctx;
+    const api = (p) => `/api/markdown${p}`;
+    const json = (res, code, data) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    const ok = (res, data) => json(res, 200, { success: true, ...data });
+    const fail = (res, error, label) => {
+        console.error(error);
+        CrashLogger_1.CrashLogger.log(error, label);
+        json(res, 500, { success: false, error: String(error) });
+    };
+    const readBody = (req) => new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+    const resolveRuntimeConfig = async () => {
+        if (ctx.loadFrontendSettings) {
+            const frontendSettings = await ctx.loadFrontendSettings();
+            return (0, MarkdownGateway_1.normalizeMarkdownRuntimeConfig)(frontendSettings?.reading);
+        }
+        return (0, MarkdownGateway_1.normalizeMarkdownRuntimeConfig)({});
+    };
+    return [
+        {
+            method: 'POST',
+            path: api('/index'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    const filePath = payload.filePath || payload.path || '';
+                    if (ctx.markdownGateway) {
+                        const runtimeConfig = await resolveRuntimeConfig();
+                        const result = await ctx.markdownGateway.buildIndex({
+                            filePath,
+                            forceRebuild: payload.forceRebuild === true,
+                        }, runtimeConfig);
+                        ok(res, result);
+                        return;
+                    }
+                    if (!filePath || !fs.existsSync(filePath)) {
+                        return fail(res, new Error('File not found: ' + filePath), 'API:POST /api/markdown/index');
+                    }
+                    const index = indexMarkdownFile(filePath);
+                    ok(res, {
+                        indexId: index.indexId,
+                        filePath: index.filePath,
+                        blocksSummary: { totalBlocks: index.blocks.length },
+                        markdownProtocolVersion: index.markdownProtocolVersion,
+                    });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/markdown/index');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/chunk'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    if (ctx.markdownGateway) {
+                        const result = await ctx.markdownGateway.getChunk({
+                            indexId: String(payload.indexId || ''),
+                            startBlock: Number(payload.startBlock) || 0,
+                            blockCount: Number(payload.blockCount) || 1,
+                        });
+                        ok(res, result);
+                        return;
+                    }
+                    const index = INDEXES.get(payload.indexId || '');
+                    if (!index)
+                        return fail(res, new Error('Index not found'), 'API:POST /api/markdown/chunk');
+                    const start = payload.startBlock || 0;
+                    const count = payload.blockCount || index.blocks.length;
+                    const blocks = index.blocks.slice(start, start + count).map(b => ({
+                        blockId: b.id,
+                        text: b.text,
+                        heading: b.heading,
+                        headingLevel: b.headingLevel,
+                    }));
+                    ok(res, { blocks });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/markdown/chunk');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/resolve-node'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    if (ctx.markdownGateway) {
+                        const runtimeConfig = await resolveRuntimeConfig();
+                        const result = await ctx.markdownGateway.resolveNode({
+                            nodeId: String(payload.nodeId || ''),
+                            currentFilePath: String(payload.currentFilePath || '').trim() || undefined,
+                        }, runtimeConfig);
+                        ok(res, result);
+                        return;
+                    }
+                    const index = INDEXES.get(payload.indexId || '');
+                    // Fallback: search all indexes
+                    const searchIndex = index || [...INDEXES.values()].find(i => i.filePath === payload.currentFilePath);
+                    if (!searchIndex && INDEXES.size > 0) {
+                        return ok(res, { filePath: payload.currentFilePath || '', targetBlockId: 0 });
+                    }
+                    if (!searchIndex)
+                        return fail(res, new Error('No index available'), 'API:POST /api/markdown/resolve-node');
+                    const result = resolveNodeFromIndex(searchIndex, payload.nodeId || '');
+                    ok(res, result || { filePath: searchIndex.filePath, targetBlockId: 0 });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/markdown/resolve-node');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: api('/resolve-wiki'),
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    if (ctx.markdownGateway) {
+                        const runtimeConfig = await resolveRuntimeConfig();
+                        const result = await ctx.markdownGateway.resolveWiki({
+                            wikiTarget: String(payload.wikiTarget || ''),
+                            currentFilePath: String(payload.currentFilePath || ''),
+                        }, runtimeConfig);
+                        ok(res, result);
+                        return;
+                    }
+                    const index = INDEXES.get(payload.indexId || '');
+                    const searchIndex = index || [...INDEXES.values()].find(i => i.filePath === payload.currentFilePath);
+                    if (!searchIndex && INDEXES.size > 0) {
+                        return ok(res, { filePath: payload.currentFilePath || '', matchType: 'fallback' });
+                    }
+                    if (!searchIndex)
+                        return fail(res, new Error('No index available'), 'API:POST /api/markdown/resolve-wiki');
+                    const result = resolveWikiFromIndex(searchIndex, payload.wikiTarget || '');
+                    ok(res, result || { filePath: searchIndex.filePath, matchType: 'fallback' });
+                }
+                catch (e) {
+                    fail(res, e, 'API:POST /api/markdown/resolve-wiki');
+                }
+            },
+        },
+    ];
+}