lore_engine/engine/

vault_ops.rs

//! Core vault operations — pure business logic.
//!
//! No framework dependencies (no Tauri, no Qt).
//! Takes &`AppState`, returns Result<T, `LoreError`>.

use super::error::LoreError;
use super::{db, file_loader, graph::WikiGraph, link_parser, search};
use crate::state::AppState;
use crate::types::{VaultInfo, PageData, BacklinkEntry, PageListEntry};
use rusqlite::Connection;
use std::collections::HashSet;
use std::path::Path;

/// Resolve a wiki link slug using shortest-path matching.
///
/// If the exact slug exists, returns it unchanged. Otherwise, searches all known
/// slugs for one that ends with `/<slug>` (folder-relative match). If exactly one
/// match is found, returns that full slug. If ambiguous or no match, returns the
/// original slug (which will create a placeholder).
fn resolve_link_slug(short_slug: &str, known_slugs: &HashSet<String>) -> String {
    // Exact match — fast path
    if known_slugs.contains(short_slug) {
        return short_slug.to_string();
    }

    // Suffix match: find slugs ending with "/short_slug"
    let suffix = format!("/{short_slug}");
    let matches: Vec<&String> = known_slugs
        .iter()
        .filter(|s| s.ends_with(&suffix))
        .collect();

    if matches.len() == 1 {
        return matches[0].clone();
    }

    // Ambiguous or no match — return original
    short_slug.to_string()
}

/// Collect all known slugs from the DB for fuzzy link resolution.
fn get_known_slugs(conn: &Connection) -> Result<HashSet<String>, LoreError> {
    db::get_all_slugs(conn)
}

/// Public accessor for known slugs — used by the file watcher.
pub(crate) fn get_known_slugs_from(conn: &Connection) -> Result<HashSet<String>, LoreError> {
    get_known_slugs(conn)
}

/// Validate that a path is relative and doesn't escape the vault directory.
///
/// Rejects absolute paths, `..` components, and paths starting with `/` or `\`.
fn validate_relative_path(path: &str) -> Result<(), LoreError> {
    let p = Path::new(path);
    if p.is_absolute() {
        return Err(LoreError::UnsafePath(path.to_string()));
    }
    for component in p.components() {
        if matches!(component, std::path::Component::ParentDir) {
            return Err(LoreError::UnsafePath(path.to_string()));
        }
    }
    Ok(())
}

/// Extract wiki links from content, resolve slugs, create placeholder pages for
/// unknown targets, insert link rows, and update FTS. Returns the resolved target
/// slugs (for graph updates).
///
/// This is the shared link-sync logic used by `open_vault`, `save_page`, and the
/// file watcher.
pub(crate) fn sync_page_links(
    conn: &Connection,
    source_slug: &str,
    title: &str,
    content: &str,
    known_slugs: &HashSet<String>,
) -> Result<Vec<String>, LoreError> {
    let wiki_links = link_parser::extract_links(content);

    // Resolve each link slug once upfront
    let resolved: Vec<(String, &link_parser::WikiLink)> = wiki_links
        .iter()
        .map(|wl| (resolve_link_slug(&wl.slug, known_slugs), wl))
        .collect();

    db::delete_links_from(conn, source_slug)?;

    let link_rows: Vec<db::LinkRow> = resolved
        .iter()
        .map(|(slug, wl)| db::LinkRow {
            source_slug: source_slug.to_string(),
            target_slug: slug.clone(),
            alias: wl.alias.clone(),
            line_number: Some(i32::try_from(wl.line_number).unwrap_or(i32::MAX)),
        })
        .collect();

    // Create placeholder pages for unknown link targets
    for (slug, wl) in &resolved {
        if db::get_page(conn, slug)?.is_none() {
            db::upsert_page(conn, slug, &wl.target, None, None, true)?;
        }
    }

    db::insert_links(conn, &link_rows)?;
    db::update_fts(conn, source_slug, title, content)?;

    let target_slugs: Vec<String> = resolved.into_iter().map(|(slug, _)| slug).collect();
    Ok(target_slugs)
}

