sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use serde::Serialize;
use snip::Library;
use snip::error::{Result, SnipError};
use snip::git::{self, Status, Unavailable};
use snip::importer::import_snippetslab;
use snip::service::{doctor, organize};
use std::path::Path;

use super::output::{print_record, print_records};
use crate::cli::{
    DoctorArgs, GitArgs, GitCommand, ImportArgs, ImportCommand, OrganizeArgs, OutputMode,
};

pub fn command_doctor(library: &Library, args: &DoctorArgs, output: OutputMode) -> Result<()> {
    let report = doctor(library, args.repair);
    if output == OutputMode::Human {
        println!("checked: {} snippets", report.checked);
        println!("errors: {}", report.errors.len());
        println!("warnings: {}", report.warnings.len());
        println!(
            "pending transactions: {}",
            report.pending_transactions.len()
        );
        for message in &report.repaired {
            println!("REPAIRED: {message}");
        }
        for message in &report.errors {
            println!("ERROR: {message}");
        }
        for message in &report.warnings {
            println!("WARNING: {message}");
        }
    } else {
        print_record(&report, output)?;
    }
    if !report.ok {
        return Err(SnipError::validation("library validation failed"));
    }
    Ok(())
}

pub fn command_organize(library: &Library, args: &OrganizeArgs, output: OutputMode) -> Result<()> {
    let changes = organize(library, args.dry_run)?;
    if output == OutputMode::Human {
        for change in &changes {
            println!(
                "{}{} -> {}",
                if args.dry_run {
                    "would move: "
                } else {
                    "moved: "
                },
                change
                    .old_path
                    .as_deref()
                    .unwrap_or_else(|| Path::new("-"))
                    .display(),
                change
                    .new_path
                    .as_deref()
                    .unwrap_or_else(|| Path::new("-"))
                    .display()
            );
        }
        println!("changes: {}", changes.len());
    } else {
        print_records(&changes, output)?;
    }
    Ok(())
}

pub fn command_import(args: &ImportArgs, output: OutputMode) -> Result<()> {
    match &args.command {
        ImportCommand::Snippetslab {
            source,
            into,
            dry_run,
        } => {
            let report = import_snippetslab(source, into, *dry_run)?;
            if output == OutputMode::Human {
                println!("source: {}", report.source.display());
                println!("destination: {}", report.destination.display());
                println!("dry run: {}", report.dry_run);
                println!("snippets: {}", report.snippets);
                println!("folders: {}", report.folders);
                println!("tags: {}", report.tags);
                println!("fragments: {}", report.fragments);
                println!("notes: {}", report.notes);
                println!("attachments: {}", report.attachments);
                for item in report.normalized_tags {
                    println!("NORMALIZED TAG: {item}");
                }
                for item in report.warnings {
                    println!("WARNING: {item}");
                }
            } else {
                print_record(&report, output)?;
            }
        }
    }
    Ok(())
}

pub fn command_git(library: &Library, args: &GitArgs, output: OutputMode) -> Result<()> {
    match &args.command {
        GitCommand::Status => command_git_status(library, output),
        GitCommand::Init => command_git_init(library, output),
        GitCommand::Commit { message } => command_git_commit(library, message.as_deref(), output),
        GitCommand::Backup => command_git_backup(library, output),
        GitCommand::Push => command_git_push(library, output),
        GitCommand::Fetch => command_git_fetch(library, output),
    }
}

#[derive(Serialize)]
struct GitStatusReport<'a> {
    available: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    reason: Option<&'a Unavailable>,
    #[serde(skip_serializing_if = "Option::is_none")]
    repository_root: Option<&'a Path>,
    #[serde(skip_serializing_if = "Option::is_none")]
    library_prefix: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    status: Option<&'a Status>,
}

fn command_git_status(library: &Library, output: OutputMode) -> Result<()> {
    let repo = match git::probe(library.root()) {
        Ok(repo) => repo,
        Err(reason) => {
            let report = GitStatusReport {
                available: false,
                reason: Some(&reason),
                repository_root: None,
                library_prefix: None,
                status: None,
            };
            if output == OutputMode::Human {
                println!(
                    "{}",
                    match &reason {
                        Unavailable::BinaryMissing => "git not found in PATH",
                        Unavailable::NotARepository => {
                            "this library is not inside a git repository"
                        }
                        Unavailable::ProbeFailed { message } => message,
                    }
                );
                return Ok(());
            }
            return print_record(&report, output);
        }
    };
    let status = git::status(&repo)?;
    let report = GitStatusReport {
        available: true,
        reason: None,
        repository_root: Some(&repo.root),
        library_prefix: repo.library_prefix.as_deref(),
        status: Some(&status),
    };
    if output != OutputMode::Human {
        return print_record(&report, output);
    }
    println!("repository: {}", repo.root.display());
    println!("branch: {}", branch_label(&status));
    println!(
        "changes: {} staged, {} unstaged, {} untracked",
        status.staged, status.unstaged, status.untracked
    );
    println!("ahead/behind: {}/{}", status.ahead, status.behind);
    println!(
        "upstream: {}",
        status.upstream.as_deref().unwrap_or("not configured")
    );
    if let Some(commit) = &status.last_commit {
        let now = time::OffsetDateTime::now_utc().unix_timestamp();
        println!(
            "last commit: {} ({}) {}",
            commit.short_id,
            git::relative_time(commit.timestamp, now),
            commit.subject
        );
    } else {
        println!("last commit: none");
    }
    if !status.conflicted.is_empty() {
        println!("conflicts: {}", status.conflicted.len());
    }
    if status.state != git::RepoState::Clean {
        println!("repository state: {}", status.state.label());
    }
    Ok(())
}

