use anyhow::Result;
use clap::{Parser, Subcommand, ValueHint};
use std::path::{Path, PathBuf};
#[derive(Parser, Debug)]
#[command(
name = "f",
bin_name = "f",
about = "f — Folder Auto Banner\nA directory listing with instant context.",
version,
author
)]
pub struct Cli {
#[arg(short, long, global = true)]
pub debug: bool,
#[command(subcommand)]
pub command: Option<Commands>,
#[arg(short = 't', long = "timesort")]
pub timesort: bool,
#[arg(short = 'S', long = "sizesort")]
pub sizesort: bool,
#[arg(short = 'X', long = "extensionsort")]
pub extensionsort: bool,
#[arg(short = 'G', long = "gitsort")]
pub gitsort: bool,
#[arg(short = 'r', long = "reverse")]
pub reverse: bool,
#[arg(short = 'a', long = "hidden")]
pub hidden: bool,
#[arg(short = '1', long = "oneline")]
pub oneline: bool,
#[arg(short = 'f', long = "filter")]
pub filter: Option<String>,
#[arg(short = 'm', long = "max")]
pub max: Option<usize>,
#[arg(long)]
pub tree: Option<Option<usize>>,
#[arg(short = 'L', long = "level")]
pub level: Option<usize>,
#[arg(short = 'c', long = "compact")]
pub compact: bool,
#[arg(short = 'v', long = "verbose")]
pub verbose: bool,
#[arg(long = "raw")]
pub raw: bool,
#[arg(long)]
pub json: bool,
#[arg(short = 'R', long = "recursive")]
pub recursive: bool,
#[arg(short = 'D', long = "only-dirs")]
pub only_dirs: bool,
#[arg(long = "only-files")]
pub only_files: bool,
#[arg(long = "git-ignore")]
pub git_ignore: bool,
#[arg(long = "highlight-recent")]
pub highlight_recent: Option<String>,
#[arg(long = "highlight-old")]
pub highlight_old: Option<String>,
}
#[derive(Subcommand, Debug)]
pub enum Commands {
Banner {
#[arg(value_hint = ValueHint::DirPath)]
path: Option<PathBuf>,
#[arg(short, long)]
raw: bool,
#[arg(long)]
json: bool,
#[arg(short, long)]
compact: bool,
#[arg(short, long)]
verbose: bool,
#[arg(long, value_parser = ["name", "size", "date", "type", "git", "extension", "version"])]
sort: Option<String>,
#[arg(short = 't', long = "timesort")]
timesort: bool,
#[arg(short = 'S', long = "sizesort")]
sizesort: bool,
#[arg(short = 'X', long = "extensionsort")]
extensionsort: bool,
#[arg(short = 'G', long = "gitsort")]
gitsort: bool,
#[arg(long = "versionsort")]
versionsort: bool,
#[arg(short = 'U', long = "no-sort")]
no_sort: bool,
#[arg(long, value_parser = ["none", "first", "last"])]
group_dirs: Option<String>,
#[arg(long = "reverse")]
reverse: bool,
#[arg(long)]
hidden: bool,
#[arg(long)]
relative_date: bool,
#[arg(short, long)]
filter: Option<String>,
#[arg(short, long)]
max: Option<usize>,
#[arg(long)]
group: bool,
#[arg(long)]
classify: bool,
#[arg(long)]
blocks: Option<String>,
#[arg(long)]
tree: Option<Option<usize>>,
#[arg(short = '1', long = "oneline")]
oneline: bool,
#[arg(long)]
total_size: bool,
#[arg(long)]
ignore_glob: Vec<String>,
#[arg(long)]
no_symlink: bool,
#[arg(long)]
hyperlink: bool,
#[arg(value_name = "ACTION")]
action: Option<String>,
#[arg(short = 'e', long = "edit")]
edit: bool,
#[arg(short = 'x', long = "run")]
run: bool,
},
Env {
#[arg(value_hint = ValueHint::DirPath)]
path: Option<PathBuf>,
#[arg(long, default_value = "shell")]
format: Option<String>,
},
Install,
Config,
Daemon {
#[command(subcommand)]
action: DaemonAction,
},
}
#[derive(Subcommand, Debug)]
pub enum DaemonAction {
Start,
Restart,
ClearCache,
Stop,
Status,
}
impl Cli {
pub fn run(&self) -> Result<()> {
use Commands::*;
if self.debug {
tracing_subscriber::fmt()
.with_env_filter("f=debug,f=trace")
.init();
} else {
tracing_subscriber::fmt().with_env_filter("f=warn").init();
}
match &self.command {
Some(Banner {
path,
raw,
json,
compact,
verbose,
sort,
timesort,
sizesort,
extensionsort,
gitsort,
versionsort,
no_sort,
group_dirs,
reverse,
hidden,
relative_date,
filter,
max,
group,
classify,
blocks,
tree,
oneline,
total_size,
ignore_glob,
no_symlink,
hyperlink,
action,
edit: force_edit,
run: force_run,
}) => {
let p: Option<&Path> = path.as_ref().map(|p| p.as_path());
crate::cmd::banner::run_banner(crate::cmd::banner::BannerOptions {
path: p,
raw: *raw,
json: *json,
compact: *compact,
verbose: *verbose,
sort: sort.as_deref(),
timesort: *timesort,
sizesort: *sizesort,
extensionsort: *extensionsort,
gitsort: *gitsort,
versionsort: *versionsort,
no_sort: *no_sort,
group_dirs: group_dirs.as_deref(),
reverse: *reverse,
hidden: *hidden,
relative_date: *relative_date,
filter: filter.as_deref(),
max: *max,
group: *group,
classify: *classify,
blocks: blocks.as_deref(),
tree: *tree,
oneline: *oneline,
total_size: *total_size,
ignore_glob: ignore_glob.clone(),
no_symlink: *no_symlink,
hyperlink: *hyperlink,
action: action.clone(),
force_edit: *force_edit,
force_run: *force_run,
..Default::default()
})
}
None => {
crate::cmd::banner::run_banner(crate::cmd::banner::BannerOptions {
path: None,
raw: self.raw,
json: self.json,
compact: self.compact,
verbose: self.verbose,
sort: None,
timesort: self.timesort,
sizesort: self.sizesort,
extensionsort: self.extensionsort,
gitsort: self.gitsort,
versionsort: false,
no_sort: false,
group_dirs: None,
reverse: self.reverse,
hidden: self.hidden,
relative_date: false,
filter: self.filter.as_deref(),
max: self.max,
group: false,
classify: false,
blocks: None,
tree: self.tree,
icons: false,
colors: false,
max_items: 0,
oneline: self.oneline,
total_size: false,
ignore_glob: vec![],
no_symlink: false,
hyperlink: false,
recursive: self.recursive,
only_dirs: self.only_dirs,
only_files: self.only_files,
git_ignore: self.git_ignore,
level: self.level,
highlight_recent: self.highlight_recent.clone(),
highlight_old: self.highlight_old.clone(),
action: None,
force_edit: false,
force_run: false,
})
}
Some(Env { path, format }) => {
crate::cmd::env::run_env(path.as_ref().map(|p| p.as_path()), format.as_deref())
}
Some(Install) => crate::cmd::install::run_install(),
Some(Config) => {
let config_path = crate::state::Config::config_path()
.map_err(|e| anyhow::anyhow!("Failed to get config path: {}", e))?;
if !config_path.exists() {
if let Some(parent) = config_path.parent() {
std::fs::create_dir_all(parent)?;
}
let default_config = crate::state::Config::default();
default_config.save()?;
println!("📝 Created config file: {}", config_path.display());
}
let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
let status = std::process::Command::new(&editor)
.arg(&config_path)
.status();
match status {
Ok(s) => {
if s.success() {
println!("✅ Config updated: {}", config_path.display());
} else {
eprintln!("⚠️ Editor exited with status: {}", s);
}
}
Err(e) => {
eprintln!("❌ Failed to open editor: {}", e);
println!("💡 Config file: {}", config_path.display());
}
}
Ok(())
}
Some(Daemon { action }) => crate::cmd::daemon_mgmt::run_daemon(action),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_banner_default() {
let cli = Cli::parse_from(["f"]);
match cli.command {
Some(Commands::Banner { .. }) => {}
None => {} _ => panic!("Expected Banner or None, got something else"),
}
}
}