/// Open a folder as a Lore vault. Creates .lore/ directory, scans all .md files,
/// populates DB and graph. Returns vault info on success.
pub fn open_vault(folder_path: &Path, state: &AppState) -> Result<VaultInfo, LoreError> {
    let conn = db::open_db(folder_path)?;

    // Scan files
    let scanned = file_loader::scan_folder(folder_path)?;

    // Incremental update
    let existing_hashes = db::get_all_hashes(&conn)?;
    let (changed, deleted) = file_loader::diff_scan(&scanned, &existing_hashes);

    conn.execute_batch("BEGIN TRANSACTION")?;

    for slug in &deleted {
        db::delete_page(&conn, slug)?;
        log::info!("Deleted page: {slug}");
    }

    // Pass 1: upsert all changed pages so slugs are known for link resolution
    for file in &changed {
        db::upsert_page(
            &conn,
            &file.slug,
            &file.title,
            Some(&file.relative_path),
            Some(&file.content_hash),
            false,
        )?;
    }

    // Collect all known slugs for fuzzy link resolution
    let known_slugs = get_known_slugs(&conn)?;

    // Pass 2: extract and resolve links
    for file in &changed {
        sync_page_links(&conn, &file.slug, &file.title, &file.content, &known_slugs)?;
    }

    conn.execute_batch("COMMIT")?;

    // Build in-memory graph
    let all_pages = db::get_all_pages(&conn)?;
    let mut graph = WikiGraph::new();

    for page in &all_pages {
        graph.upsert_node(&page.slug, &page.title, page.is_placeholder);
    }

    for page in &all_pages {
        let targets = db::get_outgoing_targets(&conn, &page.slug)?;
        if !targets.is_empty() {
            graph.set_outgoing_edges(&page.slug, &targets);
        }
    }

    let orphans = graph.cleanup_orphaned_placeholders();
    for slug in &orphans {
        if let Err(e) = db::delete_page(&conn, slug) {
            log::warn!("Failed to clean up orphan placeholder '{slug}': {e}");
        }
    }

    let (node_count, edge_count) = graph.stats();
    let vault_path_str = folder_path.to_string_lossy().into_owned();

    log::info!("Vault opened: {vault_path_str} ({node_count} pages, {edge_count} links)");

    // Store state
    *state.vault_path.lock()? = Some(folder_path.to_path_buf());
    *state.db.lock()? = Some(conn);
    *state.graph.lock()? = graph;

    Ok(VaultInfo {
        path: vault_path_str,
        page_count: node_count,
        link_count: edge_count,
    })
}

/// Load a page by slug. Returns content + backlinks.
pub fn load_page(slug: &str, state: &AppState) -> Result<PageData, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    let vault_lock = state.vault_path.lock()?;
    let vault_path = vault_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    // Try exact slug first, then fuzzy resolution
    let page = if let Some(p) = db::get_page(conn, slug)? { p } else {
        let known_slugs = get_known_slugs(conn)?;
        let resolved = resolve_link_slug(slug, &known_slugs);
        db::get_page(conn, &resolved)?
            .ok_or_else(|| LoreError::PageNotFound(slug.to_string()))?
    };

    let content = if let Some(ref fp) = page.file_path {
        let full_path = vault_path.join(fp);
        std::fs::read_to_string(&full_path)
            .map(|c| c.replace("\r\n", "\n"))?
    } else {
        String::new()
    };

    let backlink_pages = db::get_backlinks(conn, &page.slug)?;
    let backlinks = backlink_pages
        .into_iter()
        .map(|p| BacklinkEntry {
            slug: p.slug,
            title: p.title,
        })
        .collect();

    Ok(PageData {
        slug: page.slug,
        title: page.title,
        content,
        backlinks,
        is_placeholder: page.is_placeholder,
    })
}

