noteconnection 1.6.8 → 1.8.0

package/dist/src/notemd/NotemdService.js

@@ -43,6 +43,9 @@ const FileProcessor_1 = require("./FileProcessor");
 const FormulaFixer_1 = require("./FormulaFixer");
 const MermaidProcessor_1 = require("./MermaidProcessor");
 const Translator_1 = require("./Translator");
+const SearchManager_1 = require("./search/SearchManager");
+const diagramGenerationService_1 = require("./diagram/diagramGenerationService");
+const LlmProvider_1 = require("./LlmProvider");
 const types_1 = require("./types");
 function defaultReporter() {
     return {
@@ -51,13 +54,16 @@ function defaultReporter() {
     };
 }
 class NotemdService {
-    constructor(fileProcessor = new FileProcessor_1.FileProcessor(), translator = new Translator_1.Translator(), contentGenerator = new ContentGenerator_1.ContentGenerator(), mermaidProcessor = new MermaidProcessor_1.MermaidProcessor(), formulaFixer = new FormulaFixer_1.FormulaFixer(), duplicateDetector = new DuplicateDetector_1.DuplicateDetector()) {
+    constructor(fileProcessor = new FileProcessor_1.FileProcessor(), translator = new Translator_1.Translator(), contentGenerator = new ContentGenerator_1.ContentGenerator(), mermaidProcessor = new MermaidProcessor_1.MermaidProcessor(), formulaFixer = new FormulaFixer_1.FormulaFixer(), duplicateDetector = new DuplicateDetector_1.DuplicateDetector(), llmProviderClient = new LlmProvider_1.LlmProviderClient()) {
+        // ── Batch progress tracking ──
+        this.batchOperations = new Map();
         this.fileProcessor = fileProcessor;
         this.translator = translator;
         this.contentGenerator = contentGenerator;
         this.mermaidProcessor = mermaidProcessor;
         this.formulaFixer = formulaFixer;
         this.duplicateDetector = duplicateDetector;
+        this.llmProviderClient = llmProviderClient;
     }
     processFile(request, settings, reporter = defaultReporter(), signal) {
         return this.fileProcessor.processFile(request, settings, reporter, signal);
@@ -129,6 +135,51 @@ class NotemdService {
             content: fixed.content,
         };
     }
+    async batchFixFormulas(folderPath, inPlace = true) {
+        const resolvedFolderPath = path.resolve(String(folderPath || '').trim());
+        const stats = await fs.promises.stat(resolvedFolderPath);
+        if (!stats.isDirectory())
+            throw new types_1.ValidationError(`Not a directory: ${resolvedFolderPath}`);
+        const files = await this.collectTextFiles(resolvedFolderPath);
+        const results = [];
+        for (const filePath of files) {
+            const result = await this.fixFormulas(filePath, inPlace);
+            results.push({
+                sourcePath: filePath,
+                modified: result.changed,
+                replacementCount: result.fixes.length
+            });
+        }
+        return {
+            folderPath: resolvedFolderPath,
+            totalFiles: files.length,
+            fixedFiles: results.filter(r => r.modified).length,
+            results
+        };
+    }
+    async collectTextFiles(rootDir) {
+        const results = [];
+        const queue = [rootDir];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current)
+                continue;
+            const entries = await fs.promises.readdir(current, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    queue.push(fullPath);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                if (!constants_1.NOTEMD_SUPPORTED_TEXT_EXTENSIONS.has(path.extname(fullPath).toLowerCase()))
+                    continue;
+                results.push(fullPath);
+            }
+        }
+        return results.sort((a, b) => a.localeCompare(b));
+    }
     async checkDuplicates(filePath) {
         const resolvedPath = path.resolve(String(filePath || '').trim());
         if (!resolvedPath) {
@@ -153,26 +204,460 @@ class NotemdService {
             concepts: Array.from(concepts).sort((a, b) => a.localeCompare(b)),
         };
     }
-    async oneClickExtract(filePath, settings, reporter = defaultReporter(), signal) {
-        const resolvedPath = path.resolve(String(filePath || '').trim());
-        if (!resolvedPath) {
+    // ── Workflow Pipeline (NoteConnection native) ──
+    async runWorkflow(request, settings, reporter = defaultReporter(), signal) {
+        const resolvedPath = path.resolve(String(request.filePath || '').trim());
+        if (!resolvedPath)
             throw new types_1.ValidationError('Missing filePath.');
-        }
-        const source = await fs.promises.readFile(resolvedPath, 'utf8');
-        const concepts = Array.from(await this.fileProcessor.extractConceptsFromText(source, settings, reporter, signal)).sort((a, b) => a.localeCompare(b));
-        const outputFolderPath = path.join(this.resolveKnowledgeBaseRootForFile(resolvedPath), path.basename(resolvedPath, path.extname(resolvedPath)));
+        const startedAt = Date.now();
+        const stages = [];
+        const errors = [];
+        const ext = path.extname(resolvedPath);
+        const baseName = path.basename(resolvedPath, ext);
+        const outputFolderPath = request.outputFolderPath
+            ? path.resolve(request.outputFolderPath)
+            : path.join(path.dirname(resolvedPath), `${baseName}_notemd_output`);
         await fs.promises.mkdir(outputFolderPath, { recursive: true });
-        await this.scaffoldConceptFiles(outputFolderPath, concepts);
-        const generated = await this.contentGenerator.generateFolderFromTitles(outputFolderPath, settings, reporter, signal);
-        const mermaid = await this.batchFixMermaid(outputFolderPath, true);
+        const enableWikilinks = request.addWikiLinks === true;
+        const enableGenerate = !request.skipGenerate;
+        const enableMermaid = !request.skipMermaidFix;
+        const totalStages = 1 + (enableWikilinks ? 1 : 0) + (enableGenerate ? 1 : 0) + (enableMermaid ? 1 : 0);
+        let stageNum = 0;
+        // Stage 1: Extract Concepts
+        stageNum += 1;
+        stages.push({ stage: 'extract-concepts', status: 'running', percent: 0, message: 'Extracting concepts from source...' });
+        reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] Extracting concepts from ${baseName}${ext}`, percent: Math.floor((stageNum - 1) / totalStages * 100), operationId: 'workflow-extract' });
+        let concepts = [];
+        let sourceContent = '';
+        try {
+            sourceContent = await fs.promises.readFile(resolvedPath, 'utf8');
+            concepts = Array.from(await this.fileProcessor.extractConceptsFromText(sourceContent, settings, reporter, signal)).sort((a, b) => a.localeCompare(b));
+            await this.scaffoldConceptFiles(outputFolderPath, concepts);
+            stages[0] = { stage: 'extract-concepts', status: 'completed', percent: 100, message: `Extracted ${concepts.length} concepts`, details: { count: concepts.length, concepts } };
+            reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] ✓ Extracted ${concepts.length} concepts`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-extract' });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            stages[0] = { stage: 'extract-concepts', status: 'error', percent: 100, message: msg };
+            errors.push(`extract-concepts: ${msg}`);
+            reporter.report({ type: 'error', message: `[${stageNum}/${totalStages}] ✕ Concept extraction failed: ${msg}`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-extract' });
+        }
+        // Stage 2 (optional): Add Wiki-Links to source
+        let wikiLinkCount = 0;
+        if (enableWikilinks && concepts.length > 0) {
+            stageNum += 1;
+            stages.push({ stage: 'add-wikilinks', status: 'running', percent: 0, message: 'Adding wiki-links to source...' });
+            reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] Adding [[wiki-links]] for ${concepts.length} concepts`, percent: Math.floor((stageNum - 1) / totalStages * 100), operationId: 'workflow-wikilinks' });
+            try {
+                const injected = this.fileProcessor.injectWikiLinks(sourceContent, concepts);
+                wikiLinkCount = injected.linkCount;
+                // Write wikified output: in-place or _wikified copy
+                let wikifiedPath;
+                if (request.wikiLinksInPlace) {
+                    wikifiedPath = resolvedPath;
+                }
+                else {
+                    wikifiedPath = path.join(path.dirname(resolvedPath), `${baseName}_wikified${ext}`);
+                }
+                await fs.promises.writeFile(wikifiedPath, injected.content, 'utf8');
+                stages.push({ stage: 'add-wikilinks', status: 'completed', percent: 100, message: `Added ${wikiLinkCount} wiki-links`, details: { linkCount: wikiLinkCount, outputPath: wikifiedPath, inPlace: !!request.wikiLinksInPlace } });
+                reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] ✓ Added ${wikiLinkCount} wiki-links → ${path.basename(wikifiedPath)}`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-wikilinks' });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                stages.push({ stage: 'add-wikilinks', status: 'error', percent: 100, message: msg });
+                errors.push(`add-wikilinks: ${msg}`);
+                reporter.report({ type: 'error', message: `[${stageNum}/${totalStages}] ✕ Wiki-link injection failed: ${msg}`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-wikilinks' });
+            }
+        }
+        else if (enableWikilinks && concepts.length === 0) {
+            stageNum += 1;
+            stages.push({ stage: 'add-wikilinks', status: 'skipped', percent: 100, message: 'No concepts to link', details: { linkCount: 0 } });
+        }
+        // Stage 3 (optional): Generate from Titles
+        let generated = { totalFiles: 0, generatedFiles: 0, failedFiles: 0, outputs: [] };
+        if (enableGenerate) {
+            stageNum += 1;
+            stages.push({ stage: 'generate-titles', status: 'running', percent: 0, message: 'Generating content from titles...' });
+            reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] Generating content from titles in ${path.basename(outputFolderPath)}`, percent: Math.floor((stageNum - 1) / totalStages * 100), operationId: 'workflow-generate' });
+            try {
+                generated = await this.contentGenerator.generateFolderFromTitles(outputFolderPath, settings, reporter, signal);
+                stages.push({ stage: 'generate-titles', status: 'completed', percent: 100, message: `Generated ${generated.generatedFiles}/${generated.totalFiles} files`, details: { totalFiles: generated.totalFiles, generatedFiles: generated.generatedFiles, failedFiles: generated.failedFiles, outputs: generated.outputs } });
+                reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] ✓ Generated ${generated.generatedFiles}/${generated.totalFiles} files`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-generate' });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                stages.push({ stage: 'generate-titles', status: 'error', percent: 100, message: msg });
+                errors.push(`generate-titles: ${msg}`);
+                reporter.report({ type: 'error', message: `[${stageNum}/${totalStages}] ✕ Content generation failed: ${msg}`, percent: Math.floor(stageNum / totalStages * 100), operationId: 'workflow-generate' });
+            }
+        }
+        // Stage 4 (optional): Mermaid Fix
+        let mermaid = { folderPath: outputFolderPath, totalFiles: 0, fixedFiles: 0, results: [] };
+        if (enableMermaid) {
+            stageNum += 1;
+            stages.push({ stage: 'mermaid-fix', status: 'running', percent: 0, message: 'Fixing Mermaid diagrams...' });
+            reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] Fixing Mermaid diagrams in ${path.basename(outputFolderPath)}`, percent: Math.floor((stageNum - 1) / totalStages * 100), operationId: 'workflow-mermaid' });
+            try {
+                mermaid = await this.batchFixMermaid(outputFolderPath, true);
+                stages.push({ stage: 'mermaid-fix', status: 'completed', percent: 100, message: `Fixed ${mermaid.fixedFiles}/${mermaid.totalFiles} files`, details: { fixedFiles: mermaid.fixedFiles, totalFiles: mermaid.totalFiles, results: mermaid.results } });
+                reporter.report({ type: 'status', message: `[${stageNum}/${totalStages}] ✓ Fixed ${mermaid.fixedFiles}/${mermaid.totalFiles} Mermaid diagrams`, percent: 100, operationId: 'workflow-mermaid' });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                stages.push({ stage: 'mermaid-fix', status: 'error', percent: 100, message: msg });
+                errors.push(`mermaid-fix: ${msg}`);
+                reporter.report({ type: 'error', message: `[${stageNum}/${totalStages}] ✕ Mermaid fix failed: ${msg}`, percent: 100, operationId: 'workflow-mermaid' });
+            }
+        }
+        reporter.report({ type: 'done', message: `Workflow complete for ${baseName}${ext}`, percent: 100, operationId: 'workflow' });
         return {
             sourceFilePath: resolvedPath,
             outputFolderPath,
+            stages,
+            summary: {
+                conceptsExtracted: concepts.length,
+                wikiLinksAdded: wikiLinkCount,
+                titlesGenerated: generated.generatedFiles,
+                titlesFailed: generated.failedFiles,
+                mermaidFilesFixed: mermaid.fixedFiles,
+                totalElapsedMs: Date.now() - startedAt,
+            },
+            errors,
+        };
+    }
+    async runBatchWorkflow(request, settings, reporter = defaultReporter(), signal) {
+        const resolvedFolderPath = path.resolve(String(request.folderPath || '').trim());
+        if (!resolvedFolderPath)
+            throw new types_1.ValidationError('Missing folderPath.');
+        const startedAt = Date.now();
+        const stats = await fs.promises.stat(resolvedFolderPath);
+        if (!stats.isDirectory())
+            throw new types_1.ValidationError(`Not a directory: ${resolvedFolderPath}`);
+        const outputBase = request.outputBasePath
+            ? path.resolve(request.outputBasePath)
+            : path.join(resolvedFolderPath, '_notemd_batch_output');
+        await fs.promises.mkdir(outputBase, { recursive: true });
+        reporter.report({ type: 'status', message: `Scanning ${resolvedFolderPath} for matching files...`, percent: 0, operationId: 'batch-workflow' });
+        // Collect matching files
+        let files = await this.collectTextFiles(resolvedFolderPath);
+        // Apply extension filter
+        if (request.fileExtensions && request.fileExtensions.length > 0) {
+            const exts = new Set(request.fileExtensions.map(e => e.toLowerCase()));
+            files = files.filter(f => exts.has(path.extname(f).toLowerCase()));
+        }
+        // Apply regex pattern filter
+        if (request.filePattern) {
+            try {
+                const regex = new RegExp(request.filePattern, 'i');
+                files = files.filter(f => regex.test(path.basename(f)));
+            }
+            catch {
+                throw new types_1.ValidationError(`Invalid regex pattern: ${request.filePattern}`);
+            }
+        }
+        // Limit files
+        if (request.maxFiles && request.maxFiles > 0) {
+            files = files.slice(0, request.maxFiles);
+        }
+        const totalFiles = files.length;
+        reporter.report({ type: 'status', message: `Found ${totalFiles} matching files. Starting batch workflow...`, percent: 5, operationId: 'batch-workflow' });
+        const results = [];
+        const errors = [];
+        for (let i = 0; i < files.length; i++) {
+            if (signal?.aborted)
+                break;
+            const filePath = files[i];
+            const fileBaseName = path.basename(filePath, path.extname(filePath));
+            const baseProgress = 5 + Math.floor((i / files.length) * 90);
+            reporter.report({
+                type: 'status',
+                message: `[${i + 1}/${totalFiles}] Processing ${path.basename(filePath)}...`,
+                percent: baseProgress,
+                operationId: 'batch-workflow'
+            });
+            try {
+                const fileOutputFolder = path.join(outputBase, fileBaseName);
+                const result = await this.runWorkflow({
+                    filePath,
+                    outputFolderPath: fileOutputFolder,
+                    language: request.language,
+                    skipGenerate: request.skipGenerate,
+                    skipMermaidFix: request.skipMermaidFix,
+                }, settings, reporter, signal);
+                results.push(result);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                errors.push({ filePath, error: msg });
+                reporter.report({ type: 'error', message: `Failed ${path.basename(filePath)}: ${msg}`, percent: baseProgress, operationId: 'batch-workflow' });
+            }
+        }
+        reporter.report({ type: 'done', message: `Batch workflow complete: ${results.length}/${totalFiles} files processed`, percent: 100, operationId: 'batch-workflow' });
+        return {
+            folderPath: resolvedFolderPath,
+            outputBasePath: outputBase,
+            filter: { pattern: request.filePattern, extensions: request.fileExtensions },
+            totalFiles,
+            completedFiles: results.length,
+            failedFiles: errors.length,
+            results,
+            errors,
+            totalElapsedMs: Date.now() - startedAt,
+        };
+    }
+    // Backward-compatible wrapper — uses knowledge-base-root-relative output path
+    async oneClickExtract(filePath, settings, reporter = defaultReporter(), signal) {
+        const resolvedPath = path.resolve(String(filePath || '').trim());
+        const kbRoot = this.resolveKnowledgeBaseRootForFile(resolvedPath);
+        const outputFolderPath = path.join(kbRoot, path.basename(resolvedPath, path.extname(resolvedPath)));
+        const result = await this.runWorkflow({
+            filePath: resolvedPath,
+            outputFolderPath,
+        }, settings, reporter, signal);
+        const findStage = (name) => [...result.stages].reverse().find(s => s.stage === name);
+        const conceptsStage = findStage('extract-concepts');
+        const concepts = (conceptsStage?.status === 'completed' && conceptsStage?.details?.concepts)
+            ? conceptsStage.details.concepts
+            : [];
+        const genStage = findStage('generate-titles');
+        const genDetails = (genStage?.details || {});
+        const mermaidStage = findStage('mermaid-fix');
+        const mermaidDetails = (mermaidStage?.details || {});
+        return {
+            sourceFilePath: resolvedPath,
+            outputFolderPath: result.outputFolderPath,
             concepts,
-            generated,
-            mermaid,
+            generated: {
+                totalFiles: genDetails.totalFiles || 0,
+                generatedFiles: genDetails.generatedFiles || 0,
+                failedFiles: genDetails.failedFiles || 0,
+                outputs: genDetails.outputs || [],
+            },
+            mermaid: {
+                folderPath: result.outputFolderPath,
+                totalFiles: mermaidDetails.totalFiles || 0,
+                fixedFiles: mermaidDetails.fixedFiles || 0,
+                results: mermaidDetails.results || [],
+            },
+        };
+    }
+    // ── Diagram generation (obsidian-notemd v1.8.4) ──
+    async generateDiagram(request, settings, llmInvoker) {
+        const content = String(request.content || '').trim();
+        if (!content)
+            throw new types_1.ValidationError('Missing content for diagram generation.');
+        const intent = (request.intent || 'mermaid');
+        const compatMode = (request.compatibilityMode ?? settings.experimentalDiagramCompatibilityMode ?? 'legacy-mermaid');
+        const errors = [];
+        if (llmInvoker) {
+            try {
+                const result = await (0, diagramGenerationService_1.generateDiagramArtifact)(content, {
+                    compatibilityMode: compatMode,
+                    requestedIntent: intent,
+                    targetLanguage: undefined,
+                    llmInvoker
+                });
+                return {
+                    diagramType: result.spec.intent,
+                    spec: JSON.stringify(result.spec, null, 2),
+                    mermaidCode: result.mermaidContent,
+                    renderErrors: result.renderError ? [result.renderError] : [],
+                    intent: result.spec.intent,
+                    generatedAt: new Date().toISOString(),
+                };
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        // Fallback: basic Mermaid fix without LLM
+        const fixed = this.mermaidProcessor.fixInMarkdown(content);
+        return {
+            diagramType: intent,
+            spec: content,
+            mermaidCode: fixed.changed ? fixed.content : content,
+            renderErrors: fixed.changed ? ['Auto-fixed Mermaid syntax errors detected.', ...errors] : errors,
+            intent,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    async previewDiagram(request, _settings) {
+        const content = String(request.content || '').trim();
+        if (!content)
+            throw new types_1.ValidationError('Missing content for diagram preview.');
+        const fmt = request.format || 'png';
+        const fixed = this.mermaidProcessor.fixInMarkdown(content);
+        const errors = fixed.changed ? ['Mermaid syntax was auto-fixed in preview.'] : [];
+        return {
+            format: fmt,
+            dataUrl: '',
+            errors,
+        };
+    }
+    async exportDiagram(request, _settings) {
+        const content = String(request.content || '').trim();
+        if (!content)
+            throw new types_1.ValidationError('Missing content for diagram export.');
+        const outputPath = request.outputPath || '';
+        return {
+            outputPath,
+            format: request.format || 'png',
+            size: Buffer.byteLength(content, 'utf8'),
+        };
+    }
+    // ── Search (obsidian-notemd v1.8.4) ──
+    async search(request, settings) {
+        const query = String(request.query || '').trim();
+        if (!query) {
+            throw new types_1.ValidationError('Missing query for search.');
+        }
+        const provider = SearchManager_1.SearchManager.getProvider(request.provider || settings.searchProvider || 'duckduckgo');
+        let apiKey;
+        if (provider.name === 'tavily') {
+            apiKey = settings.tavilyApiKey;
+            if (!apiKey)
+                throw new types_1.ValidationError('Tavily API key is required in settings.');
+        }
+        const results = await provider.search({
+            query,
+            maxResults: request.maxResults ?? settings.tavilyMaxResults ?? 5,
+            searchDepth: request.searchDepth ?? settings.tavilySearchDepth ?? 'basic'
+        }, apiKey, settings.ddgFetchTimeout ?? 10000);
+        return {
+            query,
+            provider: provider.name,
+            results,
+            totalResults: results.length,
+            searchedAt: new Date().toISOString(),
+        };
+    }
+    // ── LLM diagnostics (obsidian-notemd v1.8.4) ──
+    async diagnoseLlmProvider(request, settings, llmCallImpl) {
+        const providerName = request.provider || settings.activeProvider || 'unknown';
+        const modelName = request.model || settings.providers.find(p => p.name === providerName)?.model || 'unknown';
+        const provider = settings.providers.find(p => p.name === providerName);
+        if (!provider)
+            throw new types_1.ValidationError(`Provider not found: ${providerName}`);
+        if (!llmCallImpl)
+            throw new types_1.ValidationError('LLM call implementation required for diagnostics.');
+        const startMs = Date.now();
+        try {
+            const { buildDefaultProviderDiagnosticPayload } = await Promise.resolve().then(() => __importStar(require('./providerDiagnostics')));
+            const payload = buildDefaultProviderDiagnosticPayload(providerName);
+            await llmCallImpl(provider, payload.prompt, payload.content, { ...settings, enableApiErrorDebugMode: true, enableStableApiCall: true });
+            return { provider: providerName, model: modelName, status: 'ok', latencyMs: Date.now() - startMs };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { provider: providerName, model: modelName, status: 'error', latencyMs: Date.now() - startMs, error: msg };
+        }
+    }
+    async testLlmConnection(request, settings) {
+        const requestedProvider = request && typeof request.provider === 'object'
+            ? request.provider
+            : null;
+        const requestedProviderName = String((request && typeof request.providerName === 'string' ? request.providerName : '') ||
+            (requestedProvider && typeof requestedProvider.name === 'string' ? requestedProvider.name : '') ||
+            settings.activeProvider ||
+            '').trim();
+        const persistedProvider = settings.providers.find((provider) => provider.name === requestedProviderName);
+        if (!persistedProvider && !requestedProvider) {
+            throw new types_1.ValidationError(`Provider not found: ${requestedProviderName || settings.activeProvider}`);
+        }
+        const resolvedProviderName = String((persistedProvider && persistedProvider.name) ||
+            requestedProviderName ||
+            settings.activeProvider).trim();
+        const provider = {
+            ...(persistedProvider || {
+                name: resolvedProviderName,
+                apiKey: '',
+                baseUrl: '',
+                model: '',
+                temperature: 0.5,
+                enabled: true,
+            }),
+            ...(requestedProvider ? {
+                name: resolvedProviderName,
+                apiKey: String(requestedProvider.apiKey || '').trim(),
+                baseUrl: String(requestedProvider.baseUrl || '').trim(),
+                model: String(requestedProvider.model || '').trim(),
+                temperature: Number.isFinite(Number(requestedProvider.temperature))
+                    ? Number(requestedProvider.temperature)
+                    : Number((persistedProvider && persistedProvider.temperature) || 0.5),
+                apiVersion: String(requestedProvider.apiVersion || '').trim(),
+            } : {}),
+        };
+        const result = await this.llmProviderClient.testConnection(provider);
+        return {
+            success: result.success,
+            message: result.message,
+            provider: provider.name,
+            model: provider.model,
         };
     }
+    // ── Extract original text (obsidian-notemd v1.8.4) ──
+    async extractOriginalText(request, _settings, _reporter = defaultReporter(), _signal) {
+        const resolvedPath = path.resolve(String(request.filePath || '').trim());
+        if (!resolvedPath)
+            throw new types_1.ValidationError('Missing filePath.');
+        const source = await fs.promises.readFile(resolvedPath, 'utf8');
+        const mergedMode = request.mergedMode ?? false;
+        const outputPath = request.outputPath || resolvedPath.replace(/\.md$/, '_original.md');
+        const replacedSuffixPath = resolvedPath.replace(/\.md$/, `${request.outputPath ? '' : '_original'}.md`);
+        const targetPath = outputPath || replacedSuffixPath;
+        if (targetPath !== resolvedPath) {
+            await fs.promises.writeFile(targetPath, source, 'utf8');
+        }
+        return {
+            filePath: resolvedPath,
+            outputPath: targetPath,
+            originalText: mergedMode ? source.replace(/\n/g, ' ').replace(/\[\[([^\]]+)\]\]/g, '$1') : source,
+            changed: targetPath !== resolvedPath,
+        };
+    }
+    getBatchProgress(operationId) {
+        if (operationId && this.batchOperations.has(operationId)) {
+            return this.batchOperations.get(operationId);
+        }
+        return {
+            operationId: operationId || '',
+            status: 'completed',
+            totalItems: 0,
+            completedItems: 0,
+            failedItems: 0,
+            logs: [],
+            percent: 100,
+            startedAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    startBatchOperation(operationId, totalItems) {
+        const progress = {
+            operationId,
+            status: 'running',
+            totalItems,
+            completedItems: 0,
+            failedItems: 0,
+            logs: [],
+            percent: 0,
+            startedAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        this.batchOperations.set(operationId, progress);
+        return progress;
+    }
+    updateBatchOperation(operationId, update) {
+        const existing = this.batchOperations.get(operationId);
+        if (!existing)
+            return undefined;
+        const updated = { ...existing, ...update, updatedAt: new Date().toISOString() };
+        if (updated.failedItems > 0 && updated.status === 'running') {
+            updated.status = 'error';
+        }
+        this.batchOperations.set(operationId, updated);
+        return updated;
+    }
     async scaffoldConceptFiles(outputFolderPath, concepts) {
         for (const concept of concepts) {
             const safeName = concept.replace(/[\\/:*?"<>|]/g, '').trim();

package/dist/src/notemd/PromptManager.js

@@ -33,6 +33,21 @@ const DEFAULT_PROMPTS = {
         'Do not paraphrase.',
         'If none found, output: No match found in reference.',
     ].join('\n'),
+    extractOriginalTextMerged: [
+        'For each user query, extract exact matching passages from reference content.',
+        'Combine matching passages into a single merged response.',
+        'Do not paraphrase. If none found, output: No match found in reference.',
+    ].join('\n'),
+    searchResearch: [
+        'Research the given topic using web search results.',
+        'Summarize findings in structured markdown with citations.',
+        'Include key facts, different perspectives, and references.',
+    ].join('\n'),
+    ragSufficiencyJudge: [
+        'Review whether the supplied RAG context is sufficient to answer the user query.',
+        'Use only the supplied context and do not write the final answer.',
+        'Return exactly one JSON object with status, score, reasons, and degradationState.',
+    ].join('\n'),
 };
 exports.DEFAULT_PROMPTS = DEFAULT_PROMPTS;
 function safeReplace(template, replacements) {