feat(odin): ported edit-config command to odin.

.gitignore

@@ -7,4 +7,5 @@ man
 # build artifacts
 builds
 envr
+envr-go
 result

cli.odin

@@ -0,0 +1,181 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+
+Command :: struct {
+	name:     string,
+	args:     [dynamic]string,
+	flags:    map[string]string,
+	bool_set: map[string]bool,
+}
+
+CommandInfo :: struct {
+	name:  string,
+	usage: string,
+	short: string,
+	long:  string,
+}
+
+COMMANDS := []CommandInfo{
+	{"init", "envr init", "Set up envr",
+		"The init command generates your initial config and saves it to\n~/.envr/config in JSON format.\n\nDuring setup, you will be prompted to select one or more ssh keys with which to\nencrypt your databse. **Make 100% sure** that you have **a remote copy** of this\nkey somewhere, otherwise your data could be lost forever."},
+	{"scan", "envr scan", "Find and select .env files for backup", ""},
+	{"sync", "envr sync", "Update or restore your env backups", ""},
+	{"backup", "envr backup <path>", "Import a .env file into envr", ""},
+	{"add", "envr add <path>", "Import a .env file into envr", ""},
+	{"restore", "envr restore <path>", "Restore a .env file from the database", ""},
+	{"list", "envr list", "View your tracked files", ""},
+	{"remove", "envr remove <path>", "Remove a .env file from your database", ""},
+	{"check", "envr check [path]", "Check if files are backed up", ""},
+	{"deps", "envr deps", "Check for missing binaries",
+		"envr relies on external binaries for certain functionality.\n\nThe check command reports on which binaries are available and which are not."},
+	{"version", "envr version", "Show envr's version", ""},
+	{"edit-config", "envr edit-config", "Edit your config with your default editor", ""},
+}
+
+IMPLEMENTED_COMMANDS := []string{
+	"version",
+	"deps",
+	"list",
+	"backup",
+	"add",
+	"remove",
+	"restore",
+	"edit-config",
+}
+
+parse_args :: proc() -> (cmd: Command, ok: bool) {
+	args := os.args
+	if len(args) < 2 {
+		print_usage()
+		return Command{}, false
+	}
+
+	cmd.name = args[1]
+
+	if cmd.name == "--help" || cmd.name == "-h" {
+		print_usage()
+		return Command{}, false
+	}
+
+	cmd.args = make([dynamic]string)
+	cmd.flags = make(map[string]string)
+	cmd.bool_set = make(map[string]bool)
+
+	i := 2
+	for i < len(args) {
+		arg := args[i]
+		if strings.starts_with(arg, "--") {
+			key := arg[2:]
+			if i+1 < len(args) && !strings.starts_with(args[i+1], "-") {
+				cmd.flags[key] = args[i+1]
+				i += 2
+			} else {
+				cmd.bool_set[key] = true
+				i += 1
+			}
+		} else if strings.starts_with(arg, "-") && len(arg) == 2 {
+			key_slice := arg[1:2]
+			if i+1 < len(args) && !strings.starts_with(args[i+1], "-") {
+				cmd.flags[key_slice] = args[i+1]
+				i += 2
+			} else {
+				cmd.bool_set[key_slice] = true
+				i += 1
+			}
+		} else {
+			append(&cmd.args, arg)
+			i += 1
+		}
+	}
+
+	if has_flag(&cmd, "help") {
+		print_command_help(cmd.name)
+		return Command{}, false
+	}
+
+	return cmd, true
+}
+
+is_implemented :: proc(name: string) -> bool {
+	for c in IMPLEMENTED_COMMANDS {
+		if c == name {
+			return true
+		}
+	}
+	return false
+}
+
+has_flag :: proc(cmd: ^Command, name: string) -> bool {
+	_, ok := cmd.flags[name]
+	if ok {
+		return true
+	}
+	_, ok2 := cmd.bool_set[name]
+	return ok2
+}
+
+find_command :: proc(name: string) -> (CommandInfo, bool) {
+	for c in COMMANDS {
+		if c.name == name {
+			return c, true
+		}
+	}
+	return CommandInfo{}, false
+}
+
+print_command_help :: proc(name: string) {
+	info, found := find_command(name)
+	if !found {
+		fmt.printf("Unknown command: %s\n", name)
+		print_usage()
+		return
+	}
+	fmt.printf("Usage: %s\n\n%s\n", info.usage, info.short)
+	if len(info.long) > 0 {
+		fmt.printf("\n%s\n", info.long)
+	}
+}
+
+print_usage :: proc() {
+	fmt.println("envr - Manage your .env files.")
+	fmt.println("")
+	fmt.println("envr keeps your .env synced to a local, age encrypted database.")
+	fmt.println("Is a safe and easy way to gather all your .env files in one place where they can")
+	fmt.println("easily be backed by another tool such as restic or git.")
+	fmt.println("")
+	fmt.println("All your data is stored in ~/data.age")
+	fmt.println("")
+	fmt.println("Getting started is easy:")
+	fmt.println("")
+	fmt.println("1. Create your configuration file and set up encrypted storage:")
+	fmt.println("")
+	fmt.println("> envr init")
+	fmt.println("")
+	fmt.println("2. Scan for existing .env files:")
+	fmt.println("")
+	fmt.println("> envr scan")
+	fmt.println("")
+	fmt.println("Select the files you want to back up from the interactive list.")
+	fmt.println("")
+	fmt.println("3. Verify that it worked:")
+	fmt.println("")
+	fmt.println("> envr list")
+	fmt.println("")
+	fmt.println("Usage: envr <command> [args]")
+	fmt.println("")
+	fmt.println("Commands:")
+	fmt.println("  init          Set up envr")
+	fmt.println("  scan          Find and select .env files for backup")
+	fmt.println("  sync          Update or restore your env backups")
+	fmt.println("  backup <path> Import a .env file into envr")
+	fmt.println("  restore <path> Restore a .env file from the database")
+	fmt.println("  list          View your tracked files")
+	fmt.println("  remove <path> Remove a .env file from your database")
+	fmt.println("  check [path]  Check if files are backed up")
+	fmt.println("  deps          Check for missing binaries")
+	fmt.println("  version       Show envr's version")
+	fmt.println("  edit-config   Edit your config with your default editor")
+}