/// Save page content. Re-parses links, updates DB, graph, and FTS.
///
/// Upserts: if the page doesn't exist, creates it automatically.
/// If the page is a placeholder, promotes it to a real page.
pub fn save_page(slug: &str, content: &str, state: &AppState) -> Result<(), LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    let vault_lock = state.vault_path.lock()?;
    let vault_path = vault_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let page = db::get_page(conn, slug)?;

    // Derive effective title: H1 from content > existing DB title > title from slug
    let effective_title = link_parser::extract_h1(content)
        .unwrap_or_else(|| {
            page.as_ref().map_or_else(
                || link_parser::title_from_slug(slug),
                |p| p.title.clone(),
            )
        });

    // Determine file path and write to disk (before transaction)
    let file_path = match &page {
        Some(p) if !p.is_placeholder => {
            let fp = p.file_path
                .as_ref()
                .ok_or_else(|| LoreError::PlaceholderPage(slug.to_string()))?
                .clone();
            let full_path = vault_path.join(&fp);
            std::fs::write(&full_path, content)?;
            fp
        }
        _ => {
            // Page doesn't exist or is a placeholder — create the file.
            let file_name = format!("{}.md", file_loader::sanitize_filename(&effective_title));
            let full_path = vault_path.join(&file_name);
            std::fs::write(&full_path, content)?;
            file_name
        }
    };

    // All DB mutations in one transaction
    conn.execute_batch("BEGIN TRANSACTION")?;

    let tx_result = (|| -> Result<Vec<String>, LoreError> {
        let hash = file_loader::content_hash(content);
        db::upsert_page(conn, slug, &effective_title, Some(&file_path), Some(&hash), false)?;
        db::update_fts(conn, slug, &effective_title, content)?;

        let known_slugs = get_known_slugs(conn)?;
        let target_slugs = sync_page_links(conn, slug, &effective_title, content, &known_slugs)?;

        Ok(target_slugs)
    })();

    match tx_result {
        Ok(target_slugs) => {
            conn.execute_batch("COMMIT")?;

            // Update graph (in-memory, outside transaction)
            let mut graph = state.graph.lock()?;
            graph.upsert_node(slug, &effective_title, false);

            for resolved_slug in &target_slugs {
                if graph.degree(resolved_slug) == 0 {
                    if let Some(p) = db::get_page(conn, resolved_slug)? {
                        graph.upsert_node(resolved_slug, &p.title, p.is_placeholder);
                    }
                }
            }

            graph.set_outgoing_edges(slug, &target_slugs);

            let orphans = graph.cleanup_orphaned_placeholders();
            drop(graph);
            for orphan_slug in &orphans {
                if let Err(e) = db::delete_page(conn, orphan_slug) {
                    log::warn!("Failed to clean up orphan placeholder '{orphan_slug}': {e}");
                }
            }
        }
        Err(e) => {
            let _ = conn.execute_batch("ROLLBACK");
            return Err(e);
        }
    }

    log::info!("Saved page: {slug}");
    Ok(())
}

/// Create a new page. Creates the .md file on disk.
///
/// When `folder` is non-empty, creates the file inside that subfolder.
/// The folder must be a relative path within the vault — absolute paths
/// and `..` components are rejected.
pub fn create_page(title: &str, folder: &str, state: &AppState) -> Result<PageData, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    let vault_lock = state.vault_path.lock()?;
    let vault_path = vault_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let title_slug = link_parser::slugify(title);
    if title_slug.is_empty() {
        return Err(LoreError::InvalidSlug(title.to_string()));
    }

    // Validate folder to prevent path traversal
    if !folder.is_empty() {
        validate_relative_path(folder)?;
    }

    let safe_name = file_loader::sanitize_filename(title);
    let (slug, file_name, full_path) = if folder.is_empty() {
        let slug = title_slug;
        let file_name = format!("{safe_name}.md");
        let full_path = vault_path.join(&file_name);
        (slug, file_name, full_path)
    } else {
        let slug = format!("{folder}/{title_slug}");
        let file_name = format!("{folder}/{safe_name}.md");
        let dir = vault_path.join(folder);
        std::fs::create_dir_all(&dir)?;
        let full_path = dir.join(format!("{safe_name}.md"));
        (slug, file_name, full_path)
    };

    let initial_content = format!("# {title}\n\n");
    std::fs::write(&full_path, &initial_content)?;

    let hash = file_loader::content_hash(&initial_content);
    db::upsert_page(conn, &slug, title, Some(&file_name), Some(&hash), false)?;
    db::update_fts(conn, &slug, title, &initial_content)?;

    let mut graph = state.graph.lock()?;
    graph.upsert_node(&slug, title, false);

    log::info!("Created page: {slug}");

    Ok(PageData {
        slug,
        title: title.to_string(),
        content: initial_content,
        backlinks: Vec::new(),
        is_placeholder: false,
    })
}

