sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use serde_json::json;
use snip::Library;
use snip::config::AppConfig;
use snip::domain::Fingerprint;
use snip::error::{Result, SnipError};
use snip::service::{
    CreateOptions, EditOptions, FragmentAddOptions, FragmentEditOptions, add_fragment,
    create_snippet, delete_snippet, edit_fragment, edit_snippet, remove_fragment, reorder_fragment,
    replace_manifest_text,
};
use std::fs;
use std::io::{self, IsTerminal, Read, Write};
use std::path::Path;
use std::process::Command as ProcessCommand;
use tempfile::Builder;

use super::output::{print_mutation, print_record};
use crate::cli::{CreateArgs, DeleteArgs, EditArgs, FragmentArgs, FragmentCommand, OutputMode};

pub fn command_create(
    library: &Library,
    args: &CreateArgs,
    output: OutputMode,
    config: &AppConfig,
) -> Result<()> {
    let tags = if args.tags.is_empty() {
        config.default_tags.clone()
    } else {
        args.tags.clone()
    };
    let snippet = create_snippet(
        library,
        &CreateOptions {
            title: args.title.clone(),
            folder: args
                .folder
                .clone()
                .or_else(|| config.default_folder.clone()),
            tags,
            language: args
                .language
                .clone()
                .or_else(|| config.default_language.clone())
                .unwrap_or_else(|| "text".to_owned()),
            source_language: None,
            fragment_title: Some(args.fragment_title.clone()),
            content: read_optional_text(args.content.as_deref(), args.content_file.as_deref())?
                .unwrap_or_default(),
            note: read_optional_text(args.note.as_deref(), args.note_file.as_deref())?,
            readme: read_optional_text(args.readme.as_deref(), args.readme_file.as_deref())?,
            pinned: args.pin,
            locked: args.lock,
            ..CreateOptions::default()
        },
    )?;
    print_mutation(&snippet, None, output)
}

pub fn command_edit(
    library: &Library,
    args: &EditArgs,
    output: OutputMode,
    config: &AppConfig,
) -> Result<()> {
    if !edit_has_structured_changes(args) {
        return edit_external(library, args, output, config.editor.as_deref());
    }
    let options = EditOptions {
        title: args.title.clone(),
        folder: args.folder.clone(),
        tags: if args.clear_tags {
            Some(Vec::new())
        } else if !args.tags.is_empty() {
            Some(args.tags.clone())
        } else {
            None
        },
        pinned: args.pin.then_some(true).or(args.unpin.then_some(false)),
        locked: args.lock.then_some(true).or(args.unlock.then_some(false)),
        fragment_selector: args.fragment.clone(),
        fragment_title: args.fragment_title.clone(),
        language: args.language.clone(),
        content: read_optional_text(args.content.as_deref(), args.content_file.as_deref())?,
        note: if args.clear_note {
            Some(None)
        } else {
            read_optional_text(args.note.as_deref(), args.note_file.as_deref())?.map(Some)
        },
        readme: if args.clear_readme {
            Some(None)
        } else {
            read_optional_text(args.readme.as_deref(), args.readme_file.as_deref())?.map(Some)
        },
        if_hash: fingerprint(args.optimistic.if_hash.as_deref()),
        force: args.optimistic.force,
    };
    let (snippet, changes) = edit_snippet(library, &args.selector, &options)?;
    print_mutation(&snippet, Some(&changes), output)
}

