@@ -44,7 +45,7 @@
-
{{ results.length }} results
+
{{ $t('search.resultsCount', { count: results.length }) }}
{{ searchTime }}ms
@@ -62,18 +63,28 @@
@@ -126,10 +190,10 @@
-
No results found
-
Try different keywords or check your spelling
+
{{ $t('search.noResults') }}
+
{{ $t('search.noResultsHint') }}
@@ -151,6 +215,7 @@
import { ref, onMounted, watch } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import { useSearch } from '../composables/useSearch'
+import LanguageSwitcher from '../components/LanguageSwitcher.vue'
const route = useRoute()
const router = useRouter()
@@ -158,6 +223,8 @@ const router = useRouter()
const { results, loading, searchTime, search } = useSearch()
const searchQuery = ref(route.query.q || '')
const activePreview = ref(null)
+const expandedId = ref(null)
+const contextCache = ref({})
let previewTimer = null
async function performSearch() {
@@ -213,10 +280,43 @@ function viewDocument(result) {
})
}
+function jumpToSection(result) {
+ router.push(`/document/${result.docId}?page=${result.pageNumber}#p=${result.pageNumber}`)
+}
+
function handleImageError(event) {
event.target.closest('.nv-popover')?.remove()
}
+function shouldShowSectionHeader(result, index) {
+ if (index === 0) return true // Always show for first result
+ const prevResult = results.value[index - 1]
+ return result.sectionKey !== prevResult?.sectionKey
+}
+
+async function toggleExpand(result) {
+ const resultId = result.id
+
+ if (expandedId.value === resultId) {
+ expandedId.value = null
+ return
+ }
+
+ expandedId.value = resultId
+
+ // Fetch context if not cached
+ if (!contextCache.value[resultId]) {
+ try {
+ const response = await fetch(`/api/context?docId=${result.docId}&page=${result.pageNumber}`)
+ if (response.ok) {
+ contextCache.value[resultId] = await response.json()
+ }
+ } catch (error) {
+ console.error('Failed to fetch context:', error)
+ }
+ }
+}
+
// Watch for query changes from URL
watch(() => route.query.q, (newQuery) => {
searchQuery.value = newQuery || ''
@@ -332,6 +432,22 @@ onMounted(() => {
border-color: rgba(255, 230, 102, 0.5);
}
+.nv-chip-text {
+ font-size: 11px;
+ padding: 3px 8px;
+ border-radius: 8px;
+ background: rgba(207, 167, 255, 0.12);
+ color: #cfa7ff;
+ border: 1px solid rgba(207, 167, 255, 0.35);
+ cursor: pointer;
+ transition: all 0.15s ease;
+}
+
+.nv-chip-text:hover {
+ background: rgba(207, 167, 255, 0.2);
+ border-color: rgba(207, 167, 255, 0.5);
+}
+
.nv-link {
color: #cfa7ff;
font-weight: 500;
@@ -364,6 +480,119 @@ onMounted(() => {
height: 48px !important;
}
+/* Section header grouping */
+.nv-section-header {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 12px 0 8px 0;
+ margin-top: 16px;
+ font-size: 13px;
+ font-weight: 600;
+ color: #cfa7ff;
+ letter-spacing: 0.02em;
+}
+
+.nv-section-header:first-child {
+ margin-top: 0;
+}
+
+/* Inline expansion panel */
+.nv-expand {
+ margin-top: 12px;
+ padding-top: 12px;
+ border-top: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.nv-expand-loading {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ font-size: 12px;
+ color: #9aa0a6;
+ padding: 12px 0;
+}
+
+.spinner {
+ width: 14px;
+ height: 14px;
+ border: 2px solid rgba(207, 167, 255, 0.3);
+ border-top-color: #cfa7ff;
+ border-radius: 50%;
+ animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+ to { transform: rotate(360deg); }
+}
+
+.nv-context-pages {
+ display: flex;
+ gap: 12px;
+ margin-bottom: 12px;
+ overflow-x: auto;
+}
+
+.nv-context-page {
+ flex-shrink: 0;
+ text-align: center;
+}
+
+.nv-context-image {
+ width: 100px;
+ height: 100px;
+ background: rgba(255, 255, 255, 0.05);
+ border: 1px solid rgba(255, 255, 255, 0.1);
+ border-radius: 6px;
+ overflow: hidden;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.nv-context-page.active .nv-context-image {
+ border-color: rgba(207, 167, 255, 0.5);
+ box-shadow: 0 0 0 2px rgba(207, 167, 255, 0.2);
+}
+
+.nv-context-image img {
+ width: 100%;
+ height: 100%;
+ object-fit: cover;
+}
+
+.nv-context-noimage {
+ font-size: 10px;
+ color: #6b6b7a;
+ text-align: center;
+ padding: 8px;
+}
+
+.nv-context-page figcaption {
+ margin-top: 4px;
+ font-size: 10px;
+ color: #9aa0a6;
+}
+
+.nv-context-page.active figcaption {
+ color: #cfa7ff;
+ font-weight: 600;
+}
+
+.nv-expand-text {
+ padding: 8px 12px;
+ background: rgba(255, 255, 255, 0.03);
+ border-radius: 6px;
+ max-height: 200px;
+ overflow-y: auto;
+}
+
+.nv-expand-text .nv-snippet {
+ font-size: 14px;
+ line-height: 1.6;
+ margin: 0;
+}
+
@media (max-width: 768px) {
.nv-doc {
display: none;
diff --git a/server/db/migrations/002_add_document_toc.sql b/server/db/migrations/002_add_document_toc.sql
new file mode 100644
index 0000000..7ba98c7
--- /dev/null
+++ b/server/db/migrations/002_add_document_toc.sql
@@ -0,0 +1,35 @@
+-- Migration: Add document_toc table for interactive table of contents
+-- Date: 2025-10-20
+-- Description: Store extracted TOC entries from PDF documents for navigation
+
+CREATE TABLE IF NOT EXISTS document_toc (
+ id TEXT PRIMARY KEY,
+ document_id TEXT NOT NULL,
+
+ -- TOC entry details
+ title TEXT NOT NULL, -- "Chapter 4 - Plumbing System"
+ section_key TEXT, -- "4" or "4.1.2" for hierarchical entries
+ page_start INTEGER NOT NULL, -- Target page number
+
+ -- Hierarchy support
+ level INTEGER DEFAULT 1, -- 1 for "4", 2 for "4.1", 3 for "4.1.2"
+ parent_id TEXT, -- Reference to parent entry for nesting
+
+ -- Ordering
+ order_index INTEGER NOT NULL, -- Sequential order in TOC
+
+ -- Source tracking
+ toc_page_number INTEGER, -- Which page the TOC entry was found on
+
+ -- Metadata
+ created_at INTEGER NOT NULL,
+
+ FOREIGN KEY (document_id) REFERENCES documents(id) ON DELETE CASCADE,
+ FOREIGN KEY (parent_id) REFERENCES document_toc(id) ON DELETE CASCADE
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_toc_document ON document_toc(document_id);
+CREATE INDEX IF NOT EXISTS idx_toc_order ON document_toc(document_id, order_index);
+CREATE INDEX IF NOT EXISTS idx_toc_parent ON document_toc(parent_id);
+CREATE INDEX IF NOT EXISTS idx_toc_section ON document_toc(document_id, section_key);
diff --git a/server/index.js b/server/index.js
index aa5810b..22f4791 100644
--- a/server/index.js
+++ b/server/index.js
@@ -90,6 +90,8 @@ import searchRoutes from './routes/search.js';
import documentsRoutes from './routes/documents.js';
import imagesRoutes from './routes/images.js';
import statsRoutes from './routes/stats.js';
+import contextRoutes from './routes/context.js';
+import tocRoutes from './routes/toc.js';
// API routes
app.use('/api/upload/quick-ocr', quickOcrRoutes);
@@ -98,6 +100,8 @@ app.use('/api/jobs', jobsRoutes);
app.use('/api/search', searchRoutes);
app.use('/api/documents', documentsRoutes);
app.use('/api/stats', statsRoutes);
+app.use('/api/context', contextRoutes);
+app.use('/api', tocRoutes); // Handles /api/documents/:id/toc paths
app.use('/api', imagesRoutes);
// Error handling
diff --git a/server/package.json b/server/package.json
index c15b22b..4ece237 100644
--- a/server/package.json
+++ b/server/package.json
@@ -29,6 +29,7 @@
"helmet": "^7.0.0",
"ioredis": "^5.0.0",
"jsonwebtoken": "^9.0.0",
+ "lru-cache": "^11.2.2",
"meilisearch": "^0.41.0",
"multer": "^1.4.5-lts.1",
"pdf-img-convert": "^2.0.0",
diff --git a/server/routes/toc.js b/server/routes/toc.js
new file mode 100644
index 0000000..9df66f1
--- /dev/null
+++ b/server/routes/toc.js
@@ -0,0 +1,97 @@
+/**
+ * TOC Route - Table of Contents API
+ * GET /api/documents/:documentId/toc - Get TOC for document
+ * POST /api/documents/:documentId/toc/extract - Trigger TOC extraction
+ */
+
+import express from 'express';
+import { LRUCache } from 'lru-cache';
+import { getDocumentToc, buildTocTree, extractTocFromDocument } from '../services/toc-extractor.js';
+
+const router = express.Router();
+
+// LRU cache for TOC results
+const tocCache = new LRUCache({
+ max: 200,
+ ttl: 1000 * 60 * 30 // 30 minutes
+});
+
+/**
+ * GET /api/documents/:documentId/toc
+ * Get Table of Contents for a document
+ *
+ * @param {string} documentId - Document UUID
+ * @query {string} format - "flat" (default) or "tree"
+ * @returns {Object} { entries: Array, format: string }
+ */
+router.get('/documents/:documentId/toc', async (req, res) => {
+ try {
+ const { documentId } = req.params;
+ const format = req.query.format || 'flat';
+
+ const cacheKey = `toc:${documentId}:${format}`;
+ let entries = tocCache.get(cacheKey);
+ if (!entries) {
+ entries = getDocumentToc(documentId);
+ tocCache.set(cacheKey, entries);
+ }
+
+ if (format === 'tree') {
+ const tree = buildTocTree(entries);
+ return res.json({ entries: tree, format: 'tree', count: entries.length });
+ }
+
+ res.json({ entries, format: 'flat', count: entries.length });
+
+ } catch (error) {
+ console.error('TOC fetch error:', error);
+ res.status(500).json({
+ error: 'Failed to fetch TOC',
+ message: error.message
+ });
+ }
+});
+
+/**
+ * POST /api/documents/:documentId/toc/extract
+ * Trigger TOC extraction for a document
+ *
+ * @param {string} documentId - Document UUID
+ * @returns {Object} { success: boolean, entriesCount: number, pages: number[] }
+ */
+router.post('/documents/:documentId/toc/extract', async (req, res) => {
+ try {
+ const { documentId } = req.params;
+
+ const result = await extractTocFromDocument(documentId);
+
+ if (!result.success) {
+ return res.status(400).json({
+ error: 'TOC extraction failed',
+ message: result.error || result.message
+ });
+ }
+
+ // Invalidate cache after extraction
+ tocCache.delete(`toc:${documentId}:flat`);
+ tocCache.delete(`toc:${documentId}:tree`);
+
+ res.json({
+ success: true,
+ entriesCount: result.entriesCount,
+ tocPages: result.pages,
+ message: result.entriesCount > 0
+ ? `Extracted ${result.entriesCount} TOC entries from ${result.pages.length} page(s)`
+ : 'No TOC detected in document'
+ });
+
+ } catch (error) {
+ console.error('TOC extraction error:', error);
+ res.status(500).json({
+ error: 'TOC extraction failed',
+ message: error.message
+ });
+ }
+});
+
+export default router;
diff --git a/server/services/section-extractor.js b/server/services/section-extractor.js
new file mode 100644
index 0000000..9877e25
--- /dev/null
+++ b/server/services/section-extractor.js
@@ -0,0 +1,265 @@
+/**
+ * Section Extractor Service
+ *
+ * Extracts section/chapter metadata from PDFs using a three-tier approach:
+ * 1. PDF Outline/Bookmarks (most reliable)
+ * 2. Header Detection via Regex (fallback)
+ * 3. Table of Contents Parsing (last resort)
+ */
+
+import pdf from 'pdf-parse';
+import fs from 'fs';
+import { promisify } from 'util';
+
+const readFile = promisify(fs.readFile);
+
+/**
+ * Slugify section title for consistent keys
+ */
+function slugify(text) {
+ return text
+ .toLowerCase()
+ .replace(/[^\w\s.-]/g, '')
+ .replace(/\s+/g, '-')
+ .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Parse section number to determine order
+ * Examples: "8" -> 800, "8.6" -> 806, "8-6" -> 806, "8/6" -> 806
+ */
+function parseSectionOrder(sectionNum) {
+ if (!sectionNum) return 0;
+
+ // Normalize separators: treat -, /, . the same
+ const normalized = sectionNum.replace(/[-\/]/g, '.');
+ const parts = normalized.split('.').map(p => parseInt(p) || 0);
+
+ // Major * 100 + minor * 1
+ return (parts[0] || 0) * 100 + (parts[1] || 0);
+}
+
+/**
+ * Extract sections from PDF outline/bookmarks
+ * This is the most reliable method when available
+ */
+async function extractFromOutline(pdfPath) {
+ try {
+ const dataBuffer = await readFile(pdfPath);
+ const data = await pdf(dataBuffer, {
+ max: 0 // Don't extract text, just metadata
+ });
+
+ if (!data.metadata || !data.metadata.info) {
+ return null;
+ }
+
+ // pdf-parse doesn't expose outlines directly, we need pdf-lib or pdfjs-dist
+ // For now, return null to fall through to other methods
+ return null;
+ } catch (error) {
+ console.error('[SectionExtractor] Outline extraction failed:', error.message);
+ return null;
+ }
+}
+
+/**
+ * Detect section headers using regex patterns
+ * Looks for patterns like:
+ * - "8. Waste Systems"
+ * - "8.6 Blackwater Tank"
+ * - "CHAPTER 8: WASTE SYSTEMS"
+ */
+function detectSectionHeaders(pages) {
+ const sections = [];
+ let currentSection = null;
+ let currentSectionOrder = 0;
+
+ // Patterns to match section headers (marine manual focused)
+ const headerPatterns = [
+ // "8.6 Blackwater Tank" or "8-6 Bilge System" or "8/6 Through-Hull"
+ /^\s*(\d+(?:[.\-\/]\d+)*)\s+([A-Z][^\n]{3,60})/m,
+ // "CHAPTER 8: WASTE SYSTEMS" or "SECTION 8.6: Blackwater"
+ /^\s*(?:CHAPTER|SECTION|PART)\s+(\d+(?:[.\-\/]\d+)*)[:\s]+([A-Z][^\n]{3,60})/mi,
+ // Marine-specific: "ELECTRICAL SYSTEM", "PLUMBING", "NAVIGATION EQUIPMENT"
+ /^\s*([A-Z][A-Z\s\-]{4,59})$/m,
+ // TOC style: "8.6 Blackwater" at page start
+ /^(\d+(?:[.\-\/]\d+)*)\s+([A-Z][a-z][^\n]{3,50})/m,
+ ];
+
+ for (const page of pages) {
+ const { pageNumber, text } = page;
+
+ if (!text || text.length < 10) continue;
+
+ // Try each pattern
+ let matched = false;
+ for (const pattern of headerPatterns) {
+ const match = text.match(pattern);
+ if (match) {
+ let sectionNum = match[1];
+ let sectionTitle = match[2] || match[1];
+
+ // Skip if it's just the page number
+ if (sectionTitle.length < 5) continue;
+
+ // Clean up title
+ sectionTitle = sectionTitle.trim();
+ if (sectionTitle.endsWith(':')) {
+ sectionTitle = sectionTitle.slice(0, -1);
+ }
+
+ // Calculate section order
+ const order = sectionNum && /\d/.test(sectionNum)
+ ? parseSectionOrder(sectionNum)
+ : currentSectionOrder + 1;
+
+ // Create section key (hierarchical path)
+ const sectionKey = slugify(sectionTitle);
+
+ currentSection = {
+ section: sectionTitle,
+ sectionKey: sectionKey,
+ sectionOrder: order,
+ startPage: pageNumber
+ };
+
+ currentSectionOrder = order;
+ sections.push(currentSection);
+ matched = true;
+ break;
+ }
+ }
+
+ // If we found a section, continue to next page
+ if (matched) continue;
+
+ // Otherwise, assign current section to this page
+ if (!currentSection) {
+ // No section yet, create a default one
+ currentSection = {
+ section: 'Introduction',
+ sectionKey: 'introduction',
+ sectionOrder: 0,
+ startPage: pageNumber
+ };
+ sections.push(currentSection);
+ }
+ }
+
+ return sections;
+}
+
+/**
+ * Parse Table of Contents to extract section structure
+ * Looks for pages with dense "8.6 Title ........ 73" style entries
+ */
+function parseTableOfContents(pages) {
+ const sections = [];
+
+ // Pattern to match TOC entries: "8.6 Blackwater Tank ........ 73"
+ const tocPattern = /^\s*(\d+(?:\.\d+)*)\s+([^.\d][^\n]{3,50}?)[\s.]+(\d+)\s*$/gm;
+
+ for (const page of pages) {
+ const { text } = page;
+ if (!text) continue;
+
+ // Look for pages with multiple TOC-style entries
+ const matches = [...text.matchAll(tocPattern)];
+
+ if (matches.length >= 3) { // Likely a TOC page if 3+ entries
+ console.log(`[SectionExtractor] Found TOC page with ${matches.length} entries`);
+
+ for (const match of matches) {
+ const sectionNum = match[1];
+ const sectionTitle = match[2].trim();
+ const pageNum = parseInt(match[3]);
+
+ if (pageNum > 0 && sectionTitle.length >= 5) {
+ sections.push({
+ section: sectionTitle,
+ sectionKey: slugify(sectionTitle),
+ sectionOrder: parseSectionOrder(sectionNum),
+ startPage: pageNum
+ });
+ }
+ }
+
+ // If we found a TOC, we're done
+ if (sections.length > 0) {
+ return sections;
+ }
+ }
+ }
+
+ return sections.length > 0 ? sections : null;
+}
+
+/**
+ * Main extraction function - tries all methods in order
+ */
+export async function extractSections(pdfPath, pages) {
+ console.log('[SectionExtractor] Starting section extraction');
+
+ // Method 1: Try PDF outline/bookmarks
+ let sections = await extractFromOutline(pdfPath);
+ if (sections && sections.length > 0) {
+ console.log(`[SectionExtractor] Extracted ${sections.length} sections from PDF outline`);
+ return sections;
+ }
+
+ // Method 2: Try Table of Contents parsing
+ sections = parseTableOfContents(pages);
+ if (sections && sections.length > 0) {
+ console.log(`[SectionExtractor] Extracted ${sections.length} sections from TOC`);
+ return sections;
+ }
+
+ // Method 3: Try header detection
+ sections = detectSectionHeaders(pages);
+ if (sections && sections.length > 0) {
+ console.log(`[SectionExtractor] Detected ${sections.length} sections from headers`);
+ return sections;
+ }
+
+ console.log('[SectionExtractor] No sections found, using single section');
+
+ // Fallback: Single section for entire document
+ return [{
+ section: 'Complete Manual',
+ sectionKey: 'complete-manual',
+ sectionOrder: 0,
+ startPage: 1
+ }];
+}
+
+/**
+ * Map pages to their sections
+ * Given extracted sections and pages, assigns each page to a section
+ */
+export function mapPagesToSections(sections, totalPages) {
+ const pageMap = new Map();
+
+ // Sort sections by start page
+ const sortedSections = [...sections].sort((a, b) => a.startPage - b.startPage);
+
+ // For each section, determine its page range
+ for (let i = 0; i < sortedSections.length; i++) {
+ const section = sortedSections[i];
+ const nextSection = sortedSections[i + 1];
+
+ const startPage = section.startPage;
+ const endPage = nextSection ? nextSection.startPage - 1 : totalPages;
+
+ // Assign all pages in this range to this section
+ for (let pageNum = startPage; pageNum <= endPage; pageNum++) {
+ pageMap.set(pageNum, {
+ section: section.section,
+ sectionKey: section.sectionKey,
+ sectionOrder: section.sectionOrder
+ });
+ }
+ }
+
+ return pageMap;
+}
diff --git a/server/services/toc-extractor.js b/server/services/toc-extractor.js
new file mode 100644
index 0000000..03a7f29
--- /dev/null
+++ b/server/services/toc-extractor.js
@@ -0,0 +1,591 @@
+/**
+ * TOC Extractor Service
+ * Detects and extracts Table of Contents from OCR'd document pages
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/db.js';
+import fs from 'fs/promises';
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.mjs';
+
+/**
+ * TOC entry patterns to match:
+ * - "Chapter 4 – Plumbing System ........ 72"
+ * - "4.1 Water System.....................45"
+ * - "Section 3: Electrical . . . . . . . 89"
+ * - "Introduction 12"
+ */
+const TOC_PATTERNS = [
+ // Pattern 1: Title [dots/spaces] PageNum
+ /^(.{3,150?}?)\s*[.\s–-]{3,}\s*(\d{1,4})\s*$/,
+
+ // Pattern 2: SectionKey Title [dots/spaces] PageNum
+ /^([\d.]+)\s+(.{3,100}?)\s*[.\s–-]{3,}\s*(\d{1,4})\s*$/,
+
+ // Pattern 3: Title [whitespace] PageNum (simpler)
+ /^(.{5,120}?)\s{3,}(\d{1,4})\s*$/,
+];
+
+/**
+ * Detect if a page looks like a TOC page
+ * @param {string} pageText - OCR text from page
+ * @returns {boolean}
+ */
+function isTocPage(pageText) {
+ if (!pageText || pageText.length < 100) return false;
+
+ const lines = pageText.split('\n').map(l => l.trim()).filter(l => l.length > 5);
+ if (lines.length < 5) return false;
+
+ // Count how many lines match TOC patterns
+ let matchCount = 0;
+ let pageNumbers = [];
+
+ for (const line of lines) {
+ for (const pattern of TOC_PATTERNS) {
+ if (pattern.test(line)) {
+ matchCount++;
+ const match = line.match(pattern);
+ const pageNum = parseInt(match[match.length - 1]);
+ if (!isNaN(pageNum)) {
+ pageNumbers.push(pageNum);
+ }
+ break;
+ }
+ }
+ }
+
+ // Heuristics for TOC detection:
+ // 1. At least 5 matching lines
+ // 2. At least 30% of lines match TOC patterns
+ // 3. Page numbers are somewhat sequential or grouped
+ const matchRatio = matchCount / lines.length;
+ const hasSequentialPages = checkSequentiality(pageNumbers);
+
+ return matchCount >= 5 && matchRatio >= 0.3 && hasSequentialPages;
+}
+
+/**
+ * Check if page numbers show some sequentiality
+ * @param {number[]} pageNumbers
+ * @returns {boolean}
+ */
+function checkSequentiality(pageNumbers) {
+ if (pageNumbers.length < 3) return false;
+
+ // Sort and check for general increasing trend
+ const sorted = [...pageNumbers].sort((a, b) => a - b);
+ let increases = 0;
+
+ for (let i = 1; i < sorted.length; i++) {
+ if (sorted[i] >= sorted[i - 1]) increases++;
+ }
+
+ // At least 70% should be increasing
+ return (increases / (sorted.length - 1)) >= 0.7;
+}
+
+/**
+ * Parse section key and determine hierarchy level
+ * @param {string} sectionKey - e.g., "4", "4.1", "4.1.2"
+ * @returns {{ key: string, level: number }}
+ */
+function parseSectionKey(sectionKey) {
+ if (!sectionKey) return { key: null, level: 1 };
+
+ const trimmed = sectionKey.trim();
+ const parts = trimmed.split('.');
+
+ return {
+ key: trimmed,
+ level: parts.length
+ };
+}
+
+/**
+ * Extract TOC entries from a page
+ * @param {string} pageText
+ * @param {number} pageNumber
+ * @returns {Array