/// Get backlinks for a page.
pub fn get_backlinks_list(slug: &str, state: &AppState) -> Result<Vec<BacklinkEntry>, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let pages = db::get_backlinks(conn, slug)?;
    Ok(pages
        .into_iter()
        .map(|p| BacklinkEntry {
            slug: p.slug,
            title: p.title,
        })
        .collect())
}

/// Full-text search across all pages.
pub fn search_vault(query: &str, limit: usize, state: &AppState) -> Result<Vec<search::SearchResult>, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    search::search_pages(conn, query, limit)
}

/// Quick title search for the quick switcher.
pub fn search_titles(query: &str, state: &AppState) -> Result<Vec<search::SearchResult>, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    search::search_titles(conn, query, 20)
}

/// Get all pages for the sidebar page tree.
pub fn get_page_list(state: &AppState) -> Result<Vec<PageListEntry>, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let pages = db::get_all_pages(conn)?;
    Ok(pages
        .into_iter()
        .map(|p| PageListEntry {
            slug: p.slug,
            title: p.title,
            is_placeholder: p.is_placeholder,
            file_path: p.file_path,
        })
        .collect())
}

/// Find pages that mention this page's title but don't link to it.
pub fn find_unlinked_mentions(slug: &str, state: &AppState) -> Result<Vec<BacklinkEntry>, LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let page = db::get_page(conn, slug)?
        .ok_or_else(|| LoreError::PageNotFound(slug.to_string()))?;

    // FTS search for the title
    let fts_results = search::search_pages(conn, &page.title, 100)?;

    // Get pages that already link to this slug
    let backlinks = db::get_backlinks(conn, slug)?;
    let linked_slugs: HashSet<String> = backlinks.into_iter().map(|p| p.slug).collect();

    let mentions: Vec<BacklinkEntry> = fts_results
        .into_iter()
        .filter(|r| r.slug != slug && !linked_slugs.contains(&r.slug))
        .map(|r| BacklinkEntry {
            slug: r.slug,
            title: r.title,
        })
        .collect();

    Ok(mentions)
}

/// Get graph data for visualization.
pub fn get_graph_data(
    state: &AppState,
) -> Result<(Vec<super::graph::GraphNode>, Vec<super::graph::GraphEdge>), LoreError> {
    let graph = state.graph.lock()?;
    Ok(graph.get_full_graph())
}