#[derive(Serialize)]
struct GitMutationReport<'a> {
    action: &'static str,
    committed: bool,
    pushed: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    message: Option<&'a str>,
    outcome: &'a str,
    status: &'a Status,
}

fn command_git_commit(
    library: &Library,
    custom_message: Option<&str>,
    output: OutputMode,
) -> Result<()> {
    let repo = require_repo(library)?;
    let before = git::status(&repo)?;
    git::check_commit(&before).map_err(|refusal| SnipError::conflict(refusal.to_string()))?;
    let generated;
    let message = if let Some(message) = custom_message {
        let message = message.trim();
        if message.is_empty() {
            return Err(SnipError::usage("commit message cannot be empty"));
        }
        message
    } else {
        generated = git::backup_message(&before);
        &generated
    };
    git::commit(&repo, message)?;
    let after = git::status(&repo)?;
    print_git_mutation(
        GitMutationReport {
            action: "commit",
            committed: true,
            pushed: false,
            message: Some(message),
            outcome: "backup committed",
            status: &after,
        },
        output,
    )
}

fn command_git_backup(library: &Library, output: OutputMode) -> Result<()> {
    let repo = require_repo(library)?;
    let before = git::status(&repo)?;
    let message = git::backup_message(&before);
    let outcome = git::backup(&repo, &message)?;
    let after = git::status(&repo)?;
    print_git_mutation(
        GitMutationReport {
            action: "backup",
            committed: outcome.committed,
            pushed: outcome.pushed,
            message: outcome.committed.then_some(message.as_str()),
            outcome: &outcome.message,
            status: &after,
        },
        output,
    )
}

fn command_git_push(library: &Library, output: OutputMode) -> Result<()> {
    let repo = require_repo(library)?;
    let before = git::status(&repo)?;
    git::check_push(&before).map_err(|refusal| SnipError::conflict(refusal.to_string()))?;
    git::push(&repo)?;
    let after = git::status(&repo)?;
    print_git_mutation(
        GitMutationReport {
            action: "push",
            committed: false,
            pushed: true,
            message: None,
            outcome: "backup pushed",
            status: &after,
        },
        output,
    )
}

fn command_git_fetch(library: &Library, output: OutputMode) -> Result<()> {
    let repo = require_repo(library)?;
    git::fetch(&repo)?;
    let after = git::status(&repo)?;
    print_git_mutation(
        GitMutationReport {
            action: "fetch",
            committed: false,
            pushed: false,
            message: None,
            outcome: "remote status refreshed",
            status: &after,
        },
        output,
    )
}

#[derive(Serialize)]
struct GitInitReport<'a> {
    action: &'static str,
    created: bool,
    repository_root: &'a Path,
    outcome: &'a str,
}

fn command_git_init(library: &Library, output: OutputMode) -> Result<()> {
    // Initializing twice is not a failure, the same way `git init` itself is
    // idempotent: a caller that just wants a repository to exist should not
    // have to probe first and branch on the answer.
    let created = match git::probe(library.root()) {
        Ok(_) => false,
        Err(Unavailable::NotARepository) => {
            git::init(library.root())?;
            true
        }
        Err(Unavailable::BinaryMissing) => {
            return Err(SnipError::conflict("git not found in PATH"));
        }
        Err(Unavailable::ProbeFailed { message }) => return Err(SnipError::conflict(message)),
    };
    let repo = require_repo(library)?;
    let outcome = if created {
        "initialized a Git repository"
    } else {
        "already a Git repository"
    };
    if output == OutputMode::Human {
        println!("{outcome}: {}", repo.root.display());
        return Ok(());
    }
    print_record(
        &GitInitReport {
            action: "init",
            created,
            repository_root: &repo.root,
            outcome,
        },
        output,
    )
}

fn require_repo(library: &Library) -> Result<git::Repo> {
    git::probe(library.root()).map_err(|unavailable| match unavailable {
        Unavailable::BinaryMissing => SnipError::conflict("git not found in PATH"),
        Unavailable::NotARepository => {
            SnipError::conflict("this library is not inside a git repository")
        }
        Unavailable::ProbeFailed { message } => SnipError::conflict(message),
    })
}

fn print_git_mutation(report: GitMutationReport<'_>, output: OutputMode) -> Result<()> {
    if output == OutputMode::Human {
        println!("{}", report.outcome);
        if let Some(message) = report.message {
            println!("message: {message}");
        }
        println!(
            "ahead/behind: {}/{}",
            report.status.ahead, report.status.behind
        );
        Ok(())
    } else {
        print_record(&report, output)
    }
}

fn branch_label(status: &Status) -> String {
    match &status.branch {
        git::Branch::Named { name } => name.clone(),
        git::Branch::Detached { short_id } => format!("detached@{short_id}"),
        git::Branch::Unborn => "no commits".to_owned(),
    }
}