feat: enhance Shiori import with progress indicator and error handling

docs(specs): update feeds, documents, and omnisearch specs with latest changes
docs(specs): remove Emacs references and update links spec with future drop-down search enhancement
2025-03-04 17:54:49 +01:00 · 2025-03-04 11:37:55 +01:00 · 2025-03-04 11:37:17 +01:00 · 2025-03-04 11:23:51 +01:00 · 2025-03-04 11:09:47 +01:00
26 changed files with 2849 additions and 166 deletions
--- a/README.md
+++ b/README.md
@ -1,38 +1,57 @@
-# sv
+# QuickNotes

-Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+QuickNotes is a personal knowledge management application that allows you to create, manage, and interlink your notes, save articles for later reading, subscribe to RSS/Atom feeds, upload and view PDF documents, and perform a unified full-text search across all your content.

-## Creating a project
+## Features

-If you're seeing this, you've probably already done this step. Congrats!
+- **Notes**: Create, edit, and delete notes with Markdown support. Interlink notes using wiki-style syntax and visualize connections with an interactive graph.
+- **Readlist**: Save and view articles for later reading with automatic content extraction.
+- **Feeds**: Subscribe to and manage RSS/Atom feeds, and view feed entries with options to mark them as read or unread.
+- **Documents**: Upload and view PDF documents directly within the app without needing to download them.
+- **Omnisearch**: Perform unified full-text searches across notes, feed entries, readlist items, and documents.

-```bash
-# create a new project in the current directory
-npx sv create
+## Technology Stack

-# create a new project in my-app
-npx sv create my-app
-```
+- **Backend**: Go with the Gin web framework and GORM; SQLite for data storage.
+- **Frontend**: Svelte with SvelteKit, styled with Bulma CSS and FontAwesome for icons.
+- **Search**: Bleve for full-text search capabilities.
+- **PDF Viewing**: Integrated PDF.js-like viewer for inline document viewing.
+- **Package Management**: Bun for frontend dependencies and Go modules for backend dependencies.
+- **Testing**: Go testing framework for backend and Playwright for end-to-end frontend testing.

-## Developing
+## Installation

-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+1. **Server Setup**:
+   - Ensure Go is installed.
+   - Build the backend server using `go build` or the provided `build.sh` script.
+   - Ensure Bun is installed and run `bun install` in the frontend directory.
+   - Start the backend server (default URL: `http://localhost:3000`).

-```bash
-npm run dev
+2. **Frontend**:
+   - The SvelteKit frontend is served by the Go backend after being built, or can be run separately for development.
+   - Access the application via your web browser at `http://localhost:3000`.

