agentvfs 0.1.6

Virtual filesystem CLI backed by embedded databases for AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! aliases command - generate shell aliases.

use clap::{Args, ValueEnum};
use serde::Serialize;

use crate::commands::Output;
use crate::error::Result;

/// Shell type for alias generation.
#[derive(Debug, Clone, Copy, ValueEnum, Default)]
pub enum ShellType {
    #[default]
    Bash,
    Zsh,
    Fish,
}

#[derive(Args)]
pub struct AliasesArgs {
    /// Shell type for alias syntax
    #[arg(long, short, value_enum, default_value = "bash")]
    pub shell: ShellType,

    /// Prefix for alias names (default: v)
    #[arg(long, short, default_value = "v")]
    pub prefix: String,
}

/// List of commands to create aliases for.
const ALIAS_COMMANDS: &[&str] = &[
    "ls", "cat", "write", "mkdir", "rm", "cp", "mv", "tree", "pwd",
    "log", "checkout", "revert", "diff",
    "search", "grep", "find",
    "tag", "untag", "meta",
    "import", "export", "exec",
    "stats", "prune", "gc", "compact", "maintain",
    "quota", "audit", "snapshot", "checkpoint",
    "vault", "shell",
    #[cfg(feature = "fuse")]
    "mount",
    #[cfg(feature = "fuse")]
    "unmount",
    #[cfg(feature = "fuse")]
    "proxy",
];

#[derive(Serialize)]
struct AliasesOutput {
    shell: String,
    prefix: String,
    aliases: Vec<AliasEntry>,
}

#[derive(Serialize)]
struct AliasEntry {
    name: String,
    command: String,
}

pub fn run(args: AliasesArgs, output: &Output) -> Result<()> {
    let prefix = &args.prefix;

    if output.is_json() {
        let aliases: Vec<AliasEntry> = ALIAS_COMMANDS
            .iter()
            .map(|cmd| AliasEntry {
                name: format!("{}{}", prefix, cmd),
                command: format!("vfs {}", cmd),
            })
            .collect();

        output.print_json(&AliasesOutput {
            shell: format!("{:?}", args.shell).to_lowercase(),
            prefix: prefix.clone(),
            aliases,
        });
    } else {
        // Print comment header
        let comment = match args.shell {
            ShellType::Bash | ShellType::Zsh => "#",
            ShellType::Fish => "#",
        };

        println!("{} vfs aliases - add to your shell config", comment);
        println!("{} Generated with: vfs aliases --shell {:?} --prefix {}",
            comment, args.shell, prefix);
        println!();

        // Print aliases
        for cmd in ALIAS_COMMANDS {
            let alias_name = format!("{}{}", prefix, cmd);
            let alias_cmd = format!("vfs {}", cmd);

            match args.shell {
                ShellType::Bash | ShellType::Zsh => {
                    println!("alias {}='{}'", alias_name, alias_cmd);
                }
                ShellType::Fish => {
                    println!("alias {} '{}'", alias_name, alias_cmd);
                }
            }
        }

        println!();
        println!("{} Usage: eval \"$(vfs aliases)\"", comment);
    }

    Ok(())
}