noteconnection 1.6.8 → 1.8.0

package/dist/src/notemd.diagram.pipeline.test.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Diagram Pipeline unit tests — validates intent inference, planner,
+ * spec validation, and response parser (all pure functions).
+ */
+const intent_1 = require("./notemd/diagram/intent");
+const planner_1 = require("./notemd/diagram/planner");
+const diagramSpec_1 = require("./notemd/diagram/diagramSpec");
+const diagramSpecResponseParser_1 = require("./notemd/diagram/diagramSpecResponseParser");
+const diagramSpecPrompt_1 = require("./notemd/diagram/prompts/diagramSpecPrompt");
+// ── Intent Inference ──
+describe('Diagram Intent Inference', () => {
+    test('empty content defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('');
+        expect(result.intent).toBe('mindmap');
+        expect(result.confidence).toBeLessThan(0.5);
+    });
+    test('whitespace-only defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('   \n  ');
+        expect(result.intent).toBe('mindmap');
+    });
+    test('data table with numeric values infers dataChart', () => {
+        const md = [
+            '| Metric | Value |',
+            '| ------ | ----- |',
+            '| CPU    | 85%   |',
+            '| Memory | 72%   |',
+            'Monthly growth trend: 12% increase.',
+        ].join('\n');
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('dataChart');
+        expect(result.confidence).toBeGreaterThan(0.8);
+    });
+    test('request-response vocabulary infers sequence', () => {
+        const md = 'Client sends request to server. Server processes and returns response. Gateway routes the request. Service handles the response.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('sequence');
+    });
+    test('arrow markers infers sequence', () => {
+        const result = (0, intent_1.inferDiagramIntent)('User -> API -> Database -> Response');
+        expect(result.intent).toBe('sequence');
+    });
+    test('database schema vocabulary infers erDiagram', () => {
+        const md = 'The entity has a primary key. The table references a foreign key. The schema defines the column.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('erDiagram');
+    });
+    test('state transition vocabulary infers stateDiagram', () => {
+        const md = 'The state machine transitions from pending to running. Completed state follows. Failed state triggers retry.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('stateDiagram');
+    });
+    test('workflow/process vocabulary infers flowchart', () => {
+        const md = 'Step 1: Validate input. If valid then process, else stop. Continue to next step.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('flowchart');
+    });
+    test('numbered steps infers flowchart', () => {
+        const md = '1. First step\n2. Second step\n3. Third step';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('flowchart');
+    });
+    test('concept map keywords infers canvasMap', () => {
+        const md = 'This is a concept map showing the knowledge graph of spatial clusters.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('canvasMap');
+    });
+    test('general content defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('The quick brown fox jumps over the lazy dog.');
+        expect(result.intent).toBe('mindmap');
+        expect(result.confidence).toBeGreaterThan(0.4);
+    });
+});
+// ── Planner ──
+describe('Diagram Planner', () => {
+    test('best-fit mode routes dataChart to vega-lite', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.renderTarget).toBe('vega-lite');
+    });
+    test('best-fit mode routes sequence to mermaid', () => {
+        const md = 'Client sends request. Server returns response. Gateway routes. Service processes.';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.intent).toBe('sequence');
+        expect(plan.renderTarget).toBe('mermaid');
+        expect(plan.mermaidDiagramType).toBe('sequenceDiagram');
+    });
+    test('legacy-mermaid mode forces mermaid render target', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart share distribution';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'legacy-mermaid' });
+        expect(plan.renderTarget).toBe('mermaid');
+        expect(plan.legacyCompatibilityMode).toBe(true);
+    });
+    test('explicit intent overrides inference', () => {
+        const plan = (0, planner_1.buildDiagramPlan)('any content', {
+            requestedIntent: 'flowchart',
+            compatibilityMode: 'best-fit'
+        });
+        expect(plan.intent).toBe('flowchart');
+        expect(plan.confidence).toBeGreaterThan(0.9);
+    });
+    test('mindmap intent resolves to mindmap mermaid type', () => {
+        const plan = (0, planner_1.buildDiagramPlan)('# Just a regular note about topics', { compatibilityMode: 'best-fit' });
+        expect(plan.intent).toBe('mindmap');
+        expect(plan.mermaidDiagramType).toBe('mindmap');
+    });
+    test('fallback targets include html for dataChart (non-mermaid)', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart share breakdown';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.renderTarget).toBe('vega-lite');
+        // dataChart has no mermaidDiagramType, so only html is a valid fallback
+        expect(plan.fallbackTargets).toContain('html');
+    });
+});
+// ── Spec Validation ──
+describe('Diagram Spec Validation', () => {
+    const validMindmapSpec = {
+        intent: 'mindmap',
+        title: 'Test Diagram',
+        nodes: [{ id: 'n1', label: 'Node 1' }, { id: 'n2', label: 'Node 2' }],
+        edges: [{ from: 'n1', to: 'n2' }],
+    };
+    test('valid mindmap spec passes validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)(validMindmapSpec);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    test('missing title fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, title: '' });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('title'))).toBe(true);
+    });
+    test('duplicate node ids fail validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({
+            ...validMindmapSpec,
+            nodes: [{ id: 'n1', label: 'A' }, { id: 'n1', label: 'B' }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('duplicate'))).toBe(true);
+    });
+    test('edge to missing node fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({
+            ...validMindmapSpec,
+            edges: [{ from: 'n1', to: 'missing' }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('missing'))).toBe(true);
+    });
+    test('unsupported intent fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, intent: 'bogus' });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('unsupported'))).toBe(true);
+    });
+    test('assertValidDiagramSpec throws on invalid spec', () => {
+        expect(() => (0, diagramSpec_1.assertValidDiagramSpec)({ ...validMindmapSpec, title: '' })).toThrow();
+    });
+    test('dataChart intent requires data series', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, intent: 'dataChart', nodes: [] });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('data series'))).toBe(true);
+    });
+});
+// ── Response Parser ──
+describe('Diagram Spec Response Parser', () => {
+    test('parses valid JSON DiagramSpec', () => {
+        const json = JSON.stringify({
+            intent: 'mindmap',
+            title: 'Test',
+            nodes: [{ id: 'a', label: 'A' }],
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('mindmap');
+        expect(spec.title).toBe('Test');
+        expect(spec.nodes).toHaveLength(1);
+        expect(spec.nodes[0].id).toBe('a');
+    });
+    test('strips code fences from response', () => {
+        const json = '```json\n' + JSON.stringify({
+            intent: 'flowchart',
+            title: 'Test',
+            nodes: [{ id: 'a', label: 'A' }],
+        }) + '\n```';
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('flowchart');
+        expect(spec.title).toBe('Test');
+    });
+    test('handles diagramSpec wrapper key', () => {
+        const json = JSON.stringify({
+            diagramSpec: {
+                intent: 'sequence',
+                title: 'Test',
+                nodes: [{ id: 'a', label: 'A' }],
+            }
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('sequence');
+    });
+    test('throws on non-JSON input', () => {
+        expect(() => (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)('not json at all')).toThrow();
+    });
+    test('normalizes edge fields (source→from, target→to)', () => {
+        const json = JSON.stringify({
+            intent: 'mindmap', title: 'E',
+            nodes: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }],
+            edges: [{ source: 'a', target: 'b', label: 'connects' }],
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.edges[0].from).toBe('a');
+        expect(spec.edges[0].to).toBe('b');
+    });
+});
+// ── Prompt Builder ──
+describe('Diagram Spec Prompt', () => {
+    test('includes required intent in output', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ requiredIntent: 'flowchart' });
+        expect(prompt).toContain('REQUIRED');
+        expect(prompt).toContain('flowchart');
+    });
+    test('includes preferred intent', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ preferredIntent: 'sequence' });
+        expect(prompt).toContain('Preferred');
+        expect(prompt).toContain('sequence');
+    });
+    test('includes target language', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ targetLanguage: 'zh' });
+        expect(prompt).toContain('zh');
+    });
+    test('output rules forbid code fences', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)();
+        expect(prompt).toContain('Do not wrap');
+    });
+});

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const providerTemplates_1 = require("./notemd/providerTemplates");
+const constants_1 = require("./notemd/constants");
+describe('notemd provider templates', () => {
+    test('exposes curated templates inspired by Cherry Studio and DeepTutor', () => {
+        expect(providerTemplates_1.NOTEMD_PROVIDER_TEMPLATES.length).toBeGreaterThanOrEqual(6);
+        expect((0, providerTemplates_1.getNotemdProviderTemplate)('openai-official')?.providerName).toBe('OpenAI');
+        expect((0, providerTemplates_1.getNotemdProviderTemplate)('lmstudio-local')?.inspiredBy).toContain('DeepTutor');
+    });
+    test('applies a template to the matching provider and switches activeProvider', () => {
+        const next = (0, providerTemplates_1.applyProviderTemplateToSettings)(constants_1.DEFAULT_SETTINGS, 'openrouter-gateway');
+        const provider = next.providers.find((item) => item.name === 'OpenRouter');
+        expect(next.activeProvider).toBe('OpenRouter');
+        expect(provider).toBeTruthy();
+        expect(provider?.baseUrl).toContain('openrouter.ai');
+        expect(provider?.model).toContain('openai/');
+    });
+    test('merges provider_templates into the notemd TOML section without dropping existing overrides', () => {
+        const next = (0, providerTemplates_1.mergeProviderTemplatesIntoNotemdSection)({
+            active_provider: 'DeepSeek',
+            provider_templates: {
+                custom_keep: {
+                    label: 'Keep Me',
+                },
+            },
+        });
+        const templates = next.provider_templates;
+        expect(templates).toBeTruthy();
+        expect(templates.custom_keep.label).toBe('Keep Me');
+        expect(templates['openai-official']).toBeTruthy();
+        expect(templates['openai-official'].provider_name).toBe('OpenAI');
+    });
+});