cmd_backup.odin

@@ -0,0 +1,34 @@
+package main
+
+import "core:fmt"
+import "core:strings"
+
+cmd_backup :: proc(cmd: ^Command) {
+	if len(cmd.args) != 1 {
+		fmt.println("Usage: envr backup <path>")
+		return
+	}
+
+	path := cmd.args[0]
+	if len(strings.trim_space(path)) == 0 {
+		fmt.println("Error: No path provided")
+		return
+	}
+
+	file, ok := new_env_file(path)
+	if !ok {
+		return
+	}
+
+	db, db_ok := db_open()
+	if !db_ok {
+		return
+	}
+	defer db_close(&db)
+
+	if !db_insert(&db, file) {
+		return
+	}
+
+	fmt.printf("Saved %s into the database\n", path)
+}

cmd_deps.odin

@@ -0,0 +1,30 @@
+package main
+
+import "core:fmt"
+
+cmd_deps :: proc(cmd: ^Command) {
+	feats := check_features()
+
+	headers := []string{"Feature", "Status"}
+	rows: [dynamic][]string
+
+	if .Git in feats {
+		append(&rows, []string{"Git", "\u2713 Available"})
+	} else {
+		append(&rows, []string{"Git", "\u2717 Missing"})
+	}
+
+	if .Fd in feats {
+		append(&rows, []string{"fd", "\u2713 Available"})
+	} else {
+		append(&rows, []string{"fd", "\u2717 Missing"})
+	}
+
+	if .Age in feats {
+		append(&rows, []string{"age", "\u2713 Available"})
+	} else {
+		append(&rows, []string{"age", "\u2717 Missing"})
+	}
+
+	render_table(headers, rows[:])
+}

cmd_edit_config.odin

@@ -0,0 +1,49 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:strings"
+
+cmd_edit_config :: proc(cmd: ^Command) {
+    editor := os.get_env("EDITOR", context.allocator)
+    if len(editor) == 0 {
+        fmt.println("Error: $EDITOR environment variable is not set")
+        return
+    }
+
+    config_path, join_err := filepath.join([]string{envr_dir(), "config.json"})
+    if join_err != nil {
+        fmt.printf("Error building config path: %v\n", join_err)
+        return
+    }
+
+    _, stat_err := os.stat(config_path, context.allocator)
+    if stat_err != nil {
+        fmt.printf("Config file does not exist at %s. Run 'envr init' first.\n", config_path)
+        return
+    }
+
+    args := []string{editor, config_path}
+    desc := os.Process_Desc{
+        command = args,
+        stdin = os.stdin,
+        stdout = os.stdout,
+        stderr = os.stderr,
+    }
+
+    p, start_err := os.process_start(desc)
+    if start_err != nil {
+        fmt.printf("Error running editor: %v\n", start_err)
+        return
+    }
+
+    state, wait_err := os.process_wait(p)
+    if wait_err != nil {
+        fmt.printf("Error waiting for editor: %v\n", wait_err)
+        return
+    }
+    if state.exit_code != 0 {
+        os.exit(int(state.exit_code))
+    }
+}

cmd_list.odin

@@ -0,0 +1,75 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:path/filepath"
+import "core:strings"
+
+ListEntry :: struct {
+    Directory: string `json:"directory"`,
+    Path:      string `json:"path"`,
+}
+
+cmd_list :: proc(cmd: ^Command) {
+    db, db_ok := db_open()
+    if !db_ok {
+        return
+    }
+    defer db_close(&db)
+
+    rows, list_ok := db_list(&db)
+    if !list_ok {
+        return
+    }
+    defer delete(rows)
+
+    if is_tty() {
+        headers := []string{"Directory", "Path"}
+        table_rows := make([dynamic][]string, 0, len(rows))
+
+        for row in rows {
+            b: strings.Builder
+            strings.builder_init(&b)
+            strings.write_string(&b, row.Dir)
+            strings.write_string(&b, "/")
+            dir_str, _ := strings.clone(strings.to_string(b))
+
+            rel, rel_err := filepath.rel(row.Dir, row.Path)
+            if rel_err != nil {
+                fmt.printf("Error getting relative path: %v\n", rel_err)
+                return
+            }
+            cloned_rel, _ := strings.clone(rel)
+            row_slice := make([]string, 2)
+            row_slice[0] = dir_str
+            row_slice[1] = cloned_rel
+            append(&table_rows, row_slice)
+        }
+
+        render_table(headers, table_rows[:])
+    } else {
+        entries: [dynamic]ListEntry
+        for row in rows {
+            rel, rel_err := filepath.rel(row.Dir, row.Path)
+            if rel_err != nil {
+                fmt.printf("Error getting relative path: %v\n", rel_err)
+                return
+            }
+            b: strings.Builder
+            strings.builder_init(&b)
+            strings.write_string(&b, row.Dir)
+            strings.write_string(&b, "/")
+            append(&entries, ListEntry{
+                Directory = strings.to_string(b),
+                Path = rel,
+            })
+        }
+
+        data, marshal_err := json.marshal(entries[:])
+        if marshal_err != nil {
+            fmt.printf("Error marshaling JSON: %v\n", marshal_err)
+            return
+        }
+        fmt.println(string(data))
+    }
+}