-# or start the server and open the app in a new browser tab
-npm run dev -- --open
-```
+## Usage

-## Building
+- Navigate using dedicated pages for Notes, Readlist, Feeds, Documents, and Omnisearch.
+- Use the Omnisearch page to perform full-text searches across all content domains.

-To create a production version of your app:
+## Documentation

-```bash
-npm run build
-```
+For detailed specifications, see:

-You can preview the production build with `npm run preview`.
+- [Architecture](specs/architecture.md)
+- [Notes](specs/notes.md)
+- [Readlist](specs/readlist.md)
+- [Feeds](specs/feeds.md)
+- [Documents](specs/documents.md)
+- [Omnisearch](specs/omnisearch.md)
+- [Database](specs/database.md)
+- [API](specs/api.md)
+- [Frontend](specs/frontend.md)
+- [Authentication](specs/authentication.md)
+- [Links](specs/links.md)

-> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+## License
+
+This project is licensed under the MIT License.
--- a/SPECS.md
+++ b/SPECS.md
@ -0,0 +1,48 @@
+# QuickNotes Application Specifications
+
+This document provides an overview of the QuickNotes application specifications. QuickNotes is a personal knowledge management system that allows users to create and manage notes, read later items, RSS/Atom feeds, uploadable PDF documents, and perform unified full-text search across all content.
+
+## Overview
+
+QuickNotes is built with a Go backend and a Svelte frontend. It uses SQLite for data storage and provides a RESTful API for communication between the frontend and backend. In addition, the application includes an Emacs mode for integrated access directly from the Emacs editor.
+
+## Specification Documents
+
+The following table lists all the specification documents for the QuickNotes application:
+
+| Domain           | Description                                                 | Link                                     |
+|------------------|-------------------------------------------------------------|------------------------------------------|
+| Architecture     | Overall system architecture                                 | [Architecture](specs/architecture.md)    |
+| Notes            | Note creation, management, and linking                      | [Notes](specs/notes.md)                    |
+| Readlist         | Save articles for later with automatic content extraction   | [Readlist](specs/readlist.md)              |
+| Feeds            | RSS/Atom feed subscriptions and entries                     | [Feeds](specs/feeds.md)                    |
+| Documents        | Upload and view PDF documents                               | [Documents](specs/documents.md)            |
+| Omnisearch       | Full-text search across all domains                         | [Omnisearch](specs/omnisearch.md)          |
+| Database         | Database schema and relationships                           | [Database](specs/database.md)              |
+| API              | API endpoints and communication                             | [API](specs/api.md)                        |
+| Frontend         | User interface and client-side features                     | [Frontend](specs/frontend.md)              |
+| Authentication   | Local-only authentication and potential future enhancements | [Authentication](specs/authentication.md)  |
+
+## Key Features
+
+- Create, edit, and delete notes with Markdown support
+- Link notes together using wiki-style syntax
+- Visualize note connections with an interactive graph
+- Save articles for later reading with automatic content extraction
+- Manage and read RSS/Atom feeds
+- Upload and view PDF documents directly in the app
+- Unified full-text search (Omnisearch) across all content
+- Emacs integration for seamless workflow
+
+## Technology Stack
+
+- **Backend**: Go with Gin web framework and GORM; SQLite for storage
+- **Frontend**: Svelte with SvelteKit, Bulma CSS, FontAwesome
+- **Search Engine**: Bleve for full-text search
+- **PDF Viewing**: PDF.js-like viewer integrated in the frontend
+
+## Development and Deployment
+
+- Designed for local use with potential for scalability
+- Documents can be stored on local disk or blob storage (S3) in future
+- Comprehensive API and Emacs mode for enhanced user interaction 
--- a/frontend/bun.lock
+++ b/frontend/bun.lock
@ -13,8 +13,8 @@
        "@eslint/js": "^9.18.0",
        "@playwright/test": "1.50.1",
        "@sveltejs/adapter-static": "^3.0.8",
-        "@sveltejs/kit": "^2.5.27",
-        "@sveltejs/vite-plugin-svelte": "^5.0.0",
+        "@sveltejs/kit": "^2.18.0",
+        "@sveltejs/vite-plugin-svelte": "^5.0.3",
        "@types/node": "^22.13.4",
        "eslint": "^9.18.0",
        "eslint-config-prettier": "^10.0.1",
@ -22,8 +22,8 @@
        "globals": "^15.14.0",
        "prettier": "^3.4.2",
        "prettier-plugin-svelte": "^3.3.3",
-        "svelte": "^5.0.0",
-        "svelte-check": "^4.0.0",
+        "svelte": "^5.22.1",
+        "svelte-check": "^4.1.0",
        "typescript": "^5.5.0",
        "typescript-eslint": "^8.20.0",
        "vite": "^6.0.0",
@ -169,9 +169,11 @@

    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.34.8", "", { "os": "win32", "cpu": "x64" }, "sha512-U0FaE5O1BCpZSeE6gBl3c5ObhePQSfk9vDRToMmTkbhCOgW4jqvtS5LGyQ76L1fH8sM0keRp4uDTsbjiUyjk0g=="],

+    "@sveltejs/acorn-typescript": ["@sveltejs/acorn-typescript@1.0.5", "", { "peerDependencies": { "acorn": "^8.9.0" } }, "sha512-IwQk4yfwLdibDlrXVE04jTZYlLnwsTT2PIOQQGNLWfjavGifnk1JD1LcZjZaBTRcxZu2FfPfNLOE04DSu9lqtQ=="],
+
    "@sveltejs/adapter-static": ["@sveltejs/adapter-static@3.0.8", "", { "peerDependencies": { "@sveltejs/kit": "^2.0.0" } }, "sha512-YaDrquRpZwfcXbnlDsSrBQNCChVOT9MGuSg+dMAyfsAa1SmiAhrA5jUYUiIMC59G92kIbY/AaQOWcBdq+lh+zg=="],

-    "@sveltejs/kit": ["@sveltejs/kit@2.17.2", "", { "dependencies": { "@types/cookie": "^0.6.0", "cookie": "^0.6.0", "devalue": "^5.1.0", "esm-env": "^1.2.2", "import-meta-resolve": "^4.1.0", "kleur": "^4.1.5", "magic-string": "^0.30.5", "mrmime": "^2.0.0", "sade": "^1.8.1", "set-cookie-parser": "^2.6.0", "sirv": "^3.0.0" }, "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0", "svelte": "^4.0.0 || ^5.0.0-next.0", "vite": "^5.0.3 || ^6.0.0" }, "bin": { "svelte-kit": "svelte-kit.js" } }, "sha512-Vypk02baf7qd3SOB1uUwUC/3Oka+srPo2J0a8YN3EfJypRshDkNx9HzNKjSmhOnGWwT+SSO06+N0mAb8iVTmTQ=="],
+    "@sveltejs/kit": ["@sveltejs/kit@2.18.0", "", { "dependencies": { "@types/cookie": "^0.6.0", "cookie": "^0.6.0", "devalue": "^5.1.0", "esm-env": "^1.2.2", "import-meta-resolve": "^4.1.0", "kleur": "^4.1.5", "magic-string": "^0.30.5", "mrmime": "^2.0.0", "sade": "^1.8.1", "set-cookie-parser": "^2.6.0", "sirv": "^3.0.0" }, "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0", "svelte": "^4.0.0 || ^5.0.0-next.0", "vite": "^5.0.3 || ^6.0.0" }, "bin": { "svelte-kit": "svelte-kit.js" } }, "sha512-4DGCGiwNzgnPJySlMe/Qi6rKMK3ntphJaV95BTW+aggaTIAVZ5x3Bp+LURVLMxAEAtWAI5U449NafVxTS+kXbQ=="],

    "@sveltejs/vite-plugin-svelte": ["@sveltejs/vite-plugin-svelte@5.0.3", "", { "dependencies": { "@sveltejs/vite-plugin-svelte-inspector": "^4.0.1", "debug": "^4.4.0", "deepmerge": "^4.3.1", "kleur": "^4.1.5", "magic-string": "^0.30.15", "vitefu": "^1.0.4" }, "peerDependencies": { "svelte": "^5.0.0", "vite": "^6.0.0" } }, "sha512-MCFS6CrQDu1yGwspm4qtli0e63vaPCehf6V7pIMP15AsWgMKrqDGCPFF/0kn4SP0ii4aySu4Pa62+fIRGFMjgw=="],

@ -209,8 +211,6 @@

    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],

-    "acorn-typescript": ["acorn-typescript@1.4.13", "", { "peerDependencies": { "acorn": ">=8.9.0" } }, "sha512-xsc9Xv0xlVfwp2o7sQ+GCQ1PgbkdcpWdTzrwXxO3xDMTAywVS3oXVOcOHuRjAPkS4P9b+yc/qNF15460v+jp4Q=="],
-
    "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],

    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
@ -451,7 +451,7 @@

    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],

-    "svelte": ["svelte@5.20.1", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@jridgewell/sourcemap-codec": "^1.5.0", "@types/estree": "^1.0.5", "acorn": "^8.12.1", "acorn-typescript": "^1.4.13", "aria-query": "^5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", "esm-env": "^1.2.1", "esrap": "^1.4.3", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", "zimmerframe": "^1.1.2" } }, "sha512-aCARru2WTdzJl55Ws8SK27+kvQwd8tijl4kY7NoDUXUHtTHhxMa8Lf6QNZKmU7cuPu3jjFloDO1j5HgYJNIIWg=="],
+    "svelte": ["svelte@5.22.1", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@jridgewell/sourcemap-codec": "^1.5.0", "@sveltejs/acorn-typescript": "^1.0.5", "@types/estree": "^1.0.5", "acorn": "^8.12.1", "aria-query": "^5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", "esm-env": "^1.2.1", "esrap": "^1.4.3", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", "zimmerframe": "^1.1.2" } }, "sha512-b9DQGnfrZc+km4u3j6qkEY87pYe23yfgBT03CkeBlYST+Wzij7ut1o0BSoQ+UmiyAO1nPh9DMJJCoGDdUOrunw=="],

    "svelte-check": ["svelte-check@4.1.4", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "chokidar": "^4.0.1", "fdir": "^6.2.0", "picocolors": "^1.0.0", "sade": "^1.7.4" }, "peerDependencies": { "svelte": "^4.0.0 || ^5.0.0-next.0", "typescript": ">=5.0.0" }, "bin": { "svelte-check": "bin/svelte-check" } }, "sha512-v0j7yLbT29MezzaQJPEDwksybTE2Ups9rUxEXy92T06TiA0cbqcO8wAOwNUVkFW6B0hsYHA+oAX3BS8b/2oHtw=="],

--- a/frontend/package.json
+++ b/frontend/package.json
@ -22,8 +22,8 @@
 		"@eslint/js": "^9.18.0",
 		"@playwright/test": "1.50.1",
 		"@sveltejs/adapter-static": "^3.0.8",
-		"@sveltejs/kit": "^2.5.27",
-		"@sveltejs/vite-plugin-svelte": "^5.0.0",
+		"@sveltejs/kit": "^2.18.0",
+		"@sveltejs/vite-plugin-svelte": "^5.0.3",
 		"@types/node": "^22.13.4",
 		"eslint": "^9.18.0",
 		"eslint-config-prettier": "^10.0.1",
@ -31,8 +31,8 @@
 		"globals": "^15.14.0",
 		"prettier": "^3.4.2",
 		"prettier-plugin-svelte": "^3.3.3",
-		"svelte": "^5.0.0",
-		"svelte-check": "^4.0.0",
+		"svelte": "^5.22.1",
+		"svelte-check": "^4.1.0",
 		"typescript": "^5.5.0",
 		"typescript-eslint": "^8.20.0",
 		"vite": "^6.0.0"
--- a/frontend/src/lib/readlist.ts
+++ b/frontend/src/lib/readlist.ts
@ -1,6 +1,13 @@
 import { writable } from 'svelte/store';
 import type { ReadLaterItem } from './types';

+// Shiori credentials interface
+interface ShioriCredentials {
+	url: string;
+	username: string;
+	password: string;
+}
+
 function createReadLaterStore() {
 	const { subscribe, set, update } = writable<ReadLaterItem[]>([]);
 	let showArchived = false;
@ -31,7 +38,6 @@ function createReadLaterStore() {
 					...item,
 					createdAt: new Date(item.createdAt),
 					updatedAt: new Date(item.updatedAt),
-					savedAt: new Date(item.savedAt),
 					readAt: item.readAt ? new Date(item.readAt) : undefined,
 					archivedAt: item.archivedAt ? new Date(item.archivedAt) : undefined
 				},
@ -121,6 +127,24 @@ function createReadLaterStore() {
 				console.error('Failed to load read later items:', error);
 				set([]);
 			}
+		},
+		importFromShiori: async (creds: ShioriCredentials) => {
+			const response = await fetch('/api/readlist/import/shiori', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify(creds)
+			});
+			if (!response.ok) {
+				throw new Error('Failed to import from Shiori');
+			}
+			return await response.json();
+		},
+		getImportStatus: async (importId: string) => {
+			const response = await fetch(`/api/readlist/import/status/${importId}`);
+			if (!response.ok) {
+				throw new Error('Failed to get import status');
+			}
+			return await response.json();
 		}
 	};
 }
--- a/frontend/src/routes/readlist/+page.svelte
+++ b/frontend/src/routes/readlist/+page.svelte
@ -1,36 +1,65 @@
 <script lang="ts">
-	import { onMount } from 'svelte';
+	import { onMount, onDestroy } from 'svelte';
 	import { readlist } from '$lib/readlist';
 	import CardList from '$lib/components/CardList.svelte';
 	import SearchBar from '$lib/components/SearchBar.svelte';
 	import type { ReadLaterItem } from '$lib/types';

+	let items: ReadLaterItem[] = [];
 	let url = '';
 	let isLoading = false;
 	let error: string | null = null;
-	let showArchived = false;
-	let archivingItems: Record<string, boolean> = {};
+	let importCount = 0;
 	let searchQuery = '';
+	let showArchived = false;

-	onMount(() => {
-		loadItems();
+	// Shiori import
+	let showShioriImport = false;
+	let shioriUrl = '';
+	let shioriUsername = '';
+	let shioriPassword = '';
+	let isImportingShiori = false;
+	let shioriImportCount = 0;
+	let shioriError: string | null = null;
+	let currentImportId: string | null = null;
+	let importProgress = {
+		totalBookmarks: 0,
+		importedCount: 0,
+		failedCount: 0,
+		inProgress: false
+	};
+	let statusCheckInterval: ReturnType<typeof setInterval> | null = null;
+
+	onMount(async () => {
+		await loadItems();
 	});

 	async function loadItems() {
+		isLoading = true;
+		error = null;
+		try {
 			await readlist.load(showArchived);
+			const unsubscribe = readlist.subscribe((value) => {
+				items = value;
+			});
+			return () => {
+				unsubscribe();
+			};
+		} catch (e) {
+			error = e instanceof Error ? e.message : 'Failed to load items';
+		} finally {
+			isLoading = false;
+		}
 	}

-	async function toggleArchived() {
-		showArchived = !showArchived;
-		await loadItems();
+	async function handleAddUrl() {
+		if (!url.trim()) {
+			error = 'Please enter a URL';
+			return;
 		}

-	async function handleSubmit() {
-		if (!url) return;
-
 		isLoading = true;
 		error = null;
-
 		try {
 			await readlist.add(url);
 			url = '';
@ -41,12 +70,7 @@
 		}
 	}

-	function handleDelete(item: ReadLaterItem) {
-		readlist.delete(item.id);
-	}
-
 	async function handleToggleArchive(item: ReadLaterItem) {
-		archivingItems[item.id] = true;
 		try {
 			if (item.archivedAt) {
 				await readlist.unarchive(item.id);
@ -55,60 +79,195 @@
 			}
 		} catch (e) {
 			error = e instanceof Error ? e.message : 'Failed to update archive status';
-		} finally {
-			archivingItems[item.id] = false;
 		}
 	}

+	async function handleDelete(item: ReadLaterItem) {
+		if (!confirm(`Are you sure you want to delete "${item.title}"?`)) {
+			return;
+		}
+
+		try {
+			await readlist.delete(item.id);
+		} catch (e) {
+			error = e instanceof Error ? e.message : 'Failed to delete item';
+		}
+	}
+
+	async function handleToggleShowArchived() {
+		showArchived = readlist.toggleShowArchived();
+		await loadItems();
+	}
+
 	function getFilteredItems() {
 		if (!searchQuery) {
-			return $readlist;
+			return items;
 		}

-		return $readlist.filter(
+		const query = searchQuery.toLowerCase();
+		return items.filter(
 			(item) =>
-				item.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
-				item.description.toLowerCase().includes(searchQuery.toLowerCase()) ||
-				item.url.toLowerCase().includes(searchQuery.toLowerCase())
+				item.title.toLowerCase().includes(query) ||
+				item.description.toLowerCase().includes(query) ||
+				item.url.toLowerCase().includes(query)
 		);
 	}
+
+	async function handleImportFromShiori() {
+		if (!shioriUrl || !shioriUsername || !shioriPassword) {
+			shioriError = 'Please fill in all fields';
+			return;
+		}
+
+		isImportingShiori = true;
+		shioriError = null;
+		try {
+			// Start the import process - this returns an import ID
+			const result = await readlist.importFromShiori({
+				url: shioriUrl,
+				username: shioriUsername,
+				password: shioriPassword
+			});
+
+			// Store the import ID
+			currentImportId = result.id;
+
+			// Start polling for status updates
+			if (statusCheckInterval) {
+				clearInterval(statusCheckInterval);
+			}
+
+			statusCheckInterval = setInterval(async () => {
+				if (currentImportId) {
+					try {
+						const status = await readlist.getImportStatus(currentImportId);
+						importProgress = {
+							totalBookmarks: status.totalBookmarks,
+							importedCount: status.importedCount,
+							failedCount: status.failedCount,
+							inProgress: status.inProgress
+						};
+
+						// If import is complete, stop polling and update count
+						if (!status.inProgress) {
+							if (statusCheckInterval) {
+								clearInterval(statusCheckInterval);
+								statusCheckInterval = null;
+							}
+							shioriImportCount = status.importedCount;
+							isImportingShiori = false;
+
+							// Reload the list to show new items
+							await readlist.load(showArchived);
+						}
+					} catch (e) {
+						console.error('Error checking import status:', e);
+					}
+				}
+			}, 1000); // Check every second
+
+			// Clear form
+			shioriUrl = '';
+			shioriUsername = '';
+			shioriPassword = '';
+			showShioriImport = false;
+		} catch (e) {
+			shioriError = e instanceof Error ? e.message : 'Failed to import from Shiori';
+			isImportingShiori = false;
+		}
+	}
+
+	// Clean up interval on component destroy
+	onDestroy(() => {
+		if (statusCheckInterval) {
+			clearInterval(statusCheckInterval);
+		}
+	});
 </script>

 <div class="container">
+	<section class="section">
 		<h1 class="title">Read Later</h1>

-	<form onsubmit={handleSubmit} class="mb-4">
+		{#if error}
+			<div class="notification is-danger">
+				<p>{error}</p>
+			</div>
+		{/if}
+
+		{#if importCount > 0}
+			<div class="notification is-success">
+				<p>Successfully added {importCount} URLs.</p>
+			</div>
+		{/if}
+
+		{#if shioriImportCount > 0}
+			<div class="notification is-success">
+				<p>Successfully imported {shioriImportCount} bookmarks from Shiori.</p>
+			</div>
+		{/if}
+
+		<!-- Import progress indicator -->
+		{#if isImportingShiori}
+			<div class="notification is-warning">
+				{#if importProgress.totalBookmarks === 0}
+					<strong>Connecting to Shiori and preparing for import...</strong>
+				{:else}
+					<strong>Import in progress:</strong>
+					{importProgress.importedCount} imported, {importProgress.failedCount} failed out of {importProgress.totalBookmarks}
+					<progress
+						class="progress is-primary"
+						value={importProgress.importedCount + importProgress.failedCount}
+						max={importProgress.totalBookmarks}
+					></progress>
+				{/if}
+			</div>
+		{/if}
+		<!-- End of import progress indicator -->
+
+		<div class="level">
+			<div class="level-left">
+				<div class="level-item">
 					<div class="field has-addons">
-			<div class="control is-expanded">
+						<div class="control">
 							<input
 								class="input"
 								type="url"
-					placeholder="Enter a URL to save"
+								placeholder="Enter URL to save"
 								bind:value={url}
-					disabled={isLoading}
+								on:keydown={(e) => {
+									if (e.key === 'Enter') handleAddUrl();
+								}}
 							/>
 						</div>
 						<div class="control">
-				<button type="submit" class="button is-primary" disabled={isLoading || !url}>
-					{#if isLoading}
+							<button
+								class="button is-primary"
+								on:click={handleAddUrl}
+								disabled={isLoading || !url}
+							>
 								<span class="icon">
-							<i class="fas fa-spinner fa-spin"></i>
+									<i class="fas fa-plus"></i>
 								</span>
-					{:else}
-						Add Link
-					{/if}
+								<span>Add</span>
 							</button>
 						</div>
 					</div>
-		{#if error}
-			<p class="help is-danger">{error}</p>
-		{/if}
-	</form>
+				</div>

-	<div class="level mb-4">
-		<div class="level-left">
 				<div class="level-item">
-				<button class="button is-small" onclick={toggleArchived}>
+					<button class="button is-info" on:click={() => (showShioriImport = !showShioriImport)}>
+						<span class="icon">
+							<i class="fas fa-file-import"></i>
+						</span>
+						<span>Import from Shiori</span>
+					</button>
+				</div>
+			</div>
+
+			<div class="level-right">
+				<div class="level-item">
+					<button class="button" class:is-info={showArchived} on:click={handleToggleShowArchived}>
 						<span class="icon">
 							<i class="fas fa-archive"></i>
 						</span>
@ -118,15 +277,103 @@
 			</div>
 		</div>

-	<div class="mb-4">
-		<SearchBar
-			placeholder="Search saved links by title, description, or URL..."
-			bind:value={searchQuery}
+		{#if showShioriImport}
+			<div class="box mb-4">
+				<h2 class="title is-5">Import from Shiori</h2>
+
+				{#if shioriError}
+					<div class="notification is-danger">
+						<p>{shioriError}</p>
+					</div>
+				{/if}
+
+				<div class="field">
+					<label class="label" for="shiori-url">Shiori URL</label>
+					<div class="control">
+						<input
+							id="shiori-url"
+							class="input"
+							type="url"
+							placeholder="https://shiori.example.com"
+							bind:value={shioriUrl}
 						/>
 					</div>
+					<p class="help">The URL of your Shiori instance</p>
+				</div>
+
+				<div class="field">
+					<label class="label" for="shiori-username">Username</label>
+					<div class="control">
+						<input
+							id="shiori-username"
+							class="input"
+							type="text"
+							placeholder="Username"
+							bind:value={shioriUsername}
+						/>
+					</div>
+				</div>
+
+				<div class="field">
+					<label class="label" for="shiori-password">Password</label>
+					<div class="control">
+						<input
+							id="shiori-password"
+							class="input"
+							type="password"
+							placeholder="Password"
+							bind:value={shioriPassword}
+						/>
+					</div>
+				</div>
+
+				<div class="field is-grouped">
+					<div class="control">
+						<button
+							class="button is-primary"
+							on:click={handleImportFromShiori}
+							disabled={isImportingShiori || !shioriUrl || !shioriUsername || !shioriPassword}
+						>
+							<span class="icon">
+								<i class="fas fa-file-import" class:fa-spin={isImportingShiori}></i>
+							</span>
+							<span>{isImportingShiori ? 'Importing...' : 'Import'}</span>
+						</button>
+					</div>
+
+					<div class="control">
+						<button
+							class="button"
+							on:click={() => (showShioriImport = false)}
+							disabled={isImportingShiori}
+						>
+							Cancel
+						</button>
+					</div>
+				</div>
+
+				<!-- Add status message when import is in progress -->
+				{#if isImportingShiori}
+					<div class="notification is-warning mt-3">
+						<p class="has-text-weight-bold">
+							<i class="fas fa-spinner fa-spin mr-2"></i>
+							Import is running in the background
+						</p>
+						<p>
+							You can close this form and the import will continue. Progress will be shown at the
+							top of the page.
+						</p>
+					</div>
+				{/if}
+			</div>
+		{/if}
+
+		<div class="mb-4">
+			<SearchBar placeholder="Search saved links..." bind:value={searchQuery} />
+		</div>

 		<CardList
-		items={getFilteredItems()}
+			{items}
 			renderCard={(item) => {
 				const readLaterItem = item as ReadLaterItem;
 				return {
@ -160,4 +407,5 @@
 			}}
 			emptyMessage="No saved links yet."
 		/>
+	</section>
 </div>
--- a/go.mod
+++ b/go.mod
@ -35,13 +35,17 @@ require (
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.10 // indirect
 	github.com/mmcdole/gofeed v1.3.0 // indirect
 	github.com/mmcdole/goxpp v1.1.1-0.20240225020742-a0c311522b23 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rivo/uniseg v0.1.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
@ -52,6 +56,7 @@ require (
 	golang.org/x/text v0.22.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	jaytaylor.com/html2text v0.0.0-20230321000545-74c2419ad056 // indirect
 	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
 	modernc.org/memory v1.5.0 // indirect
--- a/go.sum
+++ b/go.sum
@ -75,6 +75,8 @@ github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
 github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mmcdole/gofeed v1.3.0 h1:5yn+HeqlcvjMeAI4gu6T+crm7d0anY85+M+v6fIFNG4=
 github.com/mmcdole/gofeed v1.3.0/go.mod h1:9TGv2LcJhdXePDzxiuMnukhV2/zb6VtnZt1mS+SjkLE=
@ -85,6 +87,8 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@ -93,6 +97,7 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY=
 github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
@ -101,6 +106,8 @@ github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4
 github.com/scylladb/termtables v0.0.0-20191203121021-c4c0b6d42ff4/go.mod h1:C1a7PQSMz9NShzorzCiG2fk9+xuCgLkPeCvMHYR2OWg=
 github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
 github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
+github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf h1:pvbZ0lM0XWPBqUKqFU8cmavspvIl9nulOYwdy6IFRRo=
+github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf/go.mod h1:RJID2RhlZKId02nZ62WenDCkgHFerpIOmW0iT7GKmXM=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@ -212,6 +219,8 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
 gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+jaytaylor.com/html2text v0.0.0-20230321000545-74c2419ad056 h1:6YFJoB+0fUH6X3xU/G2tQqCYg+PkGtnZ5nMR5rpw72g=
+jaytaylor.com/html2text v0.0.0-20230321000545-74c2419ad056/go.mod h1:OxvTsCwKosqQ1q7B+8FwXqg4rKZ/UG9dUW+g/VL2xH4=
 modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
 modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
 modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
--- a/main.go
+++ b/main.go
@ -166,14 +166,42 @@ func parseConfig() Configuration {
 }

 func handleFrontend(c *gin.Context) {
-	// Don't serve API routes
-	if path.Dir(c.Request.URL.Path) == "/api" {
+	requestPath := c.Request.URL.Path
+
+	// Check if the path is a direct file request (CSS, JS, etc.)
+	if isStaticFileRequest(requestPath) {
+		// Use the embedded filesystem instead of reading from disk
+		if err := serveStaticFile(c, "frontend/build"); err != nil {
+			// If not found in build, try static folder
+			if err := serveStaticFile(c, "frontend/static"); err != nil {
+				// Return 404 for static files that should exist
 				c.Status(http.StatusNotFound)
 				return
 			}
+		}
+		return
+	}

-	err := serveStaticFile(c, "frontend/build")
-	if err != nil { // if serveStaticFile returns an error, it has already tried to serve index.html as fallback
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+	// For SPA navigation - serve index.html for all non-API routes
+	// Use the embedded filesystem
+	if err := serveStaticFile(c, "frontend/build"); err != nil {
+		c.String(http.StatusInternalServerError, "Error reading index.html")
+		return
 	}
 }
+
+// isStaticFileRequest determines if a path is for a static file (CSS, JS, image, etc.)
+func isStaticFileRequest(path string) bool {
+	staticExtensions := []string{
+		".css", ".js", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico",
+		".json", ".woff", ".woff2", ".ttf", ".eot",
+	}
+
+	for _, ext := range staticExtensions {
+		if strings.HasSuffix(path, ext) {
+			return true
+		}
+	}
+
+	return false
+}
--- a/readlist/model.go
+++ b/readlist/model.go
@ -14,8 +14,11 @@ type ReadLaterItem struct {
 	Title        string     `json:"title" gorm:"not null"`
 	Content      string     `json:"content" gorm:"type:text"`
 	Description  string     `json:"description"`
+	Image        string     `json:"image"`
+	Status       string     `json:"status" gorm:"default:unread"`
 	CreatedAt    time.Time  `json:"createdAt"`
 	UpdatedAt    time.Time  `json:"updatedAt"`
+	LastModified time.Time  `json:"lastModified"`
 	ReadAt       *time.Time `json:"readAt"`
 	ArchivedAt   *time.Time `json:"archivedAt"`
 }
--- a/readlist/routes.go
+++ b/readlist/routes.go
@ -27,6 +27,8 @@ func (h *Handler) RegisterRoutes(group *gin.RouterGroup) {
 		readlist.POST("/:id/archive", h.handleArchive)
 		readlist.POST("/:id/unarchive", h.handleUnarchive)
 		readlist.DELETE("/:id", h.handleDelete)
+		readlist.POST("/import/shiori", h.handleImportFromShiori)
+		readlist.GET("/import/status/:id", h.handleImportStatus)
 	}

 	// Test endpoint
@ -124,3 +126,47 @@ func (h *Handler) handleUnarchive(c *gin.Context) {

 	c.Status(http.StatusOK)
 }
+
+// handleImportFromShiori handles importing bookmarks from a Shiori instance
+func (h *Handler) handleImportFromShiori(c *gin.Context) {
+	var creds ShioriCredentials
+	if err := c.ShouldBindJSON(&creds); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate required fields
+	if creds.URL == "" || creds.Username == "" || creds.Password == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "URL, username, and password are required"})
+		return
+	}
+
+	// Start the import process
+	importID, err := h.service.ImportFromShiori(creds)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Return the import ID
+	c.JSON(http.StatusAccepted, gin.H{"importId": importID})
+}
+
+// handleImportStatus handles getting the status of an import operation
+func (h *Handler) handleImportStatus(c *gin.Context) {
+	importID := c.Param("id")
+	if importID == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Import ID is required"})
+		return
+	}
+
+	// Get import status
+	status, exists := h.service.GetImportStatus(importID)
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Import not found"})
+		return
+	}
+
+	// Return the status
+	c.JSON(http.StatusOK, status)
+}
--- a/readlist/service.go
+++ b/readlist/service.go
@ -1,21 +1,49 @@
 package readlist

 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
 	"time"

+	"github.com/go-shiori/go-readability"
 	"github.com/google/uuid"
 	"gorm.io/gorm"
+	"jaytaylor.com/html2text"
 )

+// ImportStatus represents the status of a Shiori import operation
+type ImportStatus struct {
+	ID             string     `json:"id"`
+	TotalBookmarks int        `json:"totalBookmarks"`
+	ImportedCount  int        `json:"importedCount"`
+	FailedCount    int        `json:"failedCount"`
+	InProgress     bool       `json:"inProgress"`
+	StartedAt      time.Time  `json:"startedAt"`
+	CompletedAt    *time.Time `json:"completedAt"`
+	Error          string     `json:"error,omitempty"`
+}
+
 // Service handles read later operations
 type Service struct {
 	db           *gorm.DB
+	imports      map[string]*ImportStatus
+	importsMutex sync.RWMutex
+	rateLimiter  *time.Ticker // For rate limiting API calls
 }

 // NewService creates a new read later service
 func NewService(db *gorm.DB) *Service {
-	return &Service{db: db}
+	return &Service{
+		db:           db,
+		imports:      make(map[string]*ImportStatus),
+		importsMutex: sync.RWMutex{},
+		rateLimiter:  time.NewTicker(500 * time.Millisecond), // 500ms delay between requests
+	}
 }

 // Create adds a new URL to read later
@ -123,3 +151,473 @@ func (s *Service) Reset() error {
 	}
 	return nil
 }
+
+// ShioriCredentials contains the credentials for connecting to a Shiori instance
+type ShioriCredentials struct {
+	URL      string `json:"url"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// ShioriBookmark represents a bookmark in Shiori
+type ShioriBookmark struct {
+	ID            int             `json:"id"`
+	URL           string          `json:"url"`
+	Title         string          `json:"title"`
+	Excerpt       string          `json:"excerpt"`
+	Author        string          `json:"author"`
+	Public        int             `json:"public"`
+	CreatedAt     string          `json:"createdAt"`
+	ModifiedAt    string          `json:"modifiedAt"`
+	Modified      time.Time       `json:"modified,omitempty"`
+	Content       string          `json:"content,omitempty"`
+	HTML          string          `json:"html,omitempty"`
+	ImageURL      string          `json:"imageURL,omitempty"`
+	HasContent    bool            `json:"hasContent"`
+	HasImage      bool            `json:"hasImage"`
+	HasArchive    bool            `json:"hasArchive,omitempty"`
+	HasEbook      bool            `json:"hasEbook,omitempty"`
+	CreateArchive bool            `json:"create_archive,omitempty"`
+	CreateEbook   bool            `json:"create_ebook,omitempty"`
+	Tags          json.RawMessage `json:"tags,omitempty"`
+}
+
+// ShioriLoginResponse represents the response from Shiori login API
+type ShioriLoginResponse struct {
+	OK      bool `json:"ok"`
+	Message struct {
+		Token   string `json:"token"`   // JWT token for bearer auth
+		Session string `json:"session"` // Session ID
+		Expires int64  `json:"expires"`
+	} `json:"message"`
+}
+
+// ShioriBookmarksResponse represents the response from Shiori bookmarks API
+type ShioriBookmarksResponse struct {
+	Bookmarks []ShioriBookmark `json:"bookmarks"`
+	MaxPage   int              `json:"maxPage"`
+	Count     int              `json:"count"`
+}
+
+// ImportFromShiori imports bookmarks from a Shiori instance
+// Returns the import ID which can be used to check the status
+func (s *Service) ImportFromShiori(creds ShioriCredentials) (string, error) {
+	// For debugging
+	fmt.Printf("[DEBUG] Starting import from Shiori URL: %s\n", creds.URL)
+
+	// Create a new import status
+	importID := s.CreateImportStatus()
+	fmt.Printf("[DEBUG] Created import status with ID: %s\n", importID)
+
+	// Start the import process in a goroutine
+	go s.runShioriImport(importID, creds)
+
+	// Return the import ID so the caller can check the status
+	return importID, nil
+}
+
+// runShioriImport performs the actual import process in the background
+func (s *Service) runShioriImport(importID string, creds ShioriCredentials) {
+	fmt.Printf("[DEBUG] Starting runShioriImport for ID: %s\n", importID)
+
+	// Define a helper function to mark import as failed
+	markFailed := func(err error) {
+		fmt.Printf("[DEBUG] Import failed: %v\n", err)
+		s.UpdateImportStatus(importID, func(status *ImportStatus) {
+			status.InProgress = false
+			status.Error = err.Error()
+		})
+	}
+
+	// Login to Shiori
+	fmt.Printf("[DEBUG] Attempting to login to Shiori at %s\n", creds.URL)
+	token, err := s.loginToShiori(creds)
+	if err != nil {
+		fmt.Printf("[DEBUG] Login failed: %v\n", err)
+		markFailed(fmt.Errorf("failed to login to Shiori: %v", err))
+		return
+	}
+	fmt.Printf("[DEBUG] Login successful, token: %s...\n", token[:min(len(token), 10)])
+
+	// Fetch all bookmarks from Shiori with pagination
+	fmt.Printf("[DEBUG] Fetching bookmarks from Shiori\n")
+	allBookmarks, err := s.fetchShioriBookmarks(creds.URL, token)
+	if err != nil {
+		fmt.Printf("[DEBUG] Fetching bookmarks failed: %v\n", err)
+		markFailed(fmt.Errorf("failed to fetch bookmarks: %v", err))
+		return
+	}
+	fmt.Printf("[DEBUG] Fetched %d bookmarks\n", len(allBookmarks))
+
+	// Setup counters
+	importedCount := 0
+	failedCount := 0
+
+	// Update status with total count
+	s.UpdateImportStatus(importID, func(status *ImportStatus) {
+		status.TotalBookmarks = len(allBookmarks)
+	})
+	fmt.Printf("[DEBUG] Updated import status with total count: %d\n", len(allBookmarks))
+
+	// Process each bookmark
+	for i, bookmark := range allBookmarks {
+		fmt.Printf("[DEBUG] Processing bookmark %d/%d: %s\n", i+1, len(allBookmarks), bookmark.URL)
+		<-s.rateLimiter.C // Apply rate limiting for processing each bookmark
+
+		// Create a ReadLaterItem from the bookmark
+		item := ReadLaterItem{
+			ID:          uuid.New().String(),
+			URL:         bookmark.URL,
+			Title:       bookmark.Title,
+			Image:       bookmark.ImageURL,
+			Description: bookmark.Excerpt,
+			Status:      "unread",
+			Content:     bookmark.Content,
+			CreatedAt:   time.Now(),
+			UpdatedAt:   time.Now(),
+		}
+
+		// If content is empty, try to fetch it
+		if item.Content == "" {
+			fmt.Printf("[DEBUG] Content empty, fetching from URL: %s\n", bookmark.URL)
+			article, err := readability.FromURL(bookmark.URL, 30*time.Second)
+			if err == nil && article.Content != "" {
+				item.Content = article.Content
+
+				// If description/excerpt is empty, use the beginning of the content
+				if item.Description == "" {
+					plainText, err := s.ConvertHTMLToText(article.Content)
+					if err == nil && plainText != "" {
+						// Use the first 150 characters as description
+						if len(plainText) > 150 {
+							item.Description = plainText[:150] + "..."
+						} else {
+							item.Description = plainText
+						}
+					}
+				}
+
+				// If title is empty, use article title
+				if item.Title == "" && article.Title != "" {
+					item.Title = article.Title
+				}
+
+				// If image is empty, use article image
+				if item.Image == "" && article.Image != "" {
+					item.Image = article.Image
+				}
+			} else if err != nil {
+				fmt.Printf("[DEBUG] Error fetching article content: %v\n", err)
+			}
+		} else if item.Description == "" { // Convert any existing HTML content to plain text for the description if needed
+			plainText, err := s.ConvertHTMLToText(item.Content)
+			if err == nil && plainText != "" {
+				// Use the first 150 characters as description
+				if len(plainText) > 150 {
+					item.Description = plainText[:150] + "..."
+				} else {
+					item.Description = plainText
+				}
+			} else if err != nil {
+				fmt.Printf("[DEBUG] Error converting HTML to text: %v\n", err)
+			}
+		}
+
+		// Ensure we have at least a basic title if it's still empty
+		if item.Title == "" {
+			item.Title = bookmark.URL
+		}
+
+		// Save the item to the database
+		fmt.Printf("[DEBUG] Saving item to database: %s\n", item.URL)
+		err = s.db.Create(&item).Error
+		if err != nil {
+			fmt.Printf("[DEBUG] Error saving item: %v\n", err)
+			failedCount++
+		} else {
+			importedCount++
+		}
+
+		// Update import status
+		s.UpdateImportStatus(importID, func(status *ImportStatus) {
+			status.ImportedCount = importedCount
+			status.FailedCount = failedCount
+		})
+	}
+
+	// Mark import as complete
+	fmt.Printf("[DEBUG] Import complete. Imported: %d, Failed: %d\n", importedCount, failedCount)
+	s.UpdateImportStatus(importID, func(status *ImportStatus) {
+		status.InProgress = false
+		completedAt := time.Now()
+		status.CompletedAt = &completedAt
+	})
+}
+
+// loginToShiori logs in to a Shiori instance and returns the session token
+func (s *Service) loginToShiori(creds ShioriCredentials) (string, error) {
+	// Apply rate limiting
+	<-s.rateLimiter.C
+
+	fmt.Printf("[DEBUG] loginToShiori: Starting login to %s\n", creds.URL)
+
+	// Construct login URL
+	loginURL := fmt.Sprintf("%s/api/v1/auth/login", strings.TrimSuffix(creds.URL, "/"))
+	fmt.Printf("[DEBUG] loginToShiori: Login URL: %s\n", loginURL)
+
+	// Prepare login data
+	loginData := map[string]string{
+		"username": creds.Username,
+		"password": creds.Password,
+	}
+
+	// Convert login data to JSON
+	jsonData, err := json.Marshal(loginData)
+	if err != nil {
+		fmt.Printf("[DEBUG] loginToShiori: Error marshaling login data: %v\n", err)
+		return "", fmt.Errorf("failed to marshal login data: %v", err)
+	}
+
+	// Create request
+	req, err := http.NewRequest("POST", loginURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		fmt.Printf("[DEBUG] loginToShiori: Error creating request: %v\n", err)
+		return "", fmt.Errorf("failed to create login request: %v", err)
+	}
+
+	// Set headers
+	req.Header.Set("Content-Type", "application/json")
+
+	// Send request
+	fmt.Printf("[DEBUG] loginToShiori: Sending login request\n")
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Printf("[DEBUG] loginToShiori: Error sending request: %v\n", err)
+		return "", fmt.Errorf("failed to send login request: %v", err)
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error closing response body: %v\n", err)
+		}
+	}()
+
+	// Check response status
+	fmt.Printf("[DEBUG] loginToShiori: Response status: %s\n", resp.Status)
+	if resp.StatusCode != http.StatusOK {
+		// Read the error response body
+		errBody, _ := io.ReadAll(resp.Body)
+		fmt.Printf("[DEBUG] loginToShiori: Error response body: %s\n", string(errBody))
+		return "", fmt.Errorf("login failed with status code: %d", resp.StatusCode)
+	}
+
+	// Read response body
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Printf("[DEBUG] loginToShiori: Error reading response body: %v\n", err)
+		return "", fmt.Errorf("failed to read login response: %v", err)
+	}
+
+	// Print response body for debugging
+	fmt.Printf("[DEBUG] loginToShiori: Response body: %s\n", string(bodyBytes))
+
+	// We need to re-create the reader since we consumed it
+	resp.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+	// Parse response
+	var loginResp ShioriLoginResponse
+	if err := json.NewDecoder(resp.Body).Decode(&loginResp); err != nil {
+		fmt.Printf("[DEBUG] loginToShiori: Error parsing response: %v\n", err)
+		return "", fmt.Errorf("failed to parse login response: %v", err)
+	}
+
+	// Extract token
+	token := loginResp.Message.Token
+	fmt.Printf("[DEBUG] loginToShiori: Successfully logged in, token length: %d\n", len(token))
+
+	return token, nil
+}
+
+// fetchShioriBookmarks retrieves bookmarks from a Shiori instance using the session token
+func (s *Service) fetchShioriBookmarks(baseURL, session string) ([]ShioriBookmark, error) {
+	fmt.Printf("[DEBUG] fetchShioriBookmarks: Starting fetching bookmarks from %s\n", baseURL)
+	// Apply rate limiting
+	<-s.rateLimiter.C
+
+	// Ensure baseURL doesn't have a trailing slash
+	baseURL = strings.TrimSuffix(baseURL, "/")
+
+	// Initialize results
+	allBookmarks := []ShioriBookmark{}
+
+	// Start with page 1
+	page := 1
+	maxPage := 1 // Will be updated from the first response
+
+	for page <= maxPage {
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Fetching page %d of %d\n", page, maxPage)
+
+		// Construct URL for the current page - fixing the API endpoint path
+		url := fmt.Sprintf("%s/api/bookmarks?page=%d", baseURL, page)
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Request URL for page %d: %s\n", page, url)
+
+		// Create request
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error creating request for page %d: %v\n", page, err)
+			return nil, fmt.Errorf("failed to create request: %v", err)
+		}
+
+		// Set headers
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", session))
+
+		// Send request
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Sending request for page %d\n", page)
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		if err != nil {
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error sending request for page %d: %v\n", page, err)
+			return nil, fmt.Errorf("failed to send request: %v", err)
+		}
+		defer func() {
+			if err := resp.Body.Close(); err != nil {
+				fmt.Printf("[DEBUG] fetchShioriBookmarks: Error closing response body: %v\n", err)
+			}
+		}()
+
+		// Check response
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Response status for page %d: %s\n", page, resp.Status)
+		if resp.StatusCode != http.StatusOK {
+			// Read the error response body
+			errBody, _ := io.ReadAll(resp.Body)
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error response body for page %d: %s\n", page, string(errBody))
+			return nil, fmt.Errorf("request failed with status code: %d", resp.StatusCode)
+		}
+
+		// Read response body
+		bodyBytes, err := io.ReadAll(resp.Body)
+		if err != nil {
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error reading response body for page %d: %v\n", page, err)
+			return nil, fmt.Errorf("failed to read response: %v", err)
+		}
+
+		// Print the first 200 characters of response for debugging
+		previewText := string(bodyBytes)
+		if len(previewText) > 200 {
+			previewText = previewText[:200] + "..."
+		}
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Response body preview for page %d: %s\n", page, previewText)
+
+		// We need to re-create the reader since we consumed it
+		resp.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+		// Parse response
+		var bookmarksResp ShioriBookmarksResponse
+		if err := json.NewDecoder(resp.Body).Decode(&bookmarksResp); err != nil {
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Error parsing response for page %d: %v\n", page, err)
+			return nil, fmt.Errorf("failed to parse response: %v", err)
+		}
+
+		// Update maxPage from the response (only on first page)
+		if page == 1 {
+			maxPage = bookmarksResp.MaxPage
+			fmt.Printf("[DEBUG] fetchShioriBookmarks: Updated max page to %d\n", maxPage)
+		}
+
+		// Add bookmarks from this page to results
+		allBookmarks = append(allBookmarks, bookmarksResp.Bookmarks...)
+		fmt.Printf("[DEBUG] fetchShioriBookmarks: Added %d bookmarks from page %d, total so far: %d\n",
+			len(bookmarksResp.Bookmarks), page, len(allBookmarks))
+
+		// Move to next page
+		page++
+
+		// Apply rate limiting before next request (if there is one)
+		if page <= maxPage {
+			<-s.rateLimiter.C
+		}
+	}
+
+	fmt.Printf("[DEBUG] fetchShioriBookmarks: Completed, fetched %d bookmarks total\n", len(allBookmarks))
+	return allBookmarks, nil
+}
+
+// CreateImportStatus initializes a new import status and returns its ID
+func (s *Service) CreateImportStatus() string {
+	id := uuid.New().String()
+	status := &ImportStatus{
+		ID:            id,
+		InProgress:    true,
+		StartedAt:     time.Now(),
+		ImportedCount: 0,
+		FailedCount:   0,
+	}
+
+	s.importsMutex.Lock()
+	s.imports[id] = status
+	s.importsMutex.Unlock()
+
+	return id
+}
+
+// UpdateImportStatus updates the status of an import operation
+func (s *Service) UpdateImportStatus(id string, update func(*ImportStatus)) {
+	s.importsMutex.Lock()
+	defer s.importsMutex.Unlock()
+
+	if status, exists := s.imports[id]; exists {
+		update(status)
+	}
+}
+
+// GetImportStatus retrieves the status of an import operation
+func (s *Service) GetImportStatus(id string) (*ImportStatus, bool) {
+	s.importsMutex.RLock()
+	defer s.importsMutex.RUnlock()
+
+	status, exists := s.imports[id]
+	return status, exists
+}
+
+// CleanupOldImports removes completed import statuses older than a day
+func (s *Service) CleanupOldImports() {
+	s.importsMutex.Lock()
+	defer s.importsMutex.Unlock()
+
+	cutoff := time.Now().Add(-24 * time.Hour)
+
+	for id, status := range s.imports {
+		if !status.InProgress && status.CompletedAt != nil && status.CompletedAt.Before(cutoff) {
+			delete(s.imports, id)
+		}
+	}
+}
+
+// ConvertHTMLToText converts HTML content to plain text
+// This is useful when we need to extract text from HTML for searching or displaying in non-HTML contexts
+func (s *Service) ConvertHTMLToText(htmlContent string) (string, error) {
+	if htmlContent == "" {
+		return "", nil
+	}
+
+	// Convert HTML to plain text
+	text, err := html2text.FromString(htmlContent, html2text.Options{
+		PrettyTables: true,
+		OmitLinks:    false,
+	})
+
+	if err != nil {
+		return "", err
+	}
+
+	return text, nil
+}
+
+// Add helper function for safe string slicing
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
--- a/scripts/build.sh
+++ b/scripts/build.sh
@ -25,9 +25,7 @@ cp static/css/bulma.min.css build/css/

 # Build backend (without CGO)
 popd
