Notely implements a local-first, offline-ready 13-domain AI architecture designed for privacy, low latency, multi-tool evidence orchestration, zero-latency context compaction, and deterministic grounding. Markdown notes remain the single source of truth, parsed and indexed into offline-first SQLite databases.
All 13 sub-domains expose a mandatory single entry point facade (index.js). No external module or Electron handler is permitted to import private internal files of another module. All query executions are coordinated by the master orchestrator AIFlow.js through a 5-stage pipeline with structured telemetry logging to LogDB (FlowTracker) and zero-latency Context Compaction (ai/compaction/).
Dynamically matches query terms against registered tool metadata in ApplicationToolRegistry.
Classifies intents such as workspace_task_summary (confidence >0.80), explore_knowledge_graph, reconstruct_project_timeline, and fetch_external_web_data.
Graph Traversal (explore_topic_graph, only when requested)
Empty Retrieval Handling: If get_tasks() returns empty, executes markdown task syntax parsing and recent workspace activity. If still empty, returns "No tasks found in your workspace." without fabricating unrelated notes or running graph search.
Relevance Filtering: Rejects evidence items with similarity score < 0.25.
Notely treats Markdown (.md) files as the single source of truth for both system prompts and personas:
Markdown Storage: Builtin personas reside in resources/prompts/personas/*.md and custom user personas reside in appData/personas/*.md.
Frontmatter & Body: Personas use YAML frontmatter for metadata (id, name, tone, verbosity, responseStructure) and Markdown body for role definitions & instructions.
SQLite Indexing: SQLite (personas.db) acts purely as a fast metadata index registry (without redundant prompt body columns). Frontmatter metadata and prompt body are hydrated dynamically from .md files at runtime.
Automatic Migration: Persona DB migrations automatically drop obsolete string columns (ALTER TABLE personas DROP COLUMN prompt) during startup.
Clean Evidence Truncation: Evidence payloads are capped at 4,000 characters with newline-aware truncation (lastIndexOf('\\n')) to avoid slicing words mid-sentence.
Evidence Sanitation: Tool execution errors, missing capability messages, and duplicate error strings are stripped prior to prompt injection.
Note-Scoped: While editing a note, toggle the assistant from the right side edge or the toolbar to brainstorm inside the active document.
Global Chat: While on the landing page (with no note open), click the Sparkles icon under the Quick Actions toolbar on the left panel rail. This opens the AI sidebar to chat about the entire workspace.
Whenever the assistant retrieves documents to answer your question, a Referred Notes chip list is rendered under the assistant message bubble. Hover over these chips to see file paths and relevance match percentages.
Highlight target text selection in the Markdown editor.
Press Ctrl + Space or right-click and select AI Actions.
Choose an action from the palette (e.g. Summarize, Change Tone, Improve Readability).
3. Persona Customization & Markdown Source of Truth
Customize how the AI talks to you:
Open AI Settings and click Manage Personas.
Markdown Source of Truth: All personas (builtin and custom) are authored as Markdown files (.md) with YAML frontmatter. Custom personas created in the UI are persisted as formatted .md files to disk (appData/personas/*.md), while SQLite acts strictly as an index.
Select or edit custom personas, modify frontmatter metadata (tone, verbosity, structure), and update prompt instructions.
Select a preset emoji avatar (🤖, 💻, 🧠, etc.) next to the custom avatar field to represent them in the chat panel.
Notely features a 13-domain modular, local-first AI platform designed around private data control. Markdown files remain the absolute source of truth, parsed and indexed into offline-first databases to fuel assistant reasoning.
Notely features an offline, local-first, AI-powered 8-Stage Knowledge Graph Generation Engine. It operates without any cloud dependencies, transforming raw Markdown notes, image annotations, and workspace metadata into an interconnected Property Graph using local FP16 ONNX neural models, SQLite vector storage, deterministic domain pattern mining, and hybrid GraphRAG retrieval.
The system uses an 8-stage pipeline separating document structure parsing from model-agnostic neural semantic extraction, vector embedding deduplication, and evidence fusion.
Role: Extracts structural AST entities (Note, Section, Tag, Media, CodeBlock, Task, Formula, ExternalURL, Document). Strips HTML attributes ({data-*="..."}), markdown tables (| ... |), image tags, key-value metadata lines, and frontmatter metadata to produce clean natural prose text for neural extraction.
Stage 2: Linguistic Noun-Phrase & Prose Isolator
Component:MarkdownASTParser.cleanse()
Role: Produces cleansedContent — stripped natural language prose from which all markdown structure, code syntax, and editor artifacts have been removed. This cleansed text is the sole input to both Stages 3 and 4, preventing structural tokens from corrupting neural inference or pattern matching.
Role: Mines pattern-based technical domain relationships (USES, DEPENDS_ON, GENERATES, INTEGRATES_WITH, IMPLEMENTS, ENABLES, WORKS_ON) directly from prose sentences with $0.88 - 0.92$ baseline confidence. Also performs cross-note plain text mention mining (confidence 0.85) against a live note name index (refreshed every 30s). Results are fused via EvidenceFusionEngine.fuseTriple().
Knowledge graph data is stored locally in .notes-app/ai-graph.db using native SQLite (node:sqlite) with Write-Ahead Logging (PRAGMA journal_mode = WAL;).
Every AI relationship links to an evidence record preserving exact source offsets, raw sentence text, extractor identity, and confidence score. Evidence records are content-addressed (SHA-256 hash key) and linked to relationships via the relationship_evidence junction table.
Label Propagation Clustering (CommunityDetector.js): Groups graph nodes into dense semantic communities using fast label propagation clustering. community_id is stored on each entity row.
Self-Healing Background Maintenance (GraphMaintenance.js): Runs automatically when GraphWorker queue drains:
Vector embeddings enable Semantic Search and Context Retrieval:
Local BGE Model (Recommended): Runs entirely offline inside your app. Downloads a lightweight BGE-small-en-v1.5 ONNX model (~130MB) into %AppData%/notely/ai-model/ and runs vector calculations locally via onnxruntime-node.
HuggingFace API: Runs cloud-based embeddings using an API key token.
Relationship extraction and entity graph generation:
GLiNER2-Relex ONNX (Always Local): The Knowledge Graph uses a dedicated gliner2-multi-v1-onnx model running locally via ONNX Runtime. This is separate from your text generation provider — it runs entirely offline with no API key required and is not user-configurable.
Model Location: Downloaded automatically to %AppData%/notely/models/gliner2-relex/ on first graph build.
Confidence Threshold: Adjustable in AI Settings (graphConfidence, default 0.45–0.60). Higher values produce fewer but more precise relationships.
${ssrInterpolate(((_c = unref(theme2).notFound) == null ? void 0 : _c.quote) ?? "But if you don't change your direction, and if you keep looking, you may end up where you are heading.")}
Notely is an offline-first, local-first markdown note-taking and knowledge management application built using Electron, React, CodeMirror 6, and Node.js.
Notely separates execution between a sandboxed Renderer Process (React UI) and a privileged Main Process (Node.js backend) communicating via secure IPC channels.
App Shell (App.jsx): Manages primary navigation, view routing, full-screen page overlays (KnowledgeGraph, EmbeddingsPage, AppLogsPage, AIPersonasManager, AIHealthPage, GitVC), and footer status bar.
Layout Engine (LandingView.jsx, EditorPane.jsx, DocumentDetail.jsx): Responsive split-pane layout supporting Edit mode, Preview mode, and Live Split View.
Editor Core (CodeMirrorEditor.jsx, MarkdownEditor.jsx): Built on CodeMirror 6 with custom extensions for syntax highlighting, line numbers, block folding, spell-checking, search/replace, and hotkeys.
Preview Renderer (MarkdownPreview.jsx): Full GitHub-Flavored Markdown (GFM) renderer supporting LaTeX equations (katex), task lists, local media resolution, and Wikilink navigation ([[Note]]).
Mermaid.js Integration: Real-time evaluation and SVG rendering of GFM code blocks (\`\`\`mermaid) for flowcharts, sequence diagrams, class diagrams, Gantt charts, and mindmaps across preview mode, split view, and exported documents.
Excalidraw Drawing Editor: Embedded interactive whiteboard component allowing users to sketch visual diagrams, hand-drawn wireframes, and architectural schematics. Drawings are persisted as human-readable .excalidraw JSON files or embedded SVG graphics inside workspace notes.
Security: AES-256 encrypted bundle (not readable by generic ZIP tools). Each file is SHA-256 hashed and verified on import to reject tampered packages. Optional password protection stores a salted SHA-256 signature in the manifest.
Import: Decrypts and verifies bundle integrity, resolves asset path conflicts, and places all files into the active workspace. See Export & Import Reference for full user-facing documentation.
E. AI & Context Engine Subsystem (aiService.cjs)
Vector Embeddings Engine (EmbeddingDB.js): Stores 384-dimensional BGE-small vector chunks in {workspace}/.notes-app/ai-embeddings.db. Features physical vector dimension validation (verifyModelDimensions) to prevent dimension mismatches.
Knowledge Graph Subsystem (GraphService.js, GraphDB.js): Maps note relations, tags, mentions, Wikilinks, Images, Local Documents, and External URLs in {workspace}/.notes-app/ai-graph.db. Executes relation traversals via SQLite Recursive Common Table Expressions (CTEs).
Agent & Tool Orchestration: Integrates with a local embedding runtime and cloud LLMs (Gemini, Groq, OpenAI) using the Vercel AI SDK.
Local ONNX Neural Models: Vector embeddings (BGE-small-en-v1.5) and Knowledge Graph entity/relationship extraction (gliner2-multi-v1-onnx) run 100% on-device and offline using onnxruntime-node.
Logs are persisted inside the active workspace directory at {workspace}/.notes-app/ai-logs.db:
sql
CREATE TABLE IF NOT EXISTS logs (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ subsystem TEXT NOT NULL,
+ level TEXT DEFAULT 'info',
+ message TEXT NOT NULL,
+ metadata TEXT,
+ timestamp TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_logs_subsystem ON logs(subsystem);
System Logs Console (AppLogsPage.jsx): Accessible via Help -> System & Application Logs. Features live search, subsystem/severity dropdown filters, live auto-refresh toggle, log clearing, and JSON log export.
Subsystem Data Clear Buttons: EmbeddingsPage features a Clear Embeddings Data button (aiClearEmbeddingsData), and KnowledgeGraph features a Clear Knowledge Graph Data button (aiClearGraphData) to clear data caches independently of logs.
Global App Database (%APPDATA%/Notely/app.sqlite): Manages user preferences, API keys, active themes, window dimensions, P2P sync pairs, and recently opened workspaces.
Raw .md Files: Notes are saved as plain-text UTF-8 Markdown files directly in workspace root and subdirectories ({workspace}/**/*.md). Notely imposes zero proprietary database wrapping or lock-in, enabling seamless external editing with Git, VS Code, or Obsidian.
Media/ Assets Folder: A dedicated assets directory located at {workspace}/Media/ created to house user-attached media files:
Images (.png, .jpg, .jpeg, .gif, .svg, .webp).
Video & Audio recordings (.mp4, .webm, .mp3, .wav, .m4a).
Document attachments (.pdf).
Excalidraw drawing files (.excalidraw).
Hidden Subsystem Folder ({workspace}/.notes-app/): Internal SQLite caches for AI, tasks, and system features:
task-db.sqlite: Stores workspace-wide task metadata, priorities, due dates, assignee tags, source note hashes, and line indices for bi-directional checklist synchronization.
ai-embeddings.db: Stores chunk text, line offsets, hashes, and 384-dimensional binary vector BLOBs.
ai-graph.db: Stores extracted Knowledge Graph entity nodes, Wikilinks, media links, and relationship edges.
ai-logs.db: Stores multitenant application, git, embedding, graph, and AI log entries.
app-state.json: Caches workspace UI state, last opened note handles, and view preferences.
Main Process (electron/main.cjs): Handles window lifecycle, file I/O, IPC handler registration, menu creation, and system integrations.
Background Utility Process (workerManager.cjs / workerProcess.cjs): Spawns an isolated Node.js UtilityProcess for asynchronous vector embedding generation and Knowledge Graph indexing. This keeps background indexing CPU spikes off the main thread.
Payload Schema Validation (ipcSchemas.cjs): Validate raw payloads against strict schema contracts (validatePayload) to ensure type safety before processing file paths or commands.
Notely uses Vitest for comprehensive unit, integration, and IPC service testing:
bash
# Run all unit and integration tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run P2P network integration test harness
+npm run test:p2p
This audit is a point-in-time snapshot of repository and implementation alignment on 2026-07-03.
Some findings in this report may have been addressed by subsequent documentation and shortcut updates after the audit was written.
Audited surfaces:
README.md
docs/
in-app Help Center and Keyboard Shortcuts modal
settings and microcopy surfaces in the renderer
Electron menu structure and accelerators
developer-facing docs present in the repository
Method:
Code-first verification. No documentation statement was accepted without tracing it to the implementation.
Sources of truth used for feature existence and naming were Electron menu actions, renderer action handlers, preload APIs, settings UI, and user-facing components.
Limitations:
No repository screenshots were present in the audited documentation set, so screenshot accuracy could not be validated.
This audit covers repository and in-app documentation only. It does not cover any external website, app store listing, or internal release portal.
Notely has a broad documentation set, but it is no longer internally consistent with the implementation. The docs cover many major features, yet several labels, shortcuts, settings descriptions, and help surfaces are stale or incomplete. The most serious problem is that keyboard guidance is split across multiple sources and does not match the implemented shortcut map. The second major problem is terminology drift: documentation still refers to "Notes Folder" and "Help -> Documentation" while the application exposes "Open Workspace" and "Help Center".
Overall documentation quality: 5.8/10
Estimated completeness: 72%
Estimated correctness: 54%
Highest-priority issues before end-user release:
Replace the hardcoded keyboard guide with an implementation-backed shortcut source and resolve conflicting bindings.
Update all user docs from "Notes Folder" and "Help -> Documentation" to the actual UI labels.
Document currently implemented but undocumented product surfaces: terminal, workspace activity, recent workspaces, favorites/dashboard, reference-note shortcuts, and several settings.
Add missing release notes/changelog and FAQ surfaces.
Correct stale AI and storage details in README and developer docs.
User docs and README discuss a notes root / notes folder model, but the actual user-facing menu label is Open Workspace.
In-app help is exposed as Help Center, not Help -> Documentation.
Installation guidance is incomplete for end users.
No supported-OS matrix.
No end-user install instructions.
No prerequisites section.
No environment setup section for AI, signing, or terminal hardening beyond scattered later sections.
AI provider and model documentation is stale.
README lists HuggingFace as an end-user provider concept, but the visible text-provider UI exposes Gemini and Groq while OpenAI and Local LLM are marked unavailable/coming soon.
README model lists do not match the current AISettings provider arrays.
Storage details are partly stale.
README says .notes-app/settings.json stores workspace-level settings, but the implementation uses .notes-app/app-state.json and .notes-app/app.sqlite for metadata storage.
Several implemented features are missing from README.
AI advanced generation controls: max tokens and temperature
AI feature toggles: pattern learning, embeddings, relationship discovery
Documentation quality of settings descriptions: insufficient. The code exposes the controls, but the docs do not explain defaults, impact, or recommended usage for most of them.
Notely provides a rich experience for working with code inside Markdown notes: automatic language detection, one-click formatting with Prettier, and a dedicated full-screen code editor.
You can run code snippets directly from your notes:
Hover over a code block in Preview mode.
If the block is written in a supported language, the ▶ Run button in the hover toolbar will be active.
Supported execution languages include:
JavaScript (js, javascript): runs locally via node.
Python (py, python): runs locally via system python / python3.
Bash (sh, bash): runs shell scripts locally via bash or sh.
PowerShell (ps1, powershell): runs scripts via powershell or pwsh.
HTML (html): renders live HTML DOM output inside an interactive preview drawer.
Click ▶ Run to execute the script or preview output.
Command outputs (stdout/stderr) are displayed in a collapsible, high-contrast dark terminal output frame beneath the code block.
You can also execute code from inside the Dedicated Code Editor modal using the Execute button in the top toolbar.
Security Note
Running code execution spawns a local process on your machine using your local system environment. Only run code from trusted workspaces and sources.
Execution Limits & Loops
Code execution terminates automatically after 10 seconds. If your code hangs or enters an infinite loop, the runner will kill the subprocess safely and report a timeout error. Buffer sizes are capped at 64KB.
Every code block in Preview mode has a Copy button in the top-right corner. Click it to copy the code contents without the backtick fences.
Language Tags are Important
Always specify a language tag for better highlighting and to ensure the auto-formatter chooses the right rules. Example: \`\`\`typescript instead of \`\`\`.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("editor/code-blocks.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const codeBlocks = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ codeBlocks as default
+};
diff --git a/docs-site/.vitepress/.temp/editor_diagrams.md.js b/docs-site/.vitepress/.temp/editor_diagrams.md.js
new file mode 100644
index 00000000..d46f767b
--- /dev/null
+++ b/docs-site/.vitepress/.temp/editor_diagrams.md.js
@@ -0,0 +1,40 @@
+import { resolveComponent, useSSRContext } from "vue";
+import { ssrRenderAttrs, ssrRenderStyle, ssrRenderSuspense, ssrRenderComponent } from "vue/server-renderer";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Diagrams","description":"Create flowcharts and visual diagrams in Notely using Mermaid syntax or the Excalidraw visual canvas.","frontmatter":{"title":"Diagrams","description":"Create flowcharts and visual diagrams in Notely using Mermaid syntax or the Excalidraw visual canvas.","keywords":"mermaid, excalidraw, diagrams, flowchart, sequence diagram, gantt, whiteboard, visual editor","category":"Editor"},"headers":[],"relativePath":"editor/diagrams.md","filePath":"editor/diagrams.md","lastUpdated":1786254063000}');
+const _sfc_main = { name: "editor/diagrams.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ const _component_Mermaid = resolveComponent("Mermaid");
+ _push(`
Notely supports three diagram formats: Mermaid for text-based diagrams written in code, Excalidraw for freehand whiteboard-style drawing, and Draw.io for structured technical schemas and system architectures.
If you converted an image to Excalidraw and want to revert to the original:
In Preview mode, right-click the Excalidraw preview.
Select Restore original image.
Restore Availability
The Restore original image option only appears for Excalidraw diagrams that were created from an image conversion. Diagrams created from scratch do not show this option.
Drop any existing .drawio or .drawio.xml file directly into the Markdown Editor. Notely will parse the file, copy it into the workspace media directory, and embed it as an interactive diagram block.
For maximum productivity, combine Split mode (editor + preview) with the Outline panel open. You can read the rendered output on the right while using the outline for navigation on the left.
Long Notes
If your note is long enough to need an outline, consider whether it should be split into separate notes linked with Markdown links. The graph view can help you see connections between notes.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("editor/focus-mode.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const focusMode = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ focusMode as default
+};
diff --git a/docs-site/.vitepress/.temp/editor_index.md.js b/docs-site/.vitepress/.temp/editor_index.md.js
new file mode 100644
index 00000000..bf36940b
--- /dev/null
+++ b/docs-site/.vitepress/.temp/editor_index.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Editor Overview","description":"Learn the edit modes, status bar, breadcrumbs, and copy/export actions in the Notely editor.","frontmatter":{"title":"Editor Overview","description":"Learn the edit modes, status bar, breadcrumbs, and copy/export actions in the Notely editor.","keywords":"editor, edit mode, split view, preview, status bar, breadcrumbs, word count","category":"Editor"},"headers":[],"relativePath":"editor/index.md","filePath":"editor/index.md","lastUpdated":1784865427000}');
+const _sfc_main = { name: "editor/index.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
The Notely editor is the primary workspace for writing and reviewing Markdown notes. It supports four view modes, a rich toolbar, real-time validation, and statistics.
Switch modes using the mode buttons in the editor header bar.
Mode
Description
Edit
Raw Markdown source editor with syntax highlighting and completions
Split
Editor on the left, live rendered preview on the right
Preview
Full-width read-only rendered output
Web
Website-style rendering — higher-fidelity preview with full media support
Split Mode for Writing
Split mode is the most productive mode for writing. You can edit Markdown on the left while watching the formatted output update in real time on the right.
Right-click any note tab or document list item to select Copy Link Path. This copies a workspace-relative reference link to your clipboard, making it easy to link documents together.
Typo checking — underlines suspected spelling errors in prose (skips code blocks). Right-click any flagged word to ignore it or add it to your custom spelling dictionary.
Custom spelling dictionary — manage custom spelling dictionary words via the settings menu or the command palette (under "Manage Spelling Dictionary").
When issues are found, a badge appears in the editor header. Click it to jump to the first problem.
Notely supports GitHub-style rich callout boxes using blockquote syntax:
markdown
> [!NOTE]
+> Informational note or context.
+
+> [!WARNING]
+> Warning or caution message.
+
+> [!TIP]
+> Helpful tip or shortcut suggestion.
+
+> [!TODO]
+> Action item or pending task.
+
+> [!IMPORTANT]
+> Important highlight or priority notice.
+
+> [!CAUTION]
+> High-risk action or warning.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Custom titles can also be appended to the first line:
markdown
> [!NOTE] Custom Title Header
+> Callout body content goes here.
1 2
Quick Insert via Slash Menu
Type / anywhere in the editor to open the Notion-style Slash Commands menu, or hover/click the Callout icon (`);
+ _push(ssrRenderComponent(_component_Info, { size: "{16}" }, null, _parent));
+ _push(`) in the Markdown toolbar.
When your cursor is inside a Markdown table in Edit mode, the inline table editor opens automatically as an overlay panel.
Toggle Table Editor in View Menu
You can enable or disable the Visual Table Editor modal at any time from the View ▾ dropdown menu on the editor toolbar. When disabled, tables can be edited directly as raw Markdown text.
The table editor shows:
Header cells — editable in the top row
Data cells — editable in a grid layout
Action chips — row and column controls
Alignment controls — per-column alignment buttons in the header
Maximize / Restore — expand table editor to full screen for large tables
You can copy tables directly from Microsoft Excel, Word, or web pages and paste them (Ctrl+V) straight into the editor. Notely automatically converts HTML tabular markup into clean, formatted Markdown table syntax at your cursor.
While the table editor is open, background page scrolling is locked. The table content panel has its own scroll when the table is large. This prevents accidental position changes while editing.
When you edit a table that already exists in your note, Notely preserves the original Markdown formatting style (column spacing and delimiter style) where the table shape hasn't changed.
For very large tables, click the Maximize icon in the table editor header to expand the grid to full window size. Use the header controls to keep column alignment buttons in view.
Escaped Paths
Windows file paths (e.g. C:\\Users\\name) are handled safely — backslashes are preserved correctly in cell content.
Notely can package one or more notes — together with all their linked assets — into a single portable .note file that can be shared with other Notely users and imported directly into any workspace.
Select notes — the list shows every .md file in the current workspace. Use Select All / Deselect All or click individual rows. The list scrolls when the workspace is large.
Save location — defaults to the last-used export path with the filename {workspaceName}.note. Click Browse to choose a different destination.
Password (Optional) — set a password to restrict who can import the package. If set, a salted SHA-256 hash of the password is saved securely inside the encrypted metadata.
The bundle is AES-256 encrypted using a shared app-level key so it is not readable by generic ZIP tools.
Every file in the bundle is SHA-256 hashed and the hashes are stored in metadata.json. On import, Notely verifies each hash and rejects tampered packages.
If protected by a password, the manifest contains a salted SHA-256 password signature. Unlocking verification occurs securely in memory during the import sequence before files are written.
Password Prompts: If the package is password-protected, the app will display a password field. Enter the correct password and click Import Package again to proceed.
Notely will:
Decrypt and verify the integrity of the bundle.
Authenticate the password if password protection was configured.
Copy notes into the workspace root (or appropriate subfolder).
Restore all media assets to their original relative paths.
Resolve filename collisions automatically so existing files are never overwritten.
Reload the workspace document list so imported notes appear immediately.
Table Image Export (Download Image): Exports any rendered table as a high-resolution, unclipped PNG image with clean padding and solid background styling via ExportManager.
Table CSV Export (Download CSV): Exports raw markdown table rows and columns as a clean UTF-8 encoded .csv file with a byte order mark (\\uFEFF) for immediate compatibility with Excel and spreadsheet tools.
Mermaid Diagram Export (Download): Converts rendered Mermaid SVG diagrams into high-resolution PNG image files via ExportManager.
Use File -> Versions to inspect and restore earlier versions of a note. Notes and folders moved out of the main workspace flow are also handled by Notely's removed-folder flow.
On the landing screen, the File menu exposes two shortcuts for working with the workspace folder outside Notely:
File -> Open Workspace in VS Code (Ctrl/Cmd + Shift + O) — opens the active workspace folder directly in VS Code. Falls back to the system default app if VS Code is not installed.
File -> Reveal Workspace in File Explorer (Ctrl/Cmd + Shift + J) — opens the workspace folder in the native system file browser.
The Web menu provides quick access to the rendered website output:
Web -> Open Current Note Website View (Ctrl/Cmd + Shift + W) — available when a note is open; renders the current note as a website preview in the default browser.
Web -> Open Project Website (Ctrl/Cmd + Shift + W) — available on the landing screen; opens the project website.
Create notes from File -> New Note (Ctrl/Cmd + N).
Create folders to group related notes.
Customize the icon and color of any folder or note by right-clicking it and selecting "Customize icon & color..." or from the context menu in the open tabs.
When folders or notes are deleted, they are moved to a temporary Trash Bin instead of being permanently erased immediately. The Trash Bin recovery drawer (Trash quick action on the landing view) supports:
Browsing deleted files and folders with their deletion timestamps.
Restoring items back to their original paths.
Permanently emptying the trash bin to free up disk space.
Notely provides a rich experience for working with code snippets:
Auto-detection: Paste a snippet without a language tag and Notely will automatically detect it (e.g., JavaScript, Python, HTML).
Auto-formatting: Use the 🪄 Format button in the preview hover toolbar or inside the editor to instantly auto-indent and format your code using Prettier.
Dedicated Editor: Click the ✎ Edit button on any code block in Preview mode to open a distraction-free Code Editor popup with syntax highlighting, search, and language selection.
Code Execution: Click the ▶ Run button in the hover toolbar or inside the popup editor to execute JavaScript (js), Python (py), Bash (sh), PowerShell (ps1), and HTML live-preview snippets locally. Output is displayed in an integrated high-contrast dark terminal output drawer (with exit status and a "Clear" button). Execution times out automatically after 10 seconds to prevent hanging. For unsupported languages, the run button is disabled with a helpful tooltip.
Notely flags likely spelling mistakes in real-time as you write (excluding code blocks and raw markdown syntax).
Hunspell engine: Powered by Hunspell under the hood for accurate, high-quality dictionary checks.
Ignore / Add to dictionary: Right-click on a flagged spelling error in the editor to immediately ignore the word, or click Add to dictionary to add it to your custom workspace spelling dictionary.
Spelling Dictionary Manager: Open the command palette (Ctrl/Cmd+P) and run Manage Spelling Dictionary (or click the settings menu option) to view all custom added words, search them, remove individual words, or clear the dictionary completely.
Notely integrates native Git versioning to track your document history. Workspaces can be initialized as Git repositories directly from the Version Control panel.
The full Version Control Page includes tabs to switch branches, create tags, push/pull changes to remote repositories, and stash unstaged changes to keep your workspace tidy.
The editor starts in Edit mode. Type your note content using Markdown:
markdown
# Meeting Notes — Project Kickoff
+
+## Attendees
+- Alice
+- Bob
+- Carol
+
+## Action Items
+- [ ] Share the meeting recording
+- [ ] Create project timeline by Friday
+- [x] Set up shared workspace
+
+## Notes
+The project starts **Monday July 14**. First milestone is due in **3 weeks**.
Notely saves your notes automatically as you type. You'll see a status indicator in the note header when the file is being saved.
Unsaved Changes
If you close a note with unsaved changes, Notely will prompt you to confirm. Auto-save runs continuously, so this only happens if a write error occurs.
Notely is a desktop Markdown notes app for Windows. Your notes live as plain .md files in a folder of your choice — no accounts required, no cloud lock-in.
A single self-contained application file that runs immediately without installation.
Best for: Quick testing, running from a USB drive, or on locked-down environments (e.g. corporate laptops) where administrator/install permissions are restricted.
Pros: Zero-install footprint; doesn't alter system files.
A compressed folder containing the compiled application files and dependencies.
Best for: Portable configurations where you want full control over where the application files are kept, or for offline distribution.
Pros: Easy to inspect files directly; runs without installation.
Cons & Limitations of Packaged Electron Applications
Since Notely is packaged as an Electron desktop application, it inherits a few tradeoffs compared to native Windows apps or web tools:
Large Package Size: The bundle includes both Chromium (browser engine) and Node.js runtime, resulting in a download size of over 100MB+ per package.
Memory Footprint: Each open window launches separate helper processes for the renderer, main processor, and utility threads. This consumes more RAM compared to light text editors (like Notepad).
Windows SmartScreen/Signing Warnings: Unsigned custom builds may trigger Windows Defender SmartScreen warnings on launch. Users will need to click More Info -> Run Anyway to launch the application unless it is signed with a valid Microsoft Developer Certificate.
Native Bindings (e.g., node-pty): Notely compiles binary system dependencies (like the embedded terminal interface) specifically for target operating system architectures (x64). These require corresponding C++ runtimes on the host machine.
Configure an upstream remote (like GitHub, GitLab, or a self-hosted Git server) to sync notes:
Pull: Fetch and merge changes from the remote repository to update your local workspace.
Push: Upload your local commits to the remote repository.
Authentication uses Personal Access Tokens (PAT). When performing remote actions with a PAT, Notely temporarily injects the token into the git remote URL for the operation and immediately restores the clean original URL afterwards, keeping plain-text credentials out of persistent repository settings.
Notely features a native, Git-backed version control system to track document changes. Every modification can be versioned, compared, and restored without relying on external Git tools.
Portability: Your note history is stored in standard Git format, meaning you can open the folder in any Git client (like GitHub Desktop or VS Code) to view the history.
Precision: Fine-grained line-by-line diffs of changes.
Safety: Rollback individual files or entire folders to a previous point in time.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("git/index.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ index as default
+};
diff --git a/docs-site/.vitepress/.temp/git_setup.md.js b/docs-site/.vitepress/.temp/git_setup.md.js
new file mode 100644
index 00000000..b30aeccb
--- /dev/null
+++ b/docs-site/.vitepress/.temp/git_setup.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Setting Up Git in Notely","description":"Initialize a new Git repository or clone an existing one for your workspace in Notely.","frontmatter":{"title":"Setting Up Git in Notely","description":"Initialize a new Git repository or clone an existing one for your workspace in Notely.","keywords":"git init, git clone, git config, credentials, gitignore","category":"Git"},"headers":[],"relativePath":"git/setup.md","filePath":"git/setup.md","lastUpdated":1783855203000}');
+const _sfc_main = { name: "git/setup.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
13-Domain Decoupled Facade Subsystem — Reorganized AI domain modules into 13 single-entry point facades (compaction, planner, personas, prompts, context, graph, embeddings, memory, executor, tools, grounding, formatter, testing) orchestrated by AIFlow.js.
Zero-Latency Context Compaction Engine — 2-tier sliding window algorithm compresses chat sessions into Executive Memory Summaries, cutting LLM input token usage by ~75-80% with 0ms NLP intent heuristics.
Flow Telemetry Timeline Stream — AI Health Page now features a structural 3-column timeline stream displaying 5-stage execution breakdown, latency metrics, persistent session tokens (LogDB), expandable tool call arguments/output, and full flow trace JSON export.
Keyboard Tab Switching — switch between open tabs using Ctrl+Tab (next) and Ctrl+Shift+Tab (previous).
Copy Link Path — right-click on active tabs or dashboard document list items to copy the workspace-relative path for note referencing.
Preview Link Hover overlay — hover over any link in note previews to open a popover with Copy and Navigate options (with icons). Direct link clicks are disabled to prevent accidental navigation jumps.
Dismissible Toasts & Undo actions — notification toasts now include an X dismiss button, and applying markdown quick fixes prompts an Undo toast to quickly revert changes.
Always-Visible Workspace Sidebar — the dashboard rail containing recent notes, favorites, and open tasks remains visible when navigating workspace subfolders, preventing layout shifts and keeping dashboard information at hand.
Improved Contrast on Colored Items — extracted dynamic inline styling into a semantic .custom-colored-item CSS class, ensuring document text, icons, and action chips dynamically scale contrast and remain highly readable when custom card/tab colors are applied.
Draw.io Solid Background Exports — saves of Draw.io diagrams now export with a solid white background in PNG files, preventing poorly contrasted layouts under dark theme previews.
Modal Corner Radius Standardization — custom modal borders consistently use --radius-lg (6px) to match standard dialog overlays.
Centralized CSS Keyframes — common animations like spin and modal-pop are centralized in base.css to reduce code repetition.
Double-click to open row — table list items in document dashboard now open immediately on double-click.
Validation Banner Auto-Hide — the validation banner at the top of the editor is completely hidden when there are no issues.
Spacing Token Normalization — dashboard panels and bars now use design system space tokens (var(--space-4) and var(--space-5)) for consistent alignments.
Escaped content safety — table parsing now preserves escaped pipes and plain backslashes in cell content (including Windows-style paths).
Scroll behavior during table edits — background scrolling is disabled while table editing is active; table content scrolling remains within the editor panel.
Open Workspace in VS Code — the landing File menu now includes Open Workspace in VS Code (Ctrl/Cmd + Shift + O). Opens the active workspace folder directly in VS Code, or falls back to the system default app.
Reveal Workspace in File Explorer — the landing File menu now includes Reveal Workspace in File Explorer (Ctrl/Cmd + Shift + J). Opens the workspace folder in the native system file browser.
Web menu — a new top-level Web menu (Ctrl/Cmd + Shift + W) provides one-click access to the project website (landing screen) or the current note's website view (note screen).
Custom dropdown controls — all select/dropdown controls across the app have been replaced with a fully custom listbox component. The new control supports grouped options, keyboard navigation (arrow keys, Home, End, Enter, Escape), selected-state checkmarks, and focus-aware close behaviour.
Form focus styles — focus indicators across all inputs, selects, and textareas have been softened to a subtle border tint and 2px halo for a more professional desktop feel.
Continue Writing panel — now shows only the single most recently edited note instead of a list, making it faster to resume work.
Task hover popover — the note-level task summary popover now sizes to the available viewport height before showing a scrollbar.
Note detail topbar consistency — breadcrumb chips, task summary, save status, and action controls now use aligned heights and shared corner radius styling for a cleaner, unified row.
Workspace switch website refresh — opening project website view after changing workspace now reflects the current workspace immediately instead of reusing stale scope from the previous folder.
Task summary accessibility semantics — the topbar task summary trigger now uses button semantics with screen-reader state attributes for improved accessibility.
Text provider: choose the LLM service for writing, summarizing, or refactoring text (Google Gemini, Groq, or OpenAI / OpenAI-compatible).
OpenAI Compatible: connect to OpenAI (gpt-4o, gpt-4o-mini) or any compatible endpoint by specifying your API key and Base URL.
Local ONNX Models: vector embeddings (BGE-small-en-v1.5) and Knowledge Graph extraction (GLiNER2-Relex) run completely on-device and offline via onnxruntime-node.
HuggingFace token: optional API token for cloud-based embeddings fallback.
Test buttons: verify that your saved credentials and endpoint connections work.
Learn user patterns: lets the app remember how you use AI so it can be more helpful later
Generate embeddings: turns on meaning-based search and related-note features
Discover relationships: helps the graph and AI features find links between related notes
Graph confidence threshold: controls the minimum confidence score (10% to 95%) required for neural-extracted entities and relationships. Adjusting this slider dynamically filters the Knowledge Graph visualization in real time.
Notely includes a native peer-to-peer (P2P) synchronization subsystem (p2pLive.cjs & p2pSyncEngine.cjs), allowing you to replicate notes directly between local devices without cloud servers or third-party storage.
UDP Network Discovery (Port 47653): Devices broadcast periodic UDP discovery packets every 4 seconds across the local network subnet to locate active Notely peers.
TLS/TCP Transport: Peer-to-peer payload transfers execute over encrypted TCP connections.
AES-256-GCM End-to-End Encryption: Note deltas and workspace data payloads are encrypted using 256-bit AES-GCM with unique 12-byte initialization vectors (iv) and auth tags (tag).
Workspace Keys & Key TTL: Pairing generates a 256-bit workspace key stored in global app.sqlite. Workspace key expiration (TTL) is configurable from 1 to 365 days (default 30 days). Expired keys automatically trigger re-authentication.
3-Way Line Delta Engine: Edits are processed incrementally using line-level note diffs (buildNoteDelta / applyNoteDelta). Small non-overlapping changes merge automatically without prompting.
Automatic Retry Policy: Unreachable or interrupted sync requests automatically retry up to 5 times at 2-second intervals (SYNC_RETRY_INTERVAL_MS = 2000).
Conflict Snapshot Copying: If simultaneous edits modify the exact same line block on two devices before a delta is applied:
Notely creates a timestamped conflict file: [note-name].sync-conflict-[timestamp].md.
Automated sync halts for that specific note to prevent data corruption.
The P2P Status Panel alerts you to the conflict.
Open the Conflict Resolution Panel to compare versions side-by-side and choose Keep Local, Keep Remote, or Merge Manually.
The Website View renders your workspace notes as a fully navigable, styled static website served locally by Notely. Unlike the in-editor Markdown Preview pane, the website view runs inside your browser and includes a project index, full-text search, and cross-note navigation.
Notely starts a local HTTP server (webPreview.cjs) on a random available port. The server binds to 127.0.0.1 only and is never accessible from other devices.
The server handles five route types:
Route
What it serves
GET /
Project index page — a listing of all workspace notes
GET /view/{note-path}
Individual note rendered as a website page
GET /pdf/{note-path}
Note rendered in PDF-optimised layout
GET /search
Full-text search results page
GET /search-index.json
Search index JSON (used by the search page)
GET /raw/{asset-path}
Static file passthrough for media assets (images, PDFs, Excalidraw PNGs)
All responses include Cache-Control: no-store so you always see the latest saved version.
When you open the current note's website view while editing, Notely passes the unsaved editor buffer as a content override so you see real-time changes without needing to save first.
Each note is processed through a custom rendering pipeline before being served:
Markdown-It parser with linkify and typographer enabled.
Syntax highlighting (highlight.js) with numbered lines and a one-click copy button on every code block.
Heading slug generation — all headings get deterministic id attributes (deduplicated with counters) enabling anchor links.
Asset path rewriting — relative image/media paths are rewritten to /raw/{path} server routes. Legacy Excalidraw diagram paths are automatically migrated to the current .notes-app/excali-diagrams/ layout.
Markdown link rewriting — .md links become /view/{note-path} server routes, enabling seamless cross-note navigation.
HTML injection into websiteTemplate.cjs which adds navigation, project sidebar, and the Notely website stylesheet.
The root / page lists all .md files in the active workspace (or project scope), sorted alphabetically. Notes in excluded directories (.notes-app/, .git/, node_modules/) are omitted.
The website scope tracks the active project (or workspace root if no project is open):
Switching workspace or project updates the scope — the server scope syncs on the next page load.
On scope change, the content override cache is cleared so you don't see stale overrides from a previous workspace.
Comparison: Website View vs Preview Pane vs PDF Export
Feature
Preview Pane
Website View
PDF Export
Rendered in
Electron app window
Your browser
Headless Chromium
Navigation
Single note only
Cross-note links, project index
Single note only
Full-text search
❌
✅ (client-side)
❌
Live refresh
✅ (auto on typing)
Manual browser refresh
One-shot render
Media resolved
✅
✅
✅
Syntax highlighting
✅
✅ (with line numbers)
✅
Shareable output
❌
❌ (local only)
✅ (save as file)
To publish the website view as a static site, use File → Export Workspace → Web Format which packages the full rendered HTML output as a .zip archive you can host on GitHub Pages, Netlify, or any static server. See Export Reference for details.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("web-view.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const webView = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ webView as default
+};
diff --git a/docs-site/.vitepress/.temp/workspace_calendar.md.js b/docs-site/.vitepress/.temp/workspace_calendar.md.js
new file mode 100644
index 00000000..4f7af515
--- /dev/null
+++ b/docs-site/.vitepress/.temp/workspace_calendar.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Calendar & Scheduling","description":"Guide to using the Calendar workspace, task scheduling, due dates, and visual timeline management in Notely.","frontmatter":{"title":"Calendar & Scheduling","description":"Guide to using the Calendar workspace, task scheduling, due dates, and visual timeline management in Notely.","keywords":"calendar, schedule, due dates, task timeline, month view, week view, day view","category":"Workspace"},"headers":[],"relativePath":"workspace/calendar.md","filePath":"workspace/calendar.md","lastUpdated":1786125015000}');
+const _sfc_main = { name: "workspace/calendar.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
Notely includes an integrated Calendar Workspace that turns scheduled Markdown tasks and due dates into a visual timeline. View project deadlines, schedule tasks across days or hours, and track upcoming workloads visually.
Provides a high-level overview of the entire month. Scheduled tasks and due date markers appear inside their respective date cells. Click any date cell to quickly inspect or add tasks for that day.
A 7-day grid showing time slots for hourly scheduled tasks alongside an All-Day Header for day-wide deadlines. Perfect for weekly sprint planning and time-blocking.
Notely includes a dedicated Downloads & Export History Manager that automatically tracks all document exports, workspace zip bundles, diagram renders, and media files created in your active workspace.
Access the downloads manager anytime via:
Top Workspace → Downloads & Export History menu item
Global keyboard shortcut Ctrl/Cmd + J
Quick 📥 Download icon button in the title bar
Command Palette (Ctrl/Cmd + Shift + P) → search for Open Downloads & Export History
Every PDF export, .note package, workspace .zip archive, Excalidraw diagram, Draw.io diagram, and exported media file is logged automatically.
Category Tabs
Filter exports into All, Documents (PDF, HTML, packages), Diagrams (Excalidraw, Draw.io), or Media (images, video, audio) with live item counter badges.
Show in Folder
Opens the exact file location in Windows File Explorer or macOS Finder.
Open File
Launches the exported file directly in your system's default application.
Downloads Directory
Quick action button to open your system's default Downloads directory (~/Downloads).
Disk Status Indicator
Automatically checks if exported files still exist on disk or have been moved/deleted.
By default, all exports and downloads in Notely save directly to your system's Downloads folder (app.getPath("downloads")). You can customize the destination path during export prompts.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("workspace/downloads.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const downloads = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ downloads as default
+};
diff --git a/docs-site/.vitepress/.temp/workspace_export.md.js b/docs-site/.vitepress/.temp/workspace_export.md.js
new file mode 100644
index 00000000..316076f2
--- /dev/null
+++ b/docs-site/.vitepress/.temp/workspace_export.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Exporting Workspaces","description":"Export your workspace as a zip archive containing raw markdown, PDFs, or a built website package.","frontmatter":{"title":"Exporting Workspaces","description":"Export your workspace as a zip archive containing raw markdown, PDFs, or a built website package.","keywords":"export, zip, backup, pdf bundle, web format","category":"Workspace"},"headers":[],"relativePath":"workspace/export.md","filePath":"workspace/export.md","lastUpdated":1786163747000}');
+const _sfc_main = { name: "workspace/export.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
Open the export window from File → Export Workspace as Zip:
Notes As-Is: Bundles your raw Markdown files and the assets/ directory. Perfect for backups or migrating to another Markdown editor (like Obsidian).
PDF-Only: Compiles all notes into formatted PDF documents, placing them inside a structured ZIP. Useful for offline reading or client deliverables.
Web Format: Generates a static HTML website from your notes, packaged inside a ZIP. You can host this static folder on services like GitHub Pages or Netlify.
App Data Toggle: Choose whether to include the .notes-app support folder (containing version control commits and metadata). Recommended to leave disabled unless creating full recovery backups.
Default Location: All exported workspace archives default directly to your system Downloads directory (~/Downloads).
History Tracking: View and manage all past workspace exports anytime via Workspace → Downloads & Export History (Ctrl/Cmd + J).
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("workspace/export.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const _export = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ _export as default
+};
diff --git a/docs-site/.vitepress/.temp/workspace_graph.md.js b/docs-site/.vitepress/.temp/workspace_graph.md.js
new file mode 100644
index 00000000..64123f98
--- /dev/null
+++ b/docs-site/.vitepress/.temp/workspace_graph.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Workspace Graph","description":"Explore links and relations between your notes using the visual workspace graph.","frontmatter":{"title":"Workspace Graph","description":"Explore links and relations between your notes using the visual workspace graph.","keywords":"graph, workspace graph, node link, connections, semantic clustering","category":"Workspace"},"headers":[],"relativePath":"workspace/graph.md","filePath":"workspace/graph.md","lastUpdated":1783855203000}');
+const _sfc_main = { name: "workspace/graph.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
When AI features are active, the graph clusters related notes using semantic similarity. If the clustering falls out of date, click Refresh to rebuild the semantic relations.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("workspace/graph.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const graph = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ graph as default
+};
diff --git a/docs-site/.vitepress/.temp/workspace_index.md.js b/docs-site/.vitepress/.temp/workspace_index.md.js
new file mode 100644
index 00000000..83f86e8e
--- /dev/null
+++ b/docs-site/.vitepress/.temp/workspace_index.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Workspace Management","description":"Learn how to manage workspaces, notes, folders, and navigate the dashboard in Notely.","frontmatter":{"title":"Workspace Management","description":"Learn how to manage workspaces, notes, folders, and navigate the dashboard in Notely.","keywords":"workspace, landing screen, folders, sidebar, dashboard, favorites, continue writing","category":"Workspace"},"headers":[],"relativePath":"workspace/index.md","filePath":"workspace/index.md","lastUpdated":1786126353000}');
+const _sfc_main = { name: "workspace/index.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
A workspace is the single source of truth for your notes in Notely. It maps to a folder on your local filesystem containing Markdown documents and asset subfolders.
Keep your workspace and active notes synchronized with external changes on disk:
Reload Workspace: Click the Reload button in the landing list controls, select Workspace → Reload Workspace (Ctrl + Alt + R), or run Reload Workspace from Disk in the Command Palette to re-scan all workspace documents, folder structures, open note tabs, and git status.
External Change Banner & Reload Note: When an active note is modified externally by another tool or process, Notely detects the change, temporarily disables autosave to prevent overwriting disk state, and displays a warning banner. Click Reload content from disk, select File → Reload Note from Disk (Ctrl + Shift + R), right-click the note tab and choose Reload from Disk, or use the Command Palette to force-load the latest file content from disk.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("workspace/index.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ index as default
+};
diff --git a/docs-site/.vitepress/.temp/workspace_media.md.js b/docs-site/.vitepress/.temp/workspace_media.md.js
new file mode 100644
index 00000000..eb819d9e
--- /dev/null
+++ b/docs-site/.vitepress/.temp/workspace_media.md.js
@@ -0,0 +1,19 @@
+import { ssrRenderAttrs, ssrRenderStyle } from "vue/server-renderer";
+import { useSSRContext } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.1tPrXgE0.js";
+const __pageData = JSON.parse('{"title":"Media Management","description":"How to manage files, images, PDFs, annotations, and health checks in Notely.","frontmatter":{"title":"Media Management","description":"How to manage files, images, PDFs, annotations, and health checks in Notely.","keywords":"media, assets, images, pdf, workspace health, annotations","category":"Workspace"},"headers":[],"relativePath":"workspace/media.md","filePath":"workspace/media.md","lastUpdated":1783855203000}');
+const _sfc_main = { name: "workspace/media.md" };
+function _sfc_ssrRender(_ctx, _push, _parent, _attrs, $props, $setup, $data, $options) {
+ _push(`
Notely turns standard Markdown checklist checkboxes into a workspace-wide task management system. Tasks written inside any note automatically sync in real-time with a SQLite task database, providing bi-directional status updates, detail management, and workspace-wide task views.
Markdown → Task DB: Edits inside the text editor automatically sync to the task database whenever the note is saved.
Task DB → Markdown: Updating task status from the Task Workspace or Task Detail Modal writes - [x] or - [ ] directly back into the .md file.
Buffer Safety: Active unsaved editor changes are committed to disk before task updates execute, preventing data loss, file watcher hash mismatches, or disk conflict warnings.
Pass 2: Line Number Match: Preserves task identity when task titles are edited on the same line index.
Pass 3: Fuzzy Similarity Match: Uses Jaccard word similarity (>0.35 threshold) to track tasks when lines move and title text is tweaked simultaneously.
Pass 4: Orphan Purging: Auto-removes database records when tasks are permanently deleted from a Markdown file.
When editing any note, the top header displays a live task completion progress indicator (e.g. 2/5 tasks). Clicking this indicator opens the Task Summary Popover, listing all open and completed tasks for that note with direct line-jump buttons.
Notely features an integrated, full-featured Embedded Terminal powered by node-pty. Run project-local commands, build scripts, git commands, and shell utilities without leaving your workspace.
Workspace Alignment: The terminal automatically sets its initial working directory (CWD) to your active project workspace root ({workspace}/).
Session Lifecycle: Terminal PTY sessions persist as long as the panel is open. Closing the terminal drawer terminates the PTY subprocess cleanly to free system resources.
Resize Behavior: The terminal automatically adjusts its columns and rows dynamically as you resize the panel drawer.
Comma-separated list of allowed command executables (e.g. git,npm,node,dir,ls).
Strict Policy Enforcement
When NOTELY_TERMINAL_POLICY=strict is active, any command execution attempt outside the NOTELY_TERMINAL_ALLOWLIST is blocked by IPC security guards before spawning.
`);
+}
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+ const ssrContext = useSSRContext();
+ (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("workspace/terminal.md");
+ return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const terminal = /* @__PURE__ */ _export_sfc(_sfc_main, [["ssrRender", _sfc_ssrRender]]);
+export {
+ __pageData,
+ terminal as default
+};
diff --git a/docs-site/.vitepress/config.mts b/docs-site/.vitepress/config.mts
index c8d40d3d..3c8dd97e 100644
--- a/docs-site/.vitepress/config.mts
+++ b/docs-site/.vitepress/config.mts
@@ -97,6 +97,7 @@ export default withMermaid(
{ text: "Media", link: "/workspace/media" },
{ text: "Screen Capture", link: "/workspace/screen-capture" },
{ text: "Workspace Graph", link: "/workspace/graph" },
+ { text: "Downloads & History", link: "/workspace/downloads" },
{ text: "Export", link: "/workspace/export" },
],
},
@@ -105,6 +106,7 @@ export default withMermaid(
collapsed: false,
items: [
{ text: "Export Reference", link: "/export-reference" },
+ { text: "Downloads Manager", link: "/workspace/downloads" },
{ text: "Website View", link: "/web-view" },
{ text: "Note Packages", link: "/export-import" },
],
diff --git a/docs/editor/diagrams.md b/docs/editor/diagrams.md
index 50d17b17..a4e1ebc7 100644
--- a/docs/editor/diagrams.md
+++ b/docs/editor/diagrams.md
@@ -54,6 +54,13 @@ graph TD
E -- No --> G[Stay local]
```
+### Interactive Diagram Actions
+
+In Preview and Split modes, hovering over any rendered Mermaid diagram reveals the top action bar:
+
+* **Edit**: Opens the Mermaid visual editor modal to modify diagram elements visually.
+* **Download**: Renders and exports the Mermaid diagram as a high-resolution PNG image saved directly to your system Downloads folder.
+
### Troubleshooting Mermaid
If your diagram does not render:
diff --git a/docs/editor/tables.md b/docs/editor/tables.md
index ecc826ef..201979c7 100644
--- a/docs/editor/tables.md
+++ b/docs/editor/tables.md
@@ -97,6 +97,18 @@ While the table editor is open, background page scrolling is locked. The table c
When you edit a table that already exists in your note, Notely preserves the original Markdown formatting style (column spacing and delimiter style) where the table shape hasn't changed.
+## Export Table as Image or CSV
+
+In Preview mode and Split View, hovering over any rendered Markdown table displays the action bar with direct 1-click export buttons:
+
+| Action | Icon | Result |
+|---|---|---|
+| **Edit** | `✏️` | Opens the inline visual table editor modal |
+| **Download Image** | `🖼️` | Exports the table as a high-resolution, unclipped PNG image with white background and clean padding |
+| **Download CSV** | `📄` | Exports raw tabular data as a clean UTF-8 encoded `.csv` file |
+
+Exported tables are saved directly to your system Downloads folder and automatically logged in the [Downloads & Export History Manager](/export-reference#2-downloads--export-history-manager).
+
## Tips
::: tip Large Tables & Full Screen Mode
diff --git a/docs/export-reference.md b/docs/export-reference.md
index dfc63808..8743b2af 100644
--- a/docs/export-reference.md
+++ b/docs/export-reference.md
@@ -25,13 +25,37 @@ Exports the currently active markdown note as a standalone rendered document.
* Renders the note through a **Headless Chromium** window with the active Notely theme CSS applied.
* **Local media resolved**: Embedded images and diagrams are referenced via their absolute file:// paths before rendering.
* **Mermaid diagrams** and **LaTeX equations** are rendered as vector SVG and KaTeX HTML inside the PDF.
-* Output path defaults to the last-used export directory. The app remembers the path (`getLastPdfExportPath`).
+* Output path defaults directly to your system **Downloads** folder (`~/Downloads`).
* PDF write failures (EPERM, EBUSY on OneDrive paths) are automatically retried up to 3 times with increasing delays (120ms → 320ms → 700ms).
### HTML Export
* Produces a self-contained HTML file with inline CSS and resolved media references.
* Suitable for publishing notes to static web servers or opening in any browser without Notely.
+### Block-Level Exports (Tables & Diagrams)
+* **Table Image Export (`Download Image`)**: Exports any rendered table as a high-resolution, unclipped PNG image with clean padding and solid background styling via `ExportManager`.
+* **Table CSV Export (`Download CSV`)**: Exports raw markdown table rows and columns as a clean UTF-8 encoded `.csv` file with a byte order mark (`\uFEFF`) for immediate compatibility with Excel and spreadsheet tools.
+* **Mermaid Diagram Export (`Download`)**: Converts rendered Mermaid SVG diagrams into high-resolution PNG image files via `ExportManager`.
+
+---
+
+## 2. Downloads & Export History Manager
+
+Access via top **Workspace → Downloads & Export History** menu item or press **`Ctrl/Cmd + J`**.
+
+Notely automatically tracks and logs all file exports and diagram renders to a local workspace database (`.notes-app/export-history.db`).
+
+### Features & Capabilities
+
+* **Unified Tracking**: Tracks PDF exports, `.note` packages, workspace `.zip` archives, Excalidraw diagrams, Draw.io diagrams, and exported media files.
+* **Category Tabs**: Filter by **All**, **Documents**, **Diagrams**, or **Media** with live item count badges.
+* **Instant Actions**:
+ * **Show in Folder**: Reveals the exported file directly in OS File Explorer (Windows) or Finder (macOS).
+ * **Open**: Launches the file in its default system application.
+ * **Downloads Folder**: Direct shortcut button to open your system Downloads directory.
+* **Live File Status**: Automatically detects if an exported file has been moved or deleted from disk.
+* **SQLite Persistence**: Stored per-workspace in `{workspace}/.notes-app/export-history.db` using Node's native `DatabaseSync` (`node:sqlite`). Reconnects dynamically on workspace switching.
+
---
## 2. Workspace Export (Full ZIP Bundle)
diff --git a/docs/keyboard-shortcuts.md b/docs/keyboard-shortcuts.md
index 0f2a2a16..4a6948b7 100644
--- a/docs/keyboard-shortcuts.md
+++ b/docs/keyboard-shortcuts.md
@@ -60,7 +60,7 @@ Use shortcuts to navigate and edit notes quickly across Notely.
| Action | Shortcut | Scope / Notes |
|---|---|---|
| Open AI Palette | `Ctrl/Cmd + Shift + I` | AI (Document screens) |
-| Toggle AI Assistant Chat | `Ctrl/Cmd + J` | AI (Document screens) |
+| Open Downloads & Export History | `Ctrl/Cmd + J` | Global |
| Open AI Settings | `Ctrl/Cmd + Shift + ,` | AI |
## View, Media & Tools
diff --git a/docs/workspace/downloads.md b/docs/workspace/downloads.md
new file mode 100644
index 00000000..3fea1fb8
--- /dev/null
+++ b/docs/workspace/downloads.md
@@ -0,0 +1,58 @@
+---
+title: Downloads & Export History
+description: Manage and track all note exports, diagram renders, note packages, and workspace zip archives in Notely.
+keywords: downloads, export history, exports, PDF, note package, excalidraw, draw.io, SQLite
+category: Workspace
+---
+
+# Downloads & Export History
+
+Notely includes a dedicated **Downloads & Export History Manager** that automatically tracks all document exports, workspace zip bundles, diagram renders, and media files created in your active workspace.
+
+Access the downloads manager anytime via:
+* Top **Workspace → Downloads & Export History** menu item
+* Global keyboard shortcut **`Ctrl/Cmd + J`**
+* Quick **📥 Download icon button** in the title bar
+* **Command Palette** (`Ctrl/Cmd + Shift + P`) → search for *Open Downloads & Export History*
+
+---
+
+## 1. Features & Capabilities
+
+| Feature | Description |
+|---|---|
+| **Automatic Tracking** | Every PDF export, `.note` package, workspace `.zip` archive, Excalidraw diagram, Draw.io diagram, and exported media file is logged automatically. |
+| **Category Tabs** | Filter exports into **All**, **Documents** (PDF, HTML, packages), **Diagrams** (Excalidraw, Draw.io), or **Media** (images, video, audio) with live item counter badges. |
+| **Show in Folder** | Opens the exact file location in Windows File Explorer or macOS Finder. |
+| **Open File** | Launches the exported file directly in your system's default application. |
+| **Downloads Directory** | Quick action button to open your system's default **Downloads** directory (`~/Downloads`). |
+| **Disk Status Indicator** | Automatically checks if exported files still exist on disk or have been moved/deleted. |
+
+---
+
+## 2. Storage & Database Architecture
+
+* Export history records are persisted locally per-workspace inside `{workspace}/.notes-app/export-history.db`.
+* Built on Node 22 native **SQLite** (`node:sqlite` `DatabaseSync`).
+* **Dynamic Connection Handling**: Automatically opens and queries the active workspace's SQLite database upon switching workspaces.
+* **Deduplication**: Exporting a note or diagram to the same file path updates the timestamp and metadata without creating duplicate rows.
+
+---
+
+## 3. Supported Export & Download Formats
+
+| Export Type | File Extension | Subsystem Category |
+|---|---|---|
+| **Single Note PDF** | `.pdf` | Documents |
+| **Single Note HTML** | `.html` | Documents |
+| **Note Package** | `.note` / `.nly` | Documents |
+| **Workspace Zip Archive** | `.zip` | Documents |
+| **Excalidraw Diagram** | `.png` | Diagrams |
+| **Draw.io Diagram** | `.png` | Diagrams |
+| **Exported Media Render** | `.png`, `.jpg`, `.webp` | Media |
+
+---
+
+## 4. System Downloads Directory
+
+By default, all exports and downloads in Notely save directly to your system's **Downloads** folder (`app.getPath("downloads")`). You can customize the destination path during export prompts.
diff --git a/docs/workspace/export.md b/docs/workspace/export.md
index ab80c416..937ef6d3 100644
--- a/docs/workspace/export.md
+++ b/docs/workspace/export.md
@@ -22,4 +22,5 @@ Open the export window from **File → Export Workspace as Zip**:
## 2. Advanced Options
- **App Data Toggle**: Choose whether to include the `.notes-app` support folder (containing version control commits and metadata). Recommended to leave disabled unless creating full recovery backups.
-- **Remembered Destination**: Notely remembers your last export folder. You can customize the filename before starting the process.
+- **Default Location**: All exported workspace archives default directly to your system **Downloads** directory (`~/Downloads`).
+- **History Tracking**: View and manage all past workspace exports anytime via **Workspace → Downloads & Export History** (`Ctrl/Cmd + J`).
diff --git a/electron/ai/aiHandlers.cjs b/electron/ai/aiHandlers.cjs
index 00038390..7c8880b5 100644
--- a/electron/ai/aiHandlers.cjs
+++ b/electron/ai/aiHandlers.cjs
@@ -1488,6 +1488,16 @@ async function handlePersonaImport(_event, payload) {
async function handlePersonaExport(_event, payload) {
try {
const dest = _getStore().exportPersonaToFile(payload?.id, payload?.destPath);
+ try {
+ const { getExportManager } = require("../lib/export/ExportManager.cjs");
+ const exportManager = getExportManager();
+ await exportManager.runExport({
+ type: "persona",
+ payload: { destPath: dest, personaId: payload?.id }
+ });
+ } catch (exportErr) {
+ console.warn("[aiHandlers] ExportManager record warning for persona:", exportErr);
+ }
return new AIQueryResponse(true, { path: dest });
} catch (err) {
return new AIQueryResponse(false, null, err.message);
diff --git a/electron/lib/core/appMenu.cjs b/electron/lib/core/appMenu.cjs
index d09a9a78..5d052adc 100644
--- a/electron/lib/core/appMenu.cjs
+++ b/electron/lib/core/appMenu.cjs
@@ -596,12 +596,6 @@ function buildAppMenuTemplate(win, context = {}) {
label: "Export Workspace as Zip",
accelerator: "CmdOrCtrl+Shift+E",
click: () => sendMenuAction(win, "export-workspace-zip")
- },
- { type: "separator" },
- {
- label: screen === "document" ? "Open Current Note Website View" : "Open Project Website",
- accelerator: "CmdOrCtrl+Shift+W",
- click: () => sendMenuAction(win, "open-website")
}
]
},
diff --git a/electron/lib/core/mainHelpers.cjs b/electron/lib/core/mainHelpers.cjs
index 31eabc53..27a87aa4 100644
--- a/electron/lib/core/mainHelpers.cjs
+++ b/electron/lib/core/mainHelpers.cjs
@@ -51,34 +51,7 @@ function createMainHelpers(deps) {
fs.writeFileSync(userConfigPath, JSON.stringify(nextSettings, null, 2), "utf8");
}
- function getLastPdfExportPath() {
- const settings = readUserSettings();
- const rawLastPath = typeof settings?.lastPdfExportPath === "string"
- ? settings.lastPdfExportPath.trim()
- : "";
- if (!rawLastPath) return "";
- try {
- const resolvedLastPath = path.resolve(rawLastPath);
- const lastExportDir = path.extname(resolvedLastPath).toLowerCase() === ".pdf"
- ? path.dirname(resolvedLastPath)
- : resolvedLastPath;
- if (fs.existsSync(lastExportDir)) {
- return lastExportDir;
- }
- } catch {
- return "";
- }
-
- return "";
- }
-
- function rememberPdfExportPath(filePath) {
- if (!filePath || typeof filePath !== "string") return;
- const settings = readUserSettings();
- settings.lastPdfExportPath = path.dirname(path.resolve(filePath));
- writeUserSettings(settings);
- }
function resolveInitialNotesRoot() {
const envNotesRoot = process.env.NOTES_ROOT;
@@ -291,8 +264,6 @@ function createMainHelpers(deps) {
return {
readUserSettings,
writeUserSettings,
- getLastPdfExportPath,
- rememberPdfExportPath,
resolveInitialNotesRoot,
readP2PStatusSnapshot,
listProjectsState,
diff --git a/electron/lib/documents/documentIpc.cjs b/electron/lib/documents/documentIpc.cjs
index d8a11126..7d3f53fd 100644
--- a/electron/lib/documents/documentIpc.cjs
+++ b/electron/lib/documents/documentIpc.cjs
@@ -1,16 +1,11 @@
+const { BrowserWindow, shell } = require("electron");
const { assertTrustedIpcSender } = require("../ipc/ipcSecurity.cjs");
const { buildWorkspaceGraph } = require("./workspaceGraph.cjs");
function registerDocumentIpcHandlers(ipcMain, deps) {
const {
- BrowserWindow,
- dialog,
- shell,
fs,
- os,
path,
- pathToFileURL,
- slugify,
hashContent,
filePathWithin,
listRootEntries,
@@ -32,41 +27,9 @@ function registerDocumentIpcHandlers(ipcMain, deps) {
prepareDocumentPreview,
syncWebPreviewScope,
tryOpenInChrome,
- getLastPdfExportPath,
- rememberPdfExportPath,
- buildPdfExportMarkdown,
- buildPdfExportHtml,
getAppDataDir,
} = deps;
- const PDF_WRITE_RETRY_DELAYS_MS = [120, 320, 700];
-
- function isRetryableWriteError(error) {
- const code = String(error?.code || "").toUpperCase();
- return code === "EBUSY" || code === "EPERM" || code === "EACCES";
- }
-
- async function writeFileWithRetries(filePath, data) {
- let lastError = null;
- for (let attempt = 0; attempt <= PDF_WRITE_RETRY_DELAYS_MS.length; attempt += 1) {
- try {
- fs.writeFileSync(filePath, data);
- return;
- } catch (error) {
- if (!isRetryableWriteError(error)) {
- throw error;
- }
- lastError = error;
- if (attempt >= PDF_WRITE_RETRY_DELAYS_MS.length) {
- break;
- }
- const waitMs = PDF_WRITE_RETRY_DELAYS_MS[attempt];
- await new Promise((resolve) => setTimeout(resolve, waitMs));
- }
- }
- throw lastError;
- }
-
function registerTrustedHandler(channel, handler) {
ipcMain.handle(channel, (event, payload) => {
assertTrustedIpcSender(BrowserWindow, event, channel);
@@ -400,104 +363,7 @@ function registerDocumentIpcHandlers(ipcMain, deps) {
};
});
- registerTrustedHandler("documents:download-pdf", async (_event, payload) => {
- const notesRoot = getNotesRoot();
- const resolved = path.resolve(String(payload?.filePath || ""));
- if (!filePathWithin(notesRoot, resolved) || path.extname(resolved).toLowerCase() !== ".md") {
- throw new Error("Invalid document path.");
- }
-
- const includeRawNotes = Boolean(payload?.includeRawNotes);
- const includeCleansed = Boolean(payload?.includeCleansed);
- const pdfQualityPreset = ["full", "balanced", "compact"].includes(payload?.pdfQualityPreset)
- ? payload.pdfQualityPreset
- : "full";
- const downsampleImages = Boolean(payload?.downsampleImages) || pdfQualityPreset !== "full";
- if (!includeRawNotes && !includeCleansed) {
- throw new Error("Select at least one section to export.");
- }
-
- const focusedWindow = BrowserWindow.getFocusedWindow() || BrowserWindow.getAllWindows()[0] || null;
- const defaultName = `${path.basename(resolved, ".md") || "note"}.pdf`;
- const lastPdfExportPath = getLastPdfExportPath();
- const defaultSavePath = lastPdfExportPath
- ? path.join(lastPdfExportPath, defaultName)
- : path.join(path.dirname(resolved), defaultName);
- const saveResult = await dialog.showSaveDialog(focusedWindow, {
- title: "Save note as PDF",
- defaultPath: defaultSavePath,
- filters: [{ name: "PDF", extensions: ["pdf"] }]
- });
-
- if (saveResult.canceled || !saveResult.filePath) {
- return { canceled: true };
- }
-
- const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "notely-pdf-"));
- const tempMarkdownPath = path.join(tempDir, `${slugify(path.basename(resolved))}-export.md`);
- const tempHtmlPath = path.join(tempDir, `${slugify(path.basename(resolved))}-export.html`);
- const markdownContent = buildPdfExportMarkdown(payload, { includeRawNotes, includeCleansed });
- fs.writeFileSync(tempMarkdownPath, markdownContent, "utf8");
-
- try {
- const baseHref = pathToFileURL(`${path.dirname(resolved)}${path.sep}`).href;
- const html = buildPdfExportHtml({
- title: payload?.title || path.basename(resolved, ".md"),
- markdownContent,
- baseHref,
- sourceDir: path.dirname(resolved),
- downsampleImages,
- pdfQualityPreset
- });
- fs.writeFileSync(tempHtmlPath, html, "utf8");
-
- const pdfWindow = new BrowserWindow({
- show: false,
- width: 1280,
- height: 1600,
- backgroundColor: "#ffffff",
- webPreferences: {
- backgroundThrottling: false,
- contextIsolation: true,
- nodeIntegration: false,
- sandbox: true,
- webviewTag: false
- }
- });
-
- try {
- await pdfWindow.loadFile(tempHtmlPath);
- await pdfWindow.webContents.executeJavaScript("document.fonts ? document.fonts.ready : Promise.resolve()");
-
- const pdfData = await pdfWindow.webContents.printToPDF({
- printBackground: true,
- preferCSSPageSize: true
- });
- try {
- await writeFileWithRetries(saveResult.filePath, pdfData);
- } catch (error) {
- if (isRetryableWriteError(error)) {
- throw new Error(`Unable to save PDF because the target file is busy or locked: ${saveResult.filePath}. Close any app using it (including preview panes/OneDrive sync locks) and try again.`);
- }
- throw error;
- }
- rememberPdfExportPath(saveResult.filePath);
- } finally {
- if (!pdfWindow.isDestroyed()) {
- pdfWindow.close();
- }
- }
-
- return { canceled: false, filePath: saveResult.filePath };
- } finally {
- try {
- fs.rmSync(tempDir, { recursive: true, force: true });
- } catch {
- // Ignore cleanup failures for temporary export files.
- }
- }
- });
diff --git a/electron/lib/export/ExportManager.cjs b/electron/lib/export/ExportManager.cjs
new file mode 100644
index 00000000..c107fc25
--- /dev/null
+++ b/electron/lib/export/ExportManager.cjs
@@ -0,0 +1,934 @@
+const fs = require("fs");
+const fsAsync = require("fs").promises;
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+const { pathToFileURL } = require("node:url");
+const { ZipFile } = require("yazl");
+
+const PDF_WRITE_RETRY_DELAYS_MS = [120, 320, 700];
+
+function isRetryableWriteError(error) {
+ const code = String(error?.code || "").toUpperCase();
+ return code === "EBUSY" || code === "EPERM" || code === "EACCES";
+}
+
+async function writeFileWithRetries(filePath, data) {
+ let lastError = null;
+ for (let attempt = 0; attempt <= PDF_WRITE_RETRY_DELAYS_MS.length; attempt += 1) {
+ try {
+ fs.writeFileSync(filePath, data);
+ return;
+ } catch (error) {
+ if (!isRetryableWriteError(error)) {
+ throw error;
+ }
+ lastError = error;
+ if (attempt >= PDF_WRITE_RETRY_DELAYS_MS.length) {
+ break;
+ }
+ const waitMs = PDF_WRITE_RETRY_DELAYS_MS[attempt];
+ await new Promise((resolve) => setTimeout(resolve, waitMs));
+ }
+ }
+ throw lastError;
+}
+
+function slugify(name) {
+ return String(name || "")
+ .toLowerCase()
+ .replace(/[^a-z0-9]+/g, "-")
+ .replace(/^-+|-+$/g, "");
+}
+
+const { encryptBuffer, scanNoteDependencies } = require("./notePackageIpc.cjs");
+
+class ExportManager {
+ constructor(deps = {}) {
+ this.app = deps.app;
+ this.BrowserWindow = deps.BrowserWindow;
+ this.shell = deps.shell;
+ this.exportHistoryStore = deps.exportHistoryStore;
+ this.getNotesRoot = deps.getNotesRoot;
+ this.filePathWithin = deps.filePathWithin;
+ this.buildPdfExportMarkdown = deps.buildPdfExportMarkdown;
+ this.buildPdfExportHtml = deps.buildPdfExportHtml;
+ this.parseDocument = deps.parseDocument;
+ this.getMarkdownIt = deps.getMarkdownIt;
+ }
+
+ setDeps(deps = {}) {
+ if (deps.app) this.app = deps.app;
+ if (deps.BrowserWindow) this.BrowserWindow = deps.BrowserWindow;
+ if (deps.shell) this.shell = deps.shell;
+ if (deps.exportHistoryStore) this.exportHistoryStore = deps.exportHistoryStore;
+ if (deps.getNotesRoot) this.getNotesRoot = deps.getNotesRoot;
+ if (deps.filePathWithin) this.filePathWithin = deps.filePathWithin;
+ if (deps.buildPdfExportMarkdown) this.buildPdfExportMarkdown = deps.buildPdfExportMarkdown;
+ if (deps.buildPdfExportHtml) this.buildPdfExportHtml = deps.buildPdfExportHtml;
+ if (deps.parseDocument) this.parseDocument = deps.parseDocument;
+ if (deps.getMarkdownIt) this.getMarkdownIt = deps.getMarkdownIt;
+ }
+
+ /**
+ * Central parameterized export function
+ * @param {Object} params
+ * @param {'pdf'|'note_package'|'workspace_zip'|'diagram_image'|'media'|'persona'} params.type
+ * @param {Object} params.payload
+ */
+ async runExport({ type, payload = {} }) {
+ if (!type || typeof type !== "string") {
+ throw new Error("Export type is required.");
+ }
+
+ const downloadDir = this._getDownloadDir();
+ let result = null;
+
+ switch (type) {
+ case "pdf":
+ result = await this._exportPdf(payload, downloadDir);
+ break;
+ case "note_package":
+ result = await this._exportNotePackage(payload, downloadDir);
+ break;
+ case "workspace_zip":
+ result = await this._exportWorkspaceZip(payload, downloadDir);
+ break;
+ case "diagram_image":
+ case "media":
+ result = await this._exportMediaOrDiagram(payload, downloadDir, type);
+ break;
+ case "persona":
+ result = await this._exportPersona(payload, downloadDir);
+ break;
+ default:
+ throw new Error(`Unsupported export type: "${type}"`);
+ }
+
+ if (!result || !result.success) {
+ return result || { success: false, error: "Export execution failed" };
+ }
+
+ const { targetPath, filename, fileSize, exportType, category, sourceNote } = result;
+
+ // 1. Record into SQLite database
+ let record = null;
+ if (this.exportHistoryStore && targetPath) {
+ try {
+ record = await this.exportHistoryStore.addRecord({
+ filename,
+ filePath: targetPath,
+ fileSize: fileSize || 0,
+ exportType: exportType || type,
+ category: category || "document",
+ sourceNote: sourceNote || "",
+ });
+ } catch (err) {
+ console.warn("[ExportManager] DB record creation warning:", err);
+ }
+ }
+
+ // 2. Broadcast record-added event to all windows
+ if (this.BrowserWindow) {
+ const payloadRecord = record || {
+ filename,
+ filePath: targetPath,
+ fileSize,
+ exportType: exportType || type,
+ category: category || "document",
+ timestamp: new Date().toISOString(),
+ sourceNote: sourceNote || "",
+ };
+ this.BrowserWindow.getAllWindows().forEach((win) => {
+ if (!win.isDestroyed()) {
+ win.webContents.send("exports:record-added", payloadRecord);
+ }
+ });
+ }
+
+ return {
+ success: true,
+ filePath: targetPath,
+ filename,
+ fileSize,
+ record,
+ ...(result.entryCount ? { entryCount: result.entryCount } : {}),
+ ...(result.elapsedMs ? { elapsedMs: result.elapsedMs } : {})
+ };
+ }
+
+ _getDownloadDir() {
+ try {
+ if (this.app) return this.app.getPath("downloads");
+ } catch { /* ignore fallback */ }
+ return process.cwd();
+ }
+
+ _resolveCollisionFreePath(downloadDir, defaultName) {
+ const ext = path.extname(defaultName) || ".dat";
+ const base = path.basename(defaultName, ext);
+
+ let targetName = defaultName;
+ let targetPath = path.join(downloadDir, targetName);
+ let counter = 1;
+
+ while (fs.existsSync(targetPath)) {
+ targetName = `${base} (${counter})${ext}`;
+ targetPath = path.join(downloadDir, targetName);
+ counter++;
+ }
+
+ return { targetPath, targetName };
+ }
+
+ _sendWorkspaceExportProgress(progressPayload) {
+ if (!this.BrowserWindow) return;
+ this.BrowserWindow.getAllWindows().forEach((win) => {
+ if (!win.isDestroyed()) {
+ try {
+ win.webContents.send("workspace-export:progress", progressPayload);
+ } catch { /* ignore */ }
+ }
+ });
+ }
+
+ // --- Type 1: PDF Export ---
+ async _exportPdf(payload, downloadDir) {
+ const notesRoot = typeof this.getNotesRoot === "function" ? this.getNotesRoot() : null;
+ const resolved = path.resolve(String(payload?.filePath || ""));
+
+ if (notesRoot && typeof this.filePathWithin === "function") {
+ if (!this.filePathWithin(notesRoot, resolved)) {
+ throw new Error("Invalid document path.");
+ }
+ }
+
+ const includeRawNotes = Boolean(payload?.includeRawNotes);
+ const includeCleansed = Boolean(payload?.includeCleansed);
+ const pdfQualityPreset = ["full", "balanced", "compact"].includes(payload?.pdfQualityPreset)
+ ? payload.pdfQualityPreset
+ : "full";
+ const downsampleImages = Boolean(payload?.downsampleImages) || pdfQualityPreset !== "full";
+
+ if (!includeRawNotes && !includeCleansed) {
+ throw new Error("Select at least one section to export.");
+ }
+
+ const rawTitle = payload?.title || path.basename(resolved, ".md") || "document";
+ const defaultName = `${rawTitle.replace(/[<>:"/\\|?*]/g, "_")}.pdf`;
+ const { targetPath, targetName } = this._resolveCollisionFreePath(downloadDir, defaultName);
+
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "notely-pdf-"));
+ const tempMarkdownPath = path.join(tempDir, `${slugify(path.basename(resolved))}-export.md`);
+ const tempHtmlPath = path.join(tempDir, `${slugify(path.basename(resolved))}-export.html`);
+
+ const markdownContent = typeof this.buildPdfExportMarkdown === "function"
+ ? this.buildPdfExportMarkdown(payload, { includeRawNotes, includeCleansed })
+ : (payload.cleansed || payload.rawNotes || "");
+
+ fs.writeFileSync(tempMarkdownPath, markdownContent, "utf8");
+
+ try {
+ const baseHref = pathToFileURL(`${path.dirname(resolved)}${path.sep}`).href;
+ const html = typeof this.buildPdfExportHtml === "function"
+ ? this.buildPdfExportHtml({
+ title: rawTitle,
+ markdownContent,
+ baseHref,
+ sourceDir: path.dirname(resolved),
+ downsampleImages,
+ pdfQualityPreset
+ })
+ : `${markdownContent}`;
+
+ fs.writeFileSync(tempHtmlPath, html, "utf8");
+
+ const pdfWindow = new this.BrowserWindow({
+ show: false,
+ width: 1280,
+ height: 1600,
+ backgroundColor: "#ffffff",
+ webPreferences: {
+ backgroundThrottling: false,
+ contextIsolation: true,
+ nodeIntegration: false,
+ sandbox: true,
+ webviewTag: false
+ }
+ });
+
+ try {
+ await pdfWindow.loadFile(tempHtmlPath);
+ await pdfWindow.webContents.executeJavaScript("document.fonts ? document.fonts.ready : Promise.resolve()");
+
+ const pdfData = await pdfWindow.webContents.printToPDF({
+ printBackground: true,
+ preferCSSPageSize: true
+ });
+
+ await writeFileWithRetries(targetPath, pdfData);
+ } finally {
+ if (!pdfWindow.isDestroyed()) {
+ pdfWindow.close();
+ }
+ }
+
+ let fileSize = 0;
+ try { fileSize = fs.statSync(targetPath).size; } catch { /* ignore */ }
+
+ return {
+ success: true,
+ targetPath,
+ filename: targetName,
+ fileSize,
+ exportType: "pdf",
+ category: "document",
+ sourceNote: path.basename(resolved)
+ };
+ } finally {
+ try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch { /* ignore */ }
+ }
+ }
+
+ // --- Type 2: Note Package (.nly) ---
+ async _exportNotePackage(payload, downloadDir) {
+ const notesRoot = typeof this.getNotesRoot === "function" ? this.getNotesRoot() : null;
+ if (!notesRoot) throw new Error("No notes root configured.");
+
+ const { noteFilePaths, destinationPath, fileName, password, notePaths, outputPath } = payload;
+ const pathsToExport = noteFilePaths || notePaths || [];
+
+ let finalDest = "";
+ let targetName = "";
+ if (outputPath) {
+ finalDest = path.resolve(outputPath);
+ targetName = path.basename(finalDest);
+ fs.mkdirSync(path.dirname(finalDest), { recursive: true });
+ } else if (destinationPath) {
+ const exportFileName = fileName || `export_${Date.now()}.nly`;
+ const resolvedDest = path.resolve(destinationPath);
+ fs.mkdirSync(resolvedDest, { recursive: true });
+ finalDest = path.join(resolvedDest, exportFileName);
+ targetName = exportFileName;
+ } else {
+ const rootFolderName = path.basename(notesRoot) || "notes";
+ const defaultName = fileName || `${rootFolderName}_package.nly`;
+ const res = this._resolveCollisionFreePath(downloadDir, defaultName);
+ finalDest = res.targetPath;
+ targetName = res.targetName;
+ }
+
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "notely-note-export-"));
+ const stagingNotesDir = path.join(tempDir, "notes");
+ const stagingMediaDir = path.join(tempDir, "media");
+ const stagingExcaliDir = path.join(tempDir, "excalidraw");
+ const stagingDrawioDir = path.join(tempDir, "drawio");
+
+ fs.mkdirSync(stagingNotesDir, { recursive: true });
+ fs.mkdirSync(stagingMediaDir, { recursive: true });
+ fs.mkdirSync(stagingExcaliDir, { recursive: true });
+ fs.mkdirSync(stagingDrawioDir, { recursive: true });
+
+ let passwordSalt = "";
+ let passwordHash = "";
+ if (password) {
+ passwordSalt = crypto.randomBytes(16).toString("hex");
+ passwordHash = crypto.createHash("sha256").update(password + passwordSalt).digest("hex");
+ }
+
+ const manifest = {
+ version: 1,
+ exportedAt: new Date().toISOString(),
+ notes: [],
+ media: [],
+ excalidraw: [],
+ drawio: [],
+ files: {},
+ passwordSalt,
+ passwordHash
+ };
+
+ const allMediaPaths = new Set();
+ const allExcalidrawIds = new Set();
+ const allDrawioIds = new Set();
+
+ try {
+ // 1. Gather note contents & dependencies
+ for (const inputPath of pathsToExport) {
+ const absPath = path.isAbsolute(inputPath) ? inputPath : path.resolve(notesRoot, inputPath);
+ if (typeof this.filePathWithin === "function" && !this.filePathWithin(notesRoot, absPath)) continue;
+ if (!fs.existsSync(absPath)) continue;
+
+ const relPath = path.relative(notesRoot, absPath).replace(/\\/g, "/");
+ const content = await fsAsync.readFile(absPath, "utf8");
+ const depsResult = scanNoteDependencies(content);
+
+ depsResult.images.forEach(img => allMediaPaths.add(img));
+ depsResult.excalidrawIds.forEach(id => allExcalidrawIds.add(id));
+ depsResult.drawioIds.forEach(id => allDrawioIds.add(id));
+
+ const stagingNotePath = path.join(stagingNotesDir, relPath);
+ fs.mkdirSync(path.dirname(stagingNotePath), { recursive: true });
+ await fsAsync.writeFile(stagingNotePath, content, "utf8");
+ manifest.notes.push(relPath);
+ }
+
+ // 2. Package media assets
+ for (const relMediaPath of allMediaPaths) {
+ const cleanRelPath = relMediaPath.replace(/^\/+/, "").replace(/[?#].*$/, "").trim().replace(/\\/g, "/");
+ if (!cleanRelPath) continue;
+ const absPath = path.resolve(notesRoot, cleanRelPath);
+ if (typeof this.filePathWithin === "function" && !this.filePathWithin(notesRoot, absPath)) continue;
+ if (!fs.existsSync(absPath)) continue;
+ const stagingPath = path.join(stagingMediaDir, cleanRelPath);
+ try {
+ fs.mkdirSync(path.dirname(stagingPath), { recursive: true });
+ await fsAsync.copyFile(absPath, stagingPath);
+ manifest.media.push(cleanRelPath);
+ } catch { /* ignore unreadable media */ }
+ }
+
+ // 3. Package Excalidraw diagrams
+ for (const id of allExcalidrawIds) {
+ if (!id) continue;
+ const excaliSrcDir = path.join(notesRoot, ".notes-app", "excali-diagrams", id);
+ const excaliDestDir = path.join(stagingExcaliDir, id);
+ if (!fs.existsSync(excaliSrcDir)) continue;
+ try {
+ fs.mkdirSync(excaliDestDir, { recursive: true });
+ const files = await fsAsync.readdir(excaliSrcDir);
+ for (const file of files) {
+ try { await fsAsync.copyFile(path.join(excaliSrcDir, file), path.join(excaliDestDir, file)); } catch { /* ignore */ }
+ }
+ manifest.excalidraw.push(id);
+ } catch { /* ignore */ }
+ }
+
+ // 4. Package Draw.io diagrams
+ for (const id of allDrawioIds) {
+ if (!id) continue;
+ const drawioSrcDir = path.join(notesRoot, "media", "draw.io");
+ const drawioDestDir = stagingDrawioDir;
+ const filesToCopy = [`${id}.drawio`, `${id}.png`];
+ let hasDiagram = false;
+ for (const file of filesToCopy) {
+ const srcPath = path.join(drawioSrcDir, file);
+ const destPath = path.join(drawioDestDir, file);
+ if (!fs.existsSync(srcPath)) continue;
+ try {
+ await fsAsync.copyFile(srcPath, destPath);
+ hasDiagram = true;
+ } catch { /* ignore */ }
+ }
+ if (hasDiagram) manifest.drawio.push(id);
+ }
+
+ // 5. Generate ZIP & Manifest Hashes
+ const zipfile = new ZipFile();
+ const zipEntries = [];
+
+ async function addStagedFile(localStagedPath, zipRelativePath) {
+ const fileData = await fsAsync.readFile(localStagedPath);
+ const hash = crypto.createHash("sha256").update(fileData).digest("hex");
+ manifest.files[zipRelativePath] = hash;
+ zipEntries.push({ localStagedPath, zipRelativePath });
+ }
+
+ const walkAndStage = async (dir, relativePrefix) => {
+ if (!fs.existsSync(dir)) return;
+ const entries = await fsAsync.readdir(dir, { withFileTypes: true });
+ for (const entry of entries) {
+ const fullPath = path.join(dir, entry.name);
+ const zipPath = path.join(relativePrefix, entry.name).replace(/\\/g, "/");
+ if (entry.isDirectory()) {
+ await walkAndStage(fullPath, zipPath);
+ } else {
+ await addStagedFile(fullPath, zipPath);
+ }
+ }
+ };
+
+ await walkAndStage(stagingNotesDir, "notes");
+ await walkAndStage(stagingMediaDir, "media");
+ await walkAndStage(stagingExcaliDir, "excalidraw");
+ await walkAndStage(stagingDrawioDir, "drawio");
+
+ const manifestPath = path.join(tempDir, "metadata.json");
+ await fsAsync.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+ zipEntries.push({ localStagedPath: manifestPath, zipRelativePath: "metadata.json" });
+
+ const zipOutputPath = path.join(tempDir, "temp.zip");
+ const zipStream = fs.createWriteStream(zipOutputPath);
+
+ await new Promise((resolve, reject) => {
+ zipStream.on("close", resolve);
+ zipfile.outputStream.on("error", reject);
+ zipStream.on("error", reject);
+ zipfile.outputStream.pipe(zipStream);
+ for (const entry of zipEntries) {
+ zipfile.addFile(entry.localStagedPath, entry.zipRelativePath);
+ }
+ zipfile.end();
+ });
+
+ const zipBuffer = await fsAsync.readFile(zipOutputPath);
+ const outputBuffer = password ? encryptBuffer(zipBuffer) : zipBuffer;
+
+ const finalDestTmp = finalDest + ".tmp";
+ await fsAsync.writeFile(finalDestTmp, outputBuffer);
+ try {
+ if (fs.existsSync(finalDest)) {
+ await fsAsync.unlink(finalDest);
+ }
+ await fsAsync.rename(finalDestTmp, finalDest);
+ } catch {
+ await fsAsync.writeFile(finalDest, outputBuffer);
+ try { await fsAsync.unlink(finalDestTmp); } catch { /* ignore */ }
+ }
+
+ let fileSize = 0;
+ try { fileSize = fs.statSync(finalDest).size; } catch { /* ignore */ }
+
+ return {
+ success: true,
+ targetPath: finalDest,
+ filename: targetName,
+ fileSize,
+ exportType: "note_package",
+ category: "document"
+ };
+ } finally {
+ try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch { /* ignore */ }
+ }
+ }
+
+ _walkFiles(rootDir, options = {}) {
+ const exclude = new Set(options.excludeDirs || []);
+ const files = [];
+
+ const visit = (currentDir) => {
+ if (!fs.existsSync(currentDir)) return;
+ const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+ for (const entry of entries) {
+ const nextPath = path.join(currentDir, entry.name);
+ if (entry.isDirectory()) {
+ if (exclude.has(entry.name)) continue;
+ visit(nextPath);
+ continue;
+ }
+ if (entry.isFile()) {
+ files.push(nextPath);
+ }
+ }
+ };
+
+ visit(rootDir);
+ return files;
+ }
+
+ _copyDirRecursive(sourceRoot, targetRoot, options = {}) {
+ const exclude = new Set(options.excludeDirs || []);
+
+ const copyDir = (currentSource, currentTarget) => {
+ fs.mkdirSync(currentTarget, { recursive: true });
+ const entries = fs.readdirSync(currentSource, { withFileTypes: true });
+ for (const entry of entries) {
+ if (entry.isDirectory() && exclude.has(entry.name)) continue;
+ const sourcePath = path.join(currentSource, entry.name);
+ const targetPath = path.join(currentTarget, entry.name);
+
+ if (entry.isDirectory()) {
+ copyDir(sourcePath, targetPath);
+ continue;
+ }
+
+ if (entry.isFile()) {
+ fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+ try { fs.copyFileSync(sourcePath, targetPath); } catch { /* ignore */ }
+ }
+ }
+ };
+
+ copyDir(sourceRoot, targetRoot);
+ }
+
+ async _exportPdfWorkspace({ notesRoot, stagingRoot, _contentMode }) {
+ const markdownFiles = this._walkFiles(notesRoot, {
+ excludeDirs: [".notes-app", "node_modules", ".git", ".artifacts", "dist", "build"],
+ }).filter((filePath) => path.extname(filePath).toLowerCase() === ".md");
+
+ const tempHtmlDir = path.join(stagingRoot, "_pdf-html");
+ fs.mkdirSync(tempHtmlDir, { recursive: true });
+
+ const outputRoot = path.join(stagingRoot, "pdf");
+ fs.mkdirSync(outputRoot, { recursive: true });
+
+ for (const markdownPath of markdownFiles) {
+ const content = fs.readFileSync(markdownPath, "utf8");
+ const parsed = typeof this.parseDocument === "function" ? this.parseDocument(content, markdownPath) : { title: path.basename(markdownPath, ".md") };
+ const relativeMdPath = path.relative(notesRoot, markdownPath);
+
+ const markdownContent = typeof this.buildPdfExportMarkdown === "function"
+ ? this.buildPdfExportMarkdown(parsed, { includeRawNotes: true, includeCleansed: true })
+ : content;
+ const html = typeof this.buildPdfExportHtml === "function"
+ ? this.buildPdfExportHtml({
+ title: parsed.title || path.basename(markdownPath, ".md"),
+ markdownContent,
+ baseHref: pathToFileURL(`${path.dirname(markdownPath)}${path.sep}`).href,
+ sourceDir: path.dirname(markdownPath),
+ downsampleImages: false,
+ pdfQualityPreset: "full",
+ })
+ : `${markdownContent}`;
+
+ const relativePdfPath = relativeMdPath.replace(/\.md$/i, ".pdf");
+ const htmlTempPath = path.join(tempHtmlDir, `${relativePdfPath.replace(/[\\/]/g, "__")}.html`);
+ const pdfOutputPath = path.join(outputRoot, relativePdfPath);
+
+ fs.mkdirSync(path.dirname(pdfOutputPath), { recursive: true });
+ fs.writeFileSync(htmlTempPath, html, "utf8");
+
+ if (this.BrowserWindow) {
+ const pdfWindow = new this.BrowserWindow({
+ show: false,
+ width: 1280,
+ height: 1600,
+ backgroundColor: "#ffffff",
+ webPreferences: {
+ backgroundThrottling: false,
+ contextIsolation: true,
+ nodeIntegration: false,
+ sandbox: true,
+ webviewTag: false,
+ },
+ });
+
+ try {
+ await pdfWindow.loadFile(htmlTempPath);
+ await pdfWindow.webContents.executeJavaScript("document.fonts ? document.fonts.ready : Promise.resolve()", true);
+
+ const pdfData = await pdfWindow.webContents.printToPDF({
+ printBackground: true,
+ preferCSSPageSize: true,
+ });
+
+ await writeFileWithRetries(pdfOutputPath, pdfData);
+ } finally {
+ if (!pdfWindow.isDestroyed()) {
+ pdfWindow.close();
+ }
+ }
+ }
+ }
+ }
+
+ _exportWebWorkspace({ notesRoot, stagingRoot, _contentMode }) {
+ const allFiles = this._walkFiles(notesRoot, {
+ excludeDirs: [".notes-app", "node_modules", ".git", ".artifacts", "dist", "build"],
+ });
+ const markdownFiles = allFiles.filter((filePath) => path.extname(filePath).toLowerCase() === ".md");
+ const nonMarkdownFiles = allFiles.filter((filePath) => path.extname(filePath).toLowerCase() !== ".md");
+
+ const webRoot = path.join(stagingRoot, "web");
+ fs.mkdirSync(webRoot, { recursive: true });
+
+ const mdToHtmlMap = new Map();
+ for (const markdownPath of markdownFiles) {
+ const relMdPath = path.relative(notesRoot, markdownPath).replace(/\\/g, "/");
+ const relHtmlPath = relMdPath.replace(/\.md$/i, ".html");
+ mdToHtmlMap.set(relMdPath, relHtmlPath);
+ }
+
+ let markdownIt = null;
+ if (typeof this.getMarkdownIt === "function") {
+ try {
+ const MarkdownItCtor = this.getMarkdownIt();
+ markdownIt = new MarkdownItCtor({ html: false, linkify: true, typographer: true });
+ } catch { /* fallback */ }
+ }
+
+ const indexLinks = [];
+
+ for (const markdownPath of markdownFiles) {
+ const relMdPath = path.relative(notesRoot, markdownPath).replace(/\\/g, "/");
+ const relHtmlPath = mdToHtmlMap.get(relMdPath);
+ const htmlPath = path.join(webRoot, relHtmlPath);
+ const content = fs.readFileSync(markdownPath, "utf8");
+
+ const title = path.basename(markdownPath, ".md");
+ const renderedHtml = markdownIt ? markdownIt.render(content) : `