cmd_remove.odin

@@ -0,0 +1,42 @@
+package main
+
+import "core:fmt"
+import "core:path/filepath"
+import "core:strings"
+
+cmd_remove :: proc(cmd: ^Command) {
+    if len(cmd.args) != 1 {
+        fmt.println("Usage: envr remove <path>")
+        return
+    }
+
+    path := cmd.args[0]
+    if len(strings.trim_space(path)) == 0 {
+        fmt.println("Error: No path provided")
+        return
+    }
+
+    abs_path: string
+    if filepath.is_abs(path) {
+        abs_path = path
+    } else {
+        resolved, abs_err := filepath.abs(path)
+        if abs_err != nil {
+            fmt.printf("Error getting absolute path: %v\n", abs_err)
+            return
+        }
+        abs_path = resolved
+    }
+
+    db, db_ok := db_open()
+    if !db_ok {
+        return
+    }
+    defer db_close(&db)
+
+    if !db_delete(&db, abs_path) {
+        return
+    }
+
+    fmt.printf("Removed %s from the database\n", abs_path)
+}

cmd_restore.odin

@@ -0,0 +1,53 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:strings"
+
+cmd_restore :: proc(cmd: ^Command) {
+    if len(cmd.args) != 1 {
+        fmt.println("Usage: envr restore <path>")
+        return
+    }
+
+    path := cmd.args[0]
+    if len(strings.trim_space(path)) == 0 {
+        fmt.println("Error: No path provided")
+        return
+    }
+
+    abs_path: string
+    if filepath.is_abs(path) {
+        abs_path = path
+    } else {
+        resolved, abs_err := filepath.abs(path)
+        if abs_err != nil {
+            fmt.printf("Error getting absolute path: %v\n", abs_err)
+            return
+        }
+        abs_path = resolved
+    }
+
+    db, db_ok := db_open()
+    if !db_ok {
+        return
+    }
+    defer db_close(&db)
+
+    file, fetch_ok := db_fetch(&db, abs_path)
+    if !fetch_ok {
+        return
+    }
+
+    dir := filepath.dir(file.Path)
+    os.mkdir_all(dir)
+
+    write_err := os.write_entire_file(file.Path, file.contents)
+    if write_err != nil {
+        fmt.printf("Error writing file: %v\n", write_err)
+        return
+    }
+
+    fmt.printf("Restored %s\n", file.Path)
+}

config.odin

@@ -0,0 +1,61 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+
+SshKeyPair :: struct {
+	Private: string `json:"private"`,
+	Public:  string `json:"public"`,
+}
+
+ScanConfig :: struct {
+	Matcher: string   `json:"matcher"`,
+	Exclude: []string `json:"exclude"`,
+	Include: []string `json:"include"`,
+}
+
+Config :: struct {
+	Keys:       []SshKeyPair `json:"keys"`,
+	ScanConfig: ScanConfig   `json:"scan"`,
+}
+
+load_config :: proc() -> (Config, bool) {
+	home, home_err := os.user_home_dir(context.allocator)
+	if home_err != nil {
+		fmt.printf("Error getting home dir: %v\n", home_err)
+		return Config{}, false
+	}
+	config_path, join_err := filepath.join([]string{home, ".envr", "config.json"})
+	if join_err != nil {
+		return Config{}, false
+	}
+
+	data, read_err := os.read_entire_file_from_path(config_path, context.allocator)
+	if read_err != nil {
+		fmt.println("No config file found. Please run `envr init` to generate one.")
+		return Config{}, false
+	}
+
+	cfg: Config
+	err := json.unmarshal(data, &cfg)
+	if err != nil {
+		fmt.printf("Error parsing config: %v\n", err)
+		return Config{}, false
+	}
+
+	return cfg, true
+}
+
+envr_dir :: proc() -> string {
+	home, _ := os.user_home_dir(context.allocator)
+	dir, _ := filepath.join([]string{home, ".envr"})
+	return dir
+}
+
+data_age_path :: proc() -> string {
+	dir := envr_dir()
+	path, _ := filepath.join([]string{dir, "data.age"})
+	return path
+}

db.odin

