noteconnection 1.7.0 → 1.9.0

package/dist/src/resources/ResourceRegistry.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceRegistry = void 0;
+class ResourceRegistry {
+    constructor(nextId) {
+        this.nextId = nextId;
+        this.resources = new Map();
+        this.resourceIdsByHash = new Map();
+        this.projections = new Map();
+        this.projectionIdsByStableKey = new Map();
+    }
+    upsertKnowledgeDocument(input) {
+        const existingResourceId = this.resourceIdsByHash.get(input.sourceHash);
+        const resourceId = existingResourceId || this.nextId('resource');
+        const previousResource = existingResourceId ? this.resources.get(existingResourceId) || null : null;
+        const createdAt = previousResource?.createdAt || input.updatedAt;
+        const resource = {
+            resourceId,
+            resourceHash: input.sourceHash,
+            kind: 'knowledge_document',
+            status: 'active',
+            title: input.title,
+            sourcePath: input.sourcePath,
+            language: input.language,
+            storageMode: 'inline',
+            content: input.content,
+            contentLength: input.content.length,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            sourceDocumentId: input.documentId,
+            version: input.version,
+            metadata: {
+                ...(previousResource?.metadata || {}),
+                ...(input.metadata || {}),
+            },
+            createdAt,
+            updatedAt: input.updatedAt,
+            deletedAt: null,
+        };
+        this.resources.set(resourceId, resource);
+        this.resourceIdsByHash.set(input.sourceHash, resourceId);
+        const stableKey = `knowledge_document:${input.documentId}`;
+        const existingProjectionId = this.projectionIdsByStableKey.get(stableKey);
+        const projectionId = existingProjectionId || this.nextId('projection');
+        const previousProjection = existingProjectionId ? this.projections.get(existingProjectionId) || null : null;
+        const projection = {
+            projectionId,
+            resourceId,
+            projectionKind: 'knowledge_document',
+            stableKey,
+            status: 'active',
+            documentId: input.documentId,
+            sourcePath: input.sourcePath,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            metadata: {
+                ...(previousProjection?.metadata || {}),
+                sourceHash: input.sourceHash,
+                version: input.version,
+                ...(input.metadata || {}),
+            },
+            createdAt: previousProjection?.createdAt || input.updatedAt,
+            updatedAt: input.updatedAt,
+            deletedAt: null,
+        };
+        this.projections.set(projectionId, projection);
+        this.projectionIdsByStableKey.set(stableKey, projectionId);
+        return { resource, projection };
+    }
+    upsertWorkflowArtifact(input) {
+        const existingResourceId = this.resourceIdsByHash.get(input.resourceHash);
+        const resourceId = existingResourceId || this.nextId('resource');
+        const previousResource = existingResourceId ? this.resources.get(existingResourceId) || null : null;
+        const resource = {
+            resourceId,
+            resourceHash: input.resourceHash,
+            kind: 'learning_artifact',
+            status: 'active',
+            title: input.title,
+            sourcePath: input.sourcePath || '',
+            language: input.language || 'unknown',
+            storageMode: 'inline',
+            content: input.content,
+            contentLength: input.content.length,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            sourceDocumentId: input.sourceDocumentId || null,
+            version: input.version,
+            metadata: {
+                ...(previousResource?.metadata || {}),
+                ...(input.metadata || {}),
+            },
+            createdAt: previousResource?.createdAt || input.createdAt,
+            updatedAt: input.createdAt,
+            deletedAt: null,
+        };
+        this.resources.set(resourceId, resource);
+        this.resourceIdsByHash.set(input.resourceHash, resourceId);
+        const existingProjectionId = this.projectionIdsByStableKey.get(input.stableKey);
+        const projectionId = existingProjectionId || this.nextId('projection');
+        const previousProjection = existingProjectionId ? this.projections.get(existingProjectionId) || null : null;
+        const projection = {
+            projectionId,
+            resourceId,
+            projectionKind: input.projectionKind,
+            stableKey: input.stableKey,
+            status: 'active',
+            documentId: input.sourceDocumentId || null,
+            sourcePath: input.sourcePath || null,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            metadata: {
+                ...(previousProjection?.metadata || {}),
+                ...(input.metadata || {}),
+            },
+            createdAt: previousProjection?.createdAt || input.createdAt,
+            updatedAt: input.createdAt,
+            deletedAt: null,
+        };
+        this.projections.set(projectionId, projection);
+        this.projectionIdsByStableKey.set(input.stableKey, projectionId);
+        return { resource, projection };
+    }
+    /**
+     * Keeps the resource/projection owners aligned with a document move without
+     * allocating a new resource or changing the stable document projection key.
+     * The document store owns the transition journal; this adapter only mirrors
+     * the committed identity metadata for export and diagnostics consumers.
+     */
+    updateKnowledgeDocumentIdentity(input) {
+        const projection = this.getProjectionByDocumentId(input.documentId);
+        if (!projection) {
+            return false;
+        }
+        const resource = this.resources.get(projection.resourceId);
+        const identityMetadata = {
+            ...(input.sourceUri !== undefined ? { sourceUri: input.sourceUri } : {}),
+            ...(input.revision !== undefined ? { revision: input.revision } : {}),
+            ...(input.identityAliases !== undefined ? { identityAliases: [...input.identityAliases] } : {}),
+        };
+        this.projections.set(projection.projectionId, {
+            ...projection,
+            sourcePath: input.sourcePath,
+            metadata: {
+                ...projection.metadata,
+                ...identityMetadata,
+            },
+            updatedAt: input.updatedAt,
+        });
+        if (resource) {
+            this.resources.set(resource.resourceId, {
+                ...resource,
+                sourcePath: input.sourcePath,
+                title: input.title || resource.title,
+                metadata: {
+                    ...resource.metadata,
+                    ...identityMetadata,
+                },
+                updatedAt: input.updatedAt,
+            });
+        }
+        return true;
+    }
+    markDocumentProjectionDeleted(documentId, deletedAt) {
+        const stableKey = `knowledge_document:${String(documentId || '').trim()}`;
+        const projectionId = this.projectionIdsByStableKey.get(stableKey);
+        if (!projectionId) {
+            return;
+        }
+        const projection = this.projections.get(projectionId);
+        if (!projection) {
+            return;
+        }
+        this.projections.set(projectionId, {
+            ...projection,
+            status: 'deleted',
+            updatedAt: deletedAt,
+            deletedAt,
+        });
+        const resource = this.resources.get(projection.resourceId);
+        if (resource) {
+            this.resources.set(resource.resourceId, {
+                ...resource,
+                status: 'deleted',
+                updatedAt: deletedAt,
+                deletedAt,
+            });
+        }
+    }
+    getProjectionByDocumentId(documentId) {
+        const stableKey = `knowledge_document:${String(documentId || '').trim()}`;
+        const projectionId = this.projectionIdsByStableKey.get(stableKey);
+        if (!projectionId) {
+            return null;
+        }
+        return this.projections.get(projectionId) || null;
+    }
+    getProjectionByStableKey(stableKey) {
+        const projectionId = this.projectionIdsByStableKey.get(String(stableKey || '').trim());
+        if (!projectionId) {
+            return null;
+        }
+        return this.projections.get(projectionId) || null;
+    }
+    getResourceById(resourceId) {
+        return this.resources.get(String(resourceId || '').trim()) || null;
+    }
+    listResourcesByIds(resourceIds, options = {}) {
+        const allowedIds = new Set(resourceIds
+            .map((resourceId) => String(resourceId || '').trim())
+            .filter(Boolean));
+        if (allowedIds.size <= 0) {
+            return [];
+        }
+        return Array.from(this.resources.values())
+            .filter((resource) => allowedIds.has(resource.resourceId))
+            .filter((resource) => options.includeDeleted === true || resource.status === 'active');
+    }
+    listProjectionsByIds(projectionIds, options = {}) {
+        const allowedIds = new Set(projectionIds
+            .map((projectionId) => String(projectionId || '').trim())
+            .filter(Boolean));
+        if (allowedIds.size <= 0) {
+            return [];
+        }
+        return Array.from(this.projections.values())
+            .filter((projection) => allowedIds.has(projection.projectionId))
+            .filter((projection) => options.includeDeleted === true || projection.status === 'active');
+    }
+    listActiveResources() {
+        return Array.from(this.resources.values()).filter((resource) => resource.status === 'active');
+    }
+    listActiveProjections() {
+        return Array.from(this.projections.values()).filter((projection) => projection.status === 'active');
+    }
+    buildSnapshot() {
+        return {
+            resources: Array.from(this.resources.values()).map((resource) => ({ ...resource, metadata: { ...resource.metadata } })),
+            projections: Array.from(this.projections.values()).map((projection) => ({ ...projection, metadata: { ...projection.metadata } })),
+        };
+    }
+    restoreFromSnapshot(snapshot) {
+        this.resources.clear();
+        this.resourceIdsByHash.clear();
+        this.projections.clear();
+        this.projectionIdsByStableKey.clear();
+        (snapshot?.resources || []).forEach((resource) => {
+            this.resources.set(resource.resourceId, {
+                ...resource,
+                metadata: { ...(resource.metadata || {}) },
+            });
+            this.resourceIdsByHash.set(resource.resourceHash, resource.resourceId);
+        });
+        (snapshot?.projections || []).forEach((projection) => {
+            this.projections.set(projection.projectionId, {
+                ...projection,
+                metadata: { ...(projection.metadata || {}) },
+            });
+            this.projectionIdsByStableKey.set(projection.stableKey, projection.projectionId);
+        });
+    }
+}
+exports.ResourceRegistry = ResourceRegistry;

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResourceRegistry_1 = require("./ResourceRegistry");
+describe('ResourceRegistry', () => {
+    test('reuses resource ids by source hash and exposes stable projection lookups', () => {
+        let idCounter = 0;
+        const registry = new ResourceRegistry_1.ResourceRegistry((prefix = 'resource') => `${prefix}_${++idCounter}`);
+        const first = registry.upsertKnowledgeDocument({
+            documentId: 'doc_a',
+            sourcePath: 'Knowledge_Base/optics/doc_a.md',
+            content: '# A\ncontent',
+            sourceHash: 'hash_a',
+            title: 'doc_a',
+            language: 'en',
+            version: 1,
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            updatedAt: '2026-05-26T00:00:00.000Z',
+        });
+        const second = registry.upsertKnowledgeDocument({
+            documentId: 'doc_a',
+            sourcePath: 'Knowledge_Base/optics/doc_a.md',
+            content: '# A\ncontent updated',
+            sourceHash: 'hash_a',
+            title: 'doc_a',
+            language: 'en',
+            version: 2,
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            updatedAt: '2026-05-26T01:00:00.000Z',
+        });
+        expect(second.resource.resourceId).toBe(first.resource.resourceId);
+        expect(second.projection.projectionId).toBe(first.projection.projectionId);
+        expect(registry.getProjectionByDocumentId('doc_a')?.projectionId).toBe(first.projection.projectionId);
+        expect(registry.listResourcesByIds([first.resource.resourceId])).toHaveLength(1);
+        expect(registry.listProjectionsByIds([first.projection.projectionId])).toHaveLength(1);
+    });
+    test('marks document projections deleted and restores from snapshot', () => {
+        let idCounter = 0;
+        const registry = new ResourceRegistry_1.ResourceRegistry((prefix = 'resource') => `${prefix}_${++idCounter}`);
+        const created = registry.upsertKnowledgeDocument({
+            documentId: 'doc_delete',
+            sourcePath: 'Knowledge_Base/chem/doc_delete.md',
+            content: '# Delete\ncontent',
+            sourceHash: 'hash_delete',
+            title: 'doc_delete',
+            language: 'en',
+            version: 1,
+            workspaceId: 'chem',
+            corpusId: 'chem',
+            updatedAt: '2026-05-26T02:00:00.000Z',
+        });
+        registry.markDocumentProjectionDeleted('doc_delete', '2026-05-26T03:00:00.000Z');
+        expect(registry.getProjectionByDocumentId('doc_delete')?.status).toBe('deleted');
+        expect(registry.getResourceById(created.resource.resourceId)?.status).toBe('deleted');
+        const restored = new ResourceRegistry_1.ResourceRegistry((prefix = 'resource') => `${prefix}_${++idCounter}`);
+        restored.restoreFromSnapshot(registry.buildSnapshot());
+        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/resources/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/routes/agentWorkspaceDiagnostics.js

@@ -0,0 +1,173 @@
+"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.registerAgentWorkspaceDiagnosticsRoutes = registerAgentWorkspaceDiagnosticsRoutes;
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function readJsonSafe(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function ensureDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function readAgentWorkspaceDiagnosticsIndex(indexPath) {
+    const data = readJsonSafe(indexPath);
+    if (!data || !Array.isArray(data.entries))
+        return [];
+    return data.entries;
+}
+function readAgentWorkspaceDiagnosticsReport(workspaceDir, reportId) {
+    const reportPath = path.join(workspaceDir, `${reportId}.json`);
+    const report = readJsonSafe(reportPath);
+    if (!report)
+        return null;
+    return {
+        metadata: {
+            reportId,
+            timestamp: String(report.timestamp || ''),
+            status: String(report.status || ''),
+            strictMode: Boolean(report.strictMode),
+            checks: Number(report.totalChecks || 0),
+            passed: Number(report.passedChecks || 0),
+        },
+        report,
+    };
+}
+function getAlertThresholds() {
+    return {
+        conversationTurnCache: { maxAlertRate: 0.3, windowMinutes: 60, minSampleSize: 10 },
+        knowledgeGraphHealth: { maxDegradationRate: 0.2, windowMinutes: 120 },
+        queryLatency: { maxP95Ms: 5000, windowMinutes: 30 },
+        memoryPressure: { maxUsageRatio: 0.85, windowMinutes: 15 },
+    };
+}
+function registerAgentWorkspaceDiagnosticsRoutes(ctx) {
+    const { knowledgeLearningPlatform, runtimeDataDir } = ctx;
+    const workspaceDir = path.join(runtimeDataDir, 'agent_workspace_diagnostics');
+    const indexPath = path.join(workspaceDir, 'index.v1.json');
+    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) });
+    };
+    return [
+        {
+            method: 'GET',
+            path: '/api/knowledge/foundation/readiness',
+            handler: async (_req, res) => {
+                try {
+                    await knowledgeLearningPlatform.ensureReady();
+                    const readiness = await knowledgeLearningPlatform.getFoundationReadiness();
+                    ok(res, { readiness });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/knowledge/foundation/readiness');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: '/api/knowledge/backend/sufficiency',
+            handler: async (_req, res) => {
+                try {
+                    await knowledgeLearningPlatform.ensureReady();
+                    const sufficiency = await knowledgeLearningPlatform.getBackendBaselineSufficiency();
+                    ok(res, { sufficiency });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/knowledge/backend/sufficiency');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: '/api/knowledge/operator/agent-workspace-diagnostics/index',
+            handler: async (_req, res) => {
+                try {
+                    const index = readAgentWorkspaceDiagnosticsIndex(indexPath);
+                    ok(res, { index, count: index.length, maxEntries: 40 });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/knowledge/operator/agent-workspace-diagnostics/index');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: '/api/knowledge/operator/agent-workspace-diagnostics/latest',
+            handler: async (_req, res) => {
+                try {
+                    const index = readAgentWorkspaceDiagnosticsIndex(indexPath);
+                    let latest = null;
+                    for (const entry of index) {
+                        latest = readAgentWorkspaceDiagnosticsReport(workspaceDir, entry.reportId);
+                        if (latest)
+                            break;
+                    }
+                    ok(res, { latest, count: index.length, maxEntries: 40 });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/knowledge/operator/agent-workspace-diagnostics/latest');
+                }
+            },
+        },
+        {
+            method: 'GET',
+            path: '/api/knowledge/operator/agent-workspace-diagnostics/triage/thresholds',
+            handler: async (_req, res) => {
+                try {
+                    const alertThresholds = getAlertThresholds();
+                    ok(res, { alertThresholds });
+                }
+                catch (e) {
+                    fail(res, e, 'API:GET /api/knowledge/operator/agent-workspace-diagnostics/triage/thresholds');
+                }
+            },
+        },
+    ];
+}

package/dist/src/routes/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAllRoutes = registerAllRoutes;
+const knowledge_1 = require("./knowledge");
+const notemd_1 = require("./notemd");
+const markdown_1 = require("./markdown");
+const render_1 = require("./render");
+const settings_1 = require("./settings");
+const agentWorkspaceDiagnostics_1 = require("./agentWorkspaceDiagnostics");
+function registerAllRoutes(ctx) {
+    return [
+        ...(0, knowledge_1.registerKnowledgeRoutes)(ctx),
+        ...(0, notemd_1.registerNotemdRoutes)(ctx),
+        ...(0, markdown_1.registerMarkdownRoutes)(ctx),
+        ...(0, render_1.registerRenderRoutes)(ctx),
+        ...(0, settings_1.registerSettingsRoutes)(ctx),
+        ...(0, agentWorkspaceDiagnostics_1.registerAgentWorkspaceDiagnosticsRoutes)(ctx),
+    ];
+}