update

cli-bin/src/main.rs

@@ -0,0 +1,395 @@
+//! Marlin CLI entry-point (post crate-split)
+//!
+//! All heavy lifting now lives in the `libmarlin` crate; this file
+//! handles argument parsing, logging, orchestration and the few
+//! helpers that remain CLI-specific.
+
+#![deny(warnings)]
+
+mod cli; // sub-command definitions and argument structs
+
+/* ── shared modules re-exported from libmarlin ─────────────────── */
+use libmarlin::{
+    config,
+    db,
+    logging,
+    scan,
+    utils::determine_scan_root,
+};
+
+use anyhow::{Context, Result};
+use clap::{CommandFactory, Parser};
+use clap_complete::generate;
+use glob::Pattern;
+use shellexpand;
+use shlex;
+use std::{
+    env,
+    fs,
+    io,
+    path::Path,
+    process::Command,
+};
+use tracing::{debug, error, info};
+use walkdir::WalkDir;
+
+use cli::{Cli, Commands};
+
+fn main() -> Result<()> {
+    /* ── CLI parsing & logging ────────────────────────────────── */
+
+    let args = Cli::parse();
+    if args.verbose {
+        env::set_var("RUST_LOG", "debug");
+    }
+    logging::init();
+
+    /* ── shell-completion shortcut ────────────────────────────── */
+
+    if let Commands::Completions { shell } = &args.command {
+        let mut cmd = Cli::command();
+        generate(*shell, &mut cmd, "marlin", &mut io::stdout());
+        return Ok(());
+    }
+
+    /* ── config & automatic backup ───────────────────────────── */
+
+    let cfg = config::Config::load()?; // resolves DB path
+
+    match &args.command {
+        Commands::Init | Commands::Backup | Commands::Restore { .. } => {}
+        _ => match db::backup(&cfg.db_path) {
+            Ok(p)  => info!("Pre-command auto-backup created at {}", p.display()),
+            Err(e) => error!("Failed to create pre-command auto-backup: {e}"),
+        },
+    }
+
+    /* ── open DB (runs migrations) ───────────────────────────── */
+
+    let mut conn = db::open(&cfg.db_path)?;
+
+    /* ── command dispatch ────────────────────────────────────── */
+
+    match args.command {
+        Commands::Completions { .. } => {} // handled above
+
+        /* ---- init ------------------------------------------------ */
+        Commands::Init => {
+            info!("Database initialised at {}", cfg.db_path.display());
+            let cwd   = env::current_dir().context("getting current directory")?;
+            let count = scan::scan_directory(&mut conn, &cwd)
+                .context("initial scan failed")?;
+            info!("Initial scan complete – indexed/updated {count} files");
+        }
+
+        /* ---- scan ------------------------------------------------ */
+        Commands::Scan { paths } => {
+            let scan_paths = if paths.is_empty() {
+                vec![env::current_dir()?]
+            } else { paths };
+
+            for p in scan_paths {
+                scan::scan_directory(&mut conn, &p)?;
+            }
+        }
+
+        /* ---- tag / attribute / search --------------------------- */
+        Commands::Tag { pattern, tag_path } =>
+            apply_tag(&conn, &pattern, &tag_path)?,
+
+        Commands::Attr { action } => match action {
+            cli::AttrCmd::Set { pattern, key, value } =>
+                attr_set(&conn, &pattern, &key, &value)?,
+            cli::AttrCmd::Ls { path } =>
+                attr_ls(&conn, &path)?,
+        },
+
+        Commands::Search { query, exec } =>
+            run_search(&conn, &query, exec)?,
+
+        /* ---- maintenance ---------------------------------------- */
+        Commands::Backup => {
+            let p = db::backup(&cfg.db_path)?;
+            println!("Backup created: {}", p.display());
+        }
+
+        Commands::Restore { backup_path } => {
+            drop(conn); // close handle before overwrite
+            db::restore(&backup_path, &cfg.db_path).with_context(|| {
+                format!("Failed to restore DB from {}", backup_path.display())
+            })?;
+            println!("Restored DB from {}", backup_path.display());
+            db::open(&cfg.db_path).with_context(|| {
+                format!("Could not open restored DB at {}", cfg.db_path.display())
+            })?;
+            info!("Successfully opened restored database.");
+        }
+
+        /* ---- passthrough sub-modules (some still stubs) ---------- */
+        Commands::Link(link_cmd)   => cli::link::run(&link_cmd,   &mut conn, args.format)?,
+        Commands::Coll(coll_cmd)   => cli::coll::run(&coll_cmd,   &mut conn, args.format)?,
+        Commands::View(view_cmd)   => cli::view::run(&view_cmd,   &mut conn, args.format)?,
+        Commands::State(state_cmd) => cli::state::run(&state_cmd, &mut conn, args.format)?,
+        Commands::Task(task_cmd)   => cli::task::run(&task_cmd,   &mut conn, args.format)?,
+        Commands::Remind(rm_cmd)   => cli::remind::run(&rm_cmd,   &mut conn, args.format)?,
+        Commands::Annotate(a_cmd)  => cli::annotate::run(&a_cmd,  &mut conn, args.format)?,
+        Commands::Version(v_cmd)   => cli::version::run(&v_cmd,   &mut conn, args.format)?,
+        Commands::Event(e_cmd)     => cli::event::run(&e_cmd,     &mut conn, args.format)?,
+    }
+
+    Ok(())
+}
+
+/* ─────────────────── helpers & sub-routines ─────────────────── */
+
+/* ---------- TAGS ---------- */
+
+fn apply_tag(conn: &rusqlite::Connection, pattern: &str, tag_path: &str) -> Result<()> {
+    // ensure_tag_path returns ID of deepest node
+    let leaf_tag_id = db::ensure_tag_path(conn, tag_path)?;
+
+    // collect leaf + ancestors
+    let mut tag_ids = Vec::new();
+    let mut current = Some(leaf_tag_id);
+    while let Some(id) = current {
+        tag_ids.push(id);
+        current = conn.query_row(
+            "SELECT parent_id FROM tags WHERE id=?1",
+            [id],
+            |r| r.get::<_, Option<i64>>(0),
+        )?;
+    }
+
+    let expanded = shellexpand::tilde(pattern).into_owned();
+    let pat  = Pattern::new(&expanded)
+        .with_context(|| format!("Invalid glob pattern `{expanded}`"))?;
+    let root = determine_scan_root(&expanded);
+
+    let mut stmt_file   = conn.prepare("SELECT id FROM files WHERE path=?1")?;
+    let mut stmt_insert = conn.prepare(
+        "INSERT OR IGNORE INTO file_tags(file_id, tag_id) VALUES (?1, ?2)",
+    )?;
+
+    let mut count = 0usize;
+    for entry in WalkDir::new(&root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_type().is_file())
+    {
+        let p = entry.path().to_string_lossy();
+        if !pat.matches(&p) { continue; }
+
+        match stmt_file.query_row([p.as_ref()], |r| r.get::<_, i64>(0)) {
+            Ok(fid) => {
+                let mut newly = false;
+                for &tid in &tag_ids {
+                    if stmt_insert.execute([fid, tid])? > 0 {
+                        newly = true;
+                    }
+                }
+                if newly {
+                    info!(file=%p, tag=tag_path, "tagged");
+                    count += 1;
+                }
+            }
+            Err(rusqlite::Error::QueryReturnedNoRows) =>
+                error!(file=%p, "not indexed – run `marlin scan` first"),
+            Err(e) =>
+                error!(file=%p, error=%e, "could not lookup file ID"),
+        }
+    }
+
+    info!("Applied tag '{}' to {} file(s).", tag_path, count);
+    Ok(())
+}
+
+/* ---------- ATTRIBUTES ---------- */
+
+fn attr_set(conn: &rusqlite::Connection, pattern: &str, key: &str, value: &str) -> Result<()> {
+    let expanded = shellexpand::tilde(pattern).into_owned();
+    let pat  = Pattern::new(&expanded)
+        .with_context(|| format!("Invalid glob pattern `{expanded}`"))?;
+    let root = determine_scan_root(&expanded);
+
+    let mut stmt_file = conn.prepare("SELECT id FROM files WHERE path=?1")?;
+    let mut count = 0usize;
+
+    for entry in WalkDir::new(&root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_type().is_file())
+    {
+        let p = entry.path().to_string_lossy();
+        if !pat.matches(&p) { continue; }
+
+        match stmt_file.query_row([p.as_ref()], |r| r.get::<_, i64>(0)) {
+            Ok(fid) => {
+                db::upsert_attr(conn, fid, key, value)?;
+                info!(file=%p, key, value, "attr set");
+                count += 1;
+            }
+            Err(rusqlite::Error::QueryReturnedNoRows) =>
+                error!(file=%p, "not indexed – run `marlin scan` first"),
+            Err(e) =>
+                error!(file=%p, error=%e, "could not lookup file ID"),
+        }
+    }
+
+    info!("Attribute '{}={}' set on {} file(s).", key, value, count);
+    Ok(())
+}
+
+fn attr_ls(conn: &rusqlite::Connection, path: &Path) -> Result<()> {
+    let fid = db::file_id(conn, &path.to_string_lossy())?;
+    let mut stmt = conn.prepare(
+        "SELECT key, value FROM attributes WHERE file_id=?1 ORDER BY key"
+    )?;
+    for row in stmt
+        .query_map([fid], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?
+    {
+        let (k, v) = row?;
+        println!("{k} = {v}");
+    }
+    Ok(())
+}
+
+/* ---------- SEARCH ---------- */
+
+fn run_search(conn: &rusqlite::Connection, raw_query: &str, exec: Option<String>) -> Result<()> {
+    /* ── build FTS expression -------------------------------- */
+    let mut parts = Vec::new();
+    let toks = shlex::split(raw_query).unwrap_or_else(|| vec![raw_query.to_string()]);
+    for tok in toks {
+        if ["AND", "OR", "NOT"].contains(&tok.as_str()) {
+            parts.push(tok);
+        } else if let Some(tag) = tok.strip_prefix("tag:") {
+            for (i, seg) in tag.split('/').filter(|s| !s.is_empty()).enumerate() {
+                if i > 0 { parts.push("AND".into()); }
+                parts.push(format!("tags_text:{}", escape_fts(seg)));
+            }
+        } else if let Some(attr) = tok.strip_prefix("attr:") {
+            let mut kv = attr.splitn(2, '=');
+            let key = kv.next().unwrap();
+            if let Some(val) = kv.next() {
+                parts.push(format!("attrs_text:{}", escape_fts(key)));
+                parts.push("AND".into());
+                parts.push(format!("attrs_text:{}", escape_fts(val)));
+            } else {
+                parts.push(format!("attrs_text:{}", escape_fts(key)));
+            }
+        } else {
+            parts.push(escape_fts(&tok));
+        }
+    }
+    let fts_expr = parts.join(" ");
+    debug!("FTS MATCH expression: {fts_expr}");
+
+    /* ── primary FTS query ---------------------------------- */
+    let mut stmt = conn.prepare(
+        r#"
+        SELECT f.path
+          FROM files_fts
+          JOIN files f ON f.rowid = files_fts.rowid
+         WHERE files_fts MATCH ?1
+         ORDER BY rank
+        "#,
+    )?;
+    let mut hits: Vec<String> = stmt
+        .query_map([&fts_expr], |r| r.get::<_, String>(0))?
+        .filter_map(Result::ok)
+        .collect();
+
+    /* ── graceful fallback (substring scan) ----------------- */
+    if hits.is_empty() && !raw_query.contains(':') {
+        hits = naive_substring_search(conn, raw_query)?;
+    }
+
+    /* ── output / exec -------------------------------------- */
+    if let Some(cmd_tpl) = exec {
+        run_exec(&hits, &cmd_tpl)?;
+    } else {
+        if hits.is_empty() {
+            eprintln!(
+                "No matches for query: `{raw_query}` (FTS expr: `{fts_expr}`)"
+            );
+        } else {
+            for p in hits { println!("{p}"); }
+        }
+    }
+    Ok(())
+}
+
+/// Fallback: case-insensitive substring scan over paths *and* small file bodies.
+fn naive_substring_search(conn: &rusqlite::Connection, term: &str) -> Result<Vec<String>> {
+    let needle = term.to_lowercase();
+    let mut stmt = conn.prepare("SELECT path FROM files")?;
+    let rows = stmt.query_map([], |r| r.get::<_, String>(0))?;
+
+    let mut out = Vec::new();
+    for p in rows {
+        let p = p?;
+        if p.to_lowercase().contains(&needle) {
+            out.push(p.clone());
+            continue;
+        }
+        // Only scan files ≤ 64 kB
+        if let Ok(meta) = fs::metadata(&p) {
+            if meta.len() > 65_536 { continue; }
+        }
+        if let Ok(body) = fs::read_to_string(&p) {
+            if body.to_lowercase().contains(&needle) {
+                out.push(p);
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// Run external command template on every hit (`{}` placeholder supported).
+fn run_exec(paths: &[String], cmd_tpl: &str) -> Result<()> {
+    let mut ran_without_placeholder = false;
+
+    // optimisation: if no hits and no placeholder, run once
+    if paths.is_empty() && !cmd_tpl.contains("{}") {
+        if let Some(mut parts) = shlex::split(cmd_tpl) {
+            if !parts.is_empty() {
+                let prog = parts.remove(0);
+                let status = Command::new(&prog).args(parts).status()?;
+                if !status.success() {
+                    error!(command=%cmd_tpl, code=?status.code(), "command failed");
+                }
+            }
+        }
+        ran_without_placeholder = true;
+    }
+
+    if !ran_without_placeholder {
+        for p in paths {
+            let quoted = shlex::try_quote(p).unwrap_or_else(|_| p.into());
+            let final_cmd = if cmd_tpl.contains("{}") {
+                cmd_tpl.replace("{}", &quoted)
+            } else {
+                format!("{cmd_tpl} {quoted}")
+            };
+            if let Some(mut parts) = shlex::split(&final_cmd) {
+                if parts.is_empty() { continue; }
+                let prog = parts.remove(0);
+                let status = Command::new(&prog).args(parts).status()?;
+                if !status.success() {
+                    error!(file=%p, command=%final_cmd, code=?status.code(), "command failed");
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/* ---------- misc helpers ---------- */
+
+fn escape_fts(term: &str) -> String {
+    if term.contains(|c: char| c.is_whitespace() || "-:()\"".contains(c))
+        || ["AND", "OR", "NOT", "NEAR"].contains(&term.to_uppercase().as_str())
+    {
+        format!("\"{}\"", term.replace('"', "\"\""))
+    } else { term.to_string() }
+}