@@ -0,0 +1,473 @@
+package main
+
+import "core:c"
+import "core:crypto/hash"
+import "core:encoding/hex"
+import "core:encoding/json"
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:strings"
+import "core:time"
+
+import "sqlite"
+
+Db :: struct {
+    db:      ^rawptr,
+    cfg:     Config,
+    changed: bool,
+}
+
+EnvFile :: struct {
+    Path:     string,
+    Dir:      string,
+    Remotes:  [dynamic]string,
+    Sha256:   string,
+    contents: string,
+}
+
+make_temp_path :: proc() -> string {
+    ts := time.time_to_unix(time.now())
+    b: strings.Builder
+    strings.builder_init(&b)
+    fmt.sbprintf(&b, "/tmp/envr-%d-%d.db", os.get_pid(), ts)
+    return strings.to_string(b)
+}
+
+db_open :: proc() -> (Db, bool) {
+    cfg, ok := load_config()
+    if !ok {
+        return Db{}, false
+    }
+
+    age_path := data_age_path()
+    _, stat_err := os.stat(age_path, context.allocator)
+
+    db: ^rawptr
+    rc := sqlite.db_open(":memory:", &db)
+    if rc != sqlite.OK {
+        fmt.printf("Error opening in-memory database: %s\n", sqlite.db_errmsg(db))
+        return Db{}, false
+    }
+
+    create_sql := "CREATE TABLE IF NOT EXISTS envr_env_files (path TEXT PRIMARY KEY NOT NULL, remotes TEXT, sha256 TEXT NOT NULL, contents TEXT NOT NULL)"
+    rc = sqlite.db_exec(db, string_to_cstring(create_sql), nil, nil, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error creating table: %s\n", sqlite.db_errmsg(db))
+        sqlite.db_close(db)
+        return Db{}, false
+    }
+
+    if stat_err == nil {
+        if !db_restore_from_age(db, cfg) {
+            sqlite.db_close(db)
+            return Db{}, false
+        }
+    }
+
+    return Db{db = db, cfg = cfg, changed = stat_err != nil}, true
+}
+
+db_close :: proc(d: ^Db) {
+    if d.changed {
+        tmp_path := make_temp_path()
+
+        if !db_vacuum_to_file(d.db, tmp_path) {
+            os.remove(tmp_path)
+            sqlite.db_close(d.db)
+            return
+        }
+
+        db_encrypt_file(tmp_path, d.cfg.Keys)
+        os.remove(tmp_path)
+        d.changed = false
+    }
+    sqlite.db_close(d.db)
+}
+
+db_list :: proc(d: ^Db) -> (results: [dynamic]EnvFile, ok: bool) {
+    sql := "SELECT path, remotes, sha256, contents FROM envr_env_files"
+    stmt: ^rawptr
+    rc := sqlite.prepare_v2(d.db, string_to_cstring(sql), -1, &stmt, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error preparing query: %s\n", sqlite.db_errmsg(d.db))
+        return
+    }
+
+    for {
+        rc = sqlite.step(stmt)
+        if rc == sqlite.DONE {
+            break
+        }
+        if rc != sqlite.ROW {
+            fmt.printf("Error stepping query: %s\n", sqlite.db_errmsg(d.db))
+            sqlite.finalize(stmt)
+            return
+        }
+
+        path := cstring_to_string(sqlite.column_text(stmt, 0))
+        remotes_json := cstring_to_string(sqlite.column_text(stmt, 1))
+        sha := cstring_to_string(sqlite.column_text(stmt, 2))
+        contents := cstring_to_string(sqlite.column_text(stmt, 3))
+
+        remotes: [dynamic]string
+        if len(remotes_json) > 0 {
+            json.unmarshal_string(remotes_json, &remotes)
+        }
+
+        append(&results, EnvFile{
+            Path = path,
+            Dir = filepath.dir(path),
+            Remotes = remotes,
+            Sha256 = sha,
+            contents = contents,
+        })
+    }
+
+    sqlite.finalize(stmt)
+    ok = true
+    return
+}
+
+db_vacuum_to_file :: proc(db: ^rawptr, path: string) -> bool {
+    b: strings.Builder
+    strings.builder_init(&b)
+    fmt.sbprintf(&b, "VACUUM INTO '%s'", path)
+    sql := strings.to_string(b)
+    rc := sqlite.db_exec(db, string_to_cstring(sql), nil, nil, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error vacuuming database: %s\n", sqlite.db_errmsg(db))
+        return false
+    }
+    return true
+}
+
+db_restore_from_age :: proc(db: ^rawptr, cfg: Config) -> bool {
+    tmp_path := make_temp_path()
+    defer os.remove(tmp_path)
+
+    if !db_decrypt_to_file(tmp_path, cfg.Keys) {
+        return false
+    }
+
+    if !db_attach_and_copy(db, tmp_path) {
+        return false
+    }
+
+    return true
+}
+
+db_decrypt_to_file :: proc(tmp_path: string, keys: []SshKeyPair) -> bool {
+    age_path := data_age_path()
+
+    args := make([dynamic]string)
+    append(&args, "age")
+    append(&args, "--decrypt")
+    append(&args, "-o")
+    append(&args, tmp_path)
+    for key in keys {
+        append(&args, "-i")
+        append(&args, key.Private)
+    }
+    append(&args, age_path)
+
+    desc := os.Process_Desc{
+        command = args[:],
+        stdout = os.stderr,
+        stderr = os.stderr,
+    }
+
+    p, err := os.process_start(desc)
+    if err != nil {
+        fmt.printf("Error running age decrypt: %v\n", err)
+        return false
+    }
+
+    state, wait_err := os.process_wait(p)
+    if wait_err != nil {
+        fmt.printf("Error waiting for age: %v\n", wait_err)
+        return false
+    }
+    if state.exit_code != 0 {
+        fmt.println("Error: age decryption failed")
+        return false
+    }
+    return true
+}
+
+db_encrypt_file :: proc(tmp_path: string, keys: []SshKeyPair) -> bool {
+    age_path := data_age_path()
+    envr_d := envr_dir()
+    os.mkdir_all(envr_d)
+
+    args := make([dynamic]string)
+    append(&args, "age")
+    append(&args, "--encrypt")
+    for key in keys {
+        append(&args, "-r")
+        pub_data, pub_err := os.read_entire_file_from_path(key.Public, context.allocator)
+        if pub_err != nil {
+            fmt.printf("Error reading public key: %s\n", key.Public)
+            return false
+        }
+        pub_str := string(pub_data)
+        if strings.has_suffix(pub_str, "\n") {
+            pub_str = pub_str[:len(pub_str)-1]
+        }
+        append(&args, pub_str)
+    }
+    append(&args, "-o")
+    append(&args, age_path)
+    append(&args, tmp_path)
+
+    desc := os.Process_Desc{
+        command = args[:],
+        stdout = os.stderr,
+        stderr = os.stderr,
+    }
+
+    p, err := os.process_start(desc)
+    if err != nil {
+        fmt.printf("Error running age encrypt: %v\n", err)
+        return false
+    }
+
+    state, wait_err := os.process_wait(p)
+    if wait_err != nil {
+        fmt.printf("Error waiting for age: %v\n", wait_err)
+        return false
+    }
+    if state.exit_code != 0 {
+        fmt.println("Error: age encryption failed")
+        return false
+    }
+    return true
+}
+
+db_attach_and_copy :: proc(mem_db: ^rawptr, src_path: string) -> bool {
+    b: strings.Builder
+    strings.builder_init(&b)
+    fmt.sbprintf(&b, "ATTACH DATABASE '%s' AS source", src_path)
+    attach_sql := strings.to_string(b)
+
+    rc := sqlite.db_exec(mem_db, string_to_cstring(attach_sql), nil, nil, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error attaching database: %s\n", sqlite.db_errmsg(mem_db))
+        return false
+    }
+
+    rc = sqlite.db_exec(mem_db, "INSERT INTO main.envr_env_files SELECT * FROM source.envr_env_files", nil, nil, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error copying data: %s\n", sqlite.db_errmsg(mem_db))
+        sqlite.db_exec(mem_db, "DETACH DATABASE source", nil, nil, nil)
+        return false
+    }
+
+    sqlite.db_exec(mem_db, "DETACH DATABASE source", nil, nil, nil)
+    return true
+}
+
+get_git_remotes :: proc(dir: string) -> [dynamic]string {
+    remotes: [dynamic]string
+    remote_set: map[string]bool
+
+    b: strings.Builder
+    strings.builder_init(&b)
+    fmt.sbprintf(&b, "%s-git-remotes", make_temp_path())
+    tmp_path := strings.to_string(b)
+    tmp_file, tmp_err := os.open(tmp_path, os.O_CREATE | os.O_WRONLY | os.O_TRUNC)
+    if tmp_err != nil {
+        return remotes
+    }
+
+    args := []string{"git", "remote", "-v"}
+    desc := os.Process_Desc{
+        command = args,
+        stdout = tmp_file,
+        stderr = nil,
+        working_dir = dir,
+    }
+
+    p, start_err := os.process_start(desc)
+    os.close(tmp_file)
+    if start_err != nil {
+        os.remove(tmp_path)
+        return remotes
+    }
+
+    state, wait_err := os.process_wait(p)
+    if wait_err != nil || state.exit_code != 0 {
+        os.remove(tmp_path)
+        return remotes
+    }
+
+    data, read_err := os.read_entire_file_from_path(tmp_path, context.allocator)
+    os.remove(tmp_path)
+    if read_err != nil {
+        return remotes
+    }
+
+    output_str := string(data)
+    lines := strings.split(output_str, "\n")
+
+    for &line in lines {
+        line = strings.trim_space(line)
+        if len(line) == 0 {
+            continue
+        }
+        parts := strings.fields(line)
+        if len(parts) >= 2 {
+            remote_set[parts[1]] = true
+        }
+    }
+
+    for remote, _ in remote_set {
+        cloned, _ := strings.clone(remote)
+        append(&remotes, cloned)
+    }
+
+    return remotes
+}
+
+new_env_file :: proc(path: string) -> (EnvFile, bool) {
+    abs_path, abs_err := filepath.abs(path)
+    if abs_err != nil {
+        fmt.printf("Error getting absolute path: %v\n", abs_err)
+        return EnvFile{}, false
+    }
+    cloned_path, _ := strings.clone(abs_path)
+
+    dir := filepath.dir(cloned_path)
+    cloned_dir, _ := strings.clone(dir)
+
+    remotes := get_git_remotes(cloned_dir)
+
+    data, read_err := os.read_entire_file_from_path(cloned_path, context.allocator)
+    if read_err != nil {
+        fmt.printf("Error reading file %s: %v\n", cloned_path, read_err)
+        return EnvFile{}, false
+    }
+
+    digest := hash.hash_bytes(hash.Algorithm.SHA256, data)
+    hex_bytes, _ := hex.encode(digest)
+    sha_str := string(hex_bytes)
+
+    return EnvFile{
+        Path = cloned_path,
+        Dir = cloned_dir,
+        Remotes = remotes,
+        Sha256 = sha_str,
+        contents = string(data),
+    }, true
+}
+
+db_insert :: proc(d: ^Db, file: EnvFile) -> bool {
+    remotes_json, marshal_err := json.marshal(file.Remotes)
+    if marshal_err != nil {
+        fmt.printf("Error marshaling remotes: %v\n", marshal_err)
+        return false
+    }
+
+    sql := "INSERT OR REPLACE INTO envr_env_files (path, remotes, sha256, contents) VALUES (?, ?, ?, ?)"
+    stmt: ^rawptr
+    rc := sqlite.prepare_v2(d.db, string_to_cstring(sql), -1, &stmt, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error preparing insert: %s\n", sqlite.db_errmsg(d.db))
+        return false
+    }
+    defer sqlite.finalize(stmt)
+
+    rc = sqlite.bind_text(stmt, 1, string_to_cstring(file.Path), -1, nil)
+    rc = sqlite.bind_text(stmt, 2, string_to_cstring(string(remotes_json)), -1, nil)
+    rc = sqlite.bind_text(stmt, 3, string_to_cstring(file.Sha256), -1, nil)
+    rc = sqlite.bind_text(stmt, 4, string_to_cstring(file.contents), -1, nil)
+
+    rc = sqlite.step(stmt)
+    if rc != sqlite.DONE {
+        fmt.printf("Error inserting: %s\n", sqlite.db_errmsg(d.db))
+        return false
+    }
+
+    d.changed = true
+    return true
+}
+
+db_fetch :: proc(d: ^Db, path: string) -> (EnvFile, bool) {
+    sql := "SELECT path, remotes, sha256, contents FROM envr_env_files WHERE path = ?"
+    stmt: ^rawptr
+    rc := sqlite.prepare_v2(d.db, string_to_cstring(sql), -1, &stmt, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error preparing fetch: %s\n", sqlite.db_errmsg(d.db))
+        return EnvFile{}, false
+    }
+    defer sqlite.finalize(stmt)
+
+    rc = sqlite.bind_text(stmt, 1, string_to_cstring(path), -1, nil)
+    rc = sqlite.step(stmt)
+    if rc == sqlite.DONE {
+        fmt.printf("No file found with path: %s\n", path)
+        return EnvFile{}, false
+    }
+    if rc != sqlite.ROW {
+        fmt.printf("Error fetching: %s\n", sqlite.db_errmsg(d.db))
+        return EnvFile{}, false
+    }
+
+    file_path := cstring_to_string(sqlite.column_text(stmt, 0))
+    remotes_json := cstring_to_string(sqlite.column_text(stmt, 1))
+    sha := cstring_to_string(sqlite.column_text(stmt, 2))
+    contents := cstring_to_string(sqlite.column_text(stmt, 3))
+
+    remotes: [dynamic]string
+    if len(remotes_json) > 0 {
+        json.unmarshal_string(remotes_json, &remotes)
+    }
+
+    cloned_path, _ := strings.clone(file_path)
+    return EnvFile{
+        Path = cloned_path,
+        Dir = filepath.dir(cloned_path),
+        Remotes = remotes,
+        Sha256 = sha,
+        contents = contents,
+    }, true
+}
+
+db_delete :: proc(d: ^Db, path: string) -> bool {
+    sql := "DELETE FROM envr_env_files WHERE path = ?"
+    stmt: ^rawptr
+    rc := sqlite.prepare_v2(d.db, string_to_cstring(sql), -1, &stmt, nil)
+    if rc != sqlite.OK {
+        fmt.printf("Error preparing delete: %s\n", sqlite.db_errmsg(d.db))
+        return false
+    }
+    defer sqlite.finalize(stmt)
+
+    rc = sqlite.bind_text(stmt, 1, string_to_cstring(path), -1, nil)
+    rc = sqlite.step(stmt)
+    if rc != sqlite.DONE {
+        fmt.printf("Error deleting: %s\n", sqlite.db_errmsg(d.db))
+        return false
+    }
+
+    if sqlite.changes(d.db) == 0 {
+        fmt.printf("No file found with path: %s\n", path)
+        return false
+    }
+
+    d.changed = true
+    return true
+}
+
+cstring_to_string :: proc(cs: cstring) -> string {
+    if cs == nil {
+        return ""
+    }
+    s, _ := strings.clone_from_cstring(cs)
+    return s
+}
+
+string_to_cstring :: proc(s: string) -> cstring {
+    cs, _ := strings.clone_to_cstring(s)
+    return cs
+}

