Import dropped PDFs as converted documents

Allow users to add PDFs without selecting a Markdown note, so external
documents become standalone searchable notes rather than being forced
into an existing editor.

Preserve selected-note embedding for the existing workflow. Link each
generated Markdown file to its original PDF, then refresh the note list
after conversion so progress and completed documents are visible.

Author: mzagozda

README.md

@@ -403,7 +403,9 @@ the newest first, and invokes DOC2MD once per document. A source is converted
 only when the sibling path produced by replacing its extension with `.md` does
 not already exist. The plugin never passes DOC2MD's `--overwrite` option, so an
 existing Markdown counterpart is not changed. A failure affects only that
-document; successful outputs from the same scan are preserved.
+document; successful outputs from the same scan are preserved. Generated
+Markdown from a PDF ends with an Obsidian embed of that original PDF, keeping
+the extracted text and source document connected.
 
 The generated `settings.json` uses recursive conversion, local PDF processing,
 and `eng+pol` OCR by default. Deactivate the plugin before editing that file,

src/NoteManager.Core/Plugins/INoteManagerPlugin.cs

@@ -11,6 +11,15 @@ Task StartAsync(
     Task StopAsync(CancellationToken cancellationToken = default);
 }
 
+/// <summary>
+/// Lets the desktop request an immediate conversion after it imports a document.
+/// </summary>
+public interface IDocumentConversionTrigger
+{
+    Task ConvertPendingDocumentsAsync(
+        CancellationToken cancellationToken = default);
+}
+
 public sealed record PluginMetadata(
     string Id,
     string Name,

src/NoteManager.Core/ViewModels/MainViewModel.cs

@@ -613,6 +613,69 @@ public bool CanImportPdfIntoNote(NoteItem? note)
            && IsFolderMode
            && IsMarkdownPathInCurrentFolder(note.SourceFilePath);
 
+    public bool CanImportPdfDocuments
+        => IsFolderMode && !string.IsNullOrWhiteSpace(CurrentFolderPath);
+
+    public async Task<ImportedPdf[]> ImportPdfDocumentsAsync(
+        IReadOnlyList<string> sourcePaths)
+    {
+        ArgumentNullException.ThrowIfNull(sourcePaths);
+
+        var pdfPaths = sourcePaths
+            .Where(path => File.Exists(path)
+                           && Path.GetExtension(path).Equals(
+                               ".pdf",
+                               StringComparison.OrdinalIgnoreCase))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        if (pdfPaths.Length == 0)
+        {
+            SetStatus("Select one or more PDF files to import as documents");
+            return [];
+        }
+
+        if (!CanImportPdfDocuments)
+        {
+            SetStatus("Open a Markdown folder before importing PDF documents");
+            return [];
+        }
+
+        var folderPath = CurrentFolderPath;
+        var folderGeneration = _folderGeneration;
+        SetStatus(
+            pdfPaths.Length == 1
+                ? $"Importing {Path.GetFileName(pdfPaths[0])} for conversion…"
+                : $"Importing {pdfPaths.Length:N0} PDF documents for conversion…");
+
+        try
+        {
+            // Do not create a Markdown embed here: the converter owns the new document's Markdown counterpart.
+            var importedPdfs = await Task.Run(
+                () => ImportPdfFiles(pdfPaths, folderPath, markdownFilePath: null));
+            if (folderGeneration != _folderGeneration)
+            {
+                DeleteCopiedImports(importedPdfs);
+                return [];
+            }
+
+            var copiedCount = importedPdfs.Count(pdf => pdf.WasCopied);
+            SetStatus(
+                copiedCount == 0
+                    ? $"Imported {importedPdfs.Length:N0} PDF document(s) for conversion"
+                    : $"Imported {importedPdfs.Length:N0} PDF document(s); {copiedCount:N0} copied to the folder root");
+            return importedPdfs;
+        }
+        catch (Exception exception) when (
+            exception is IOException
+            or UnauthorizedAccessException
+            or ArgumentException
+            or NotSupportedException)
+        {
+            SetStatus($"Could not import the PDF document: {exception.Message}");
+            return [];
+        }
+    }
+
     public async Task ImportPdfFilesAsync(
         NoteItem targetNote,
         IReadOnlyList<string> sourcePaths,
@@ -705,7 +768,7 @@ or ArgumentException
     private static ImportedPdf[] ImportPdfFiles(
         IEnumerable<string> sourcePaths,
         string folderPath,
-        string markdownFilePath)
+        string? markdownFilePath)
     {
         var importedPdfs = new List<ImportedPdf>();
         try

src/NoteManager.Desktop/MainWindow.axaml

@@ -22,8 +22,10 @@
                   Command="{Binding NewNoteCommand}" />
         <MenuItem Header="_Open folder…"
                   Click="OpenFolder_OnClick" />
-        <MenuItem Header="_Import PDF…"
+        <MenuItem Header="_Import PDF into note…"
                   Click="ImportPdf_OnClick" />
+        <MenuItem Header="Import PDF _documents…"
+                  Click="ImportPdfDocuments_OnClick" />
         <Separator />
         <MenuItem Header="E_xit"
                   Click="Exit_OnClick" />

src/NoteManager.Desktop/MainWindow.axaml.cs

@@ -278,30 +278,58 @@ private async Task RequireFolderSelectionAsync()
 
     private async void ImportPdf_OnClick(object? sender, RoutedEventArgs e)
     {
-        if (_storagePickerOpen)
+        var note = ViewModel.SelectedNote;
+        if (note is null || !ViewModel.CanImportPdfIntoNote(note))
         {
+            ViewModel.StatusText = "Select a Markdown note before importing a PDF";
             return;
         }
 
-        var note = ViewModel.SelectedNote;
-        if (note is null || !ViewModel.CanImportPdfIntoNote(note))
+        var paths = await PickPdfPathsAsync("Import PDF into note");
+
+        if (paths.Length > 0)
         {
-            ViewModel.StatusText = "Select a Markdown note before importing a PDF";
+            await ViewModel.ImportPdfFilesAsync(
+                note,
+                paths,
+                MarkdownEditor.CaretIndex);
+        }
+    }
+
+    private async void ImportPdfDocuments_OnClick(object? sender, RoutedEventArgs e)
+    {
+        if (!ViewModel.CanImportPdfDocuments)
+        {
+            ViewModel.StatusText = "Open a Markdown folder before importing PDF documents";
             return;
         }
 
-        string[] paths;
+        var paths = await PickPdfPathsAsync("Import PDF documents");
+        if (paths.Length > 0)
+        {
+            // This command deliberately creates converted notes instead of modifying the selected editor.
+            await ImportPdfDocumentsAsync(paths);
+        }
+    }
+
+    private async Task<string[]> PickPdfPathsAsync(string title)
+    {
+        if (_storagePickerOpen)
+        {
+            return [];
+        }
+
         _storagePickerOpen = true;
         try
         {
             var results = await StorageProvider.OpenFilePickerAsync(
                 new FilePickerOpenOptions
                 {
-                    Title = "Import PDF",
+                    Title = title,
                     AllowMultiple = true,
                     FileTypeFilter = [PdfFileType]
                 });
-            paths = results
+            return results
                 .Select(file => file.TryGetLocalPath())
                 .Where(path => !string.IsNullOrWhiteSpace(path))
                 .Cast<string>()
@@ -311,14 +339,30 @@ private async void ImportPdf_OnClick(object? sender, RoutedEventArgs e)
         {
             _storagePickerOpen = false;
         }
+    }
 
-        if (paths.Length > 0)
+    private async Task ImportPdfDocumentsAsync(IReadOnlyList<string> paths)
+    {
+        var importedPdfs = await ViewModel.ImportPdfDocumentsAsync(paths);
+        if (importedPdfs.Length == 0)
         {
-            await ViewModel.ImportPdfFilesAsync(
-                note,
-                paths,
-                MarkdownEditor.CaretIndex);
+            return;
         }
+
+        if (!await _pluginManager.TriggerDocumentConversionAsync())
+        {
+            ViewModel.StatusText =
+                "PDF documents were imported. Activate Document Conversion to create their Markdown notes.";
+            return;
+        }
+
+        var convertedPath = importedPdfs
+            .Select(pdf => Path.ChangeExtension(pdf.DestinationPath, ".md"))
+            .FirstOrDefault(File.Exists);
+        // Reload only after the plugin returns so the note list and search index include completed outputs.
+        await ViewModel.LoadMarkdownFolderAsync(
+            ViewModel.CurrentFolderPath,
+            convertedPath);
     }
 
     private void MainWindow_OnDragOver(object? sender, DragEventArgs e)
@@ -330,7 +374,8 @@ private void MainWindow_OnDragOver(object? sender, DragEventArgs e)
                              ".pdf",
                              StringComparison.OrdinalIgnoreCase)) == true;
         e.DragEffects = hasPdf
-                        && ViewModel.CanImportPdfIntoNote(ViewModel.SelectedNote)
+                        && (ViewModel.CanImportPdfIntoNote(ViewModel.SelectedNote)
+                            || ViewModel.CanImportPdfDocuments)
             ? DragDropEffects.Copy
             : DragDropEffects.None;
     }
