noteconnection 1.7.0 → 1.8.0

package/dist/src/notemd.agent.manifest.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Agent Manifest contract test — validates that the NotemdAgentManifest
+ * endpoint produces correct data for Agent Workspace consumption.
+ */
+const registry_1 = require("./notemd/operations/registry");
+function buildAgentManifest() {
+    const defs = (0, registry_1.listOperationDefinitions)();
+    const operations = defs.map(def => ({
+        operationId: def.id,
+        description: def.commandBindings[0]?.commandId ?? def.id,
+        automationLevel: def.automationLevel,
+        requiredContext: def.requiredContext,
+        sideEffectClass: def.sideEffectClass,
+        agentAutoExecutable: def.automationLevel === 'safe',
+        requiredParams: def.inputSchema
+            ? (def.inputSchema.required ?? [])
+            : [],
+    }));
+    return {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        totalOperations: operations.length,
+        agentExecutableCount: operations.filter(o => o.agentAutoExecutable).length,
+        operations,
+    };
+}
+describe('NotemdAgentManifest', () => {
+    let manifest;
+    beforeAll(() => {
+        manifest = buildAgentManifest();
+    });
+    test('manifest version is 1', () => {
+        expect(manifest.version).toBe(1);
+    });
+    test('generatedAt is a valid ISO date string', () => {
+        expect(() => new Date(manifest.generatedAt)).not.toThrow();
+        expect(new Date(manifest.generatedAt).getTime()).toBeGreaterThan(0);
+    });
+    test('totalOperations matches operations array length', () => {
+        expect(manifest.totalOperations).toBe(manifest.operations.length);
+    });
+    test('all operations are present (27 with workflow.batch)', () => {
+        expect(manifest.operations.length).toBe(27);
+    });
+    test('agentExecutableCount matches auto-executable count', () => {
+        const count = manifest.operations.filter(o => o.agentAutoExecutable).length;
+        expect(manifest.agentExecutableCount).toBe(count);
+    });
+    test('safe operations are agent-auto-executable', () => {
+        const safeOps = manifest.operations.filter(o => o.automationLevel === 'safe');
+        expect(safeOps.length).toBeGreaterThan(0);
+        safeOps.forEach(op => {
+            expect(op.agentAutoExecutable).toBe(true);
+        });
+    });
+    test('every operation has an operationId', () => {
+        manifest.operations.forEach(op => {
+            expect(typeof op.operationId).toBe('string');
+            expect(op.operationId.length).toBeGreaterThan(0);
+        });
+    });
+    test('every operation has a valid automation level', () => {
+        const valid = ['safe', 'requires-active-file', 'requires-selection', 'interactive-ui'];
+        manifest.operations.forEach(op => {
+            expect(valid).toContain(op.automationLevel);
+        });
+    });
+    test('interactive-ui operations are NOT agent-auto-executable', () => {
+        const uiOps = manifest.operations.filter(o => o.automationLevel === 'interactive-ui');
+        uiOps.forEach(op => {
+            expect(op.agentAutoExecutable).toBe(false);
+        });
+    });
+    test('known critical operations are present', () => {
+        const ids = manifest.operations.map(o => o.operationId);
+        expect(ids).toContain('file.process-add-links');
+        expect(ids).toContain('diagram.generate');
+        expect(ids).toContain('translate.file');
+        expect(ids).toContain('provider.diagnostic.run');
+        expect(ids).toContain('workflow.extract-and-generate');
+        expect(ids).toContain('mermaid.batch-fix');
+    });
+});

package/dist/src/notemd.api.contract.test.js