/// Rename a page. Updates slug, title, file on disk, all incoming links in DB.
pub fn rename_page(old_slug: &str, new_title: &str, state: &AppState) -> Result<(), LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    let vault_lock = state.vault_path.lock()?;
    let vault_path = vault_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let page = db::get_page(conn, old_slug)?
        .ok_or_else(|| LoreError::PageNotFound(old_slug.to_string()))?;

    let title_slug = link_parser::slugify(new_title);
    if title_slug.is_empty() {
        return Err(LoreError::InvalidSlug(new_title.to_string()));
    }
    // Preserve folder prefix from the old slug
    let new_slug = if let Some(slash_pos) = old_slug.rfind('/') {
        format!("{}/{}", &old_slug[..slash_pos], title_slug)
    } else {
        title_slug
    };

    let backlink_pages = db::get_backlinks(conn, old_slug)?;

    let new_file_path = if let Some(ref old_fp) = page.file_path {
        let old_full = vault_path.join(old_fp);
        let new_file_name = format!("{}.md", file_loader::sanitize_filename(new_title));
        let new_full = old_full
            .parent()
            .unwrap_or(vault_path)
            .join(&new_file_name);

        std::fs::rename(&old_full, &new_full)?;

        let relative = new_full
            .strip_prefix(vault_path)
            .unwrap_or(&new_full)
            .to_string_lossy()
            .replace('\\', "/");
        Some(relative)
    } else {
        None
    };

    db::rename_page(conn, old_slug, &new_slug, new_title, new_file_path.as_deref())?;

    db::delete_fts(conn, old_slug)?;
    if let Some(ref fp) = new_file_path {
        let full_path = vault_path.join(fp);
        match std::fs::read_to_string(&full_path) {
            Ok(content) => db::update_fts(conn, &new_slug, new_title, &content)?,
            Err(e) => log::warn!("Could not read renamed file for FTS update: {e}"),
        }
    }

    let mut graph = state.graph.lock()?;
    let forward = graph.get_forward_links(old_slug);
    graph.remove_node(old_slug);
    graph.upsert_node(&new_slug, new_title, false);
    graph.set_outgoing_edges(&new_slug, &forward);

    // Rewrite [[wikilinks]] in all files that linked to the old slug,
    // then resync their link rows and FTS entries.
    let known_slugs = get_known_slugs(conn)?;
    for bp in &backlink_pages {
        if let Some(ref fp) = bp.file_path {
            let full_path = vault_path.join(fp);
            if let Ok(content) = std::fs::read_to_string(&full_path) {
                let updated = link_parser::replace_wikilinks(&content, old_slug, new_title);
                if updated != content {
                    if let Err(e) = std::fs::write(&full_path, &updated) {
                        log::error!("Failed to rewrite links in {fp}: {e}");
                        continue;
                    }
                    // Resync this backlink page's links and FTS
                    sync_page_links(conn, &bp.slug, &bp.title, &updated, &known_slugs)?;
                    db::update_fts(conn, &bp.slug, &bp.title, &updated)?;
                    // Update graph edges for this backlink page
                    if let Ok(targets) = db::get_outgoing_targets(conn, &bp.slug) {
                        graph.set_outgoing_edges(&bp.slug, &targets);
                    }
                }
            }
        }
    }

    log::info!("Renamed page: {old_slug} -> {new_slug}");
    Ok(())
}

/// Delete a page. Removes file from disk, DB entry, graph node.
pub fn delete_page(slug: &str, state: &AppState) -> Result<(), LoreError> {
    let db_lock = state.db.lock()?;
    let conn = db_lock.as_ref().ok_or(LoreError::VaultNotSet)?;
    let vault_lock = state.vault_path.lock()?;
    let vault_path = vault_lock.as_ref().ok_or(LoreError::VaultNotSet)?;

    let page = db::get_page(conn, slug)?
        .ok_or_else(|| LoreError::PageNotFound(slug.to_string()))?;

    if let Some(ref fp) = page.file_path {
        let full_path = vault_path.join(fp);
        if full_path.exists() {
            trash::delete(&full_path)
                .map_err(|e| LoreError::Io(std::io::Error::other(e.to_string())))?;
        }
    }

    let backlinks = db::get_backlinks(conn, slug)?;

    // DB mutations in a transaction (file already trashed above)
    conn.execute_batch("BEGIN TRANSACTION")?;

    let tx_result = if backlinks.is_empty() {
        db::delete_page(conn, slug)
    } else {
        (|| -> Result<(), LoreError> {
            db::upsert_page(conn, slug, &page.title, None, None, true)?;
            db::delete_links_from(conn, slug)?;
            db::delete_fts(conn, slug)?;
            Ok(())
        })()
    };

    match tx_result {
        Ok(()) => {
            conn.execute_batch("COMMIT")?;

            // Update graph (in-memory, outside transaction)
            if backlinks.is_empty() {
                let mut graph = state.graph.lock()?;
                graph.remove_node(slug);
            } else {
                let mut graph = state.graph.lock()?;
                graph.upsert_node(slug, &page.title, true);
                graph.set_outgoing_edges(slug, &[]);

                let orphans = graph.cleanup_orphaned_placeholders();
                drop(graph);
                for orphan_slug in &orphans {
                    if let Err(e) = db::delete_page(conn, orphan_slug) {
                        log::warn!("Failed to clean up orphan placeholder '{orphan_slug}': {e}");
                    }
                }
            }
        }
        Err(e) => {
            let _ = conn.execute_batch("ROLLBACK");
            return Err(e);
        }
    }

    log::info!("Deleted page: {slug}");
    Ok(())
}