@@ -347,20 +392,24 @@ private async void MainWindow_OnDrop(object? sender, DragEventArgs e)
             .Cast<string>()
             .Distinct(StringComparer.OrdinalIgnoreCase)
             .ToArray() ?? [];
-        if (note is null
-            || paths.Length == 0
-            || !ViewModel.CanImportPdfIntoNote(note))
+        if (paths.Length == 0)
         {
-            ViewModel.StatusText =
-                "Drop PDF files while a Markdown note is selected";
+            ViewModel.StatusText = "Drop one or more PDF files into NoteManager";
             return;
         }
 
         e.Handled = true;
-        await ViewModel.ImportPdfFilesAsync(
-            note,
-            paths,
-            MarkdownEditor.CaretIndex);
+        if (ViewModel.CanImportPdfIntoNote(note))
+        {
+            await ViewModel.ImportPdfFilesAsync(
+                note!,
+                paths,
+                MarkdownEditor.CaretIndex);
+            return;
+        }
+
+        // With no selected Markdown editor, a window drop imports documents for conversion.
+        await ImportPdfDocumentsAsync(paths);
     }
 
     private async void Tags_OnClick(object? sender, RoutedEventArgs e)

src/NoteManager.Desktop/Services/PluginManager.cs

@@ -212,6 +212,32 @@ public async Task StopAllAsync(CancellationToken cancellationToken = default)
         }
     }
 
+    public async Task<bool> TriggerDocumentConversionAsync(
+        CancellationToken cancellationToken = default)
+    {
+        await _lifecycleLock.WaitAsync(cancellationToken);
+        try
+        {
+            var converter = Plugins
+                .Where(plugin => plugin.IsRunning)
+                .Select(plugin => plugin.DiscoveredPlugin.Instance)
+                .OfType<IDocumentConversionTrigger>()
+                .FirstOrDefault();
+            if (converter is null)
+            {
+                return false;
+            }
+
+            // Reuse the active plugin so imports retain the configured converter and its status reporting.
+            await converter.ConvertPendingDocumentsAsync(cancellationToken);
+            return true;
+        }
+        finally
+        {
+            _lifecycleLock.Release();
+        }
+    }
+
     private async Task StartEntryAsync(
         PluginListItemViewModel entry,
         CancellationToken cancellationToken)