@@ -37,7 +37,12 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 describe('NoteMD API contract wiring', () => {
     const serverSourcePath = path.join(__dirname, 'server.ts');
+    const routesSourcePath = path.join(__dirname, 'routes', 'notemd.ts');
     const serverSource = fs.readFileSync(serverSourcePath, 'utf8');
+    const routesSource = fs.existsSync(routesSourcePath) ? fs.readFileSync(routesSourcePath, 'utf8') : '';
+    function endpointExistsInSource(endpoint) {
+        return serverSource.includes(endpoint) || routesSource.includes(endpoint);
+    }
     test('server exposes all planned /api/notemd endpoints', () => {
         const endpoints = [
             '/api/notemd/settings',
@@ -52,9 +57,17 @@ describe('NoteMD API contract wiring', () => {
             '/api/notemd/check-duplicates',
             '/api/notemd/extract-concepts',
             '/api/notemd/cancel',
+            // ── obsidian-notemd v1.8.4 additions ──
+            '/api/notemd/generate-diagram',
+            '/api/notemd/preview-diagram',
+            '/api/notemd/export-diagram',
+            '/api/notemd/search',
+            '/api/notemd/progress',
+            '/api/notemd/diagnose-llm',
+            '/api/notemd/extract-original-text',
         ];
         endpoints.forEach((endpoint) => {
-            expect(serverSource).toContain(endpoint);
+            expect(endpointExistsInSource(endpoint)).toBe(true);
         });
     });
     test('server persists NoteMD settings through app_config.toml helpers', () => {

package/dist/src/notemd.app_config_toml.test.js

@@ -77,6 +77,7 @@ describe('app_config.toml adapters', () => {
         expect(extracted.workspaceOutputFolderPath).toBe('E:/Knowledge_Base/math/topic');
     });
     test('path_mode settings are normalized and clamped', () => {
+        expect(AppConfigToml_1.DEFAULT_PATH_MODE_SETTINGS.background).toBe('');
         const nextConfig = (0, AppConfigToml_1.applyPathModeSettingsToAppConfig)({}, {
             ...AppConfigToml_1.DEFAULT_PATH_MODE_SETTINGS,
             bg_brightness: 99,
@@ -86,7 +87,7 @@ describe('app_config.toml adapters', () => {
             reader_render_mode: 'invalid',
         });
         const extracted = (0, AppConfigToml_1.extractPathModeSettingsFromAppConfig)(nextConfig);
-        expect(extracted.bg_brightness).toBe(10);
+        expect(extracted.bg_brightness).toBe(0.1);
         expect(extracted.reader_media_scale).toBe(0.1);
         expect(extracted.node_spacing).toBe(600);
         expect(extracted.reading_mode).toBe('window');

package/dist/src/notemd.batch.workflow.test.js

@@ -0,0 +1,117 @@
+"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 });
+/**
+ * Batch workflow contract test — validates request structure,
+ * file filtering, and error handling for runBatchWorkflow.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const NotemdService_1 = require("./notemd/NotemdService");
+class TempDir {
+    constructor(prefix) { this.root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), prefix)); }
+    file(rel, content) {
+        const p = path.join(this.root, rel);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, content, 'utf8');
+        return p;
+    }
+    cleanup() { fs.rmSync(this.root, { recursive: true, force: true }); }
+}
+function defaultSettings() {
+    return {
+        activeProvider: 'OpenAI', searchProvider: 'duckduckgo', language: 'en',
+        providers: [], enableStableApiCall: true, enableApiErrorDebugMode: false,
+        maxRetries: 0, retryDelayMs: 0, maxTokens: 256, chunkWordCount: 100,
+        enableDuplicateDetection: false, enableExperimentalDiagramPipeline: false,
+        enableBatchParallelism: false, developerMode: false,
+        developerDiagnosticCallMode: 'runtime-stable', developerDiagnosticTimeoutMs: 60000,
+        developerDiagnosticStabilityRuns: 3,
+        experimentalDiagramCompatibilityMode: 'legacy-mermaid',
+        autoMermaidFixAfterGenerate: true, tavilyApiKey: '', tavilyMaxResults: 5,
+        tavilySearchDepth: 'basic', ddgFetchTimeout: 10000,
+        useCustomConceptNoteFolder: false, conceptNoteFolder: '',
+    };
+}
+describe('Notemd Batch Workflow', () => {
+    let temp;
+    let service;
+    beforeEach(() => { temp = new TempDir('notemd-batch-'); service = new NotemdService_1.NotemdService(); });
+    afterEach(() => { temp.cleanup(); });
+    test('runBatchWorkflow processes matching .md files in a folder', async () => {
+        temp.file('notes/a.md', '# Note A\n\nContent A.');
+        temp.file('notes/b.md', '# Note B\n\nContent B.');
+        temp.file('notes/c.txt', '# Note C\n\nContent C.');
+        const folder = path.join(temp.root, 'notes');
+        const result = await service.runBatchWorkflow({ folderPath: folder, fileExtensions: ['.md'] }, defaultSettings());
+        expect(result.totalFiles).toBe(2);
+        expect(result.completedFiles).toBeGreaterThanOrEqual(0);
+        expect(result.failedFiles).toBeLessThanOrEqual(2);
+        expect(result.filter?.extensions).toEqual(['.md']);
+        expect(fs.existsSync(result.outputBasePath)).toBe(true);
+        expect(result.totalElapsedMs).toBeGreaterThan(0);
+    });
+    test('runBatchWorkflow filters by regex pattern', async () => {
+        temp.file('notes/lecture-01.md', '# L1');
+        temp.file('notes/lecture-02.md', '# L2');
+        temp.file('notes/other.md', '# Other');
+        const result = await service.runBatchWorkflow({ folderPath: path.join(temp.root, 'notes'), filePattern: 'lecture-.*' }, defaultSettings());
+        expect(result.totalFiles).toBe(2);
+        expect(result.filter?.pattern).toBe('lecture-.*');
+    });
+    test('runBatchWorkflow respects maxFiles limit', async () => {
+        temp.file('notes/a.md', '# A');
+        temp.file('notes/b.md', '# B');
+        temp.file('notes/c.md', '# C');
+        temp.file('notes/d.md', '# D');
+        const result = await service.runBatchWorkflow({ folderPath: path.join(temp.root, 'notes'), maxFiles: 2 }, defaultSettings());
+        expect(result.totalFiles).toBe(2);
+    });
+    test('runBatchWorkflow rejects invalid folder path', async () => {
+        await expect(service.runBatchWorkflow({ folderPath: path.join(temp.root, 'nonexistent') }, defaultSettings())).rejects.toThrow();
+    });
+    test('runBatchWorkflow rejects invalid regex pattern', async () => {
+        temp.file('notes/a.md', '# A');
+        await expect(service.runBatchWorkflow({ folderPath: path.join(temp.root, 'notes'), filePattern: '[invalid' }, defaultSettings())).rejects.toThrow('Invalid regex pattern');
+    });
+    test('runBatchWorkflow output base path is created', async () => {
+        temp.file('notes/a.md', '# A');
+        const customOutput = path.join(temp.root, 'custom_output');
+        const result = await service.runBatchWorkflow({ folderPath: path.join(temp.root, 'notes'), outputBasePath: customOutput }, defaultSettings());
+        expect(result.outputBasePath).toBe(customOutput);
+        expect(fs.existsSync(customOutput)).toBe(true);
+    });
+});

package/dist/src/notemd.cli.e2e.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CLI E2E pipeline test — validates the full CLI chain:
+ * parseCliArgs → findCommand → dispatchCommand → service method
+ */
+const parser_1 = require("./notemd/cli/parser");
+const commands_1 = require("./notemd/cli/commands");
+describe('CLI Parser', () => {
+    test('parseCliArgs extracts command name', () => {
+        const args = (0, parser_1.parseCliArgs)(['process-file', '--path=notes/test.md']);
+        expect(args.command).toBe('process-file');
+    });
+    test('parseCliArgs extracts --key=value params', () => {
+        const args = (0, parser_1.parseCliArgs)(['translate', '--path=notes/doc.md', '--language=zh']);
+        expect((0, parser_1.resolveParam)(args.params, ['path', 'p'])).toBe('notes/doc.md');
+        expect((0, parser_1.resolveParam)(args.params, ['language', 'l'])).toBe('zh');
+    });
+    test('parseCliArgs extracts --key value params', () => {
+        const args = (0, parser_1.parseCliArgs)(['search', '--query', 'machine learning']);
+        expect((0, parser_1.resolveParam)(args.params, ['query', 'q'])).toBe('machine learning');
+    });
+    test('parseCliArgs extracts boolean flags', () => {
+        const args = (0, parser_1.parseCliArgs)(['process-file', '--path=notes/test.md', '--dry-run', '--no-concepts']);
+        expect((0, parser_1.resolveBool)(args.params, args.flags, ['dry-run', 'n'])).toBe(true);
+        expect((0, parser_1.resolveBool)(args.params, args.flags, ['no-concepts', 'nc'])).toBe(true);
+        expect((0, parser_1.resolveBool)(args.params, args.flags, ['nonexistent'])).toBe(false);
+    });
+    test('parseCliArgs resolves param aliases', () => {
+        const args = (0, parser_1.parseCliArgs)(['process-file', '-p', 'notes/test.md', '-o', 'out/']);
+        expect((0, parser_1.resolveParam)(args.params, ['path', 'p', 'file'])).toBe('notes/test.md');
+        expect((0, parser_1.resolveParam)(args.params, ['output', 'o'])).toBe('out/');
+    });
+    test('parseCliArgs handles positional args', () => {
+        const args = (0, parser_1.parseCliArgs)(['search', 'machine learning', 'AI']);
+        expect(args.command).toBe('search');
+        expect(args.positional).toEqual(['machine learning', 'AI']);
+    });
+    test('parseCliArgs empty args returns empty command', () => {
+        const args = (0, parser_1.parseCliArgs)([]);
+        expect(args.command).toBe('');
+    });
+});
+describe('CLI Commands Registry', () => {
+    test('listCommands returns all 23 commands', () => {
+        const cmds = (0, commands_1.listCommands)();
+        expect(cmds.length).toBeGreaterThanOrEqual(22);
+    });
+    test('findCommand finds by name', () => {
+        const cmd = (0, commands_1.findCommand)('workflow');
+        expect(cmd).toBeDefined();
+        expect(cmd.operationId).toBe('workflow.extract-and-generate');
+        expect(cmd.automationLevel).toBe('requires-active-file');
+    });
+    test('findCommand finds by alias', () => {
+        const cmd = (0, commands_1.findCommand)('wf');
+        expect(cmd).toBeDefined();
+        expect(cmd.name).toBe('workflow');
+    });
+    test('findCommand returns undefined for unknown', () => {
+        expect((0, commands_1.findCommand)('nonexistent')).toBeUndefined();
+    });
+    test('getOperationForCommand resolves operation from registry', () => {
+        const op = (0, commands_1.getOperationForCommand)('process-file');
+        expect(op).toBeDefined();
+        expect(op.id).toBe('file.process-add-links');
+        expect(op.inputSchema).toBeDefined();
+    });
+    test('all commands have valid operationIds', () => {
+        const cmds = (0, commands_1.listCommands)();
+        for (const cmd of cmds) {
+            const op = (0, commands_1.getOperationForCommand)(cmd.name);
+            expect(op).toBeDefined();
+            expect(op.id).toBe(cmd.operationId);
+        }
+    });
+    test('critical workflow commands exist', () => {
+        expect((0, commands_1.findCommand)('workflow')).toBeDefined();
+        expect((0, commands_1.findCommand)('batch-workflow')).toBeDefined();
+        expect((0, commands_1.findCommand)('process-file')).toBeDefined();
+        expect((0, commands_1.findCommand)('search')).toBeDefined();
+        expect((0, commands_1.findCommand)('generate-diagram')).toBeDefined();
+        expect((0, commands_1.findCommand)('translate')).toBeDefined();
+    });
+    test('all commands have params and flags defined', () => {
+        const cmds = (0, commands_1.listCommands)();
+        for (const cmd of cmds) {
+            expect(Array.isArray(cmd.params)).toBe(true);
+            expect(Array.isArray(cmd.flags)).toBe(true);
+            if (cmd.params.length > 0) {
+                const required = cmd.params.filter(p => p.required);
+                expect(required.length).toBeGreaterThanOrEqual(0);
+            }
+        }
+    });
+    test('all commands have unique names', () => {
+        const cmds = (0, commands_1.listCommands)();
+        const names = cmds.map(c => c.name);
+        const unique = new Set(names);
+        expect(unique.size).toBe(names.length);
+    });
+    test('command aliases do not collide with command names', () => {
+        const cmds = (0, commands_1.listCommands)();
+        const names = new Set(cmds.map(c => c.name));
+        for (const cmd of cmds) {
+            for (const alias of cmd.aliases) {
+                expect(names.has(alias)).toBe(false);
+            }
+        }
+    });
+});
+describe('CLI Help Output', () => {
+    test('every command has a non-empty description', () => {
+        for (const cmd of (0, commands_1.listCommands)()) {
+            expect(cmd.description.length).toBeGreaterThan(0);
+        }
+    });
+    test('every command has at least one alias or uses the primary name', () => {
+        for (const cmd of (0, commands_1.listCommands)()) {
+            expect(cmd.name.length).toBeGreaterThan(0);
+            expect(Array.isArray(cmd.aliases)).toBe(true);
+        }
+    });
+    test('automation level is valid for all commands', () => {
+        const valid = ['safe', 'requires-active-file', 'requires-selection', 'interactive-ui'];
+        for (const cmd of (0, commands_1.listCommands)()) {
+            expect(valid).toContain(cmd.automationLevel);
+        }
+    });
+    test('side effect class is valid for all commands', () => {
+        const valid = ['read-only', 'write-file', 'batch-write', 'preview-ui', 'destructive'];
+        for (const cmd of (0, commands_1.listCommands)()) {
+            expect(valid).toContain(cmd.sideEffectClass);
+        }
+    });
+});

package/dist/src/notemd.core.test.js

@@ -100,6 +100,57 @@ describe('NoteMD core primitives', () => {
         expect(result.content).toContain('NoteTorque["Angular acceleration insight"]');
         expect(result.content).toContain('Torque -.- NoteTorque');
     });
+    test('fixMermaidSyntax repairs displaced quoted labels and legacy double-dash edge labels', () => {
+        const source = [
+            '```mermaid',
+            'graph TD;',
+            'A --> B; "Interface Normal"',
+            'P -- "theta_i" -- N;',
+            '```',
+        ].join('\n');
+        const result = (0, MermaidProcessor_1.fixMermaidSyntax)(source);
+        expect(result.changed).toBe(true);
+        expect(result.content).toContain('A -- "Interface Normal" --> B');
+        expect(result.content).toContain('P -- "theta_i" --> N;');
+    });
+    test('fixMermaidSyntax wraps bare html-break node labels into Mermaid node syntax', () => {
+        const source = [
+            '```mermaid',
+            'flowchart TD',
+            'A[Incident Wave] --> I Interface<br/>Boundary;',
+            'I --> R Reflected<br/>Wave;',
+            '```',
+        ].join('\n');
+        const result = (0, MermaidProcessor_1.fixMermaidSyntax)(source);
+        expect(result.changed).toBe(true);
+        expect(result.content).toContain('I["Interface<br/>Boundary"]');
+        expect(result.content).toContain('R["Reflected<br/>Wave"]');
+    });
+    test('fixMermaidSyntax closes Mermaid node labels that end with a stray opening bracket', () => {
+        const source = [
+            '```mermaid',
+            'graph LR',
+            'InteractionPoint["作用点 Interaction Point["',
+            'InteractionPoint --> Absorption["吸收 Absorption"]',
+            '```',
+        ].join('\n');
+        const result = (0, MermaidProcessor_1.fixMermaidSyntax)(source);
+        expect(result.changed).toBe(true);
+        expect(result.content).toContain('InteractionPoint["作用点 Interaction Point"]');
+    });
+    test('fixMermaidSyntax escapes stray quotes inside Mermaid bracketed node labels', () => {
+        const source = [
+            '```mermaid',
+            'flowchart TD',
+            'HQWG["High Quality Water Glass"] -->|"&gt;Superior Overall"| FS["Final Score "&gt;Superior Overall"| FS"]',
+            '```',
+        ].join('\n');
+        const result = (0, MermaidProcessor_1.fixMermaidSyntax)(source);
+        expect(result.changed).toBe(true);
+        expect(result.content).toContain('High Quality Water Glass');
+        expect(result.content).toContain('Final Score #quot;&gt;Superior Overall#quot;| FS');
+        expect(result.fixes).toContain('Escaped stray double quotes inside Mermaid node labels.');
+    });
     test('DuplicateDetector reports repeated terms and wiki-links', () => {
         const detector = new DuplicateDetector_1.DuplicateDetector();
         const content = 'Graph graph graph [[Node]] [[Node]] [[Edge]]';