noteconnection 1.8.0 → 1.9.0

package/dist/src/resources/ResourceRegistry.test.js

@@ -58,4 +58,40 @@ describe('ResourceRegistry', () => {
         expect(restored.getProjectionByDocumentId('doc_delete')?.status).toBe('deleted');
         expect(restored.listProjectionsByIds([created.projection.projectionId], { includeDeleted: true })).toHaveLength(1);
     });
+    test('mirrors a document move without changing resource or projection identity', () => {
+        let idCounter = 0;
+        const registry = new ResourceRegistry_1.ResourceRegistry((prefix = 'resource') => `${prefix}_${++idCounter}`);
+        const created = registry.upsertKnowledgeDocument({
+            documentId: 'doc_move',
+            sourcePath: 'Knowledge_Base/old.md',
+            content: '# Move',
+            sourceHash: 'hash_move',
+            title: 'old',
+            language: 'en',
+            version: 1,
+            updatedAt: '2026-05-26T04:00:00.000Z',
+            metadata: { sourceUri: 'note://workspace/v1/old.md' },
+        });
+        expect(registry.updateKnowledgeDocumentIdentity({
+            documentId: 'doc_move',
+            sourcePath: 'Knowledge_Base/new.md',
+            sourceUri: 'note://workspace/v1/new.md',
+            revision: 'sha256:new',
+            identityAliases: ['old.md', 'Knowledge_Base/new.md'],
+            updatedAt: '2026-05-26T05:00:00.000Z',
+        })).toBe(true);
+        expect(registry.getProjectionByDocumentId('doc_move')).toEqual(expect.objectContaining({
+            projectionId: created.projection.projectionId,
+            sourcePath: 'Knowledge_Base/new.md',
+            metadata: expect.objectContaining({
+                sourceUri: 'note://workspace/v1/new.md',
+                revision: 'sha256:new',
+                identityAliases: ['old.md', 'Knowledge_Base/new.md'],
+            }),
+        }));
+        expect(registry.getResourceById(created.resource.resourceId)).toEqual(expect.objectContaining({
+            resourceId: created.resource.resourceId,
+            sourcePath: 'Knowledge_Base/new.md',
+        }));
+    });
 });

package/dist/src/routes/index.js

@@ -6,8 +6,6 @@ const notemd_1 = require("./notemd");
 const markdown_1 = require("./markdown");
 const render_1 = require("./render");
 const settings_1 = require("./settings");
-const diagnostics_1 = require("./diagnostics");
-const data_1 = require("./data");
 const agentWorkspaceDiagnostics_1 = require("./agentWorkspaceDiagnostics");
 function registerAllRoutes(ctx) {
     return [
@@ -16,8 +14,6 @@ function registerAllRoutes(ctx) {
         ...(0, markdown_1.registerMarkdownRoutes)(ctx),
         ...(0, render_1.registerRenderRoutes)(ctx),
         ...(0, settings_1.registerSettingsRoutes)(ctx),
-        ...(0, diagnostics_1.registerDiagnosticsRoutes)(ctx),
-        ...(0, data_1.registerDataRoutes)(ctx),
         ...(0, agentWorkspaceDiagnostics_1.registerAgentWorkspaceDiagnosticsRoutes)(ctx),
     ];
 }

package/dist/src/routes/knowledge.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerKnowledgeRoutes = registerKnowledgeRoutes;
 const CrashLogger_1 = require("../backend/utils/CrashLogger");
 const requestNormalization_1 = require("../learning/requestNormalization");
+const knowledgePayload_1 = require("./knowledgePayload");
 function registerKnowledgeRoutes(ctx) {
     const { knowledgeLearningPlatform, knowledgeIngestor, knowledgeQuerier, LOOPBACK_HOST, finalPort, KNOWLEDGE_GRAPH_STORE_BACKEND, KNOWLEDGE_GRAPHDB_ADAPTER_PROVIDER, KNOWLEDGE_GRAPHDB_ADAPTER_ID, KNOWLEDGE_GRAPHDB_FALLBACK_ENABLED, KNOWLEDGE_GRAPHDB_OPERATION_MODE, runtimeRunbookOps, scheduleKnowledgeLearningPlatformWarmup, } = ctx;
     const api = (path) => `/api/knowledge${path}`;
@@ -14,11 +15,44 @@ function registerKnowledgeRoutes(ctx) {
     const fail = (res, error, label) => {
         console.error(error);
         CrashLogger_1.CrashLogger.log(error, label);
+        if (error instanceof InvalidJsonPayloadError) {
+            res.setHeader?.('X-Error-Code', error.code);
+            json(res, 400, { error: error.message, errorCode: error.code, success: false });
+            return;
+        }
+        if (error instanceof knowledgePayload_1.KnowledgePayloadError) {
+            json(res, error.statusCode, { success: false, error: error.message, code: error.code });
+            return;
+        }
         json(res, 500, { success: false, error: String(error) });
     };
+    class InvalidJsonPayloadError extends Error {
+        constructor() {
+            super('Invalid JSON body.');
+            this.code = 'invalid_json';
+            this.name = 'InvalidJsonPayloadError';
+        }
+    }
+    const parseJsonBody = (body) => {
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            throw new InvalidJsonPayloadError();
+        }
+    };
     const readBody = (req) => new Promise((resolve, reject) => {
         const chunks = [];
-        req.on('data', (c) => chunks.push(c));
+        let totalBytes = 0;
+        req.on('data', (c) => {
+            totalBytes += c.length;
+            if (totalBytes > 128 * 1024 * 1024) {
+                reject(new knowledgePayload_1.KnowledgePayloadError('Request body exceeds 128 MiB.'));
+                req.destroy?.();
+                return;
+            }
+            chunks.push(c);
+        });
         req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
         req.on('error', reject);
     });
@@ -333,34 +367,6 @@ function registerKnowledgeRoutes(ctx) {
                 }
             },
         },
