@@ -1282,6 +1279,7 @@
File Explorer
+
diff --git a/src/renderer/index.js b/src/renderer/index.js
index ffa68ab..248ba3d 100644
--- a/src/renderer/index.js
+++ b/src/renderer/index.js
@@ -72,10 +72,14 @@ function selectFile(el, filePath, lines, chars) {
* Open a .md file from an absolute path (OS double-click or second-instance forward).
* Switches the sidebar folder when needed, highlights the file, resets the chat.
*/
-async function openFileByPath(filePath) {
+async function openFileByPath(filePath, { addToRecents = false } = {}) {
if (!filePath) return;
- await SaveManager.silentSave();
+ const saved = await SaveManager.silentSave();
+ if (!saved) {
+ StatusBar.showToast('Could not save current file — please check disk space or permissions.');
+ return;
+ }
const lastSep = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
const folderPath = lastSep > 0 ? filePath.substring(0, lastSep) : '';
@@ -135,18 +139,126 @@ async function openFileByPath(filePath) {
const lines = content.split('\n').length;
selectFile(matchedItem, filePath, lines, content.length);
+ // Not added to Recent Files by default — openFileByPath is shared by
+ // search results and in-document link clicks too. Only true "opened from
+ // outside the app" callers (Windows Explorer / OS open) pass addToRecents.
+ if (addToRecents) {
+ const name = filePath.split(/[\\/]/).pop() || filePath;
+ StorageManager.addRecentItem('file', filePath, name, SaveManager.extractFirstLine(content));
+ }
+ WelcomeScreen.hideWelcomeScreen();
+ ChatPanel.clearChat();
+ RecentsPanel.render();
+}
+
+/**
+ * Open a file from the "Recent Files" sidebar section. Unlike openFileByPath,
+ * this never touches the active folder/tree — recent files are reachable
+ * regardless of which folder (if any) is currently open.
+ */
+async function openRecentFile(filePath) {
+ if (!filePath) return;
+
+ const saved = await SaveManager.silentSave();
+ if (!saved) {
+ StatusBar.showToast('Could not save current file — please check disk space or permissions.');
+ return;
+ }
+
+ const result = await window.electronAPI?.readFile(filePath);
+ if (!result) {
+ StatusBar.showToast('File not found — removed from Recent Files.');
+ StorageManager.removeRecentItem(filePath);
+ RecentsPanel.render();
+ return;
+ }
+ const content = result.content ?? '';
+
+ if (mdEditor) {
+ EditorCore.clearAiUndoStack();
+ mdEditor.value = content;
+ mdEditor.scrollTop = 0;
+ mdEditor.setSelectionRange(0, 0);
+ const gutter = document.getElementById('line-numbers');
+ if (gutter) gutter.scrollTop = 0;
+ EditorCore.updateHighlight();
+ EditorCore.updateStats();
+ EditorCore.triggerUpdate();
+ }
+ SaveManager.markClean();
+
+ const name = filePath.split(/[\\/]/).pop() || filePath;
+ currentFile = { name, path: filePath };
+ StatusBar.updateFilename(name);
+ StatusBar.updateChatContextFile(name);
+ StorageManager.addRecentItem('file', filePath, name, SaveManager.extractFirstLine(content));
+
+ const list = document.getElementById('file-list');
+ if (list) {
+ for (const item of list.querySelectorAll('.file-item')) {
+ item.classList.toggle('active', item.dataset.path === filePath);
+ }
+ }
+
+ WelcomeScreen.hideWelcomeScreen();
+ ChatPanel.clearChat();
+ RecentsPanel.render();
+}
+
+/**
+ * Restore the persisted untitled draft into the editor (from the "Recent
+ * Files" section's draft row) after having switched away to another file.
+ */
+async function restoreDraftFile() {
+ if (currentFile.path) {
+ const saved = await SaveManager.silentSave();
+ if (!saved) {
+ StatusBar.showToast('Could not save current file — please check disk space or permissions.');
+ return;
+ }
+ }
+
+ const draft = SaveManager.getDraft();
+
+ if (mdEditor) {
+ EditorCore.clearAiUndoStack();
+ mdEditor.value = draft;
+ mdEditor.scrollTop = 0;
+ mdEditor.setSelectionRange(0, 0);
+ const gutter = document.getElementById('line-numbers');
+ if (gutter) gutter.scrollTop = 0;
+ EditorCore.updateHighlight();
+ EditorCore.updateStats();
+ EditorCore.triggerUpdate();
+ }
+
+ document.querySelectorAll('.file-item.active').forEach(f => f.classList.remove('active'));
+
+ currentFile = { name: 'untitled.md', path: null };
+ StatusBar.updateFilename('untitled.md');
+ StatusBar.updateChatContextFile('untitled.md');
+ SaveManager.markDirty();
+
WelcomeScreen.hideWelcomeScreen();
ChatPanel.clearChat();
+ setMode('edit');
+ RecentsPanel.render();
}
/**
* Open a single .md file from the file picker (Ctrl+O or recent-items click).
- * Hides the explorer sidebar (no folder context), shows full path in header.
+ * This file isn't necessarily related to whatever folder was open before —
+ * shows the full path in the header, but keeps the sidebar visible (Recent
+ * Files is where this file is reachable) rather than hiding it.
*/
async function openSingleFile(filePath) {
if (!filePath) return;
- await SaveManager.silentSave();
+ const saved = await SaveManager.silentSave();
+ if (!saved) {
+ StatusBar.showToast('Could not save current file — please check disk space or permissions.');
+ return;
+ }
const result = await window.electronAPI?.readFile(filePath);
if (!result) { console.warn('[openSingleFile] could not read file:', filePath); return; }
@@ -164,7 +276,7 @@ async function openSingleFile(filePath) {
}
SaveManager.markClean();
- SidebarManager.setExplorerVisible(false, false);
+ SidebarManager.setExplorerVisible(true, true);
const label = document.getElementById('header-folder-name');
if (label) label.textContent = filePath;
@@ -172,9 +284,97 @@ async function openSingleFile(filePath) {
selectFile(null, filePath, content.split('\n').length, content.length);
const fileName = filePath.split(/[\\/]/).pop() || filePath;
- StorageManager.addRecentItem('file', filePath, fileName);
+ StorageManager.addRecentItem('file', filePath, fileName, SaveManager.extractFirstLine(content));
WelcomeScreen.hideWelcomeScreen();
ChatPanel.clearChat();
+ RecentsPanel.render();
+}
+
+/**
+ * Reset the editor to a blank untitled buffer. Assumes the caller has already
+ * handled whatever was there before (saved, discarded, or it was already
+ * empty) — this just performs the reset.
+ */
+function _resetToBlankUntitled() {
+ if (mdEditor) {
+ EditorCore.clearAiUndoStack();
+ mdEditor.value = '';
+ mdEditor.scrollTop = 0;
+ mdEditor.setSelectionRange(0, 0);
+ const gutter = document.getElementById('line-numbers');
+ if (gutter) gutter.scrollTop = 0;
+ EditorCore.updateHighlight();
+ EditorCore.updateStats();
+ EditorCore.triggerUpdate();
+ }
+
+ document.querySelectorAll('.file-item.active').forEach(f => f.classList.remove('active'));
+
+ currentFile = { name: 'untitled.md', path: null };
+ StatusBar.updateFilename('untitled.md');
+ StatusBar.updateChatContextFile('untitled.md');
+ SaveManager.markClean();
+ SaveManager.clearDraft();
+}
+
+/**
+ * Start a fresh in-memory, unsaved document (Ctrl+N).
+ * Unlike the explorer's "New File" (which creates a file inside a folder and
+ * needs the sidebar visible), this has no folder/explorer dependency at all —
+ * it works identically whether or not a folder is open or the sidebar is shown.
+ */
+async function newUntitledFile() {
+ if (currentFile.path) {
+ // Existing saved file with unsaved edits — auto-save silently, same as
+ // switching to another file elsewhere in the app.
+ const saved = await SaveManager.silentSave();
+ if (!saved) {
+ StatusBar.showToast('Could not save current file — please check disk space or permissions.');
+ return;
+ }
+
+ // There's only one untitled slot at a time. If an earlier untitled
+ // buffer was switched away from and left abandoned in Recent Files with
+ // real content, starting a new blank one would otherwise silently wipe
+ // it — ask first.
+ if (SaveManager.hasDraft() && SaveManager.getDraft()) {
+ const choice = await window.electronAPI?.confirmUnsaved();
+ if (choice === 'cancel' || !choice) return;
+ if (choice === 'save') {
+ const ok = await SaveManager.saveDraftAs();
+ if (!ok) return;
+ }
+ }
+ } else if (SaveManager.isDirty()) {
+ // Unsaved untitled buffer — there's no file to silently save to, so ask
+ // before discarding its content.
+ const choice = await window.electronAPI?.confirmUnsaved();
+ if (choice === 'cancel' || !choice) return;
+ if (choice === 'save') {
+ await SaveManager.saveFile(); // opens the native Save-As dialog
+ if (SaveManager.isDirty()) return; // user cancelled the save dialog — abort
+ }
+ }
+
+ _resetToBlankUntitled();
+
+ WelcomeScreen.hideWelcomeScreen();
+ ChatPanel.clearChat();
+ setMode('edit');
+ RecentsPanel.render();
+}
+
+/**
+ * Discard the untitled buffer that's *currently loaded* in the editor, from
+ * the Recent Files draft row's × button (after the confirm dialog already
+ * approved it). Distinct from newUntitledFile — the caller has already
+ * decided to discard, so this never re-prompts.
+ */
+function discardLiveUntitledDraft() {
+ _resetToBlankUntitled();
+ WelcomeScreen.hideWelcomeScreen();
+ ChatPanel.clearChat();
+ RecentsPanel.render();
}
/* ── Handle deleted/moved file ────────────────────────────────────── */
@@ -212,20 +412,11 @@ document.addEventListener('keydown', async e => {
}
});
-// Ctrl+N — new file
+// Ctrl+N — new untitled file (notepad-style; no folder or sidebar required)
document.addEventListener('keydown', async e => {
if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
e.preventDefault();
- const savedFolder = sessionStorage.getItem('lastFolder');
- if (savedFolder) {
- FileOperations.showNewFileInput();
- } else {
- const result = await window.electronAPI?.openFolder();
- if (result?.folderPath) {
- await FileTreeManager.setActiveFolder(result.folderPath);
- FileOperations.showNewFileInput();
- }
- }
+ await newUntitledFile();
}
});
@@ -233,7 +424,8 @@ document.addEventListener('keydown', async e => {
// Block close when unsaved — triggers Electron's will-prevent-unload
window.addEventListener('beforeunload', (e) => {
- if (SaveManager.isDirty() && !SaveManager.isBypassBeforeUnload()) {
+ const isEmptyUntitled = !currentFile.path && !(mdEditor?.value ?? '').trim();
+ if (SaveManager.isDirty() && !isEmptyUntitled && !SaveManager.isBypassBeforeUnload()) {
e.preventDefault();
e.returnValue = '';
}
@@ -301,6 +493,7 @@ document.addEventListener('DOMContentLoaded', async () => {
SidebarManager.initSidebarToggles();
SearchPanel.init();
FileTreeManager.initFolderDropdown();
+ RecentsPanel.applyExplorerMode();
const _version = window.electronAPI?.appVersion;
if (_version) document.title = `MoilStack .md ${_version}`;
@@ -311,10 +504,8 @@ document.addEventListener('DOMContentLoaded', async () => {
// the async DOMContentLoaded callback is suspended, so messages arrive early.
if (window.electronAPI?.onOpenFileFromOS) {
window.electronAPI.onOpenFileFromOS(async (filePath) => {
- SidebarManager.setExplorerVisible(true, false);
- const fileName = filePath.split(/[\\/]/).pop() || filePath;
- StorageManager.addRecentItem('file', filePath, fileName);
- await openFileByPath(filePath);
+ SidebarManager.setExplorerVisible(true, true);
+ await openFileByPath(filePath, { addToRecents: true });
});
}
@@ -348,7 +539,14 @@ document.addEventListener('DOMContentLoaded', async () => {
WelcomeScreen.hideWelcomeScreen();
});
- WelcomeScreen.showWelcomeScreen();
+ const launchBehavior = localStorage.getItem('launchBehavior') || 'untitled';
+ // An unsaved draft from a previous session outranks both the Recents screen
+ // and the "start blank" preference — there's real work to hand back.
+ const _pendingDraft = _openFileParam ? '' : SaveManager.getDraft();
+
+ if (!_openFileParam && !_pendingDraft && launchBehavior !== 'untitled') {
+ WelcomeScreen.showWelcomeScreen();
+ }
const savedFolder = sessionStorage.getItem('lastFolder') || localStorage.getItem('lastFolder');
if (savedFolder && !_openFileParam) await FileTreeManager.setActiveFolder(savedFolder);
@@ -388,10 +586,25 @@ document.addEventListener('DOMContentLoaded', async () => {
EditorCore.updateStats();
if (_openFileParam) {
- SidebarManager.setExplorerVisible(true, false);
- const _paramFileName = _openFileParam.split(/[\\/]/).pop() || _openFileParam;
- StorageManager.addRecentItem('file', _openFileParam, _paramFileName);
- await openFileByPath(_openFileParam);
+ // Opened via "Open in New Window" (Explorer context menu) or Windows
+ // Explorer/file association. This file isn't necessarily related to
+ // whatever folder was open before — persist the sidebar as visible
+ // (Recent Files is where this file is reachable) rather than hiding it;
+ // it now only closes if the user explicitly toggles it via the header icon.
+ SidebarManager.setExplorerVisible(true, true);
+ await openFileByPath(_openFileParam, { addToRecents: true });
+ } else if (_pendingDraft) {
+ await newUntitledFile();
+ if (mdEditor) {
+ mdEditor.value = _pendingDraft;
+ EditorCore.updateHighlight();
+ EditorCore.updateStats();
+ EditorCore.triggerUpdate();
+ }
+ SaveManager.markDirty();
+ StatusBar.showToast('Restored unsaved draft from your last session.');
+ } else if (launchBehavior === 'untitled') {
+ await newUntitledFile();
}
if (!_openFileParam) ChatPanel.clearChat();
@@ -399,8 +612,13 @@ document.addEventListener('DOMContentLoaded', async () => {
ChatPanel.updateTokenEstimate();
ChatPanel.updateFileSizeWarning();
- const startupMode = localStorage.getItem('startupMode') || 'preview';
- setMode(startupMode);
+ // A fresh untitled launch or a restored draft always opens in edit mode
+ // (newUntitledFile already set this) — the Startup Mode preference only
+ // applies when an existing file was opened.
+ if (_openFileParam || (!_pendingDraft && launchBehavior !== 'untitled')) {
+ const startupMode = localStorage.getItem('startupMode') || 'preview';
+ setMode(startupMode);
+ }
// ── IPC: Save-and-close (user clicked "Save" in unsaved-changes dialog)
window.electronAPI?.onSaveAndClose?.(async () => {
@@ -411,6 +629,12 @@ document.addEventListener('DOMContentLoaded', async () => {
}
});
+ // ── IPC: Discard-and-close (user clicked "Discard" in unsaved-changes dialog)
+ window.electronAPI?.onDiscardAndClose?.(() => {
+ SaveManager.setBypassBeforeUnload(true);
+ window.close();
+ });
+
// ── Custom title-bar window controls ──────────────────────────────
const _wcMinimize = document.getElementById('wc-minimize');
const _wcMaximize = document.getElementById('wc-maximize');
@@ -432,7 +656,8 @@ document.addEventListener('DOMContentLoaded', async () => {
_wcMaximize.setAttribute('aria-label', isMax ? 'Restore window' : 'Maximize window')
}
- window.electronAPI?.window?.isMaximized().then(_updateMaximizeIcon)
+ const _isMax = await window.electronAPI?.window?.isMaximized()
+ _updateMaximizeIcon(_isMax)
window.electronAPI?.window?.onMaximizedChange(_updateMaximizeIcon)
}
@@ -448,7 +673,17 @@ document.addEventListener('DOMContentLoaded', async () => {
const prevFilePath = currentFile.path;
await FileTreeManager.setActiveFolder(folderPath);
- if (prevFilePath) {
+ // Only treat a missing tree entry as "deleted" when the open file was
+ // actually supposed to live inside the active folder. A file saved,
+ // opened, or reopened from elsewhere (Save-As to another location,
+ // Ctrl+O, a Recent Files entry from a different folder) is correctly
+ // absent from this tree — that's not a deletion.
+ const insideActiveFolder = prevFilePath && (
+ prevFilePath.startsWith(folderPath + '/') ||
+ prevFilePath.startsWith(folderPath + '\\')
+ );
+
+ if (insideActiveFolder) {
if (FileTreeManager.fileExistsInTree(prevFilePath)) {
FileTreeManager.restoreActiveItem();
} else {
@@ -458,4 +693,9 @@ document.addEventListener('DOMContentLoaded', async () => {
}, 300);
});
+ RecentsPanel.render();
+
+ // ── Startup UI work is done — show the window now ──────────────────
+ window.electronAPI?.notifyReady?.();
+
});
diff --git a/src/renderer/modalManager.js b/src/renderer/modalManager.js
index 19b8756..d5d7f56 100644
--- a/src/renderer/modalManager.js
+++ b/src/renderer/modalManager.js
@@ -1,133 +1,62 @@
/**
- * modalManager.js — Save-As modal (and future modals).
+ * modalManager.js — Save-As via the native OS Save dialog.
*
* currentFile is a global var declared in index.js (resolved lazily at call time).
*/
const ModalManager = (() => {
- /* ── Save-As Modal ────────────────────────────────────────────────── */
-
- let _saveAsSelectedFolder = null;
-
- function _updateFolderDisplay(folderPath) {
- const el = document.getElementById('saveAsFolderDisplay');
- if (el) { el.textContent = folderPath; el.title = folderPath; }
- }
-
- function _showError(message) {
- const errEl = document.getElementById('saveAsError');
- const inputEl = document.getElementById('saveAsFilename');
- if (errEl) { errEl.textContent = message; errEl.classList.remove('hidden'); }
- if (inputEl) {
- inputEl.classList.add('save-as-filename--error');
- inputEl.addEventListener('animationend', () => {
- inputEl.classList.remove('save-as-filename--error');
- }, { once: true });
- }
- }
-
- function _hideError() {
- const errEl = document.getElementById('saveAsError');
- const inputEl = document.getElementById('saveAsFilename');
- if (errEl) { errEl.textContent = ''; errEl.classList.add('hidden'); }
- if (inputEl) inputEl.classList.remove('save-as-filename--error');
- }
-
- function closeSaveAsModal() {
- document.getElementById('saveAsOverlay')?.classList.add('hidden');
- _saveAsSelectedFolder = null;
- _hideError();
+ /** Derive a filesystem-safe default filename from the document's first line of text. */
+ function _suggestFilename() {
+ const raw = SaveManager.extractFirstLine(document.getElementById('mdEditor')?.value ?? '');
+ const safe = raw.replace(/[\\/:*?"<>|]/g, '').trim().slice(0, 60);
+ return safe || 'untitled';
}
+ /**
+ * Save-As — opens the native Save dialog pre-pointed at the active folder
+ * (or the OS default location if none is open) with a filename suggested
+ * from the document's first line of text.
+ */
async function showSaveAsModal() {
- let folder = sessionStorage.getItem('lastFolder') || null;
- if (!folder) {
- const result = await window.electronAPI?.openFolder();
- if (!result?.folderPath) return;
- folder = result.folderPath;
- await FileTreeManager.setActiveFolder(folder);
- }
- _saveAsSelectedFolder = folder;
- _updateFolderDisplay(folder);
-
- const inputEl = document.getElementById('saveAsFilename');
- if (inputEl) {
- inputEl.value = 'untitled.md';
- }
-
- document.getElementById('saveAsOverlay')?.classList.remove('hidden');
- if (inputEl) {
- inputEl.focus();
- inputEl.setSelectionRange(0, 'untitled'.length);
- }
- }
-
- async function confirmSaveAs() {
- const confirmBtn = document.getElementById('btnSaveAsConfirm');
- const rawName = document.getElementById('saveAsFilename')?.value.trim() ?? '';
- const folderPath = _saveAsSelectedFolder;
- const editor = document.getElementById('mdEditor');
-
- if (!rawName) { _showError('Please enter a filename.'); return; }
- if (!folderPath) { _showError('No folder selected. Click Browse…'); return; }
-
- const fileName = rawName.includes('.') ? rawName : rawName + '.md';
-
- if (confirmBtn) { confirmBtn.disabled = true; confirmBtn.textContent = 'Saving…'; }
-
- try {
- const createResult = await window.electronAPI.newFileInFolder(folderPath, fileName);
- if (createResult?.error) { _showError(createResult.error); return; }
- if (!createResult?.filePath) { _showError('Could not create file.'); return; }
-
- const filePath = createResult.filePath;
-
- const writeResult = await window.electronAPI.writeFile(filePath, editor?.value ?? '');
- if (!writeResult?.ok) { _showError(writeResult?.error || 'Write failed.'); return; }
-
- await FileTreeManager.setActiveFolder(folderPath);
-
- const name = filePath.split(/[\\/]/).pop();
- currentFile = { name, path: filePath };
- StatusBar.updateFilename(name);
- StatusBar.updateChatContextFile(name);
- SaveManager.markClean();
-
- document.querySelectorAll('#file-list .file-item').forEach(item => {
- item.classList.toggle('active', item.dataset.path === filePath);
- });
-
- closeSaveAsModal();
- } finally {
- if (confirmBtn) { confirmBtn.disabled = false; confirmBtn.textContent = 'Save'; }
+ const folder = sessionStorage.getItem('lastFolder') || null;
+ const result = await window.electronAPI?.newFile(_suggestFilename(), folder);
+ if (!result?.filePath) return;
+
+ const editor = document.getElementById('mdEditor');
+ const content = editor?.value ?? '';
+
+ const writeResult = await window.electronAPI.writeFile(result.filePath, content);
+ if (!writeResult?.ok) { StatusBar.showToast(writeResult?.error || 'Save failed.'); return; }
+
+ const filePath = result.filePath;
+
+ // Only re-point the explorer at the saved-into folder if it's the one
+ // already active (or none was active) — saving somewhere you merely
+ // browsed to for this one file shouldn't yank the sidebar away from
+ // what you were viewing.
+ const savedFolder = filePath.replace(/[\\/][^\\/]+$/, '');
+ const activeFolder = sessionStorage.getItem('lastFolder');
+ if (!activeFolder || activeFolder === savedFolder) {
+ await FileTreeManager.setActiveFolder(savedFolder);
}
- }
- /* ── Event wiring ─────────────────────────────────────────────────── */
+ const name = filePath.split(/[\\/]/).pop();
+ currentFile = { name, path: filePath };
+ StatusBar.updateFilename(name);
+ StatusBar.updateChatContextFile(name);
+ SaveManager.markClean();
+ SaveManager.clearDraft();
+ StorageManager.addRecentItem('file', filePath, name, SaveManager.extractFirstLine(content));
- (function wireSaveAsModal() {
- document.getElementById('btnCloseSaveAs')?.addEventListener('click', closeSaveAsModal);
- document.getElementById('btnSaveAsCancel')?.addEventListener('click', closeSaveAsModal);
- document.getElementById('btnSaveAsConfirm')?.addEventListener('click', confirmSaveAs);
-
- document.getElementById('btnSaveAsPickFolder')?.addEventListener('click', async () => {
- const result = await window.electronAPI?.openFolder();
- if (!result?.folderPath) return;
- _saveAsSelectedFolder = result.folderPath;
- await FileTreeManager.setActiveFolder(result.folderPath);
- _updateFolderDisplay(result.folderPath);
- _hideError();
+ document.querySelectorAll('#file-list .file-item').forEach(item => {
+ item.classList.toggle('active', item.dataset.path === filePath);
});
- document.getElementById('saveAsFilename')?.addEventListener('keydown', e => {
- if (e.key === 'Enter') { e.preventDefault(); confirmSaveAs(); }
- if (e.key === 'Escape') { e.preventDefault(); closeSaveAsModal(); }
- else _hideError();
- });
- })();
+ RecentsPanel.render();
+ }
- return { showSaveAsModal, closeSaveAsModal };
+ return { showSaveAsModal };
})();
if (typeof module !== 'undefined' && module.exports) {
diff --git a/src/renderer/recentsPanel.js b/src/renderer/recentsPanel.js
new file mode 100644
index 0000000..f877094
--- /dev/null
+++ b/src/renderer/recentsPanel.js
@@ -0,0 +1,279 @@
+/**
+ * recentsPanel.js — "Recent Files" section at the bottom of the Explorer sidebar.
+ *
+ * Shows two kinds of rows:
+ * 1. The unsaved untitled draft (if one exists and isn't the buffer currently
+ * loaded in the editor) — the way back to it after switching to another file.
+ * 2. Recently opened/saved files (global — not filtered to the active folder),
+ * via StorageManager's existing recent-items store.
+ *
+ * currentFile is a global var declared in index.js (resolved lazily at call time).
+ */
+
+const RecentsPanel = (() => {
+
+ const COLLAPSE_KEY = 'recentsSectionCollapsed';
+ const MAX_VISIBLE_ROWS = 5;
+
+ const CLOSE_ICON_SVG = `
`;
+
+ const DRAFT_ICON_SVG = `
`;
+
+ const FILE_ICON_SVG = `
`;
+
+ const MD_ICON_SVG = `
`;
+
+ const TXT_ICON_SVG = `
`;
+
+ function _fileIconSVG(fileName) {
+ const dot = fileName.lastIndexOf('.');
+ const ext = dot !== -1 ? fileName.slice(dot).toLowerCase() : '';
+ if (ext === '.md') return MD_ICON_SVG;
+ if (ext === '.txt') return TXT_ICON_SVG;
+ return FILE_ICON_SVG;
+ }
+
+ function _escHtml(s) {
+ return String(s).replace(/[&<>"']/g, c => ({
+ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''',
+ }[c]));
+ }
+
+ function _isCustomMode() {
+ return (localStorage.getItem('explorerMode') || 'multi-level') === 'custom';
+ }
+
+ /**
+ * Builds one row. `withPreview` switches between the plain single-line
+ * layout (Multi-level/Root-only) and the two-line icon+name+preview
+ * layout (Custom mode) — kept as distinct markup rather than always
+ * including the preview wrapper, so the single-line case stays exactly
+ * the flat structure it always was.
+ */
+ function _rowHTML({ iconSvg, name, dataAttrs, extraClass, closeRole, closePath, closeTitle, preview, withPreview }) {
+ const attrs = dataAttrs || '';
+ if (!withPreview) {
+ return `
+ `;
+ }
+ return `
+ `;
+ }
+
+ /* ── Render ───────────────────────────────────────────────────────── */
+
+ function render() {
+ const listEl = document.getElementById('recents-list');
+ const countEl = document.getElementById('recents-count');
+ if (!listEl || !countEl) return;
+
+ // The buffer currently loaded in the editor is untitled — show it live,
+ // whether or not it has been typed into yet. Once switched away from,
+ // its slot stays reachable (SaveManager.hasDraft()) even if it was
+ // never typed into — nothing about it should vanish silently.
+ const isLive = !currentFile.path;
+ const showDraft = isLive || SaveManager.hasDraft();
+
+ // Content-preview second line only in Custom mode (no folder tree to
+ // provide that context) — Multi-level/Root-only stay single-line.
+ const withPreview = _isCustomMode();
+
+ const recentItems = StorageManager.getRecentItems().filter(i => i.type === 'file');
+
+ const count = (showDraft ? 1 : 0) + recentItems.length;
+ countEl.textContent = String(count);
+
+ if (count === 0) {
+ listEl.innerHTML = `
Nothing here yet`;
+ return;
+ }
+
+ let html = '';
+
+ if (showDraft) {
+ const draftPreview = withPreview
+ ? SaveManager.extractFirstLine(isLive ? (document.getElementById('mdEditor')?.value ?? '') : SaveManager.getDraft())
+ : '';
+ html += _rowHTML({
+ iconSvg: DRAFT_ICON_SVG,
+ name: 'Untitled (unsaved)',
+ dataAttrs: `data-role="draft" title="Unsaved draft"`,
+ extraClass: isLive ? ' active' : '',
+ closeRole: 'draft-close',
+ closeTitle: 'Discard or save draft',
+ preview: draftPreview,
+ withPreview,
+ });
+ }
+
+ for (const item of recentItems) {
+ const escapedPath = item.path.replace(/"/g, '"');
+ const isActive = item.path === currentFile.path;
+ html += _rowHTML({
+ iconSvg: _fileIconSVG(item.name),
+ name: item.name,
+ dataAttrs: `data-path="${escapedPath}" title="${escapedPath}"`,
+ extraClass: isActive ? ' active' : '',
+ closeRole: 'recent-close',
+ closePath: escapedPath,
+ closeTitle: 'Remove from Recent Files',
+ preview: withPreview ? (item.preview || '') : '',
+ withPreview,
+ });
+ }
+
+ listEl.innerHTML = html;
+ listEl.classList.toggle('recents-list--scroll', count > MAX_VISIBLE_ROWS);
+ // In Custom mode the list fills the whole sidebar via CSS flex (see
+ // .left-sidebar--custom .recents-list) — no fixed row cap there. The
+ // 5-row cap only applies to the accordion in Multi-level/Root-only mode.
+ listEl.style.maxHeight = (!withPreview && count > MAX_VISIBLE_ROWS)
+ ? `${MAX_VISIBLE_ROWS * 28}px`
+ : '';
+ }
+
+ /* ── Explorer-mode wiring (hide folder tree entirely in Custom mode) ── */
+
+ function applyExplorerMode() {
+ const sidebar = document.querySelector('.left-sidebar');
+ const folderWrap = document.querySelector('.app-header__folder-wrap');
+ const custom = _isCustomMode();
+ if (sidebar) sidebar.classList.toggle('left-sidebar--custom', custom);
+ if (folderWrap) folderWrap.classList.toggle('hidden', custom);
+ if (custom) setCollapsed(false);
+ }
+
+ /* ── Collapse state ──────────────────────────────────────────────── */
+
+ function setCollapsed(collapsed) {
+ const section = document.getElementById('recents-section');
+ const header = document.getElementById('recents-header');
+ if (!section || !header) return;
+ section.classList.toggle('recents-section--collapsed', collapsed);
+ header.setAttribute('aria-expanded', String(!collapsed));
+ localStorage.setItem(COLLAPSE_KEY, collapsed ? '1' : '0');
+ }
+
+ /* ── Event wiring ─────────────────────────────────────────────────── */
+
+ document.getElementById('recents-header')?.addEventListener('click', () => {
+ if (_isCustomMode()) return; // always expanded — it's the only way to open a file
+ const section = document.getElementById('recents-section');
+ setCollapsed(!section?.classList.contains('recents-section--collapsed'));
+ });
+
+ document.getElementById('recents-list')?.addEventListener('click', async e => {
+ const closeBtn = e.target.closest('.recents-close-btn');
+ if (closeBtn) {
+ e.stopPropagation();
+ if (closeBtn.dataset.role === 'draft-close') {
+ const isLive = !currentFile.path;
+ const liveContent = isLive ? (document.getElementById('mdEditor')?.value ?? '') : '';
+ const hasContent = isLive ? liveContent.length > 0 : !!SaveManager.getDraft();
+
+ if (!hasContent) {
+ // Nothing typed yet — nothing to lose, just reset silently.
+ if (!isLive) SaveManager.clearDraft();
+ else window.discardLiveUntitledDraft?.();
+ render();
+ return;
+ }
+
+ const choice = await window.electronAPI?.confirmUnsaved();
+ if (choice === 'cancel' || !choice) return;
+
+ if (choice === 'save') {
+ if (isLive) {
+ await SaveManager.saveFile(); // opens the native Save-As dialog on the live buffer
+ if (SaveManager.isDirty()) return; // cancelled — keep the buffer as-is
+ } else {
+ const ok = await SaveManager.saveDraftAs();
+ if (!ok) return; // cancelled or failed — keep the draft
+ }
+ } else if (choice === 'discard') {
+ if (isLive) window.discardLiveUntitledDraft?.();
+ else SaveManager.clearDraft();
+ }
+ render();
+ } else if (closeBtn.dataset.role === 'recent-close') {
+ StorageManager.removeRecentItem(closeBtn.dataset.path);
+ render();
+ }
+ return;
+ }
+
+ const row = e.target.closest('.recents-item');
+ if (!row) return;
+
+ // Clicking the active draft row while the welcome screen is up should
+ // dismiss it and switch to edit mode — the row is "active" because the
+ // untitled buffer is already loaded, but the overlay is hiding the editor.
+ if (row.classList.contains('active')) {
+ if (row.dataset.role === 'draft') {
+ const welcomeScreen = document.getElementById('welcome-screen');
+ if (welcomeScreen && !welcomeScreen.classList.contains('hidden')) {
+ WelcomeScreen.hideWelcomeScreen();
+ setMode('edit');
+ }
+ }
+ return;
+ }
+
+ if (row.dataset.role === 'draft') {
+ await window.restoreDraftFile?.();
+ } else if (row.dataset.path) {
+ await window.openRecentFile?.(row.dataset.path);
+ }
+ });
+
+ // Restore collapsed state on load
+ if ((localStorage.getItem(COLLAPSE_KEY) || '0') === '1') setCollapsed(true);
+
+ return { render, applyExplorerMode, setCollapsed };
+})();
+
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = { RecentsPanel };
+}
diff --git a/src/renderer/saveManager.js b/src/renderer/saveManager.js
index accad24..4ac7137 100644
--- a/src/renderer/saveManager.js
+++ b/src/renderer/saveManager.js
@@ -17,6 +17,54 @@ const SaveManager = (() => {
const AUTO_SAVE_DELAY = 30_000;
let _autoSaveTimer = null;
+ /* ── Untitled-buffer draft (survives close / crash until saved-as or discarded) ── */
+
+ const DRAFT_KEY = 'untitledDraft';
+ const DRAFT_EXISTS_KEY = 'untitledDraftExists';
+
+ function getDraft() { return localStorage.getItem(DRAFT_KEY) || ''; }
+
+ // Distinct from getDraft() being non-empty: an untitled buffer that was
+ // switched away from before anything was typed still needs to be
+ // reachable from Recent Files, so its "slot" is tracked even when the
+ // persisted content is an empty string.
+ function hasDraft() { return localStorage.getItem(DRAFT_EXISTS_KEY) === '1'; }
+
+ function _setDraft(content) {
+ localStorage.setItem(DRAFT_KEY, content);
+ localStorage.setItem(DRAFT_EXISTS_KEY, '1');
+ }
+
+ function clearDraft() {
+ localStorage.removeItem(DRAFT_KEY);
+ localStorage.removeItem(DRAFT_EXISTS_KEY);
+ }
+
+ /**
+ * Save the persisted draft to disk via the native Save dialog, without
+ * touching whatever is currently loaded in the editor. Used by the
+ * "Recent Files" draft row's × button when the user chooses "Save".
+ */
+ async function saveDraftAs() {
+ const content = getDraft();
+ if (!content) return true;
+
+ const raw = _extractFirstLine(content);
+ const safe = raw.replace(/[\\/:*?"<>|]/g, '').trim().slice(0, 60) || 'untitled';
+ const folder = sessionStorage.getItem('lastFolder') || null;
+
+ const result = await window.electronAPI?.newFile(safe, folder);
+ if (!result?.filePath) return false; // cancelled
+
+ const writeResult = await window.electronAPI.writeFile(result.filePath, content);
+ if (!writeResult?.ok) { StatusBar.showToast(writeResult?.error || 'Save failed.'); return false; }
+
+ clearDraft();
+ const name = result.filePath.split(/[\\/]/).pop();
+ StorageManager.addRecentItem('file', result.filePath, name, raw);
+ return true;
+ }
+
/* ── Auto-save ────────────────────────────────────────────────────── */
function _scheduleAutoSave() {
@@ -96,9 +144,18 @@ const SaveManager = (() => {
async function silentSave() {
const filePath = currentFile.path;
- if (!filePath || !_isDirty) return true;
+
+ if (!filePath) {
+ const content = mdEditor ? mdEditor.value : '';
+ _setDraft(content);
+ RecentsPanel?.render();
+ return true;
+ }
+
+ if (!_isDirty) return true;
const content = mdEditor ? mdEditor.value : '';
+
try {
const result = await window.electronAPI.writeFile(filePath, content);
if (!result?.ok) throw new Error(result?.error || 'write failed');
@@ -162,7 +219,7 @@ const SaveManager = (() => {
console.error('[saveFile]', err);
btn.innerHTML = `
✗ Error`;
setTimeout(() => { btn.innerHTML = `${FLOPPY_SVG}
Save`; }, 2000);
- alert(`Save failed: ${err.message}`);
+ StatusBar.showToast(`Save failed: ${err.message}`);
} finally {
btn.disabled = false;
delete btn.dataset.saving;
@@ -215,7 +272,7 @@ const SaveManager = (() => {
const editor = document.getElementById('mdEditor');
const md = editor ? editor.value : '';
- if (!md.trim()) { alert('Nothing to export — the document is empty.'); return; }
+ if (!md.trim()) { StatusBar.showToast('Nothing to export — the document is empty.'); return; }
const filename = currentFile.name || 'export.md';
@@ -307,6 +364,11 @@ const SaveManager = (() => {
silentSave,
saveFile,
exportFile,
+ extractFirstLine: _extractFirstLine,
+ getDraft,
+ hasDraft,
+ clearDraft,
+ saveDraftAs,
};
})();
diff --git a/src/renderer/searchPanel.js b/src/renderer/searchPanel.js
index 64a7ec7..01dbafb 100644
--- a/src/renderer/searchPanel.js
+++ b/src/renderer/searchPanel.js
@@ -90,14 +90,33 @@ const SearchPanel = (() => {
_activeIndex = -1
}
+ function _isCustomMode() {
+ return (localStorage.getItem('explorerMode') || 'multi-level') === 'custom'
+ }
+
async function _doSearch(query) {
- const folderPath = sessionStorage.getItem('lastFolder')
- if (!folderPath) {
- _dropdown.innerHTML = '
No folder open
'
- _dropdown.classList.remove('hidden')
- return
- }
try {
+ if (_isCustomMode()) {
+ // No folder tree in Custom mode — search the Recent Files list instead.
+ const filePaths = StorageManager.getRecentItems()
+ .filter(i => i.type === 'file')
+ .map(i => i.path)
+ if (!filePaths.length) {
+ _dropdown.innerHTML = '
No recent files
'
+ _dropdown.classList.remove('hidden')
+ return
+ }
+ const { results } = await window.electronAPI.searchRecentFiles(filePaths, query)
+ _render(results, query)
+ return
+ }
+
+ const folderPath = sessionStorage.getItem('lastFolder')
+ if (!folderPath) {
+ _dropdown.innerHTML = '
No folder open
'
+ _dropdown.classList.remove('hidden')
+ return
+ }
const { results } = await window.electronAPI.searchFiles(folderPath, query)
_render(results, query)
} catch (err) {
diff --git a/src/renderer/storageManager.js b/src/renderer/storageManager.js
index 5c3d5d2..4f07f19 100644
--- a/src/renderer/storageManager.js
+++ b/src/renderer/storageManager.js
@@ -16,11 +16,18 @@ const StorageManager = (() => {
catch { return []; }
}
- function addRecentItem(type, itemPath, name) {
+ // Re-opening an already-tracked item refreshes its name/preview/timestamp
+ // in place — it does NOT jump to the top. Only brand-new items are
+ // inserted (at the top); list position otherwise stays stable.
+ function addRecentItem(type, itemPath, name, preview) {
let items = getRecentItems();
- items = items.filter(i => i.path !== itemPath);
- items.unshift({ type, path: itemPath, name, timestamp: Date.now() });
- items = items.slice(0, RECENT_MAX);
+ const idx = items.findIndex(i => i.path === itemPath);
+ if (idx !== -1) {
+ items[idx] = { ...items[idx], name, preview, timestamp: Date.now() };
+ } else {
+ items.unshift({ type, path: itemPath, name, preview, timestamp: Date.now() });
+ items = items.slice(0, RECENT_MAX);
+ }
localStorage.setItem(RECENT_ITEMS_KEY, JSON.stringify(items));
}
@@ -28,6 +35,11 @@ const StorageManager = (() => {
localStorage.removeItem(RECENT_ITEMS_KEY);
}
+ function removeRecentItem(itemPath) {
+ const items = getRecentItems().filter(i => i.path !== itemPath);
+ localStorage.setItem(RECENT_ITEMS_KEY, JSON.stringify(items));
+ }
+
function getRecentFolders() {
return getRecentItems().filter(i => i.type === 'folder');
}
@@ -89,6 +101,7 @@ const StorageManager = (() => {
return {
getRecentItems,
addRecentItem,
+ removeRecentItem,
clearRecentItems,
getRecentFolders,
getPinnedForFolder,
diff --git a/src/renderer/styles.css b/src/renderer/styles.css
index e14b9be..83a5ac8 100644
--- a/src/renderer/styles.css
+++ b/src/renderer/styles.css
@@ -13,7 +13,7 @@
--sidebar-max-width: none;
/* Editor typography — overridden at runtime by the Font settings panel */
- --editor-font-size: 12px;
+ --editor-font-size: 13px;
/* Accent */
--primary: #2563eb;
@@ -679,6 +679,12 @@ body {
outline-offset: 1px;
}
+.icon-btn:disabled {
+ opacity: 0.3 !important;
+ cursor: not-allowed;
+ pointer-events: none;
+}
+
/* ── 2. Folder row ───────────────────────────────────────────────── */
.folder-row {
display: flex;
@@ -864,6 +870,111 @@ body {
color: var(--text-secondary); /* hint: clicking will unpin */
}
+/* ── Recent Files section (bottom of the Explorer sidebar) ──────────── */
+.recents-section {
+ flex-shrink: 0;
+ border-top: 1px solid var(--border);
+}
+
+.recents-header {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ width: 100%;
+ height: 32px;
+ padding: 0 12px;
+ background: transparent;
+ border: none;
+ cursor: pointer;
+ color: inherit;
+ font: inherit;
+}
+
+.recents-header:hover {
+ background: var(--hover-bg);
+}
+
+.recents-header__chevron {
+ flex-shrink: 0;
+ color: var(--text-secondary);
+ transform: rotate(90deg);
+ transition: transform 200ms ease;
+}
+
+.recents-section--collapsed .recents-header__chevron {
+ transform: rotate(0deg);
+}
+
+.recents-count {
+ margin-left: auto;
+ min-width: 16px;
+ padding: 0 5px;
+ border-radius: 8px;
+ background: var(--hover-bg);
+ color: var(--text-secondary);
+ font-size: 10px;
+ font-weight: 600;
+ line-height: 16px;
+ text-align: center;
+}
+
+.recents-list {
+ overflow-y: hidden;
+ padding: 2px 0 4px;
+}
+
+.recents-list--scroll {
+ overflow-y: auto;
+ /* 5 rows max before scrolling — single-line rows, ~28px tall each */
+ max-height: 140px;
+}
+
+.recents-section--collapsed .recents-list {
+ display: none;
+}
+
+.recents-empty {
+ display: block;
+ padding: 4px 14px 8px;
+ font-size: 11px;
+ color: var(--text-secondary);
+ user-select: none;
+}
+
+.recents-close-btn {
+ position: static;
+}
+
+/* Custom explorer mode: notepad-style, no folder tree at all — the Recent
+ Files section becomes the sidebar's only content and can't be collapsed. */
+.left-sidebar--custom #file-list,
+.left-sidebar--custom #new-file-row,
+.left-sidebar--custom #btn-open-folder,
+.left-sidebar--custom #btn-new-folder,
+.left-sidebar--custom #btn-collapse-all {
+ display: none !important;
+}
+
+.left-sidebar--custom .recents-section {
+ flex: 1;
+ display: flex;
+ flex-direction: column;
+ min-height: 0;
+ border-top: none;
+}
+
+.left-sidebar--custom .recents-header {
+ cursor: default;
+ flex-shrink: 0;
+}
+
+.left-sidebar--custom .recents-list,
+.left-sidebar--custom .recents-list--scroll {
+ flex: 1;
+ max-height: none;
+ overflow-y: auto;
+}
+
/* ── Static section labels (Pinned / Files) ─────────────────────────── */
.file-list-section-header {
padding: 8px 14px 3px;
@@ -3130,37 +3241,6 @@ select.form-input {
margin-top: auto;
}
-/* ── Save-As Modal extras ─────────────────────────────────────────── */
-.save-as-folder-row {
- display: flex;
- align-items: center;
- gap: 8px;
-}
-.save-as-folder-path {
- flex: 1;
- font-size: 12px;
- color: var(--text-secondary);
- white-space: nowrap;
- overflow: hidden;
- text-overflow: ellipsis;
- min-width: 0;
- padding: 7px 10px;
- background: var(--surface);
- border: 1px solid var(--border);
- border-radius: 6px;
-}
-.save-as-error {
- font-size: 11.5px;
- color: #ef4444;
- margin-top: 4px;
- display: block;
-}
-.save-as-error.hidden { display: none; }
-.save-as-filename--error {
- animation: new-file-shake 250ms ease; /* reuses existing keyframes */
- border-color: #ef4444 !important;
-}
-
/* ════════════════════════════════════════════════════════════════════
Label Picker Modal
════════════════════════════════════════════════════════════════════ */
diff --git a/src/renderer/tableBuilder.js b/src/renderer/tableBuilder.js
index 7485fe5..238ce28 100644
--- a/src/renderer/tableBuilder.js
+++ b/src/renderer/tableBuilder.js
@@ -240,14 +240,16 @@ const TableBuilder = (() => {
if (_selStart !== null && _selEnd !== null) {
editor.setSelectionRange(_selStart, _selEnd);
- document.execCommand('insertText', false, md);
+ editor.setRangeText(md, _selStart, _selEnd, 'end');
+ editor.dispatchEvent(new Event('input', { bubbles: true }));
} else {
const pos = editor.selectionStart;
const val = editor.value;
const before = pos > 0 && val[pos - 1] !== '\n' ? '\n' : '';
const after = pos < val.length && val[pos] !== '\n' ? '\n' : '';
editor.setSelectionRange(pos, pos);
- document.execCommand('insertText', false, before + md + after);
+ editor.setRangeText(before + md + after, pos, pos, 'end');
+ editor.dispatchEvent(new Event('input', { bubbles: true }));
}
if (typeof EditorCore !== 'undefined') EditorCore.triggerUpdate();
diff --git a/src/renderer/themeInit.js b/src/renderer/themeInit.js
new file mode 100644
index 0000000..3d086d2
--- /dev/null
+++ b/src/renderer/themeInit.js
@@ -0,0 +1,12 @@
+/**
+ * themeInit.js — sets the theme attribute before the page paints.
+ *
+ * Loaded synchronously in , ahead of , so the browser never
+ * paints a frame with the wrong theme colors. themeManager.js (loaded later,
+ * at the bottom of the page) re-applies the same value and updates the
+ * toggle button's label/icon once the DOM for those exists.
+ */
+(function () {
+ var saved = localStorage.getItem('theme') || 'dark';
+ document.documentElement.setAttribute('data-theme', saved);
+})();
diff --git a/src/renderer/themeManager.js b/src/renderer/themeManager.js
index 2f17cbe..1212cc7 100644
--- a/src/renderer/themeManager.js
+++ b/src/renderer/themeManager.js
@@ -33,8 +33,7 @@ const ThemeManager = (() => {
}
function applyStoredTheme() {
- const saved = localStorage.getItem('theme');
- if (!saved) return;
+ const saved = localStorage.getItem('theme') || 'dark';
const html = document.documentElement;
html.setAttribute('data-theme', saved);
if (saved === 'dark') {
diff --git a/tests/saveManager.test.js b/tests/saveManager.test.js
new file mode 100644
index 0000000..9afab9c
--- /dev/null
+++ b/tests/saveManager.test.js
@@ -0,0 +1,160 @@
+/**
+ * @jest-environment jsdom
+ *
+ * Unit tests for SaveManager — the real save/export flows in
+ * src/renderer/saveManager.js.
+ *
+ * Tests cover:
+ * 1. saveFile() writes via electronAPI.writeFile and marks the doc clean
+ * 2. saveFile() surfaces an error and stays dirty when writeFile fails
+ * 3. silentSave() resolves true on success, false on failure
+ * 4. markDirty() / markClean() toggle isDirty()
+ * 5. exportFile() renders Markdown to HTML and calls electronAPI.exportPdf
+ *
+ * saveManager.js reads `currentFile`, `mdEditor`, `FileTreeManager`,
+ * `ModalManager`, `StatusBar`, and `MarkdownRenderer` as bare globals (it's
+ * loaded as a plain