features.odin

@@ -0,0 +1,45 @@
+package main
+
+import "core:os"
+import "core:strings"
+
+Feature :: enum {
+	Git,
+	Fd,
+	Age,
+}
+
+AvailableFeatures :: bit_set[Feature]
+
+check_features :: proc() -> AvailableFeatures {
+	feats: AvailableFeatures
+
+	if find_binary("git") != "" {
+		feats += {.Git}
+	}
+	if find_binary("fd") != "" {
+		feats += {.Fd}
+	}
+	if find_binary("age") != "" {
+		feats += {.Age}
+	}
+
+	return feats
+}
+
+find_binary :: proc(name: string) -> string {
+	path_env := os.get_env("PATH", context.allocator)
+	paths := strings.split(path_env, ":")
+	for p in paths {
+		candidate := strings.join({strings.trim_right(p, "/"), name}, "/")
+		_, err := os.stat(candidate, context.allocator)
+		if err == nil {
+			return candidate
+		}
+	}
+	return ""
+}
+
+has_feature :: proc(feats: AvailableFeatures, f: Feature) -> bool {
+	return f in feats
+}

flake.lock

@@ -5,11 +5,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1768135262,
-        "narHash": "sha256-PVvu7OqHBGWN16zSi6tEmPwwHQ4rLPU9Plvs8/1TUBY=",
+        "lastModified": 1778716662,
+        "narHash": "sha256-m1Yf0wZ8j1OHjTc2UwHwyQRSnNeSgLJOd7q5Y45hzi4=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "80daad04eddbbf5a4d883996a73f3f542fa437ac",
+        "rev": "f7c1a2d347e4c52d5fb8d10cb4d94b5884e546fb",
         "type": "github"
       },
       "original": {
@@ -36,11 +36,11 @@
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1765674936,
-        "narHash": "sha256-k00uTP4JNfmejrCLJOwdObYC9jHRrr/5M/a/8L2EIdo=",
+        "lastModified": 1777168982,
+        "narHash": "sha256-GOkGPcboWE9BmGCRMLX3worL4EMnsnG8MyKmXNeYuhQ=",
         "owner": "nix-community",
         "repo": "nixpkgs.lib",
-        "rev": "2075416fcb47225d9b68ac469a5c4801a9c4dd85",
+        "rev": "f5901329dade4a6ea039af1433fb087bd9c1fe14",
         "type": "github"
       },
       "original": {
@@ -51,11 +51,11 @@
     },
     "nixpkgs-unstable": {
       "locked": {
-        "lastModified": 1768178648,
-        "narHash": "sha256-kz/F6mhESPvU1diB7tOM3nLcBfQe7GU7GQCymRlTi/s=",
+        "lastModified": 1781173989,
+        "narHash": "sha256-fnzKKPvS+oieI/pTzotA5tkoM47EB1NpaBcgk4R97hE=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3fbab70c6e69c87ea2b6e48aa6629da2aa6a23b0",
+        "rev": "8c91a71d13451abc40eb9dae8910f972f979852f",
         "type": "github"
       },
       "original": {
@@ -80,11 +80,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1768158989,
-        "narHash": "sha256-67vyT1+xClLldnumAzCTBvU0jLZ1YBcf4vANRWP3+Ak=",
+        "lastModified": 1780220602,
+        "narHash": "sha256-eynAfOmbmxJnkp7YewvCEbShNnnYJ9gLLqkzsYtBPeM=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "e96d59dff5c0d7fddb9d113ba108f03c3ef99eca",
+        "rev": "db947814a175b7ca6ded66e21383d938df01c227",
         "type": "github"
       },
       "original": {

flake.nix

@@ -97,6 +97,11 @@
                 gotools
                 cobra-cli
 
+                age
+                sqlite
+                unstable.odin
+                unstable.ols
+
                 # Build tools
                 zip
 

main.odin

@@ -0,0 +1,68 @@
+package main
+
+import "core:fmt"
+import "core:os"
+
+GO_BINARY :: "./envr-go"
+
+main :: proc() {
+	cmd, ok := parse_args()
+	if !ok {
+		return
+	}
+
+	if !is_implemented(cmd.name) {
+		fallback_to_go()
+		return
+	}
+
+	switch cmd.name {
+	case "version":
+		cmd_version(&cmd)
+	case "deps":
+		cmd_deps(&cmd)
+	case "list":
+		cmd_list(&cmd)
+	case "backup", "add":
+		cmd_backup(&cmd)
+	case "remove":
+		cmd_remove(&cmd)
+	case "restore":
+		cmd_restore(&cmd)
+	case "edit-config":
+		cmd_edit_config(&cmd)
+	case:
+		fmt.printf("Unknown command: %s\n", cmd.name)
+		print_usage()
+		os.exit(1)
+	}
+}
+
+fallback_to_go :: proc() {
+	args := make([dynamic]string)
+	append(&args, "./envr-go")
+	for i in 1..<len(os.args) {
+		append(&args, os.args[i])
+	}
+
+	desc := os.Process_Desc{
+		command = args[:],
+		stdin = os.stdin,
+		stdout = os.stdout,
+		stderr = os.stderr,
+	}
+
+	p, err1 := os.process_start(desc)
+	if err1 != nil {
+		fmt.printf("Error: failed to run envr-go: %v\n", err1)
+		os.exit(1)
+	}
+
+	state, err2 := os.process_wait(p)
+	if err2 != nil {
+		fmt.printf("Error waiting for envr-go: %v\n", err2)
+		os.exit(1)
+	}
+
+	os.exit(int(state.exit_code))
+}

sqlite/sqlite.odin

@@ -0,0 +1,34 @@
+package sqlite
+
+import "core:c"
+
+foreign import lib "system:sqlite3"
+
+OK :: 0
+ROW :: 100
+DONE :: 101
+
+foreign lib {
+    @(link_name="sqlite3_open")
+    db_open          :: proc(filename: cstring, ppDb: ^^rawptr) -> c.int ---
+    @(link_name="sqlite3_close")
+    db_close         :: proc(db: ^rawptr) -> c.int ---
+    @(link_name="sqlite3_errmsg")
+    db_errmsg        :: proc(db: ^rawptr) -> cstring ---
+    @(link_name="sqlite3_exec")
+    db_exec          :: proc(db: ^rawptr, sql: cstring, callback: rawptr, callback_arg: rawptr, errmsg: ^cstring) -> c.int ---
+    @(link_name="sqlite3_prepare_v2")
+    prepare_v2       :: proc(db: ^rawptr, sql: cstring, nByte: c.int, ppStmt: ^^rawptr, pzTail: ^cstring) -> c.int ---
+    @(link_name="sqlite3_step")
+    step             :: proc(stmt: ^rawptr) -> c.int ---
+    @(link_name="sqlite3_finalize")
+    finalize         :: proc(stmt: ^rawptr) -> c.int ---
+    @(link_name="sqlite3_column_text")
+    column_text      :: proc(stmt: ^rawptr, iCol: c.int) -> cstring ---
+    @(link_name="sqlite3_column_bytes")
+    column_bytes     :: proc(stmt: ^rawptr, iCol: c.int) -> c.int ---
+    @(link_name="sqlite3_bind_text")
+    bind_text        :: proc(stmt: ^rawptr, idx: c.int, val: cstring, n: c.int, destructor: rawptr) -> c.int ---
+    @(link_name="sqlite3_changes")
+    changes          :: proc(db: ^rawptr) -> c.int ---
+}

stubs.odin

@@ -0,0 +1,19 @@
+package main
+
+import "core:fmt"
+
+cmd_init :: proc(cmd: ^Command) {
+	fmt.println("TODO: init")
+}
+
+cmd_scan :: proc(cmd: ^Command) {
+	fmt.println("TODO: scan")
+}
+
+cmd_sync :: proc(cmd: ^Command) {
+	fmt.println("TODO: sync")
+}
+
+cmd_check :: proc(cmd: ^Command) {
+	fmt.println("TODO: check")
+}

table.odin

@@ -0,0 +1,90 @@
+package main
+
+import "core:fmt"
+import "core:strings"
+
+render_table :: proc(headers: []string, rows: [][]string) {
+	if !is_tty() {
+		render_json_rows(headers, rows)
+		return
+	}
+
+	col_widths := make([dynamic]int, 0, len(headers))
+	for i in 0..<len(headers) {
+		append(&col_widths, strings.rune_count(headers[i]))
+	}
+	for r in rows {
+		for i in 0..<len(r) {
+			w := strings.rune_count(r[i])
+			if i < len(col_widths) && w > col_widths[i] {
+				col_widths[i] = w
+			}
+		}
+	}
+
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+	defer delete(col_widths)
+
+	hline :: proc(b: ^strings.Builder, left, mid, right: string, widths: [dynamic]int) {
+		strings.write_string(b, left)
+		for i in 0..<len(widths) {
+			for _ in 0..<widths[i]+2 {
+				strings.write_string(b, "\u2500")
+			}
+			if i < len(widths)-1 {
+				strings.write_string(b, mid)
+			} else {
+				strings.write_string(b, right)
+			}
+		}
+		fmt.println(strings.to_string(b^))
+		strings.builder_reset(b)
+	}
+
+	hline(&b, "\u250c", "\u252c", "\u2510", col_widths)
+
+	cell :: proc(b: ^strings.Builder, s: string, width: int) {
+		extra := len(s) - strings.rune_count(s)
+		fmt.sbprintf(b, " %-*s \u2502", width + extra, s)
+	}
+
+	strings.write_string(&b, "\u2502")
+	for i in 0..<len(headers) {
+		cell(&b, headers[i], col_widths[i])
+	}
+	fmt.println(strings.to_string(b))
+	strings.builder_reset(&b)
+
+	hline(&b, "\u251c", "\u253c", "\u2524", col_widths)
+
+	for r in rows {
+		strings.write_string(&b, "\u2502")
+		for i in 0..<len(r) {
+			cell(&b, r[i], col_widths[i])
+		}
+		fmt.println(strings.to_string(b))
+		strings.builder_reset(&b)
+	}
+
+	hline(&b, "\u2514", "\u2534", "\u2518", col_widths)
+}
+
+render_json_rows :: proc(headers: []string, rows: [][]string) {
+	fmt.print("[")
+	for i in 0..<len(rows) {
+		if i > 0 {
+			fmt.print(",")
+		}
+		fmt.print("{")
+		for j in 0..<len(headers) {
+			if j > 0 {
+				fmt.print(",")
+			}
+			fmt.printf("\"%s\":\"%s\"", headers[j], rows[i][j])
+		}
+		fmt.print("}")
+	}
+	fmt.println("]")
+}

tty.odin

@@ -0,0 +1,7 @@
+package main
+
+import "core:sys/posix"
+
+is_tty :: proc() -> bool {
+	return bool(posix.isatty(1))
+}

version.odin

@@ -0,0 +1,13 @@
+package main
+
+import "core:fmt"
+
+VERSION :: "0.2.0"
+
+cmd_version :: proc(cmd: ^Command) {
+	if has_flag(cmd, "long") || has_flag(cmd, "l") {
+		fmt.printf("envr version %s\n", VERSION)
+	} else {
+		fmt.println(VERSION)
+	}
+}