-        {
-            method: 'GET',
-            path: api('/conversation/turn-cache/diagnostics'),
-            handler: async (req, res) => {
-                try {
-                    const params = parseQuery(req);
-                    const result = await knowledgeLearningPlatform.getAgentConversationTurnCacheDiagnostics({ format: params.get('format') || 'summary' });
-                    ok(res, result);
-                }
-                catch (e) {
-                    fail(res, e, 'GET /api/knowledge/conversation/turn-cache/diagnostics');
-                }
-            },
-        },
-        {
-            method: 'GET',
-            path: api('/conversation/turn-cache/diagnostics/trend'),
-            handler: async (req, res) => {
-                try {
-                    const params = parseQuery(req);
-                    const result = await knowledgeLearningPlatform.getAgentConversationTurnCacheTrend({ limit: Number(params.get('limit')) || 20, windowSize: Number(params.get('windowSize')) || 6, minSamples: Number(params.get('minSamples')) || 3 });
-                    ok(res, result);
-                }
-                catch (e) {
-                    fail(res, e, 'GET /api/knowledge/conversation/turn-cache/diagnostics/trend');
-                }
-            },
-        },
         {
             method: 'GET',
             path: api('/runtime-capability-matrix'),
@@ -534,8 +540,9 @@ function registerKnowledgeRoutes(ctx) {
             handler: async (req, res) => {
                 try {
                     const body = await readBody(req);
-                    const result = await knowledgeIngestor.ingestKnowledge(JSON.parse(body));
-                    ok(res, { result, ingestStats: { avgLatencyMs: knowledgeIngestor.averageIngestLatencyMs(20) } });
+                    const result = await knowledgeIngestor.ingestKnowledge((0, knowledgePayload_1.parseKnowledgeIngestBody)(body));
+                    // Preserve the legacy response shape; diagnostics remain available via runtime metrics.
+                    ok(res, { result });
                 }
                 catch (e) {
                     fail(res, e, 'POST /api/knowledge/ingest');
@@ -548,8 +555,10 @@ function registerKnowledgeRoutes(ctx) {
             handler: async (req, res) => {
                 try {
                     const body = await readBody(req);
-                    const result = await knowledgeQuerier.queryKnowledge((0, requestNormalization_1.normalizeKnowledgeQueryRequestPayload)(JSON.parse(body)));
-                    ok(res, { result, queryStats: knowledgeQuerier.getDiagnosticsSummary() });
+                    // Keep the migration boundary on the legacy platform facade so
+                    // registry dispatch preserves the established response contract.
+                    const result = await knowledgeLearningPlatform.queryKnowledge((0, requestNormalization_1.normalizeKnowledgeQueryRequestPayload)(parseJsonBody(body)));
+                    ok(res, { result });
                 }
                 catch (e) {
                     fail(res, e, 'POST /api/knowledge/query');
@@ -804,6 +813,10 @@ function registerKnowledgeRoutes(ctx) {
             handler: async (req, res) => {
                 try {
                     const body = await readBody(req);
+                    if (ctx.executeQueryBackendConfigUpdate) {
+                        ok(res, await ctx.executeQueryBackendConfigUpdate(JSON.parse(body)));
+                        return;
+                    }
                     const result = await knowledgeLearningPlatform.updateQueryBackendConfig(JSON.parse(body));
                     ok(res, { result });
                 }

package/dist/src/routes/knowledgePayload.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgePayloadError = void 0;
+exports.parseKnowledgeIngestBody = parseKnowledgeIngestBody;
+const MAX_DOCUMENTS_PER_REQUEST = 5000;
+const MAX_ALIASES_PER_DOCUMENT = 64;
+const MAX_ALIAS_LENGTH = 2048;
+const MAX_CONTENT_BYTES = 64 * 1024 * 1024;
+class KnowledgePayloadError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 400;
+        this.code = 'invalid_knowledge_payload';
+        this.name = 'KnowledgePayloadError';
+    }
+}
+exports.KnowledgePayloadError = KnowledgePayloadError;
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function firstValue(record, keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(record, key)) {
+            return record[key];
+        }
+    }
+    return undefined;
+}
+function normalizeStringArray(value, field) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new KnowledgePayloadError(`${field} must be an array of strings.`);
+    }
+    if (value.length > MAX_ALIASES_PER_DOCUMENT) {
+        throw new KnowledgePayloadError(`${field} exceeds ${MAX_ALIASES_PER_DOCUMENT} entries.`);
+    }
+    const values = Array.from(new Set(value.map((item, index) => {
+        if (typeof item !== 'string' || item.trim().length === 0) {
+            throw new KnowledgePayloadError(`${field}[${index}] must be a non-empty string.`);
+        }
+        const normalized = item.trim();
+        if (normalized.length > MAX_ALIAS_LENGTH) {
+            throw new KnowledgePayloadError(`${field}[${index}] exceeds ${MAX_ALIAS_LENGTH} characters.`);
+        }
+        return normalized;
+    })));
+    return values;
+}
+function normalizeDocument(raw) {
+    if (!isRecord(raw)) {
+        throw new KnowledgePayloadError('Each ingest document must be an object.');
+    }
+    const contentRaw = firstValue(raw, ['content', 'text', 'body', 'markdown']);
+    const content = typeof contentRaw === 'string' ? contentRaw : String(contentRaw ?? '');
+    if (Buffer.byteLength(content, 'utf8') > MAX_CONTENT_BYTES) {
+        throw new KnowledgePayloadError(`Document content exceeds ${MAX_CONTENT_BYTES} bytes.`);
+    }
+    if (!content.trim() && !firstString(raw, ['documentId', 'docId', 'id', 'sourcePath', 'source_path', 'path'])) {
+        throw new KnowledgePayloadError('Document requires content or an identity.');
+    }
+    const identityAliases = normalizeStringArray(firstValue(raw, ['identityAliases', 'identity_aliases', 'aliases']), 'identityAliases');
+    return {
+        documentId: firstString(raw, ['documentId', 'docId', 'id']),
+        sourcePath: firstString(raw, ['sourcePath', 'source_path', 'path', 'filePath', 'filepath', 'file']) || '',
+        sourceUri: firstString(raw, ['sourceUri', 'source_uri', 'uri']),
+        revision: firstString(raw, ['revision', 'sourceRevision', 'source_revision']),
+        identityAliases: identityAliases.length > 0 ? identityAliases : undefined,
+        content,
+        language: firstString(raw, ['language', 'lang', 'locale']),
+        updatedAt: firstString(raw, ['updatedAt', 'updated_at', 'timestamp', 'now']),
+        workspaceId: firstString(raw, ['workspaceId', 'workspace_id']),
+        corpusId: firstString(raw, ['corpusId', 'corpus_id']),
+        exportProfileId: firstString(raw, ['exportProfileId', 'export_profile_id']),
+        metadata: isRecord(raw.metadata) ? { ...raw.metadata } : undefined,
+    };
+}
+function normalizeDelete(raw) {
+    if (!isRecord(raw)) {
+        throw new KnowledgePayloadError('Each deleted document must be an object.');
+    }
+    const identityAliases = normalizeStringArray(firstValue(raw, ['identityAliases', 'identity_aliases', 'aliases']), 'identityAliases');
+    const result = {
+        documentId: firstString(raw, ['documentId', 'docId', 'id']),
+        sourcePath: firstString(raw, ['sourcePath', 'source_path', 'path', 'filePath', 'filepath', 'file']),
+        sourceUri: firstString(raw, ['sourceUri', 'source_uri', 'uri']),
+        identityAliases: identityAliases.length > 0 ? identityAliases : undefined,
+    };
+    if (!result.documentId && !result.sourcePath && !result.sourceUri && identityAliases.length === 0) {
+        throw new KnowledgePayloadError('Delete requires documentId, sourcePath, sourceUri, or identityAliases.');
+    }
+    return result;
+}
+function normalizeMove(raw) {
+    if (!isRecord(raw)) {
+        throw new KnowledgePayloadError('Each move document must be an object.');
+    }
+    const toSourcePath = firstString(raw, ['toSourcePath', 'to_source_path', 'destinationPath', 'destination_path']);
+    if (!toSourcePath) {
+        throw new KnowledgePayloadError('Move requires toSourcePath.');
+    }
+    const aliases = normalizeStringArray(firstValue(raw, ['toIdentityAliases', 'to_identity_aliases', 'aliases']), 'toIdentityAliases');
+    const fromAliases = normalizeStringArray(firstValue(raw, ['fromIdentityAliases', 'from_identity_aliases', 'fromAliases']), 'fromIdentityAliases');
+    return {
+        documentId: firstString(raw, ['documentId', 'docId', 'id']),
+        fromSourcePath: firstString(raw, ['fromSourcePath', 'from_source_path', 'sourcePath', 'source_path']),
+        fromSourceUri: firstString(raw, ['fromSourceUri', 'from_source_uri', 'sourceUri', 'source_uri']),
+        fromIdentityAliases: fromAliases.length > 0 ? fromAliases : undefined,
+        toSourcePath,
+        toSourceUri: firstString(raw, ['toSourceUri', 'to_source_uri', 'destinationUri', 'destination_uri']),
+        toIdentityAliases: aliases.length > 0 ? aliases : undefined,
+        revision: firstString(raw, ['revision', 'sourceRevision', 'source_revision']),
+        updatedAt: firstString(raw, ['updatedAt', 'updated_at', 'timestamp', 'now']),
+    };
+}
+function normalizeOperation(raw) {
+    if (!isRecord(raw)) {
+        throw new KnowledgePayloadError('Each ingest operation must be an object.');
+    }
+    const operation = (firstString(raw, ['op', 'operation', 'action', 'type']) || 'upsert').toLowerCase();
+    const nested = firstValue(raw, ['document', 'payload', 'item']) ?? raw;
+    if (operation === 'delete' || operation === 'remove' || operation === 'del') {
+        return { op: 'delete', document: normalizeDelete(nested) };
+    }
+    if (operation === 'move' || operation === 'rename') {
+        return { op: 'move', document: normalizeMove(nested) };
+    }
+    if (operation === 'upsert' || operation === 'insert' || operation === 'update' || operation === 'put') {
+        return { op: 'upsert', document: normalizeDocument(nested) };
+    }
+    throw new KnowledgePayloadError(`Unsupported ingest operation: ${operation}.`);
+}
+function asArray(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function parseKnowledgeIngestBody(body) {
+    let payload;
+    try {
+        payload = body.trim() ? JSON.parse(body) : {};
+    }
+    catch (_error) {
+        throw new KnowledgePayloadError('Request body must be valid JSON.');
+    }
+    if (!isRecord(payload) && !Array.isArray(payload)) {
+        throw new KnowledgePayloadError('Request body must be an object or document array.');
+    }
+    const record = isRecord(payload) ? payload : {};
+    const rawDocuments = firstValue(record, ['documents', 'docs', 'items']);
+    const rawDeletes = firstValue(record, ['deletedDocuments', 'deleted', 'deletes']);
+    const rawOperations = firstValue(record, ['operations', 'ops']);
+    const documents = asArray(rawDocuments ?? (Array.isArray(payload) ? payload : undefined)).map(normalizeDocument);
+    const deletedDocuments = asArray(rawDeletes).map(normalizeDelete);
+    const operations = asArray(rawOperations).map(normalizeOperation);
+    const totalItems = documents.length + deletedDocuments.length + operations.length;
+    if (totalItems > MAX_DOCUMENTS_PER_REQUEST) {
+        throw new KnowledgePayloadError(`Ingest request exceeds ${MAX_DOCUMENTS_PER_REQUEST} documents/operations.`);
+    }
+    const incremental = typeof record.incremental === 'boolean' ? record.incremental : undefined;
+    const recomputeRelations = typeof record.recomputeRelations === 'boolean' ? record.recomputeRelations : undefined;
+    const relationRecomputeMode = firstString(record, ['relationRecomputeMode', 'relation_recompute_mode', 'recomputeMode']);
+    if (relationRecomputeMode && !['auto', 'none', 'incremental', 'full'].includes(relationRecomputeMode.toLowerCase())) {
+        throw new KnowledgePayloadError('relationRecomputeMode must be one of auto, none, incremental, full.');
+    }
+    return {
+        documents: documents.length > 0 ? documents : undefined,
+        deletedDocuments: deletedDocuments.length > 0 ? deletedDocuments : undefined,
+        operations: operations.length > 0 ? operations : undefined,
+        incremental,
+        recomputeRelations,
+        relationRecomputeMode: relationRecomputeMode?.toLowerCase(),
+        ingestedAt: firstString(record, ['ingestedAt', 'timestamp', 'now']),
+    };
+}

package/dist/src/routes/knowledgePayload.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const knowledgePayload_1 = require("./knowledgePayload");
+describe('knowledge HTTP payload contract', () => {
+    test('normalizes legacy aliases while preserving portable identity fields', () => {
+        const request = (0, knowledgePayload_1.parseKnowledgeIngestBody)(JSON.stringify({
+            docs: [{
+                    id: 'legacy-doc',
+                    path: 'Knowledge_Base/one.md',
+                    text: '# One',
+                    uri: 'note://workspace/v1/one.md',
+                    source_revision: 'sha256:one',
+                    aliases: ['one', 'notes/one.md'],
+                }],
+        }));
+        expect(request.documents?.[0]).toEqual(expect.objectContaining({
+            documentId: 'legacy-doc',
+            sourcePath: 'Knowledge_Base/one.md',
+            sourceUri: 'note://workspace/v1/one.md',
+            revision: 'sha256:one',
+            identityAliases: ['one', 'notes/one.md'],
+            content: '# One',
+        }));
+    });
+    test('accepts explicit move operations for replay', () => {
+        const request = (0, knowledgePayload_1.parseKnowledgeIngestBody)(JSON.stringify({
+            operations: [{
+                    op: 'rename',
+                    document: {
+                        documentId: 'doc-1',
+                        fromSourcePath: 'old.md',
+                        toSourcePath: 'new.md',
+                        toSourceUri: 'note://workspace/v1/new.md',
+                    },
+                }],
+        }));
+        expect(request.operations).toEqual([expect.objectContaining({
+                op: 'move',
+                document: expect.objectContaining({
+                    documentId: 'doc-1',
+                    toSourcePath: 'new.md',
+                }),
+            })]);
+    });
+    test('rejects malformed identity arrays and oversized documents at the edge', () => {
+        expect(() => (0, knowledgePayload_1.parseKnowledgeIngestBody)(JSON.stringify({
+            documents: [{ content: '# invalid', aliases: ['ok', 3] }],
+        }))).toThrow(knowledgePayload_1.KnowledgePayloadError);
+        expect(() => (0, knowledgePayload_1.parseKnowledgeIngestBody)(JSON.stringify({
+            documents: [{ content: 'x'.repeat(64 * 1024 * 1024 + 1) }],
+        }))).toThrow(/exceeds 67108864 bytes/);
+    });
+});

package/dist/src/routes/markdown.js

@@ -161,6 +161,14 @@ function registerMarkdownRoutes(_ctx) {
                     const body = await readBody(req);
                     const payload = JSON.parse(body);
                     const filePath = payload.filePath || payload.path || '';
+                    if (!filePath) {
+                        json(res, 400, {
+                            success: false,
+                            error: 'Missing filePath for /api/markdown/index',
+                            markdownProtocolVersion: PROTOCOL_VERSION,
+                        });
+                        return;
+                    }
                     if (ctx.markdownGateway) {
                         const runtimeConfig = await resolveRuntimeConfig();
                         const result = await ctx.markdownGateway.buildIndex({