-echo "Building Go backend..."
 CGO_ENABLED=0 $GO_CMD build -v -o notes-app || {
    echo "Go build failed!"
    exit 1
 }
-echo "Go build completed successfully."
--- a/specs/api.md
+++ b/specs/api.md
@ -0,0 +1,369 @@
+# API Specification
+
+## Overview
+
+QuickNotes provides a RESTful API for communication between the frontend and backend. The API is built using the Gin web framework and follows REST principles.
+
+## Base URL
+
+All API endpoints are prefixed with `/api`.
+
+## Authentication
+
+The API does not currently implement authentication as it is designed for local use.
+
+## Response Format
+
+API responses are formatted as JSON with the following structure:
+
+- For successful responses returning data:
+  ```json
+  {
+    "field1": "value1",
+    "field2": "value2",
+    ...
+  }
+  ```
+
+- For successful responses returning arrays:
+  ```json
+  [
+    {
+      "field1": "value1",
+      "field2": "value2",
+      ...
+    },
+    ...
+  ]
+  ```
+
+- For error responses:
+  ```json
+  {
+    "error": "Error message"
+  }
+  ```
+
+## Status Codes
+
+The API uses standard HTTP status codes:
+
+- `200 OK`: The request was successful
+- `400 Bad Request`: The request was invalid
+- `404 Not Found`: The requested resource was not found
+- `500 Internal Server Error`: An error occurred on the server
+
+## Endpoints
+
+### Notes
+
+#### List Notes
+
+- **URL**: `/api/notes`
+- **Method**: `GET`
+- **Description**: Get a list of all notes
+- **Response**: Array of Note objects
+  ```json
+  [
+    {
+      "id": "note-id",
+      "title": "Note Title",
+      "content": "Note content in Markdown",
+      "createdAt": "2023-01-01T12:00:00Z",
+      "updatedAt": "2023-01-01T12:00:00Z"
+    },
+    ...
+  ]
+  ```
+
+#### Create Note
+
+- **URL**: `/api/notes`
+- **Method**: `POST`
+- **Description**: Create a new note
+- **Request Body**: Note object without ID
+  ```json
+  {
+    "title": "Note Title",
+    "content": "Note content in Markdown"
+  }
+  ```
+- **Response**: Created Note object with ID
+  ```json
+  {
+    "id": "note-id",
+    "title": "Note Title",
+    "content": "Note content in Markdown",
+    "createdAt": "2023-01-01T12:00:00Z",
+    "updatedAt": "2023-01-01T12:00:00Z"
+  }
+  ```
+
+#### Get Note
+
+- **URL**: `/api/notes/:id`
+- **Method**: `GET`
+- **Description**: Get a specific note by ID
+- **URL Parameters**: `id` - ID of the note
+- **Response**: Note object
+  ```json
+  {
+    "id": "note-id",
+    "title": "Note Title",
+    "content": "Note content in Markdown",
+    "createdAt": "2023-01-01T12:00:00Z",
+    "updatedAt": "2023-01-01T12:00:00Z",
+    "linksTo": [
+      {
+        "id": "linked-note-id",
+        "title": "Linked Note Title"
+      }
+    ],
+    "linkedBy": [
+      {
+        "id": "linking-note-id",
+        "title": "Linking Note Title"
+      }
+    ]
+  }
+  ```
+
+#### Update Note
+
+- **URL**: `/api/notes/:id`
+- **Method**: `PUT`
+- **Description**: Update a specific note
+- **URL Parameters**: `id` - ID of the note
+- **Request Body**: Note object with updated fields
+  ```json
+  {
+    "title": "Updated Title",
+    "content": "Updated content"
+  }
+  ```
+- **Response**: Updated Note object
+  ```json
+  {
+    "id": "note-id",
+    "title": "Updated Title",
+    "content": "Updated content",
+    "createdAt": "2023-01-01T12:00:00Z",
+    "updatedAt": "2023-01-02T12:00:00Z"
+  }
+  ```
+
+#### Delete Note
+
+- **URL**: `/api/notes/:id`
+- **Method**: `DELETE`
+- **Description**: Delete a specific note
+- **URL Parameters**: `id` - ID of the note
+- **Response**: Empty response with status code 200
+
+#### Import Obsidian Vault
+
+- **URL**: `/api/notes/import`
+- **Method**: `POST`
+- **Description**: Import notes from an Obsidian vault
+- **Request Body**: Multipart form with a `file` field containing the zip file
+- **Response**: Import result
+  ```json
+  {
+    "imported": 42
+  }
+  ```
+
+### Readlist
+
+#### List Read Later Items
+
+- **URL**: `/api/readlist`
+- **Method**: `GET`
+- **Description**: Get a list of all read later items
+- **Query Parameters**:
+  - `status` - Filter by status (`read`, `unread`, `archived`, `unarchived`)
+- **Response**: Array of ReadLaterItem objects
+  ```json
+  [
+    {
+      "id": "item-id",
+      "url": "https://example.com/article",
+      "title": "Article Title",
+      "description": "Article description",
+      "createdAt": "2023-01-01T12:00:00Z",
+      "updatedAt": "2023-01-01T12:00:00Z",
+      "readAt": null,
+      "archivedAt": null
+    },
+    ...
+  ]
+  ```
+
+#### Save Article
+
+- **URL**: `/api/readlist`
+- **Method**: `POST`
+- **Description**: Save a new article
+- **Request Body**: ReadLaterItem object with URL
+  ```json
+  {
+    "url": "https://example.com/article"
+  }
+  ```
+- **Response**: Created ReadLaterItem object
+  ```json
+  {
+    "id": "item-id",
+    "url": "https://example.com/article",
+    "title": "Article Title",
+    "content": "Article content in HTML",
+    "description": "Article description",
+    "createdAt": "2023-01-01T12:00:00Z",
+    "updatedAt": "2023-01-01T12:00:00Z",
+    "readAt": null,
+    "archivedAt": null
+  }
+  ```
+
+#### Get Article
+
+- **URL**: `/api/readlist/:id`
+- **Method**: `GET`
+- **Description**: Get a specific article by ID
+- **URL Parameters**: `id` - ID of the article
+- **Response**: ReadLaterItem object
+  ```json
+  {
+    "id": "item-id",
+    "url": "https://example.com/article",
+    "title": "Article Title",
+    "content": "Article content in HTML",
+    "description": "Article description",
+    "createdAt": "2023-01-01T12:00:00Z",
+    "updatedAt": "2023-01-01T12:00:00Z",
+    "readAt": null,
+    "archivedAt": null
+  }
+  ```
+
+#### Mark as Read/Unread
+
+- **URL**: `/api/readlist/:id/read` or `/api/readlist/:id/unread`
+- **Method**: `PUT`
+- **Description**: Mark an article as read or unread
+- **URL Parameters**: `id` - ID of the article
+- **Response**: Updated ReadLaterItem object
+
+#### Archive/Unarchive
+
+- **URL**: `/api/readlist/:id/archive` or `/api/readlist/:id/unarchive`
+- **Method**: `PUT`
+- **Description**: Archive or unarchive an article
+- **URL Parameters**: `id` - ID of the article
+- **Response**: Updated ReadLaterItem object
+
+### Feeds
+
+#### List Feeds
+
+- **URL**: `/api/feeds`
+- **Method**: `GET`
+- **Description**: Get a list of all feeds
+- **Response**: Array of Feed objects
+  ```json
+  [
+    {
+      "id": "feed-id",
+      "title": "Feed Title",
+      "url": "https://example.com/feed.xml",
+      "description": "Feed description",
+      "siteUrl": "https://example.com",
+      "imageUrl": "https://example.com/logo.png",
+      "lastFetched": "2023-01-01T12:00:00Z",
+      "createdAt": "2023-01-01T12:00:00Z",
+      "updatedAt": "2023-01-01T12:00:00Z"
+    },
+    ...
+  ]
+  ```
+
+#### Subscribe to Feed
+
+- **URL**: `/api/feeds`
+- **Method**: `POST`
+- **Description**: Subscribe to a new feed
+- **Request Body**: Feed object with URL
+  ```json
+  {
+    "url": "https://example.com/feed.xml"
+  }
+  ```
+- **Response**: Created Feed object
+
+#### List Entries
+
+- **URL**: `/api/feeds/entries` or `/api/feeds/:id/entries`
+- **Method**: `GET`
+- **Description**: Get a list of entries from all feeds or a specific feed
+- **URL Parameters**: `id` (optional) - ID of the feed
+- **Query Parameters**:
+  - `status` - Filter by status (`read`, `unread`)
+  - `limit` - Maximum number of entries to return
+  - `offset` - Offset for pagination
+- **Response**: Array of Entry objects
+  ```json
+  [
+    {
+      "id": "entry-id",
+      "feedId": "feed-id",
+      "title": "Entry Title",
+      "url": "https://example.com/article",
+      "content": "Entry content in HTML",
+      "summary": "Entry summary",
+      "author": "Author Name",
+      "published": "2023-01-01T12:00:00Z",
+      "updated": "2023-01-01T12:00:00Z",
+      "readAt": null,
+      "createdAt": "2023-01-01T12:00:00Z",
+      "updatedAt": "2023-01-01T12:00:00Z"
+    },
+    ...
+  ]
+  ```
+
+#### Refresh Feeds
+
+- **URL**: `/api/feeds/refresh` or `/api/feeds/:id/refresh`
+- **Method**: `POST`
+- **Description**: Refresh all feeds or a specific feed
+- **URL Parameters**: `id` (optional) - ID of the feed
+- **Response**: Refresh result
+  ```json
+  {
+    "newEntries": 5
+  }
+  ```
+
+## Error Handling
+
+The API handles errors by returning appropriate HTTP status codes and error messages:
+
+```json
+{
+  "error": "Detailed error message"
+}
+```
+
+Common error scenarios:
+
+1. **Invalid Input**: Returns 400 Bad Request
+2. **Resource Not Found**: Returns 404 Not Found
+3. **Server Error**: Returns 500 Internal Server Error
+
+## Rate Limiting
+
+The API does not currently implement rate limiting as it is designed for local use.
+
+## Versioning
+
+The API does not currently implement versioning. Future versions may include a version prefix in the URL path (e.g., `/api/v1/notes`). 
--- a/specs/architecture.md
+++ b/specs/architecture.md
@ -0,0 +1,103 @@
+# Architecture Specification
+
+## Overview
+
+QuickNotes is a personal knowledge management application with a client-server architecture. It consists of a Go backend and a Svelte frontend, with SQLite as the database.
+
+## System Components
+
+### Backend
+
+The backend is built with Go and uses the following key components:
+
+1. **Gin Web Framework**: Handles HTTP routing and middleware
+2. **GORM**: Object-relational mapping for database operations
+3. **SQLite**: Embedded database for data storage
+4. **Domain Modules**:
+   - Notes: Manages note creation, retrieval, and linking
+   - Readlist: Handles read-later functionality
+   - Feeds: Manages RSS/Atom feed subscriptions and entries
+
+### Frontend
+
+The frontend is built with Svelte and SvelteKit, providing a responsive single-page application experience:
+
+1. **SvelteKit**: Framework for building the frontend application
+2. **Bulma CSS**: CSS framework for styling
+3. **FontAwesome**: Icon library
+4. **D3.js**: Used for the notes graph visualization
+5. **Marked**: Markdown parsing and rendering
+
+### Database
+
+SQLite is used as the database, with the following main tables:
+
+1. **Notes**: Stores user notes
+2. **Note Links**: Stores relationships between notes
+3. **Read Later Items**: Stores saved articles
+4. **Feeds**: Stores feed subscriptions
+5. **Entries**: Stores feed entries
+
+## Communication Flow
+
+1. The frontend communicates with the backend via RESTful API calls
+2. The backend processes these requests, interacts with the database, and returns responses
+3. The frontend renders the data and handles user interactions
+
+```
+┌─────────────┐      HTTP/JSON      ┌─────────────┐      SQL      ┌─────────────┐
+│   Frontend  │ ─────────────────► │   Backend   │ ───────────► │  Database   │
+│  (Svelte)   │ ◄───────────────── │    (Go)     │ ◄───────────  │  (SQLite)   │
+└─────────────┘                     └─────────────┘               └─────────────┘
+```
+
+## Deployment Architecture
+
+The application is designed to be run locally as a single binary that embeds the frontend assets:
+
+1. The Go backend serves the compiled Svelte frontend
+2. The SQLite database is stored as a local file
+3. The application is accessed via a web browser at `http://localhost:3000`
+
+## File Structure
+
+```
+quicknotes/
+├── main.go                 # Application entry point
+├── go.mod                  # Go module definition
+├── go.sum                  # Go module checksums
+├── notes/                  # Notes module
+│   ├── model.go            # Note data models
+│   ├── service.go          # Business logic
+│   └── routes.go           # API endpoints
+├── readlist/               # Readlist module
+│   ├── model.go            # Readlist data models
+│   ├── service.go          # Business logic
+│   └── routes.go           # API endpoints
+├── feeds/                  # Feeds module
+│   ├── model.go            # Feed data models
+│   ├── service.go          # Business logic
+│   └── handler.go          # API endpoints
+├── frontend/               # Frontend application
+│   ├── src/                # Source code
+│   │   ├── routes/         # SvelteKit routes
+│   │   ├── lib/            # Shared components and utilities
+│   │   └── app.html        # HTML template
+│   ├── static/             # Static assets
+│   └── build/              # Compiled frontend (embedded in binary)
+└── notes.db                # SQLite database file
+```
+
+## Design Patterns
+
+1. **Model-View-Controller (MVC)**: The backend follows an MVC-like pattern with models, services, and handlers
+2. **Repository Pattern**: Database operations are abstracted in service layers
+3. **Dependency Injection**: Services are injected into handlers
+4. **RESTful API**: The backend exposes a RESTful API for the frontend to consume
+
+## Security Considerations
+
+1. The application is designed for local use and does not implement authentication
+2. Input validation is performed on both client and server sides
+3. Content Security Policy headers are set for frontend assets
+4. The application uses parameterized queries to prevent SQL injection 
--- a/specs/authentication.md
+++ b/specs/authentication.md
@ -0,0 +1,93 @@
+# Authentication Specification
+
+## Overview
+
+The QuickNotes application is designed primarily for local use and does not currently implement a comprehensive authentication system. This document outlines the current state of authentication in the application and potential future enhancements.
+
+## Current Implementation
+
+### Local Usage Model
+
+QuickNotes currently operates on a local-only model:
+
+1. The application runs as a local server on the user's machine
+2. Access is restricted to localhost connections
+3. No user accounts or login functionality is implemented
+4. All data is stored locally in the SQLite database
+
+### Security Considerations
+
+Despite the lack of formal authentication, the application implements several security measures:
+
+1. **Trusted Proxies**: The application only trusts loopback addresses (127.0.0.1, ::1)
+2. **Input Validation**: All user inputs are validated to prevent injection attacks
+3. **Content Security Policy**: Headers are set to prevent cross-site scripting
+4. **CSRF Protection**: The application includes measures to prevent cross-site request forgery
+
+## Potential Future Authentication
+
+If authentication were to be implemented in the future, the following approach could be adopted:
+
+### User Model
+
+A potential `User` entity would have the following attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ID | string | Unique identifier for the user (UUID) |
+| Username | string | Username for login |
+| PasswordHash | string | Hashed password (not stored in plaintext) |
+| Email | string | User's email address |
+| CreatedAt | timestamp | When the user account was created |
+| UpdatedAt | timestamp | When the user account was last updated |
+
+### Authentication Flow
+
+1. **Registration**: Users would create an account with a username and password
+2. **Login**: Users would authenticate with their credentials
+3. **Session Management**: Authenticated sessions would be maintained using JWT or session cookies
+4. **Logout**: Users would be able to terminate their sessions
+
+### API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | /api/auth/register | Register a new user |
+| POST | /api/auth/login | Authenticate a user |
+| POST | /api/auth/logout | End a user's session |
+| GET | /api/auth/me | Get the current user's information |
+| PUT | /api/auth/password | Change a user's password |
+
+### Multi-User Support
+
+With authentication, the application could support multiple users:
+
+1. **Data Isolation**: Each user would only see their own notes, readlist items, and feeds
+2. **User Preferences**: Users could have individual settings and preferences
+3. **Sharing**: Users could optionally share specific notes or collections with other users
+
+### Security Enhancements
+
+Authentication would bring additional security measures:
+
+1. **Password Hashing**: Using bcrypt or Argon2 for secure password storage
+2. **Rate Limiting**: Preventing brute force attacks
+3. **Two-Factor Authentication**: Optional additional security layer
+4. **API Tokens**: For programmatic access to the API
+
+## Integration with Emacs Mode
+
+The Emacs mode would need to be updated to support authentication:
+
+1. **Credential Storage**: Securely storing user credentials
+2. **Authentication Flow**: Handling login and session management
+3. **Token Refresh**: Automatically refreshing expired tokens
+
+## Implementation Considerations
+
+If authentication were to be implemented, the following considerations would be important:
+
+1. **Backward Compatibility**: Ensuring existing data can be migrated to user accounts
+2. **Simplicity**: Maintaining the application's ease of use
+3. **Privacy**: Ensuring user data remains private and secure
+4. **Performance**: Minimizing the performance impact of authentication checks 
--- a/specs/database.md
+++ b/specs/database.md
@ -0,0 +1,145 @@
+# Database Specification
+
+## Overview
+
+QuickNotes uses SQLite as its database engine, with GORM as the object-relational mapping (ORM) layer. The database stores notes, read later items, feeds, and feed entries.
+
+## Database Engine
+
+- **SQLite**: A self-contained, serverless, zero-configuration, transactional SQL database engine
+- **File Location**: The database is stored in a file named `notes.db` in the application root directory
+- **Access**: The database is accessed directly by the Go backend using the `glebarez/sqlite` driver for GORM
+
+## Schema
+
+### Notes Table
+
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| id | TEXT | PRIMARY KEY | Unique identifier for the note |
+| title | TEXT | NOT NULL | Title of the note |
+| content | TEXT | NOT NULL | Content of the note in Markdown format |
+| created_at | DATETIME | | When the note was created |
+| updated_at | DATETIME | | When the note was last updated |
+
+### Note Links Table
+
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| source_note_id | TEXT | PRIMARY KEY, FOREIGN KEY | ID of the source note |
+| target_note_id | TEXT | PRIMARY KEY, FOREIGN KEY | ID of the target note |
+| created_at | DATETIME | | When the link was created |
+
+### Read Later Items Table
+
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| id | TEXT | PRIMARY KEY | Unique identifier for the item |
+| url | TEXT | NOT NULL | Original URL of the article |
+| title | TEXT | NOT NULL | Title of the article |
+| content | TEXT | | Extracted HTML content of the article |
+| description | TEXT | | Brief description or excerpt of the article |
+| created_at | DATETIME | | When the item was saved |
+| updated_at | DATETIME | | When the item was last updated |
+| read_at | DATETIME | | When the item was marked as read (null if unread) |
+| archived_at | DATETIME | | When the item was archived (null if not archived) |
+
+### Feeds Table
+
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| id | TEXT | PRIMARY KEY | Unique identifier for the feed |
+| title | TEXT | | Title of the feed |
+| url | TEXT | UNIQUE | URL of the feed (RSS/Atom) |
+| description | TEXT | | Description of the feed |
+| site_url | TEXT | | URL of the website associated with the feed |
+| image_url | TEXT | | URL of the feed's image or logo |
+| last_fetched | DATETIME | | When the feed was last fetched |
+| created_at | DATETIME | | When the feed was added |
+| updated_at | DATETIME | | When the feed was last updated |
+
+### Entries Table
+
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| id | TEXT | PRIMARY KEY | Unique identifier for the entry |
+| feed_id | TEXT | FOREIGN KEY, INDEX | ID of the parent feed |
+| title | TEXT | | Title of the entry |
+| url | TEXT | UNIQUE | URL of the entry |
+| content | TEXT | | HTML content of the entry |
+| summary | TEXT | | Summary or excerpt of the entry |
+| author | TEXT | | Author of the entry |
+| published | DATETIME | | When the entry was published |
+| updated | DATETIME | | When the entry was last updated |
+| read_at | DATETIME | | When the entry was marked as read (null if unread) |
+| full_content | TEXT | | Full content of the entry (if fetched separately) |
+| created_at | DATETIME | | When the entry was added to the system |
+| updated_at | DATETIME | | When the entry was last updated in the system |
+
+## Relationships
+
+1. **Notes to Notes (Many-to-Many)**:
+   - A note can link to many other notes
+   - A note can be linked from many other notes
+   - The relationship is managed through the `note_links` table
+
+2. **Feeds to Entries (One-to-Many)**:
+   - A feed can have many entries
+   - An entry belongs to one feed
+   - The relationship is managed through the `feed_id` foreign key in the `entries` table
+
+## Initialization
+
+The database schema is automatically created and migrated when the application starts:
+
+```go
+// Initialize database
+db, err := gorm.Open(sqlite.Open(config.DBPath), &gorm.Config{})
+if err != nil {
+    log.Fatal(err)
+}
+
+// Auto migrate the schema
+if err := db.AutoMigrate(&notes.Note{}, &notes.NoteLink{}, &readlist.ReadLaterItem{}, &feeds.Feed{}, &feeds.Entry{}); err != nil {
+    log.Fatal(err)
+}
+```
+
+## Indexes
+
+The following indexes are created to optimize query performance:
+
+1. **URL Index on Feeds**: Ensures fast lookup of feeds by URL
+2. **Feed ID Index on Entries**: Ensures fast lookup of entries by feed
+3. **URL Index on Entries**: Ensures fast lookup of entries by URL
+
+## Data Access
+
+Data access is managed through GORM, which provides:
+
+1. **Object-Relational Mapping**: Maps Go structs to database tables
+2. **Query Building**: Simplifies building SQL queries
+3. **Transactions**: Ensures data consistency
+4. **Hooks**: Allows for custom logic before and after database operations
+
+## Data Integrity
+
+The following measures ensure data integrity:
+
+1. **Foreign Key Constraints**: Ensure referential integrity between related tables
+2. **Unique Constraints**: Prevent duplicate entries for URLs
+3. **Not Null Constraints**: Ensure required fields are provided
+4. **Transactions**: Used for operations that affect multiple tables
+
+## Backup and Recovery
+
+The SQLite database file (`notes.db`) can be backed up by:
+
+1. Copying the file when the application is not running
+2. Using SQLite's backup API
+3. Exporting data to a SQL dump file
+
+Recovery can be performed by:
+
+1. Replacing the database file with a backup
+2. Importing data from a SQL dump file 
--- a/specs/documents.md
+++ b/specs/documents.md
@ -0,0 +1,59 @@
+# Documents Specification
+
+## Overview
+
+The Documents domain allows users to upload and view PDF documents within the QuickNotes application. This feature is designed to extend the application so that users can manage and view important documents without having to download them.
+
+## Data Model
+
+A new entity, `Document`, will be introduced with the following attributes:
+
+| Field       | Type      | Description                                     |
+|-------------|-----------|-------------------------------------------------|
+| ID          | string    | Unique identifier for the document (UUID)       |
+| Filename    | string    | Original filename of the uploaded document      |
+| Path        | string    | Server-side path or storage reference           |
+| URL         | string    | Public URL to access the document (if needed)   |
+| UploadedAt  | timestamp | When the document was uploaded                  |
+| UpdatedAt   | timestamp | When the document was last updated              |
+
+## Storage Architecture
+
+There are two options for storing PDF documents:
+
+1. **Local Disk Storage**: Documents are stored on the local server's filesystem. This method is simple and sufficient for local or small-scale usage.
+
+2. **Blob Storage (e.g., S3)**: For scalability and better durability, a cloud-based blob storage system (like Amazon S3) could be used. For now, local disk storage is assumed.
+
+
+## API Endpoints
+
+| Method | Endpoint             | Description                                      |
+|--------|----------------------|--------------------------------------------------|
+| POST   | /api/documents       | Upload a new PDF document                        |
+| GET    | /api/documents       | List all uploaded documents                      |
+| GET    | /api/documents/:id   | Retrieve details of a specific document          |
+| DELETE | /api/documents/:id   | Delete a specific document                       |
+
+### Upload Endpoint
+
+- Accepts multipart/form-data with a file field (PDF).
+- Validates that the uploaded file is a PDF.
+- Stores the file in the designated storage (local disk for now).
+- Returns metadata about the uploaded document.
+
+## Frontend Integration
+
+### PDF Viewer
+
+The frontend will integrate a PDF viewer (similar to PDF.js) to display the PDF inline without forcing a download:
+
+1. **Upload Form**: A page where users can select and upload a PDF document.
+2. **Viewer Page**: A page that embeds a PDF viewer component to display the document. This viewer supports zoom, search within the PDF, and navigation between pages.
+
+
+## Implementation Considerations
+
+1. **Security**: Validate file types and implement proper access controls.
+2. **Performance**: If stored locally, ensure that the server has sufficient storage and backup mechanisms.
+3. **Scalability**: For future scalability, consider integrating with a cloud blob storage service (e.g., Amazon S3) and a CDN for faster delivery. 
--- a/specs/emacs_integration.md
+++ b/specs/emacs_integration.md
@ -0,0 +1,143 @@
+# Emacs Integration Specification
+
+## Overview
+
+QuickNotes provides an Emacs mode that allows users to access and interact with the application directly from Emacs. This integration enables viewing feeds, readlist items, and notes without leaving the editor.
+
+## Features
+
+### Core Functionality
+
+1. **View Feed Entries**: Browse entries from RSS/Atom feeds
+2. **Browse Readlist**: Access saved read-later items
+3. **Navigate Notes**: Browse and search through notes
+4. **View Content**: Read feed entries, readlist items, and notes
+5. **Mark as Read**: Mark items as read/unread
+6. **HTML to Org Conversion**: Convert HTML content to Org mode format
+
+### Navigation
+
+1. **List Views**: Display lists of feeds, readlist items, and notes
+2. **Item View**: Display the content of a selected item
+3. **Back Navigation**: Return to previous views
+4. **Refresh**: Update content from the server
+
+### Content Rendering
+
+1. **HTML Rendering**: Display HTML content in Emacs
+2. **Org Mode Conversion**: Convert HTML to Org mode format using Pandoc
+3. **Syntax Highlighting**: Apply appropriate syntax highlighting to code blocks
+4. **Link Handling**: Make links clickable and functional
+
+## Implementation
+
+### Dependencies
+
+1. **request.el**: For API communication
+2. **markdown-mode**: For rendering Markdown content
+3. **pandoc**: For converting HTML to Org mode format (optional)
+
+### Configuration
+
+```elisp
+;; Set the API URL
+(setq quicknotes-api-url "http://localhost:3000/api")
+
+;; Enable Pandoc conversion to Org mode
+(setq quicknotes-use-pandoc t)
+```
+
+### Key Bindings
+
+| Key | Function | Description |
+|-----|----------|-------------|
+| `RET` | `quicknotes-open-item` | Open the item at point |
+| `r` | `quicknotes-mark-read` | Mark the item as read |
+| `f` | `quicknotes-list-feeds` | List feed entries |
+| `l` | `quicknotes-list-readlist` | List read later items |
+| `n` | `quicknotes-list-notes` | List notes |
+| `o` | `quicknotes-toggle-org` | Toggle between HTML and Org mode rendering |
+| `g` | `quicknotes-refresh` | Refresh the current buffer |
+| `q` | `quicknotes-quit` | Quit the current buffer |
+
+### Buffer Types
+
+1. **Feeds List Buffer**: Displays a list of feed entries
+2. **Readlist Buffer**: Displays a list of read later items
+3. **Notes List Buffer**: Displays a list of notes
+4. **Content Buffer**: Displays the content of a selected item
+
+## API Integration
+
+### API Endpoints Used
+
+1. **GET /api/feeds/entries**: Fetch feed entries
+2. **GET /api/readlist**: Fetch read later items
+3. **GET /api/notes**: Fetch notes
+4. **GET /api/feeds/entries/:id**: Fetch a specific feed entry
+5. **GET /api/readlist/:id**: Fetch a specific read later item
+6. **GET /api/notes/:id**: Fetch a specific note
+7. **PUT /api/feeds/entries/:id/read**: Mark a feed entry as read
+8. **PUT /api/readlist/:id/read**: Mark a read later item as read
+
+### Authentication
+
+The Emacs mode does not currently implement authentication, as the QuickNotes API is designed for local use without authentication.
+
+## User Interface
+
+### List View
+
+```
+QuickNotes - Feeds
+
+[2023-01-01] Title of Feed Entry 1
+[2023-01-02] Title of Feed Entry 2
+[2023-01-03] Title of Feed Entry 3
+
+Press 'f' for feeds, 'l' for readlist, 'n' for notes, 'q' to quit
+```
+
+### Content View
+
+```
+Title: Example Article
+
+This is the content of the article, rendered in Emacs.
+
+Links are clickable, and code blocks have syntax highlighting.
+
+Press 'r' to mark as read, 'o' to toggle Org mode, 'q' to return to list
+```
+
+## HTML to Org Conversion
+
+The Emacs mode can convert HTML content to Org mode format using Pandoc:
+
+```elisp
+(defun quicknotes-html-to-org (html)
+  "Convert HTML to Org mode format using Pandoc."
+  (when (and quicknotes-use-pandoc (executable-find "pandoc"))
+    (with-temp-buffer
+      (insert html)
+      (shell-command-on-region (point-min) (point-max)
+                               "pandoc -f html -t org"
+                               (current-buffer) t)
+      (buffer-string))))
+```
+
+## Error Handling
+
+1. **Connection Errors**: Display a message when the API is unreachable
+2. **Not Found Errors**: Handle 404 responses gracefully
+3. **Server Errors**: Display error messages from the server
+4. **Pandoc Errors**: Fall back to HTML rendering if Pandoc conversion fails
+
+## Future Enhancements
+
+1. **Create/Edit Notes**: Allow creating and editing notes from Emacs
+2. **Save to Readlist**: Add the ability to save URLs to the readlist
+3. **Subscribe to Feeds**: Add the ability to subscribe to new feeds
+4. **Search**: Implement search functionality across all content types
+5. **Offline Mode**: Cache content for offline access
+6. **Customizable Faces**: Allow customizing the appearance of different elements 
--- a/specs/feeds.md
+++ b/specs/feeds.md
@ -0,0 +1,178 @@
+# Feeds Specification
+
+## Overview
+
+The Feeds module allows users to subscribe to and read RSS/Atom feeds. It provides feed management, automatic fetching of new entries, and a clean reading experience for feed content.
+
+## Data Model
+
+### Feed
+
+The `Feed` entity has the following attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ID | string | Unique identifier for the feed (UUID) |
+| Title | string | Title of the feed |
+| URL | string | URL of the feed (RSS/Atom) |
+| Description | string | Description of the feed |
+| SiteURL | string | URL of the website associated with the feed |
+| ImageURL | string | URL of the feed's image or logo |
+| LastFetched | timestamp | When the feed was last fetched |
+| CreatedAt | timestamp | When the feed was added |
+| UpdatedAt | timestamp | When the feed was last updated |
+
+### Entry
+
+The `Entry` entity represents a single item in a feed:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ID | string | Unique identifier for the entry (UUID) |
+| FeedID | string | ID of the parent feed |
+| Title | string | Title of the entry |
+| URL | string | URL of the entry |
+| Content | string | HTML content of the entry |
+| Summary | string | Summary or excerpt of the entry |
+| Author | string | Author of the entry |
+| Published | timestamp | When the entry was published |
+| Updated | timestamp | When the entry was last updated |
+| ReadAt | timestamp | When the entry was marked as read (null if unread) |
+| FullContent | string | Full content of the entry (if fetched separately) |
+| CreatedAt | timestamp | When the entry was added to the system |
+| UpdatedAt | timestamp | When the entry was last updated in the system |
+
+## UUID Generation
+
+Both Feed and Entry entities have GORM BeforeCreate hooks which ensure that a UUID is automatically generated if the ID is not provided:
+
+- For the Feed entity:
+  ```go
+  func (f *Feed) BeforeCreate(tx *gorm.DB) error {
+      if f.ID == "" {
+          f.ID = uuid.New().String()
+      }
+      return nil
+  }
+  ```
+
+- For the Entry entity:
+  ```go
+  func (e *Entry) BeforeCreate(tx *gorm.DB) error {
+      if e.ID == "" {
+          e.ID = uuid.New().String()
+      }
+      return nil
+  }
+  ```
+
+## Features
+
+### Feed Management
+
+1. **Subscribe to Feed**: Users can subscribe to new feeds by providing a URL
+2. **Unsubscribe from Feed**: Users can unsubscribe from feeds
+3. **List Feeds**: Users can view a list of all subscribed feeds
+4. **View Feed Details**: Users can view details about a specific feed
+
+### Entry Management
+
+1. **List Entries**: Users can view a list of entries from all feeds or a specific feed
+2. **View Entry**: Users can view the content of a specific entry
+3. **Mark as Read**: Users can mark entries as read
+4. **Mark as Unread**: Users can mark entries as unread
+5. **Filter Entries**: Users can filter entries by read/unread status
+
+### Feed Fetching
+
+1. **Manual Refresh**: Users can manually refresh feeds to fetch new entries
+2. **Automatic Refresh**: The system can automatically refresh feeds at regular intervals
+3. **Content Extraction**: For feeds that only provide summaries, the system can fetch the full content
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /api/feeds | List all feeds |
+| POST | /api/feeds | Subscribe to a new feed |
+| GET | /api/feeds/:id | Get a specific feed by ID |
+| PUT | /api/feeds/:id | Update a specific feed |
+| DELETE | /api/feeds/:id | Unsubscribe from a feed |
+| GET | /api/feeds/:id/entries | List entries for a specific feed |
+| GET | /api/feeds/entries | List entries from all feeds |
+| GET | /api/feeds/entries/:id | Get a specific entry by ID |
+| PUT | /api/feeds/entries/:id/read | Mark an entry as read |
+| PUT | /api/feeds/entries/:id/unread | Mark an entry as unread |
+| POST | /api/feeds/refresh | Refresh all feeds |
+| POST | /api/feeds/:id/refresh | Refresh a specific feed |
+
+## Frontend Routes
+
+| Route | Description |
+|-------|-------------|
+| /feeds | List of subscribed feeds |
+| /feeds/:id | View entries from a specific feed |
+| /feeds/entries/:id | View a specific entry |
+
+## Implementation Details
+
+### Feed Parsing
+
+The system uses the `gofeed` library to parse RSS and Atom feeds:
+
+```go
+func (s *Service) parseFeed(feedURL string) (*gofeed.Feed, error) {
+    fp := gofeed.NewParser()
+    feed, err := fp.ParseURL(feedURL)
+    if err != nil {
+        return nil, fmt.Errorf("failed to parse feed: %w", err)
+    }
+    return feed, nil
+}
+```
+
+### Feed Refreshing
+
+When refreshing a feed, the system:
+
+1. Fetches the feed content from the URL
+2. Parses the feed to extract entries
+3. Compares entries with existing ones to identify new entries
+4. Saves new entries to the database
+
+### Content Extraction
+
+For feeds that only provide summaries, the system can optionally fetch the full content of entries:
+
+1. Extract the URL of the entry
+2. Fetch the web page at that URL
+3. Use a content extraction algorithm to extract the main content
+4. Save the extracted content as the entry's full content
+
+## User Interface
+
+### Feed List
+
+- Displays a list of subscribed feeds with titles, descriptions, and icons
+- Shows the number of unread entries for each feed
+- Provides buttons for refreshing, editing, and unsubscribing
+
+### Entry List
+
+- Displays a list of entries from all feeds or a specific feed
+- Shows entry titles, summaries, publication dates, and read status
+- Provides filters for read/unread status
+- Includes buttons for marking as read/unread
+
+### Entry Viewer
+
+- Displays the entry content in a clean, reader-friendly format
+- Shows the entry title, author, and publication date
+- Provides buttons for marking as read/unread and returning to the list
+- Includes a link to the original article
+
+### Subscribe Form
+
+- Input field for the feed URL
+- Automatic detection of feed format (RSS/Atom)
+- Preview of feed details before subscribing 
--- a/specs/frontend.md
+++ b/specs/frontend.md
@ -0,0 +1,187 @@
+# Frontend Specification
+
+## Overview
+
+The QuickNotes frontend is built with Svelte and SvelteKit, providing a responsive single-page application experience. It communicates with the backend via RESTful API calls and provides a user-friendly interface for managing notes, read later items, and feeds.
+
+## Technology Stack
+
+- **SvelteKit**: Framework for building the frontend application
+- **Bulma CSS**: CSS framework for styling
+- **FontAwesome**: Icon library
+- **D3.js**: Used for the notes graph visualization
+- **Marked**: Markdown parsing and rendering
+
+## Architecture
+
+The frontend follows the SvelteKit architecture:
+
+1. **Routes**: Defined in the `src/routes` directory, with each route corresponding to a page in the application
+2. **Components**: Reusable UI components in the `src/lib/components` directory
+3. **Stores**: Svelte stores for state management in the `src/lib` directory
+4. **API Client**: Functions for communicating with the backend API in the `src/lib/api` directory
+
+## Routes
+
+| Route | Component | Description |
+|-------|-----------|-------------|
+| `/` | `+page.svelte` | Home page with list of notes |
+| `/notes/new` | `notes/new/+page.svelte` | Create a new note |
+| `/notes/:id` | `notes/[id]/+page.svelte` | View or edit a specific note |
+| `/notes/graph` | `notes/graph/+page.svelte` | View the notes graph |
+| `/readlist` | `readlist/+page.svelte` | List of read later items |
+| `/readlist/:id` | `readlist/[id]/+page.svelte` | View a specific read later item |
+| `/feeds` | `feeds/+page.svelte` | List of feeds |
+| `/feeds/:id` | `feeds/[id]/+page.svelte` | View entries from a specific feed |
+| `/feeds/entries/:id` | `feeds/entries/[id]/+page.svelte` | View a specific feed entry |
+
+## Components
+
+### Layout Components
+
+- **Navigation**: Main navigation bar with links to different sections
+- **Footer**: Page footer with application information
+- **Layout**: Main layout component that wraps all pages
+
+### UI Components
+
+- **CardList**: Reusable component for displaying lists of items as cards
+- **SearchBar**: Search input with filtering functionality
+- **Pagination**: Pagination controls for lists
+- **Modal**: Modal dialog for confirmations and forms
+- **Tabs**: Tabbed interface for switching between views
+- **Dropdown**: Dropdown menu for actions
+- **Toast**: Notification component for displaying messages
+
+### Feature Components
+
+- **NoteEditor**: Markdown editor for creating and editing notes
+- **NoteViewer**: Component for rendering note content with Markdown support
+- **NoteGraph**: D3.js-based graph visualization of note connections
+- **ReadLaterForm**: Form for saving new read later items
+- **ArticleViewer**: Component for displaying read later items with clean formatting
+- **FeedList**: Component for displaying a list of feeds
+- **EntryList**: Component for displaying a list of feed entries
+
+## State Management
+
+The frontend uses Svelte stores for state management:
+
+1. **Notes Store**: Manages the state of notes
+   ```javascript
+   // Example notes store
+   export const notes = writable([]);
+   
+   // Load notes from the API
+   notes.load = async () => {
+     const response = await fetch('/api/notes');
+     const data = await response.json();
+     notes.set(data);
+   };
+   
+   // Add other methods for CRUD operations
+   ```
+
+2. **Readlist Store**: Manages the state of read later items
+3. **Feeds Store**: Manages the state of feeds and entries
+
+## API Integration
+
+The frontend communicates with the backend API using the Fetch API:
+
+```javascript
+// Example API client function
+export async function fetchNotes() {
+  const response = await fetch('/api/notes');
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.message || 'Failed to fetch notes');
+  }
+  return await response.json();
+}
+```
+
+## User Interface
+
+### Home Page
+
+- List of notes with search functionality
+- Buttons for creating new notes and importing from Obsidian
+- Link to the notes graph visualization
+
+### Note Editor
+
+- Markdown editor with preview functionality
+- Title input field
+- Save and cancel buttons
+- Auto-save functionality
+
+### Note Viewer
+
+- Rendered Markdown content
+- Links to related notes
+- Edit and delete buttons
+
+### Notes Graph
+
+- Interactive graph visualization of note connections
+- Zoom and pan controls
+- Search functionality to find specific notes in the graph
+
+### Readlist Page
+
+- List of read later items with filters for read/unread and archived/unarchived
+- Form for saving new items
+- Buttons for marking as read, archiving, and deleting
+
+### Article Viewer
+
+- Clean, reader-friendly display of article content
+- Buttons for marking as read, archiving, and returning to the list
+
+### Feeds Page
+
+- List of subscribed feeds with unread counts
+- Form for subscribing to new feeds
+- Buttons for refreshing, editing, and unsubscribing
+
+### Feed Entries Page
+
+- List of entries from a specific feed or all feeds
+- Filters for read/unread status
+- Buttons for marking as read/unread
+
+## Responsive Design
+
+The frontend is designed to be responsive and work well on different screen sizes:
+
+1. **Desktop**: Full layout with sidebar navigation
+2. **Tablet**: Adapted layout with collapsible navigation
+3. **Mobile**: Simplified layout with mobile-friendly controls
+
+## Accessibility
+
+The frontend follows accessibility best practices:
+
+1. **Semantic HTML**: Using appropriate HTML elements for their intended purpose
+2. **ARIA Attributes**: Adding ARIA attributes where necessary
+3. **Keyboard Navigation**: Ensuring all functionality is accessible via keyboard
+4. **Color Contrast**: Ensuring sufficient contrast for text and UI elements
+
+## Performance Optimization
+
+The frontend is optimized for performance:
+
+1. **Code Splitting**: Loading only the necessary code for each route
+2. **Lazy Loading**: Loading components and data only when needed
+3. **Caching**: Caching API responses where appropriate
+4. **Optimized Assets**: Minimizing CSS and JavaScript files
+
+## Testing
+
+The frontend includes tests using Playwright for end-to-end testing:
+
+1. **Page Tests**: Testing each page's functionality
+2. **Component Tests**: Testing individual components
+3. **Integration Tests**: Testing the interaction between components
+4. **API Mock Tests**: Testing with mocked API responses 
--- a/specs/links.md
+++ b/specs/links.md
@ -0,0 +1,70 @@
+# Links Specification
+
+## Overview
+
+This document describes the enhanced linking functionality introduced in QuickNotes. Users can create links to items in various domains using a unified syntax. These links are processed by both the backend and the frontend to generate clickable hyperlinks that navigate to the appropriate detail pages.
+
+## Link Syntax
+
+Users should create links using the following syntax:
+
+```
+[[<domain>:::<uuid>]]
+```
+
+- `<domain>` specifies the type of the referenced item. Allowed values are:
+  - `note` – for notes
+  - `feed` – for feed subscriptions
+  - `entry` – for individual feed entries
+  - `doc` – for uploaded documents
+  - `post` – for posts (if implemented in the future)
+
+- `<uuid>` is the unique identifier of the target item.
+
+### Example
+
+For example, to link to a note:
+
+```
+[[note:::123e4567-e89b-12d3-a456-426614174000]]
+```
+
+## Backend Implementation Changes
+
+1. **Link Extraction**: Update the link extraction function (e.g., `ExtractLinks`) to recognize the new pattern. A suggested regular expression is:
+
+   ```go
+   re := regexp.MustCompile(`\[\[([a-z]+):::(.+?)\]\]`)
+   ```
+
+   This regex captures two groups: the domain (`[a-z]+`) and the UUID (`.+?`).
+
+2. **Validation and URL Generation**:
+   - Validate that the extracted domain is one of the allowed values: `note`, `feed`, `entry`, `doc`, or `post`.
+   - Generate the appropriate URL based on the domain:
+     - For `note`: `/notes/<uuid>`
+     - For `feed`: `/feeds/<uuid>`
+     - For `entry`: `/feeds/entries/<uuid>`
+     - For `doc`: `/documents/<uuid>`
+     - For `post`: `/posts/<uuid>` (if posts are later implemented)
+
+3. **Link Storage and Updates**: When a note is created or updated, the link management routines should:
+   - Extract all links using the new regex.
+   - Validate and resolve these links by verifying the existence of the target items.
+   - Store the relationships if needed, so that bidirectional navigation or graph visualization can be supported.
+
+## Frontend Implementation Changes
+
+1. **Rendering**: Modify the markdown or HTML rendering components so that when the new link syntax is encountered, it is transformed into an HTML `<a>` tag whose `href` attribute is the generated URL.
+
+2. **Routing**: Ensure that client-side routing is properly set up so that clicking the link navigates to the corresponding detail page (e.g., a note detail view, feed entry view, or document viewer).
+
+3. **Styling**: Apply CSS rules to these links to visually indicate their interactive nature.
+
+## Summary
+
+The enhanced linking functionality unifies the way references to various content types are created and handled within QuickNotes. By adopting the `[[<domain>:::<uuid>]]` syntax, the system improves consistency and makes it easier to navigate across different domains.
+
+## Future Enhancements
+
+A potential future improvement is to implement a search drop-down feature in the editor. When a user types "[[<domain>:::" (for example, "[[note:::"), the editor could display a drop-down list of items from the selected domain, searchable by title. Upon selection, the link would be automatically completed with the corresponding item's UUID. This enhancement would improve usability by making it easier to find and link to existing items. 
--- a/specs/notes.md
+++ b/specs/notes.md
@ -0,0 +1,188 @@
+# Notes Specification
+
+## Overview
+
+The Notes module is a core component of QuickNotes that allows users to create, edit, view, and link notes. It supports a wiki-style linking system and provides a graph visualization of note connections.
+
+## Data Model
+
+### Note
+
+The `Note` entity has the following attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ID | string | Unique identifier for the note (UUID) |
+| Title | string | Title of the note |
+| Content | string | Content of the note in Markdown format |
+| CreatedAt | timestamp | When the note was created |
+| UpdatedAt | timestamp | When the note was last updated |
+| LinksTo | []*Note | Notes that this note links to |
+| LinkedBy | []*Note | Notes that link to this note |
+
+### NoteLink
+
+The `NoteLink` entity represents a connection between two notes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| SourceNoteID | string | ID of the source note |
+| TargetNoteID | string | ID of the target note |
+| CreatedAt | timestamp | When the link was created |
+
+## Features
+
+### Note Management
+
+1. **Create Note**: Users can create new notes with a title and content
+2. **Edit Note**: Users can edit existing notes
+3. **Delete Note**: Users can delete notes
+4. **View Note**: Users can view notes with rendered Markdown content
+5. **List Notes**: Users can view a list of all notes
+
+### Note Linking
+
+The application now supports an enhanced linking syntax that allows users to reference items from various domains using the following format:
+
+```
+[[<domain>:::<uuid>]]
+```
+
+Where:
+
+- `<domain>` is one of the following keywords: `note`, `feed`, `entry`, `doc`, or `post`.
+- `<uuid>` is the unique identifier of the target item.
+
+For example, to link to a note, a user might write:
+
+```
+[[note:::123e4567-e89b-12d3-a456-426614174000]]
+```
+
+This link will be processed and rendered as a clickable hyperlink that navigates to the corresponding detail page.
+
+#### Backend Implementation Changes
+
+1. **Link Extraction:** Update the link extraction function (e.g., `ExtractLinks`) to recognize the new pattern. A suggested regular expression is:
+
+```go
+re := regexp.MustCompile(`\[\[([a-z]+):::(.+?)\]\]`)
+```
+
+This regex captures the domain and UUID portions.
+
+2. **Validation and URL Generation:** After extraction, validate that the domain is one of the allowed values. Then, generate the appropriate URL for the link:
+   - For `note`: `/notes/<uuid>`
+   - For `feed`: `/feeds/<uuid>`
+   - For `entry`: `/feeds/entries/<uuid>`
+   - For `doc`: `/documents/<uuid>`
+   - For `post`: `/posts/<uuid>` (if posts are implemented in the future)
+
+3. **Link Storage and Updates:** Ensure that link creation, updates, and deletions in the note service properly handle the new syntax.
+
+#### Frontend Implementation Changes
+
+1. **Rendering:** Modify the markdown or HTML rendering component to detect the new link format and replace it with an HTML `<a>` tag with the generated URL.
+
+2. **Routing:** Use client-side routing to navigate to the appropriate detail view when the link is clicked.
+
+3. **Styling:** Apply specific styling to these links to indicate they are interactive.
+
+For a complete description of the enhanced linking functionality, please refer to the standalone [Links Specification](../specs/links.md).
+
+### Note Graph
+
+1. **Graph Visualization**: Users can view a graph visualization of note connections
+2. **Interactive Navigation**: Users can click on nodes in the graph to navigate to notes
+3. **Force-directed Layout**: The graph uses a force-directed layout for optimal visualization
+
+### Obsidian Import
+
+1. **Import Vault**: Users can import notes from an Obsidian vault (zip file)
+2. **Markdown Compatibility**: Imported Markdown files are converted to QuickNotes format
+3. **Link Preservation**: Links between notes are preserved during import
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /api/notes | List all notes |
+| POST | /api/notes | Create a new note |
+| GET | /api/notes/:id | Get a specific note by ID |
+| PUT | /api/notes/:id | Update a specific note |
+| DELETE | /api/notes/:id | Delete a specific note |
+| POST | /api/notes/import | Import notes from an Obsidian vault |
+
+## Frontend Routes
+
+| Route | Description |
+|-------|-------------|
+| / | Home page with list of notes |
+| /notes/new | Create a new note |
+| /notes/:id | View a specific note |
+| /notes/:id?edit=true | Edit a specific note |
+| /notes/graph | View the notes graph |
+
+## Implementation Details
+
+### Link Extraction
+
+The system extracts links from note content using a regular expression that matches the `[[note-title]]` pattern:
+
+```go
+func (n *Note) ExtractLinks(content string) []string {
+    re := regexp.MustCompile(`\[\[(.*?)\]\]`)
+    matches := re.FindAllStringSubmatch(content, -1)
+    titles := make([]string, 0, len(matches))
+    for _, match := range matches {
+        if len(match) > 1 {
+            titles = append(titles, match[1])
+        }
+    }
+    return titles
+}
+```
+
+### Link Management
+
+When a note is created or updated, the system:
+
+1. Extracts all links from the note content
+2. Finds the corresponding target notes by title
+3. Creates link records in the database
+4. Updates the note's relationships
+
+### Graph Visualization
+
+The notes graph is implemented using D3.js with a force-directed layout:
+
+1. Nodes represent notes
+2. Edges represent links between notes
+3. Node size can be based on the number of connections
+4. Users can zoom, pan, and click on nodes to navigate
+
+## User Interface
+
+### Note List
+
+- Displays a list of all notes with titles and snippets
+- Provides search functionality to filter notes
+- Includes buttons for creating, editing, and deleting notes
+
+### Note Editor
+
+- Markdown editor with preview functionality
+- Auto-completion for note links
+- Save and cancel buttons
+
+### Note Viewer
+
+- Rendered Markdown content
+- Clickable links to other notes
+- Edit button to switch to editor mode
+
+### Graph View
+
+- Interactive visualization of note connections
+- Zoom and pan controls
+- Search functionality to find specific notes in the graph 
--- a/specs/omnisearch.md
+++ b/specs/omnisearch.md
@ -0,0 +1,86 @@
+# Omnisearch Specification
+
+## Overview
+
+The Omnisearch domain provides a unified full-text search functionality across all domains of the QuickNotes application. It allows users to perform text searches on notes, feed entries, read later items, and uploaded PDF documents, and returns a list of results that link to the appropriate detail pages.
+
+## Architecture and Components
+
+### Full-Text Search Engine
+
+To support full-text search, a search engine such as [Bleve](https://github.com/blevesearch/bleve) can be integrated into the backend. Bleve is a full-text search and indexing library for Go and is well-suited for this purpose.
+
+### Indexing
+
+The following content types will be indexed for search:
+
+- **Notes**: Index title and content
+- **Feed Entries**: Index title, summary, and full content
+- **Readlater Items**: Index title, description, and content
+- **Documents**: Extract text from PDF documents (using an OCR or PDF text extraction tool, if necessary) and index the extracted content
+
+### API Endpoints
+
+| Method | Endpoint            | Description                                           |
+|--------|---------------------|-------------------------------------------------------|
+| GET    | /api/search         | Perform a full-text search across all domains         |
+
+#### Search API
+
+- Accepts a query parameter (e.g., `q`) containing the search text.
+- Optionally accepts pagination parameters (e.g., `limit` and `offset`).
+- Returns a list of search results, each containing:
+  - **Type**: Indicates the domain (note, feed entry, readlist item, document)
+  - **ID**: The identifier of the result
+  - **Title/Name**: The title or name of the result
+  - **Snippet**: A short excerpt showing the context of the match
+  - **Link**: A URL to the relevant detail page
+
+Example response:
+
+```json
+[
+  {
+    "type": "note",
+    "id": "note-id",
+    "title": "Note Title",
+    "snippet": "... matching text ...",
+    "link": "/notes/note-id"
+  },
+  {
+    "type": "feed-entry",
+    "id": "entry-id",
+    "title": "Entry Title",
+    "snippet": "... matching text ...",
+    "link": "/feeds/entries/entry-id"
+  }
+]
+```
+
+## Frontend Integration
+
+### Omnisearch Page
+
+The frontend will feature a dedicated Omnisearch page with the following components:
+
+1. **Search Input**: A single input field where users can enter their search query.
+2. **Search Results List**: A list that dynamically displays the search results returned by the API.
+3. **Result Filtering**: (Optional) Filters to narrow down results by domain (notes, feed entries, readlist items, documents).
+
+Navigation to a result should route the user to the corresponding detail page:
+
+- **Notes**: `/notes/:id`
+- **Feed Entries**: `/feeds/entries/:id` (or `/feeds/:id` for feed-specific views)
+- **Readlist Items**: `/readlist/:id`
+- **Documents**: A new page (e.g., `/documents/:id`) for viewing the PDF using the integrated PDF viewer.
+
+## Implementation Considerations
+
+1. **Indexing Strategy**: Index updates should occur whenever content is created, updated, or deleted. This may be triggered in the service layers of each domain.
+2. **Extraction for Documents**: For PDFs, text extraction might be performed using tools like [pdfcpu](https://github.com/pdfcpu/pdfcpu) or similar to convert PDF content into text for indexing.
+3. **Performance**: Ensure that the indexing and search queries are performant. Consider asynchronous indexing and regular index updates.
+4. **Scalability**: Although Bleve works well for local deployments, evaluate if a more robust search solution is needed as the application scales.
+
+## Summary
+
+The Omnisearch feature provides a unified search experience, leveraging full-text indexing with Bleve to search across all content domains. It improves usability by allowing users to quickly find information regardless of its domain, with results linking to the appropriate detail pages. 
--- a/specs/readlist.md
+++ b/specs/readlist.md
@ -0,0 +1,136 @@
+# Readlist Specification
+
+## Overview
+
+The Readlist module allows users to save web articles for later reading. It provides a "read it later" service similar to Pocket or Instapaper, with automatic content extraction and a clean reading experience.
+
+## Data Model
+
+### ReadLaterItem
+
+The `ReadLaterItem` entity has the following attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ID | string | Unique identifier for the item (UUID) |
+| URL | string | Original URL of the article |
+| Title | string | Title of the article |
+| Content | string | Extracted HTML content of the article |
+| Description | string | Brief description or excerpt of the article |
+| CreatedAt | timestamp | When the item was saved |
+| UpdatedAt | timestamp | When the item was last updated |
+| ReadAt | timestamp | When the item was marked as read (null if unread) |
+| ArchivedAt | timestamp | When the item was archived (null if not archived) |
+
+## Features
+
+### Item Management
+
+1. **Save Article**: Users can save articles by providing a URL
+2. **View Article**: Users can view saved articles in a clean, reader-friendly format
+3. **Mark as Read**: Users can mark articles as read
+4. **Archive Article**: Users can archive articles to remove them from the main list
+5. **Delete Article**: Users can delete articles permanently
+6. **List Articles**: Users can view a list of all saved articles
+
+### Content Extraction
+
+1. **Automatic Extraction**: The system automatically extracts the main content from web pages
+2. **Title Extraction**: The system extracts the title of the article
+3. **Description Extraction**: The system extracts a brief description or excerpt of the article
+4. **HTML Cleaning**: The system cleans the HTML to provide a distraction-free reading experience
+
+### Filtering and Sorting
+
+1. **Filter by Status**: Users can filter articles by read/unread status
+2. **Filter by Archive**: Users can filter articles by archived/unarchived status
+3. **Sort by Date**: Users can sort articles by date saved or date read
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /api/readlist | List all read later items |
+| POST | /api/readlist | Save a new article |
+| GET | /api/readlist/:id | Get a specific article by ID |
+| PUT | /api/readlist/:id | Update a specific article |
+| DELETE | /api/readlist/:id | Delete a specific article |
+| PUT | /api/readlist/:id/read | Mark an article as read |
+| PUT | /api/readlist/:id/unread | Mark an article as unread |
+| PUT | /api/readlist/:id/archive | Archive an article |
+| PUT | /api/readlist/:id/unarchive | Unarchive an article |
+
+## Frontend Routes
+
+| Route | Description |
+|-------|-------------|
+| /readlist | List of saved articles |
+| /readlist/:id | View a specific article |
+
+## Implementation Details
+
+### Content Extraction
+
+The system uses the `go-readability` library to extract content from web pages:
+
+```go
+func (r *ReadLaterItem) ParseURL() error {
+    article, err := readability.FromURL(r.URL, 30*time.Second)
+    if err != nil {
+        return fmt.Errorf("failed to parse URL: %w", err)
+    }
+
+    r.Title = article.Title
+    r.Content = article.Content
+    r.Description = article.Excerpt
+    return nil
+}
+```
+
+### HTML Sanitization
+
+The extracted HTML content is sanitized to remove potentially harmful elements and provide a consistent reading experience:
+
+1. Remove JavaScript and other active content
+2. Preserve images, links, and basic formatting
+3. Apply a consistent style to the content
+
+### Status Management
+
+The system tracks the status of articles using nullable timestamp fields:
+
+1. `ReadAt`: When set, indicates the article has been read
+2. `ArchivedAt`: When set, indicates the article has been archived
+
+## User Interface
+
+### Article List
+
+- Displays a list of saved articles with titles, descriptions, and dates
+- Provides filters for read/unread and archived/unarchived status
+- Includes buttons for marking as read, archiving, and deleting
+
+### Article Viewer
+
+- Displays the article content in a clean, reader-friendly format
+- Preserves images and links from the original article
+- Provides buttons for marking as read, archiving, and returning to the list
+
+### Save Form
+
+- Input field for the URL to save
+- Automatic extraction of content after submission
+- Preview of the extracted content before saving
+
+## Shiori Import
+
+The Readlist module now supports importing bookmarks from a Shiori instance. This feature allows users to migrate or synchronize their bookmarks by connecting to a Shiori service using their credentials.
+
+### API Endpoint
+- POST /api/readlist/import/shiori: Accepts a JSON payload containing `url`, `username`, and `password`. The backend authenticates with the Shiori instance, fetches bookmarks, and creates corresponding read later items.
+
+### Frontend Integration
+- A form in the readlist UI accepts Shiori credentials. The readlist store includes an `importFromShiori` method that sends a request to the endpoint and processes the response, updating the list of saved articles accordingly.
+
+### Error Handling
+- Both the backend and frontend provide clear error messages if authentication or bookmark retrieval fails.
Author	SHA1	Message	Date
Nicola Zangrandi	c3b15a14d2	feat: enhance Shiori import with progress indicator and error handling	2025-03-04 17:54:49 +01:00
Nicola Zangrandi	b1ac38d4ab	docs(specs): update feeds, documents, and omnisearch specs with latest changes	2025-03-04 11:37:55 +01:00
Nicola Zangrandi	f75a7a0c09	docs(specs): remove Emacs references and update links spec with future drop-down search enhancement	2025-03-04 11:37:17 +01:00
Nicola Zangrandi	fb519760b5	docs(specs): update SPECS.md and README.md with Documents and Omnisearch details	2025-03-04 11:23:51 +01:00
Nicola Zangrandi	1097cd8804	docs(specs): create comprehensive application specifications	2025-03-04 11:09:47 +01:00