noteconnection 1.7.0 → 1.9.0

package/dist/src/learning/graphExpansionPolicy.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGraphExpansionPolicy = resolveGraphExpansionPolicy;
+const EXPLICIT_DEPTH_PATTERN = /\b(?:deep|detailed|comprehensive|thorough|in-depth|in depth|in detail|fully|complete|research)\b|深入|深度|详细|详尽|完整|充分|展开|研究/u;
+function resolveGraphExpansionPolicy(message) {
+    const explicitDepthRequested = EXPLICIT_DEPTH_PATTERN.test(String(message || '').toLowerCase());
+    return explicitDepthRequested
+        ? {
+            enabled: true,
+            reason: 'explicit_depth_request',
+            maxSteps: 1,
+            maxNeighbors: 8,
+            maxPathDepth: 8,
+        }
+        : {
+            enabled: false,
+            reason: 'ordinary_query',
+            maxSteps: 0,
+            maxNeighbors: 6,
+            maxPathDepth: 6,
+        };
+}

package/dist/src/learning/graphExpansionPolicy.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphExpansionPolicy_1 = require("./graphExpansionPolicy");
+describe('resolveGraphExpansionPolicy', () => {
+    test.each([
+        'what is water glass',
+        'explain water glass',
+        '为什么杯壁会传热',
+    ])('keeps ordinary questions on deterministic bounded retrieval: %s', (message) => {
+        expect((0, graphExpansionPolicy_1.resolveGraphExpansionPolicy)(message)).toEqual({
+            enabled: false,
+            reason: 'ordinary_query',
+            maxSteps: 0,
+            maxNeighbors: 6,
+            maxPathDepth: 6,
+        });
+    });
+    test.each([
+        'explain water glass in detail',
+        'perform a deep analysis of water glass',
+        'research the complete thermal mechanism',
+        '详细解释水杯的热交换机制',
+        '深入研究杯壁与环境的关系',
+    ])('enables one replayable bounded expansion for explicit depth: %s', (message) => {
+        expect((0, graphExpansionPolicy_1.resolveGraphExpansionPolicy)(message)).toEqual({
+            enabled: true,
+            reason: 'explicit_depth_request',
+            maxSteps: 1,
+            maxNeighbors: 8,
+            maxPathDepth: 8,
+        });
+    });
+});

package/dist/src/learning/identityMetadata.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+describe('knowledge document identity metadata', () => {
+    test('deletes a document through its portable source URI after ingest', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(() => new Date('2026-08-17T00:00:00.000Z'));
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [{
+                    documentId: 'legacy_doc',
+                    sourcePath: 'Knowledge_Base/notes/identity.md',
+                    sourceUri: 'note://workspace/v1/notes/identity.md',
+                    revision: 'sha256:identity-revision',
+                    identityAliases: ['identity', 'notes/identity.md'],
+                    content: '# Identity\nPortable identity metadata stays additive.',
+                }],
+        });
+        const deleted = await platform.ingestKnowledge({
+            incremental: true,
+            deletedDocuments: [{ sourceUri: 'note://workspace/v1/notes/identity.md' }],
+        });
+        expect(deleted.summary.deletedDocuments).toBe(1);
+        expect(deleted.staleness[0]?.documentId).toBe('legacy_doc');
+        expect(deleted.staleness[0]?.status).toBe('deleted');
+    });
+});

package/dist/src/learning/index.js