pub fn command_fragment(
    library: &Library,
    args: &FragmentArgs,
    output: OutputMode,
    config: &AppConfig,
) -> Result<()> {
    let (snippet, changes) = match &args.command {
        FragmentCommand::Add(args) => add_fragment(
            library,
            &args.selector,
            &FragmentAddOptions {
                title: args.title.clone(),
                language: args
                    .language
                    .clone()
                    .or_else(|| config.default_language.clone())
                    .unwrap_or_else(|| "text".to_owned()),
                source_language: None,
                content: read_optional_text(args.content.as_deref(), args.content_file.as_deref())?
                    .unwrap_or_default(),
                note: read_optional_text(args.note.as_deref(), args.note_file.as_deref())?,
                if_hash: fingerprint(args.optimistic.if_hash.as_deref()),
                force: args.optimistic.force,
                ..FragmentAddOptions::default()
            },
        )?,
        FragmentCommand::Edit(args) => edit_fragment(
            library,
            &args.selector,
            &args.fragment,
            &FragmentEditOptions {
                title: args.title.clone(),
                language: args.language.clone(),
                content: read_optional_text(args.content.as_deref(), args.content_file.as_deref())?,
                note: if args.clear_note {
                    Some(None)
                } else {
                    read_optional_text(args.note.as_deref(), args.note_file.as_deref())?.map(Some)
                },
                if_hash: fingerprint(args.optimistic.if_hash.as_deref()),
                force: args.optimistic.force,
            },
        )?,
        FragmentCommand::Remove(args) => remove_fragment(
            library,
            &args.selector,
            &args.fragment,
            fingerprint(args.optimistic.if_hash.as_deref()).as_ref(),
            args.optimistic.force,
        )?,
        FragmentCommand::Reorder(args) => reorder_fragment(
            library,
            &args.selector,
            &args.fragment,
            args.position,
            fingerprint(args.optimistic.if_hash.as_deref()).as_ref(),
            args.optimistic.force,
        )?,
    };
    print_mutation(&snippet, Some(&changes), output)
}

pub fn command_delete(library: &Library, args: &DeleteArgs, output: OutputMode) -> Result<()> {
    let entry = delete_snippet(
        library,
        &args.selector,
        fingerprint(args.optimistic.if_hash.as_deref()).as_ref(),
        args.optimistic.force,
    )?;
    if output == OutputMode::Human {
        println!("moved to trash: {} ({})", entry.title, entry.entry_id);
    } else {
        print_record(&entry, output)?;
    }
    Ok(())
}

fn edit_external(
    library: &Library,
    args: &EditArgs,
    output: OutputMode,
    configured_editor: Option<&str>,
) -> Result<()> {
    if !io::stdin().is_terminal() || !io::stdout().is_terminal() {
        return Err(SnipError::usage(
            "external editing requires an interactive terminal; pass a structured change instead, such as --content, --content-file, --title, or --tag",
        ));
    }
    let catalog = library.scan()?;
    let original = library.resolve_snippet(&catalog, &args.selector)?.clone();
    let expected = fingerprint(args.optimistic.if_hash.as_deref())
        .unwrap_or_else(|| original.fingerprint.clone());
    if expected != original.fingerprint {
        return Err(SnipError::conflict(format!(
            "snippet changed since it was read: expected {expected}, found {}",
            original.fingerprint
        )));
    }
    let (initial, suffix, target) = if args.metadata_editor {
        (
            fs::read_to_string(original.package_path.join("snippet.toml"))?,
            ".toml".to_owned(),
            ExternalTarget::Metadata,
        )
    } else if args.readme_editor {
        (
            original.readme.clone().unwrap_or_default(),
            ".md".to_owned(),
            ExternalTarget::Readme,
        )
    } else {
        let fragment = library.resolve_fragment(&original, args.fragment.as_deref())?;
        if args.note_editor {
            (
                fragment.note_content.clone().unwrap_or_default(),
                ".md".to_owned(),
                ExternalTarget::Note(fragment.id.to_string()),
            )
        } else {
            let suffix = Path::new(&fragment.file)
                .extension()
                .and_then(|value| value.to_str())
                .map(|value| format!(".{value}"))
                .unwrap_or_default();
            (
                fragment.content.clone(),
                suffix,
                ExternalTarget::Content(fragment.id.to_string()),
            )
        }
    };
    let mut temp = Builder::new()
        .prefix("snip-edit-")
        .suffix(&suffix)
        .tempfile()?;
    temp.write_all(initial.as_bytes())?;
    temp.as_file().sync_all()?;
    launch_editor(temp.path(), configured_editor)?;
    let edited = fs::read_to_string(temp.path())?;
    if edited == initial {
        if output == OutputMode::Human {
            println!("unchanged: {}", original.id);
        } else {
            print_record(&json!({"unchanged": true, "id": original.id}), output)?;
        }
        return Ok(());
    }
    let fresh_catalog = library.scan()?;
    let fresh = library.resolve_snippet(&fresh_catalog, &original.id.to_string())?;
    if fresh.fingerprint != original.fingerprint {
        return Err(SnipError::conflict(format!(
            "snippet changed while the editor was open: expected {}, found {}",
            original.fingerprint, fresh.fingerprint
        )));
    }
    let (snippet, changes) = match target {
        ExternalTarget::Metadata => replace_manifest_text(
            library,
            &original.id.to_string(),
            &edited,
            Some(&expected),
            args.optimistic.force,
        )?,
        ExternalTarget::Readme => edit_snippet(
            library,
            &original.id.to_string(),
            &EditOptions {
                readme: Some(Some(edited)),
                if_hash: Some(expected),
                force: args.optimistic.force,
                ..EditOptions::default()
            },
        )?,
        ExternalTarget::Content(fragment) => edit_snippet(
            library,
            &original.id.to_string(),
            &EditOptions {
                fragment_selector: Some(fragment),
                content: Some(edited),
                if_hash: Some(expected),
                force: args.optimistic.force,
                ..EditOptions::default()
            },
        )?,
        ExternalTarget::Note(fragment) => edit_snippet(
            library,
            &original.id.to_string(),
            &EditOptions {
                fragment_selector: Some(fragment),
                note: Some(Some(edited)),
                if_hash: Some(expected),
                force: args.optimistic.force,
                ..EditOptions::default()
            },
        )?,
    };
    print_mutation(&snippet, Some(&changes), output)
}