package/dist/src/notemd.server.integration.test.js

@@ -141,11 +141,35 @@ describe('NoteMD server integration', () => {
     let temp;
     let envRestorers;
     let server;
+    let serverModule;
     let port;
     let kbFilePath;
     let runtimeDataDir;
     let appConfigPath;
     let originalArgv;
+    function loadFreshServerModule() {
+        jest.resetModules();
+        process.argv = process.argv.slice(0, 2);
+        jest.doMock('./index', () => ({
+            buildGraph: jest.fn().mockResolvedValue(undefined),
+        }));
+        jest.doMock('./core/PathBridge', () => ({
+            PathBridge: jest.fn().mockImplementation(() => ({})),
+        }));
+        jest.doMock('./reader_renderer', () => ({
+            renderMathPng: jest.fn().mockResolvedValue({
+                pngBase64: 'math',
+                width: 100,
+                height: 50,
+            }),
+            renderMermaidPng: jest.fn().mockResolvedValue({
+                pngBase64: 'mermaid',
+                width: 100,
+                height: 50,
+            }),
+        }));
+        return require('./server');
+    }
     beforeAll(async () => {
         temp = new TempDir('noteconnection-notemd');
         const projectRoot = temp.mkdir('project');
@@ -186,45 +210,29 @@ describe('NoteMD server integration', () => {
         envRestorers.push(setEnv('npm_config_workers', undefined));
         envRestorers.push(setEnv('npm_config_static', undefined));
         port = await getFreePort();
-        jest.resetModules();
         originalArgv = [...process.argv];
-        process.argv = process.argv.slice(0, 2);
-        jest.doMock('./index', () => ({
-            buildGraph: jest.fn().mockResolvedValue(undefined),
-        }));
-        jest.doMock('./core/PathBridge', () => ({
-            PathBridge: jest.fn().mockImplementation(() => ({})),
-        }));
-        jest.doMock('./reader_renderer', () => ({
-            renderMathPng: jest.fn().mockResolvedValue({
-                pngBase64: 'math',
-                width: 100,
-                height: 50,
-            }),
-            renderMermaidPng: jest.fn().mockResolvedValue({
-                pngBase64: 'mermaid',
-                width: 100,
-                height: 50,
-            }),
-        }));
-        const serverModule = require('./server');
+        serverModule = loadFreshServerModule();
         server = await serverModule.startServer({ port });
     });
-    afterAll(async () => {
-        if (server) {
-            if (typeof server.closeAllConnections === 'function') {
-                server.closeAllConnections();
-            }
-            await new Promise((resolve, reject) => {
-                server.close((err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            });
+    async function shutdownServerInstance(instance) {
+        if (!instance) {
+            return;
+        }
+        if (typeof instance.closeAllConnections === 'function') {
+            instance.closeAllConnections();
         }
+        await new Promise((resolve, reject) => {
+            instance.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    afterAll(async () => {
+        await shutdownServerInstance(server);
         envRestorers.reverse().forEach((restore) => restore());
         process.argv = originalArgv;
         jest.dontMock('./index');
@@ -462,4 +470,104 @@ describe('NoteMD server integration', () => {
         expect(fs.existsSync(appConfigPath)).toBe(true);
         expect(fs.existsSync(path.join(runtimeDataDir, 'notemd_config.json'))).toBe(false);
     });
+    test('foundation readiness and backend sufficiency reflect embedded sqlite graph runtime after ingest', async () => {
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_foundation_runtime',
+                    sourcePath: path.join(path.dirname(kbFilePath), 'foundation_runtime.md'),
+                    language: 'en',
+                    content: '# Foundation Runtime\n\nEmbedded graph backend readiness should be measurable after ingest.',
+                },
+            ],
+        });
+        expect(ingestResponse.status).toBe(200);
+        expect(ingestResponse.body.success).toBe(true);
+        const readinessResponse = await requestJson(port, 'GET', '/api/knowledge/foundation/readiness');
+        expect(readinessResponse.status).toBe(200);
+        expect(readinessResponse.body.success).toBe(true);
+        expect(readinessResponse.body.readiness).toEqual(expect.objectContaining({
+            status: 'integrated',
+            decision: 'go',
+            ready: true,
+        }));
+        expect(readinessResponse.body.readiness.baseline).toEqual(expect.objectContaining({
+            storeType: 'sqlite',
+            graphBackendStatus: 'independent',
+            graphBackendSignalKind: 'embedded_graphdb',
+            graphBackendIndependent: true,
+            queryBackendDefaultMode: 'local_hybrid',
+            vectorAdapterStatus: 'independent',
+            vectorAdapterSignalKind: 'embedding_ann',
+        }));
+        expect(readinessResponse.body.readiness.promotionCriteriaPassed).toBe(readinessResponse.body.readiness.promotionCriteriaTotal);
+        const sufficiencyResponse = await requestJson(port, 'GET', '/api/knowledge/backend/sufficiency');
+        expect(sufficiencyResponse.status).toBe(200);
+        expect(sufficiencyResponse.body.success).toBe(true);
+        expect(sufficiencyResponse.body.sufficiency).toEqual(expect.objectContaining({
+            sufficient: true,
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.knowledgeGraph).toEqual(expect.objectContaining({
+            passed: true,
+            reason: 'embedded_graphdb',
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.queryBackend).toEqual(expect.objectContaining({
+            passed: true,
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.vectorIndex).toEqual(expect.objectContaining({
+            passed: true,
+            reason: 'embedding_ann',
+        }));
+    });
+    test('embedded sqlite graph runtime survives server restart and preserves query/store diagnostics', async () => {
+        const sqliteStorePath = path.join(runtimeDataDir, 'knowledge_graph_store.graphdb.v1.sqlite');
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_restart_runtime',
+                    sourcePath: path.join(path.dirname(kbFilePath), 'restart_runtime.md'),
+                    language: 'en',
+                    content: '# Restart Runtime\n\nPersist this graph content across server restart for sqlite proof.',
+                },
+            ],
+        });
+        expect(ingestResponse.status).toBe(200);
+        expect(ingestResponse.body.success).toBe(true);
+        expect(fs.existsSync(sqliteStorePath)).toBe(true);
+        await shutdownServerInstance(server);
+        port = await getFreePort();
+        serverModule = loadFreshServerModule();
+        server = await serverModule.startServer({ port });
+        const diagnosticsResponse = await requestJson(port, 'GET', '/api/knowledge/store-diagnostics');
+        expect(diagnosticsResponse.status).toBe(200);
+        expect(diagnosticsResponse.body.success).toBe(true);
+        expect(diagnosticsResponse.body.store).toEqual(expect.objectContaining({
+            storeType: 'graphdb',
+            storageEngine: 'sqlite',
+            backendReady: true,
+            usingFallback: false,
+        }));
+        const queryResponse = await requestJson(port, 'POST', '/api/knowledge/query', {
+            query: 'persist graph content restart sqlite proof',
+            topK: 3,
+        });
+        expect(queryResponse.status).toBe(200);
+        expect(queryResponse.body.success).toBe(true);
+        expect(Array.isArray(queryResponse.body.result.items)).toBe(true);
+        expect(queryResponse.body.result.items.length).toBeGreaterThan(0);
+        expect(String(queryResponse.body.result.items[0]?.atom?.documentId || '')).toBe('doc_restart_runtime');
+        const readinessResponse = await requestJson(port, 'GET', '/api/knowledge/foundation/readiness');
+        expect(readinessResponse.status).toBe(200);
+        expect(readinessResponse.body.readiness).toEqual(expect.objectContaining({
+            status: 'integrated',
+            decision: 'go',
+        }));
+        expect(readinessResponse.body.readiness.baseline).toEqual(expect.objectContaining({
+            storeType: 'sqlite',
+            graphBackendSignalKind: 'embedded_graphdb',
+            graphBackendIndependent: true,
+        }));
+    });
 });

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

@@ -0,0 +1,162 @@
+"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 });
+/**
+ * Workflow Pipeline contract test — validates the 4-stage
+ * runWorkflow pipeline (extract → wikilinks → generate → mermaid).
+ */
+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(overrides = {}) {
+    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: '',
+        ...overrides,
+    };
+}
+describe('Notemd Workflow Pipeline', () => {
+    let temp;
+    let service;
+    beforeEach(() => { temp = new TempDir('notemd-workflow-'); service = new NotemdService_1.NotemdService(); });
+    afterEach(() => { temp.cleanup(); });
+    test('runWorkflow executes all 3 stages (extract → generate → mermaid) on a simple file', async () => {
+        const src = temp.file('notes/topic.md', '# Graph Theory\n\nGraph theory studies **nodes** and **edges**.\n\n```mermaid\ngraph TD\nA-->B\n```');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        expect(result.sourceFilePath).toBe(src);
+        expect(result.outputFolderPath).toContain('topic_notemd_output');
+        expect(fs.existsSync(result.outputFolderPath)).toBe(true);
+        // All 3 stages should be present (no wiki-links)
+        expect(result.stages.length).toBeGreaterThanOrEqual(3);
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('extract-concepts');
+        expect(stageNames).toContain('generate-titles');
+        expect(stageNames).toContain('mermaid-fix');
+        // Extract stage should have completed
+        const extractStage = result.stages.find(s => s.stage === 'extract-concepts');
+        expect(['completed', 'error']).toContain(extractStage.status);
+        // Summary should have valid numbers
+        expect(typeof result.summary.conceptsExtracted).toBe('number');
+        expect(typeof result.summary.totalElapsedMs).toBe('number');
+        expect(result.summary.totalElapsedMs).toBeGreaterThan(0);
+    });
+    test('runWorkflow with addWikiLinks injects wiki-links and writes _wikified file', async () => {
+        const src = temp.file('notes/test.md', '# Machine Learning\n\nMachine learning uses neural networks and deep learning.');
+        const result = await service.runWorkflow({ filePath: src, addWikiLinks: true, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        // Wiki-links stage should be present and completed
+        const wikiStage = result.stages.find(s => s.stage === 'add-wikilinks');
+        expect(wikiStage).toBeDefined();
+        // May be 'completed' with links or 'skipped' if LLM returned no concepts
+        expect(['completed', 'skipped']).toContain(wikiStage.status);
+        // Add stage names check
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('add-wikilinks');
+        expect(stageNames).not.toContain('generate-titles');
+        expect(stageNames).not.toContain('mermaid-fix');
+    });
+    test('runWorkflow with skipGenerate and skipMermaidFix only runs extract', async () => {
+        const src = temp.file('notes/simple.md', '# Simple\n\nJust a simple note.');
+        const result = await service.runWorkflow({ filePath: src, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        // Only 1 stage should run (extract) since generate + mermaid are skipped
+        const runningStages = result.stages.filter(s => s.status !== 'skipped');
+        expect(runningStages.length).toBeGreaterThanOrEqual(1);
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('extract-concepts');
+    });
+    test('runWorkflow with wikiLinksInPlace modifies source file directly', async () => {
+        const src = temp.file('notes/inplace.md', '# AI\n\nArtificial intelligence uses machine learning and deep learning algorithms.');
+        const originalContent = fs.readFileSync(src, 'utf8');
+        const result = await service.runWorkflow({ filePath: src, addWikiLinks: true, wikiLinksInPlace: true, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        const wikiStage = result.stages.find(s => s.stage === 'add-wikilinks');
+        expect(wikiStage).toBeDefined();
+        // If wikilinks were injected in-place, file content should differ
+        if (wikiStage.status === 'completed') {
+            const newContent = fs.readFileSync(src, 'utf8');
+            // Either content changed or no concepts were found
+            expect(typeof newContent).toBe('string');
+        }
+    });
+    test('runWorkflow errors are collected per-stage without blocking other stages', async () => {
+        const src = temp.file('notes/errors.md', 'test content');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        // Each stage should report its status
+        result.stages.forEach(stage => {
+            expect(['completed', 'error', 'skipped', 'running']).toContain(stage.status);
+        });
+        // Result should always have a valid structure even on errors
+        expect(result.sourceFilePath).toBe(src);
+        expect(Array.isArray(result.errors)).toBe(true);
+        expect(typeof result.summary.totalElapsedMs).toBe('number');
+    });
+    test('runWorkflow output folder is created', async () => {
+        const src = temp.file('notes/output.md', '# Test\n\nJust testing.');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        expect(fs.existsSync(result.outputFolderPath)).toBe(true);
+    });
+});