@@ -0,0 +1,29 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./KnowledgeLearningPlatform"), exports);
+__exportStar(require("./store"), exports);
+__exportStar(require("./tutorAdapter"), exports);
+__exportStar(require("./queryBackend"), exports);
+__exportStar(require("./vectorAccelerationAdapter"), exports);
+__exportStar(require("./runtimeCapability"), exports);
+__exportStar(require("./conversationComposer"), exports);
+__exportStar(require("./agentConversationSerialization"), exports);
+__exportStar(require("./ragSufficiencyProviderJudge"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./domains"), exports);

package/dist/src/learning/mobileAnswerProjection.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION = void 0;
+exports.projectAnswerForMobile = projectAnswerForMobile;
+exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION = 1;
+const MAX_MOBILE_DIRECT_ANSWER_CHARS = 2400;
+const MAX_MOBILE_ROUTE_NODES = 8;
+const MAX_MOBILE_CITATIONS = 4;
+const MAX_MOBILE_TITLE_CHARS = 160;
+const MAX_MOBILE_SOURCE_PATH_CHARS = 320;
+function normalize(value) {
+    return String(value || '').replace(/\s+/gu, ' ').trim();
+}
+function normalizeMarkdown(value) {
+    return String(value || '').replace(/\r\n?/gu, '\n').trim();
+}
+function trimText(value, limit) {
+    const normalized = normalize(value);
+    return normalized.length <= limit ? normalized : `${normalized.slice(0, Math.max(0, limit - 1)).trim()}…`;
+}
+function countDisplayMathDelimiters(value) {
+    return (value.match(/(?<!\\)\$\$/gu) || []).length;
+}
+function trimMarkdown(value, limit) {
+    const normalized = normalizeMarkdown(value);
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    const suffix = '…';
+    let candidate = normalized.slice(0, Math.max(0, limit - suffix.length)).trimEnd();
+    // Do not publish an answer with an unmatched display-math fence. If a
+    // block crosses the mobile byte/character budget, omit that incomplete
+    // block rather than asking every client to repair malformed Markdown.
+    if (countDisplayMathDelimiters(candidate) % 2 !== 0) {
+        const openingIndex = candidate.lastIndexOf('$$');
+        candidate = openingIndex >= 0 ? candidate.slice(0, openingIndex).trimEnd() : '';
+    }
+    return `${candidate}${suffix}`.trim();
+}
+function stripRouteFromAnswer(answer) {
+    const normalized = normalizeMarkdown(answer);
+    const headingIndex = normalized.search(/(?:^|\n)#{1,6}\s+(?:建议学习路径|推荐学习路径|Suggested learning path)\s*$/imu);
+    const withoutHeadingRoute = headingIndex >= 0
+        ? normalized.slice(0, headingIndex).trimEnd()
+        : normalized;
+    return withoutHeadingRoute
+        .replace(/(?:建议学习路径|推荐学习路径|Suggested learning path)\s*[:：][^\n]*(?:\n[^\n]*)*$/iu, '')
+        .replace(/([。.!?])\1+/gu, '$1')
+        .trim();
+}
+function resolveTaskPlan(response) {
+    return response.answerTaskPlan
+        || response.graphAnswerPlan?.answerTaskPlan
+        || response.trace?.answerTaskPlan
+        || response.knowledgeRun?.answerTaskPlan;
+}
+function projectCitation(citation) {
+    const citationId = normalize(citation.citationId);
+    const title = trimText(citation.title, MAX_MOBILE_TITLE_CHARS);
+    const sourcePath = trimText(citation.sourcePath, MAX_MOBILE_SOURCE_PATH_CHARS);
+    if (!citationId || !title || !sourcePath) {
+        return null;
+    }
+    return {
+        citationId,
+        title,
+        sourcePath,
+        ...(Number.isFinite(Number(citation.startLine)) ? { startLine: Number(citation.startLine) } : {}),
+        ...(Number.isFinite(Number(citation.endLine)) ? { endLine: Number(citation.endLine) } : {}),
+    };
+}
+function projectAnswerForMobile(response) {
+    const taskPlan = resolveTaskPlan(response);
+    const structuredAnswerBlock = (response.assistantBlocks || [])
+        .find((block) => block && block.type === 'structured_answer');
+    const directAnswer = trimMarkdown(stripRouteFromAnswer(String(response.answer
+        || response.assistantMessage
+        || (structuredAnswerBlock && 'directAnswer' in structuredAnswerBlock
+            ? structuredAnswerBlock.directAnswer
+            : '')
+        || '')), MAX_MOBILE_DIRECT_ANSWER_CHARS);
+    const route = (taskPlan?.learningRoute || [])
+        .slice()
+        .sort((left, right) => left.order - right.order)
+        .slice(0, MAX_MOBILE_ROUTE_NODES)
+        .map((node) => ({
+        nodeId: trimText(node.nodeId, MAX_MOBILE_TITLE_CHARS),
+        title: trimText(node.title, MAX_MOBILE_TITLE_CHARS),
+        role: node.role,
+        order: Math.max(1, Math.floor(Number(node.order) || 1)),
+    }))
+        .filter((node) => Boolean(node.nodeId && node.title));
+    const citations = (response.citations || [])
+        .slice(0, MAX_MOBILE_CITATIONS)
+        .map(projectCitation)
+        .filter((citation) => Boolean(citation));
+    return {
+        schemaVersion: exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION,
+        primarySubject: trimText(taskPlan?.primarySubject || '', MAX_MOBILE_TITLE_CHARS),
+        directAnswer,
+        route,
+        citations,
+    };
+}

package/dist/src/learning/mobileAnswerProjection.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mobileAnswerProjection_1 = require("./mobileAnswerProjection");
+describe('mobile answer projection', () => {
+    test('keeps a bounded task result and drops internal RAG payloads', () => {
+        const response = {
+            answer: '非晶冰是水的一种缺乏长程有序的固态形式。建议学习路径：1. 水分子与氢键网络 -> 2. 非晶冰 -> 3. 径向分布函数 g(r)。',
+            assistantMessage: 'same',
+            answerTaskPlan: {
+                schemaVersion: '1',
+                primarySubject: '非晶冰',
+                requestedDepth: 'standard',
+                subtasks: [
+                    { subtaskId: 'definition', kind: 'definition', subject: '非晶冰', required: true, expectedOutput: 'direct_answer' },
+                    { subtaskId: 'learning_route', kind: 'learning_route', subject: '非晶冰', required: true, expectedOutput: 'ordered_nodes' },
+                ],
+                learningRoute: [
+                    { nodeId: 'water', title: '水分子与氢键网络', role: 'prerequisite', order: 1, orderingBasis: 'source_order', evidenceRefs: ['e1'], reason: '基础' },
+                    { nodeId: 'ice', title: '非晶冰', role: 'core', order: 2, orderingBasis: 'source_order', evidenceRefs: ['e2'], reason: '核心' },
+                    { nodeId: 'rdf', title: '径向分布函数 g(r)', role: 'mechanism', order: 3, orderingBasis: 'source_order', evidenceRefs: ['e3'], reason: '机制' },
+                ],
+            },
+            citations: [
+                {
+                    citationId: 'e1', atomId: 'water', documentId: 'doc', sourcePath: 'Knowledge_Base/waterglass/water.md', title: '水分子', snippet: 'full source text should not be copied', startLine: 2, endLine: 3, score: 0.9,
+                },
+            ],
+            trace: {
+                ragContextPack: { fragments: [{ text: 'large internal source body' }] },
+            },
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection).toEqual(expect.objectContaining({
+            schemaVersion: 1,
+            primarySubject: '非晶冰',
+            directAnswer: '非晶冰是水的一种缺乏长程有序的固态形式。',
+            route: [
+                expect.objectContaining({ title: '水分子与氢键网络', role: 'prerequisite', order: 1 }),
+                expect.objectContaining({ title: '非晶冰', role: 'core', order: 2 }),
+                expect.objectContaining({ title: '径向分布函数 g(r)', role: 'mechanism', order: 3 }),
+            ],
+            citations: [expect.objectContaining({ title: '水分子', sourcePath: 'Knowledge_Base/waterglass/water.md' })],
+        }));
+        expect(JSON.stringify(projection)).not.toContain('large internal source body');
+        expect(JSON.stringify(projection)).not.toContain('full source text should not be copied');
+    });
+    test('preserves display-math Markdown while removing the appended learning route', () => {
+        const response = {
+            answer: [
+                '非晶冰是缺乏长程有序的水的固态形式。',
+                '',
+                '$$',
+                'g(r) = \\frac{1}{4\\pi r^2\\rho} \\frac{dN}{dr}',
+                '$$',
+                '',
+                '### 建议学习路径',
+                '',
+                '1. **水分子**（前置）',
+            ].join('\n'),
+            assistantMessage: 'fallback',
+            citations: [],
+            answerTaskPlan: {
+                schemaVersion: '1',
+                primarySubject: '非晶冰',
+                requestedDepth: 'standard',
+                subtasks: [
+                    { subtaskId: 'definition', kind: 'definition', subject: '非晶冰', required: true, expectedOutput: 'direct_answer' },
+                    { subtaskId: 'learning_route', kind: 'learning_route', subject: '非晶冰', required: true, expectedOutput: 'ordered_nodes' },
+                ],
+                learningRoute: [],
+            },
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection.directAnswer).toContain('$$\ng(r) = \\frac{1}{4\\pi r^2\\rho} \\frac{dN}{dr}\n$$');
+        expect(projection.directAnswer).not.toContain('建议学习路径');
+        expect((projection.directAnswer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+    });
+    test('does not leave an unmatched display-math fence when the mobile budget truncates an answer', () => {
+        const longPrefix = '说明。'.repeat(500);
+        const response = {
+            answer: `${longPrefix}\n\n$$\nE = mc^2\n$$`,
+            assistantMessage: '',
+            citations: [],
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection.directAnswer.length).toBeLessThanOrEqual(2400);
+        expect((projection.directAnswer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+    });
+    test('uses the response-level answer as the canonical release over a stale structured block', () => {
+        const response = {
+            answer: 'Canonical released answer for the subject.',
+            assistantMessage: 'Canonical released answer for the subject.',
+            assistantBlocks: [{
+                    blockId: 'stale',
+                    type: 'structured_answer',
+                    directAnswer: 'Stale block answer that must not win.',
+                }],
+            citations: [],
+        };
+        expect((0, mobileAnswerProjection_1.projectAnswerForMobile)(response).directAnswer).toBe('Canonical released answer for the subject.');
+    });
+});