enum ExternalTarget {
    Metadata,
    Readme,
    Content(String),
    Note(String),
}

fn launch_editor(path: &Path, configured_editor: Option<&str>) -> Result<()> {
    let editor = configured_editor.map(ToOwned::to_owned).unwrap_or_else(|| {
        std::env::var("VISUAL")
            .or_else(|_| std::env::var("EDITOR"))
            .unwrap_or_else(|_| "vi".to_owned())
    });
    let parts = shlex::split(&editor)
        .filter(|parts| !parts.is_empty())
        .ok_or_else(|| SnipError::usage(format!("invalid editor command: {editor:?}")))?;
    let status = ProcessCommand::new(&parts[0])
        .args(&parts[1..])
        .arg(path)
        .status()
        .map_err(|error| SnipError::io(format!("cannot start editor: {error}")))?;
    if !status.success() {
        return Err(SnipError::io(format!("editor exited with status {status}")));
    }
    Ok(())
}

fn read_optional_text(inline: Option<&str>, path: Option<&str>) -> Result<Option<String>> {
    match inline {
        Some(value) => Ok(Some(value.to_owned())),
        None => read_optional_file(path),
    }
}

fn read_optional_file(path: Option<&str>) -> Result<Option<String>> {
    let Some(path) = path else {
        return Ok(None);
    };
    if path == "-" {
        let mut value = String::new();
        io::stdin().read_to_string(&mut value)?;
        return Ok(Some(value));
    }
    fs::read_to_string(path)
        .map(Some)
        .map_err(|error| SnipError::io(format!("cannot read {path:?}: {error}")))
}

fn edit_has_structured_changes(args: &EditArgs) -> bool {
    args.title.is_some()
        || args.folder.is_some()
        || !args.tags.is_empty()
        || args.clear_tags
        || args.pin
        || args.unpin
        || args.lock
        || args.unlock
        || args.fragment_title.is_some()
        || args.language.is_some()
        || args.content.is_some()
        || args.content_file.is_some()
        || args.note.is_some()
        || args.note_file.is_some()
        || args.clear_note
        || args.readme.is_some()
        || args.readme_file.is_some()
        || args.clear_readme
}

fn fingerprint(value: Option<&str>) -> Option<Fingerprint> {
    value.map(|value| Fingerprint(value.to_owned()))
}