fix: fixing leaks.

.gitignore

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

.tokeignore

@@ -0,0 +1 @@
+**/*_test.{odin,go}

TODOS.md

@@ -0,0 +1,79 @@
+# TODO
+
+Note: These todos can wait until all the subcommands have been ported.
+
+## HIGH
+
+1. [x] **table.odin:74-89** — Hand-rolled JSON output doesn't escape `"`, `\`, newlines. Reimplements `json.marshal` which is already imported in `cmd_list.odin`. Replace with `json.marshal`.
+
+2. **db.odin:380-383, 405, 446** — `sqlite.bind_text` return values overwritten but never checked. A failed bind means `sqlite.step` operates on unbound params.
+
+3. **config.odin:52-54** — `os.user_home_dir` error silently ignored. If it fails, `home` is `""` and all paths become relative (`".envr"` instead of `"~/.envr"`).
+
+30. **cmd_sync.odin:46-50, 64-68** — Double `db_insert` when `BackedUp`: first insert on line 48, then `db_update_required` is also true for `BackedUp` so second insert runs on line 65. Redundant and wasteful.
+
+## MEDIUM
+
+4. **db.odin:29-35** — `make_temp_path` never calls `strings.builder_destroy`. Leaks builder buffer every call.
+
+5. **db.odin:324-327** — Map iteration (`remote_set`) is non-deterministic. Same file can produce different JSON on each backup, causing spurious DB diffs. Sort remotes before storing.
+
+6. **db.odin:470-473** — `string_to_cstring` allocates via `strings.clone_to_cstring` and never frees. Called dozens of times across db operations.
+
+7. **db.odin:470, 462** — Both `string_to_cstring` and `cstring_to_string` ignore allocation errors. A nil cstring gets passed to SQLite (UB).
+
+8. **db.odin:135, 250** — String interpolation into SQL (`VACUUM INTO '%s'`, `ATTACH DATABASE '%s'`). Currently safe because input is controlled, but fragile.
+
+9. **features.odin:30-41** — `find_binary` uses `strings.join` instead of `filepath.join`, uses `os.stat` instead of checking executability, hardcodes `:` as PATH separator (wrong on Windows).
+
+10. **cmd_restore.odin:20-30 & cmd_remove.odin:19-29** — Identical path-resolution block copy-pasted. `is_abs` guard is redundant since `filepath.abs` is a no-op on absolute paths. Extract a helper.
+
+11. **cmd_restore.odin:44** — `os.mkdir_all` error silently discarded. Subsequent write failure will be confusing.
+
+12. **cmd_edit_config.odin:27** — `$EDITOR` used as single binary name. Breaks for multi-word values like `"code -w"`. Needs `strings.fields()`.
+
+13. [x] **cmd_list.odin:31-35, 58-61** — Uses a `strings.Builder` (never destroyed) for what is just `row.Dir + "/"`. Also `filepath.rel` used where `filepath.base` would suffice since dir is always the parent.
+
+33. **config.odin:178** — `search_paths` silently ignores `os.user_home_dir` error. If home is empty, `~` isn't expanded. Same class of bug as issue 3.
+
+34. **table.odin:84-88** — `render_json_rows` creates `map[string]string` per row, copies into dynamic array. `delete(entries)` frees the array but not individual map internals — potential map bucket leak per row.
+
+35. **prompt.odin:124** — `make([dynamic]bool, len(options))` creates N zero-initialized elements. Works because `false` is the default, but same footgun as original issue 1. Should be `make([dynamic]bool, 0, len(options))`.
+
+## LOW
+
+14. [x] **db.odin:338-341** — Unnecessary `strings.clone` before `filepath.dir` (which already returns a slice into the input).
+
+15. **db.odin:115** — `json.unmarshal_string` error not checked. Malformed JSON silently produces empty/partial data.
+
+16. **db.odin:352-353** — `hex.encode` error ignored. `string(hex_bytes)` aliases the byte slice.
+
+18. **config.odin:51-60** — `envr_dir` recomputes home dir on every call. Could cache.
+
+19. **main.odin:42-46** — Dynamic array in `fallback_to_go` never deleted. Harmless since process exits.
+
+36. **cli.odin:59-76** — Single-dash multi-char flags (e.g. `-force`) silently misparse. `-force` becomes flag `f` with value `o`, then `rce` as positional arg. Only `--force` and `-f` work correctly.
+
+37. **cmd_sync.odin:80, cmd_list.odin:33, cmd_deps.odin:9** — `make([]string, 2)` for table rows never freed. Leaks per row. Defer to memory pass.
+
+## REFACTOR
+
+20. **cmd_list.odin** — Non-TTY branch builds `ListEntry` structs and marshals JSON separately. Now that `render_json_rows` (issue 1) accepts an `io.Writer` and uses `json.marshal`, unify both branches to use it. Note: will change JSON keys from `"directory"/"path"` to `"Directory"/"Path"`.
+
+21. Check for prealloc opportunities. i.e. `make([dynamic]string)` -> `make([dynamic]string, 5)`.
+
+22. Replace is_tty with terminal.is_terminal
+
+23. Add a text filter to the multi_select.
+
+24. Create backup / fallback fd.
+
+25. Add tests for untested commands.
+
+26. Add a global --config -c flag to use an alternate config.
+
+27. version --long Odin only prints version; Go also prints commit hash and build date
+
+28. 2 scan tests silently skip	Low	When fd isn't installed, tests pass without actually testing anything. These should use #assert to be sure that fd is in path.
+
+29. nushell completions?

app/config.go

@@ -51,7 +51,7 @@ func NewConfig(privateKeyPaths []string) Config {
 			Matcher: "\\.env",
 			Exclude: []string{
 				"*\\.envrc",
-				"\\.local/",
+				"\\.local",
 				"node_modules",
 				"vendor",
 			},

cli.odin

@@ -0,0 +1,226 @@
+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,
+	aliases: []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"}},
+	{"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", "", {}},
+}
+
+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
+}
+
+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
+		}
+		for a in c.aliases {
+			if a == name {
+				return c, true
+			}
+		}
+	}
+	return CommandInfo{}, false
+}
+
+command_help_text :: proc(name: string) -> (string, bool) {
+	info, found := find_command(name)
+	if !found {
+		return "", false
+	}
+
+	b: strings.Builder
+	strings.builder_init(&b)
+
+	fmt.sbprintf(&b, "Usage: %s [flags]\n\n", info.usage)
+	fmt.sbprintf(&b, "%s\n", info.short)
+
+	if len(info.aliases) > 0 {
+		fmt.sbprintf(&b, "\nAliases:\n  %s", info.name)
+		for a in info.aliases {
+			fmt.sbprintf(&b, ", %s", a)
+		}
+		fmt.sbprintf(&b, "\n")
+	}
+
+	if len(info.long) > 0 {
+		fmt.sbprintf(&b, "\n%s\n", info.long)
+	}
+
+	fmt.sbprintf(&b, "\nFlags:\n  -h, --help   help for %s\n", info.name)
+
+	s := strings.clone(strings.to_string(b))
+	strings.builder_destroy(&b)
+	return s, true
+}
+
+print_command_help :: proc(name: string) {
+	text, ok := command_help_text(name)
+	if !ok {
+		fmt.printf("Unknown command: %s\n", name)
+		print_usage()
+		return
+	}
+	fmt.println(text)
+}
+
+usage_text :: proc() -> string {
+	b: strings.Builder
+	strings.builder_init(&b)
+
+	fmt.sbprintf(&b, "envr keeps your .env synced to a local, age encrypted database.\n")
+	fmt.sbprintf(&b, "Is a safe and easy way to gather all your .env files in one place where they can\n")
+	fmt.sbprintf(&b, "easily be backed by another tool such as restic or git.\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "All your data is stored in ~/data.age\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Getting started is easy:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "1. Create your configuration file and set up encrypted storage:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr init\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "2. Scan for existing .env files:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr scan\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Select the files you want to back up from the interactive list.\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "3. Verify that it worked:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr list\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "4. After changing any of your .env files, update the backup with:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr sync\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "5. If you lose a repository, after re-cloning the repo into the same path it was\n")
+	fmt.sbprintf(&b, "at before, restore your backup with:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr restore ~/<path to repository>/.env\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Usage:\n")
+	fmt.sbprintf(&b, "  envr [command]\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Available Commands:\n")
+
+	for c in COMMANDS {
+		name_start := len(b.buf)
+		fmt.sbprintf(&b, "%s", c.name)
+		for a in c.aliases {
+			fmt.sbprintf(&b, ", %s", a)
+		}
+		name_len := len(b.buf) - name_start
+		padding := 20 - name_len
+		if padding > 0 {
+			for _ in 0..<padding {
+				strings.write_byte(&b, ' ')
+			}
+		}
+		fmt.sbprintf(&b, " %s\n", c.short)
+	}
+
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Flags:\n")
+	fmt.sbprintf(&b, "  -h, --help   help for envr\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Use \"envr [command] --help\" for more information about a command.\n")
+
+	s := strings.clone(strings.to_string(b))
+	strings.builder_destroy(&b)
+	return s
+}
+
+print_usage :: proc() {
+	fmt.print(usage_text())
+}

cli_test.odin

@@ -0,0 +1,130 @@
+package main
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_usage_text_contains_all_commands :: proc(t: ^testing.T) {
+	text := usage_text()
+
+	for c in COMMANDS {
+		testing.expect(
+			t,
+			strings.contains(text, c.name),
+			fmt.aprintf("usage_text missing command %q", c.name),
+		)
+		for a in c.aliases {
+			testing.expect(
+				t,
+				strings.contains(text, a),
+				fmt.aprintf("usage_text missing alias %q", a),
+			)
+		}
+	}
+}
+
+@(test)
+test_usage_text_contains_steps :: proc(t: ^testing.T) {
+	text := usage_text()
+
+	testing.expect(t, strings.contains(text, "1."), "missing step 1")
+	testing.expect(t, strings.contains(text, "2."), "missing step 2")
+	testing.expect(t, strings.contains(text, "3."), "missing step 3")
+	testing.expect(t, strings.contains(text, "4."), "missing step 4")
+	testing.expect(t, strings.contains(text, "5."), "missing step 5")
+	testing.expect(t, strings.contains(text, "> envr sync\n"), "step 4 missing 'envr sync'")
+	testing.expect(
+		t,
+		strings.contains(text, "> envr restore"),
+		"step 5 missing 'envr restore'",
+	)
+}
+
+@(test)
+test_usage_text_contains_flags_and_help_hint :: proc(t: ^testing.T) {
+	text := usage_text()
+
+	testing.expect(t, strings.contains(text, "Flags:"), "missing Flags section")
+	testing.expect(t, strings.contains(text, "--help"), "missing --help flag")
+	testing.expect(
+		t,
+		strings.contains(text, "Use \"envr [command] --help\""),
+		"missing help hint",
+	)
+}
+
+@(test)
+test_command_help_backup :: proc(t: ^testing.T) {
+	text, ok := command_help_text("backup")
+	testing.expect(t, ok, "command_help_text(\"backup\") returned false")
+
+	testing.expect(t, strings.contains(text, "Usage:"), "missing Usage line")
+	testing.expect(
+		t,
+		strings.contains(text, "envr backup <path>"),
+		"missing usage pattern",
+	)
+	testing.expect(
+		t,
+		strings.contains(text, "Aliases:"),
+		"missing Aliases section",
+	)
+	testing.expect(t, strings.contains(text, "add"), "missing 'add' alias")
+	testing.expect(t, strings.contains(text, "Flags:"), "missing Flags section")
+	testing.expect(
+		t,
+		strings.contains(text, "--help"),
+		"missing --help in flags",
+	)
+}
+
+@(test)
+test_command_help_add_alias :: proc(t: ^testing.T) {
+	text, ok := command_help_text("add")
+	testing.expect(t, ok, "command_help_text(\"add\") returned false")
+	testing.expect(
+		t,
+		strings.contains(text, "envr backup <path>"),
+		"'add' alias should resolve to backup usage",
+	)
+	testing.expect(t, strings.contains(text, "Aliases:"), "missing Aliases section")
+}
+
+@(test)
+test_command_help_init_no_aliases :: proc(t: ^testing.T) {
+	text, ok := command_help_text("init")
+	testing.expect(t, ok, "command_help_text(\"init\") returned false")
+
+	testing.expect(t, strings.contains(text, "Usage:"), "missing Usage line")
+	testing.expect(
+		t,
+		!strings.contains(text, "Aliases:"),
+		"init should not have Aliases section",
+	)
+	testing.expect(t, strings.contains(text, "Flags:"), "missing Flags section")
+	testing.expect(
+		t,
+		strings.contains(text, "help for init"),
+		"missing 'help for init'",
+	)
+}
+
+@(test)
+test_command_help_unknown :: proc(t: ^testing.T) {
+	text, ok := command_help_text("nonexistent")
+	testing.expect(t, !ok, "command_help_text(\"nonexistent\") should return false")
+	testing.expect(t, len(text) == 0, "text should be empty for unknown command")
+}
+
+@(test)
+test_command_help_version :: proc(t: ^testing.T) {
+	text, ok := command_help_text("version")
+	testing.expect(t, ok, "command_help_text(\"version\") returned false")
+	testing.expect(t, strings.contains(text, "Usage:"), "missing Usage line")
+	testing.expect(
+		t,
+		!strings.contains(text, "Aliases:"),
+		"version should not have Aliases section",
+	)
+}

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 {
+		print_command_help("backup")
+		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_check.odin

@@ -0,0 +1,84 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:strings"
+
+cmd_check :: proc(cmd: ^Command) {
+	feats := check_features()
+
+	check_path: string
+	if len(cmd.args) > 0 {
+		check_path = cmd.args[0]
+	} else {
+		cwd, cwd_err := os.get_working_directory(context.allocator)
+		if cwd_err != nil {
+			fmt.printf("Error getting current directory: %v\n", cwd_err)
+			return
+		}
+		check_path = cwd
+	}
+
+	abs_path: string
+	if filepath.is_abs(check_path) {
+		abs_path = check_path
+	} else {
+		resolved, abs_err := filepath.abs(check_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)
+
+	is_dir := os.is_directory(abs_path)
+
+	files_in_path: [dynamic]string
+
+	if is_dir {
+		if cant_scan(feats) {
+			fmt.println(
+				"Error: please install fd to use the check command (https://github.com/sharkdp/fd)",
+			)
+			return
+		}
+
+		scanned, scan_ok := scan_path(abs_path, db.cfg)
+		if !scan_ok {
+			fmt.println("Error scanning directory for .env files")
+			return
+		}
+		files_in_path = scanned
+	} else {
+		append(&files_in_path, abs_path)
+	}
+
+	db_files, list_ok := db_list(&db)
+	if !list_ok {
+		return
+	}
+
+	not_backed := find_unbacked(files_in_path[:], db_files[:])
+
+	if len(not_backed) == 0 {
+		if len(files_in_path) == 0 {
+			fmt.println("No .env files found in the specified directory.")
+		} else {
+			fmt.println("✓ All .env files in the directory are backed up.")
+		}
+	} else {
+		fmt.printf("Found %d .env file(s) that are not backed up:\n", len(not_backed))
+		for file in not_backed {
+			fmt.printf("  %s\n", file)
+		}
+		fmt.println("\nRun 'envr sync' to back up these files.")
+	}
+}
+

cmd_check_test.odin

@@ -0,0 +1,48 @@
+package main
+
+import "core:fmt"
+import "core:testing"
+
+@(test)
+test_find_unbacked_finds_missing :: proc(t: ^testing.T) {
+	local := []string{"/a/.env", "/b/.env", "/c/.env"}
+	db := []EnvFile{{Path = "/a/.env"}, {Path = "/b/.env"}}
+
+	result := find_unbacked(local, db[:])
+	testing.expect(t, len(result) == 1, fmt.aprintf("expected 1 unbacked, got %d", len(result)))
+	if len(result) > 0 {
+		testing.expect(
+			t,
+			result[0] == "/c/.env",
+			fmt.aprintf("expected /c/.env, got %s", result[0]),
+		)
+	}
+}
+
+@(test)
+test_find_unbacked_all_backed :: proc(t: ^testing.T) {
+	local := []string{"/a/.env", "/b/.env"}
+	db := []EnvFile{{Path = "/a/.env"}, {Path = "/b/.env"}}
+
+	result := find_unbacked(local, db[:])
+	testing.expect(t, len(result) == 0, fmt.aprintf("expected 0 unbacked, got %d", len(result)))
+}
+
+@(test)
+test_find_unbacked_no_local :: proc(t: ^testing.T) {
+	local: []string
+	db := []EnvFile{{Path = "/a/.env"}}
+
+	result := find_unbacked(local, db[:])
+	testing.expect(t, len(result) == 0, fmt.aprintf("expected 0 unbacked, got %d", len(result)))
+}
+
+@(test)
+test_find_unbacked_none_backed :: proc(t: ^testing.T) {
+	local := []string{"/a/.env", "/b/.env"}
+	db: []EnvFile
+
+	result := find_unbacked(local, db[:])
+	testing.expect(t, len(result) == 2, fmt.aprintf("expected 2 unbacked, got %d", len(result)))
+}
+

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_init.odin

@@ -0,0 +1,53 @@
+package main
+
+import "core:fmt"
+
+cmd_init :: proc(cmd: ^Command) {
+	force := has_flag(cmd, "force") || has_flag(cmd, "f")
+
+	_, cfg_exists := load_config()
+	if cfg_exists && !force {
+		fmt.println("You have already initialized envr.")
+		fmt.println("Run again with the --force flag if you want to reinitialize.")
+		return
+	}
+
+	keys, ok := find_ssh_private_keys()
+	if !ok {
+		return
+	}
+
+	if len(keys) == 0 {
+		fmt.println("No SSH private keys found in ~/.ssh")
+		return
+	}
+
+	selected, result := multi_select("Select SSH private keys:", keys[:])
+	if result == .Cancel {
+		fmt.println("\x1b[2mCancelled.\x1b[0m")
+		return
+	}
+
+	selected_paths := make([dynamic]string, 0, min(1, len(keys) / 2))
+	for i in 0 ..< len(keys) {
+		if selected[i] {
+			append(&selected_paths, keys[i])
+		}
+	}
+
+	if len(selected_paths) == 0 {
+		fmt.println("No SSH keys selected - Config not created")
+		return
+	}
+
+	cfg := new_config(selected_paths[:])
+	if !save_config(cfg, force = force) {
+		return
+	}
+
+	fmt.printf(
+		"Config initialized with %d SSH key(s). You are ready to use envr.\n",
+		len(selected_paths),
+	)
+}
+

cmd_list.odin

@@ -0,0 +1,57 @@
+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 {
+            dir_str := strings.concatenate({row.Dir, "/"})
+            filename := filepath.base(row.Path)
+            row_slice := make([]string, 2)
+            row_slice[0] = dir_str
+            row_slice[1] = filename
+            append(&table_rows, row_slice)
+        }
+
+        render_table(headers, table_rows[:])
+    } else {
+        entries: [dynamic]ListEntry
+        for row in rows {
+            filename := filepath.base(row.Path)
+            append(&entries, ListEntry{
+                Directory = strings.concatenate({row.Dir, "/"}),
+                Path = filename,
+            })
+        }
+
+        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_list_test.odin

@@ -0,0 +1,26 @@
+package main
+
+import "core:path/filepath"
+import "core:testing"
+
+@(test)
+test_filepath_base_equals_rel :: proc(t: ^testing.T) {
+	cases := []string{
+		"/home/user/.env",
+		"/home/user/project/.envrc",
+		"/tmp/foo",
+		"/a/b/c/d.txt",
+	}
+
+	for path in cases {
+		dir := filepath.dir(path)
+		rel, rel_err := filepath.rel(dir, path)
+		testing.expect(t, rel_err == nil, "filepath.rel returned an error")
+		base := filepath.base(path)
+		testing.expect(
+			t,
+			rel == base,
+			"filepath.rel(dir, path) should equal filepath.base(path)",
+		)
+	}
+}

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 {
+		print_command_help("remove")
+        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 {
+		print_command_help("restore")
+        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)
+}

cmd_scan.odin

@@ -0,0 +1,91 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+
+cmd_scan :: proc(cmd: ^Command) {
+	feats := check_features()
+	if cant_scan(feats) {
+		fmt.println(
+			"Error: please install fd to use the scan command (https://github.com/sharkdp/fd)",
+		)
+		return
+	}
+
+	db, db_ok := db_open()
+	if !db_ok {
+		return
+	}
+	defer db_close(&db)
+
+	search_dirs := search_paths(db.cfg)
+	if len(search_dirs) == 0 {
+		fmt.println("No search paths configured. Please run `envr init` or edit your config.")
+		return
+	}
+
+	// TODO: Figure out a sane default
+	all_files: [dynamic]string
+	for dir in search_dirs {
+		found, scan_ok := scan_path(dir, db.cfg)
+		if !scan_ok {
+			fmt.printf("Error scanning %s\n", dir)
+			continue
+		}
+		for f in found {
+			append(&all_files, f)
+		}
+	}
+
+	db_files, list_ok := db_list(&db)
+	if !list_ok {
+		return
+	}
+
+	files := find_unbacked(all_files[:], db_files[:])
+
+	if len(files) == 0 {
+		fmt.println("No .env files found to add.")
+		return
+	}
+
+	if !is_tty() {
+		output, marshal_err := json.marshal(files[:])
+		if marshal_err != nil {
+			fmt.printf("Error marshaling files to JSON: %v\n", marshal_err)
+			return
+		}
+		fmt.println(string(output))
+		return
+	}
+
+	selected, result := multi_select("Select .env files to backup:", files[:])
+	if result == .Cancel {
+		fmt.println("\x1b[2mCancelled.\x1b[0m")
+		return
+	}
+
+	added_count: int
+	for i in 0 ..< len(files) {
+		if !selected[i] {
+			continue
+		}
+		env_file, ok := new_env_file(files[i])
+		if !ok {
+			fmt.printf("Error reading %s\n", files[i])
+			continue
+		}
+		if !db_insert(&db, env_file) {
+			fmt.printf("Error adding %s\n", files[i])
+			continue
+		}
+		added_count += 1
+	}
+
+	if added_count > 0 {
+		fmt.printf("\x1b[1;32mSuccessfully added %d file(s) to backup.\x1b[0m\n", added_count)
+	} else {
+		fmt.println("\x1b[2mNo files were added.\x1b[0m")
+	}
+}
+

cmd_sync.odin

@@ -0,0 +1,95 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:strings"
+
+SyncEntry :: struct {
+	Path:   string `json:"path"`,
+	Status: string `json:"status"`,
+}
+
+cmd_sync :: proc(cmd: ^Command) {
+	db, db_ok := db_open()
+	if !db_ok {
+		return
+	}
+	defer db_close(&db)
+
+	files, list_ok := db_list(&db)
+	if !list_ok {
+		return
+	}
+	defer delete(files)
+
+	results: [dynamic]SyncEntry
+
+	for &file in files {
+		old_path: string
+		old_path, _ = strings.clone(file.Path)
+
+		result, err_msg := db_sync(&db, &file)
+
+		status: string
+		s := i32(result)
+		is_error := (s & i32(SyncResult.Error)) != 0
+		is_backed := (s & i32(SyncResult.BackedUp)) != 0
+		is_restored := (s & i32(SyncResult.Restored)) != 0
+		is_dir_updated := (s & i32(SyncResult.DirUpdated)) != 0
+
+		if is_error {
+			if len(err_msg) > 0 {
+				status = err_msg
+			} else {
+				status = "error"
+			}
+		} else if is_backed {
+			status = "Backed Up"
+			if !db_insert(&db, file) {
+				return
+			}
+		} else if is_restored {
+			status = "Restored"
+		} else if is_dir_updated && !is_restored {
+			status = "Moved"
+		} else {
+			status = "OK"
+		}
+
+		if is_dir_updated {
+			if !db_delete(&db, old_path) {
+				return
+			}
+		}
+		if db_update_required(result) {
+			if !db_insert(&db, file) {
+				return
+			}
+		}
+
+		path_str, _ := strings.clone(file.Path)
+		status_str, _ := strings.clone(status)
+		append(&results, SyncEntry{Path = path_str, Status = status_str})
+	}
+
+	if is_tty() {
+		headers := []string{"File", "Status"}
+		table_rows := make([dynamic][]string, 0, len(results))
+
+		for res in results {
+			row_slice := make([]string, 2)
+			row_slice[0] = res.Path
+			row_slice[1] = res.Status
+			append(&table_rows, row_slice)
+		}
+
+		render_table(headers, table_rows[:])
+	} else {
+		data, marshal_err := json.marshal(results[:])
+		if marshal_err != nil {
+			fmt.printf("Error marshaling JSON: %v\n", marshal_err)
+			return
+		}
+		fmt.println(string(data))
+	}
+}

config.odin

@@ -0,0 +1,216 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:strings"
+
+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
+}
+
+find_ssh_private_keys :: proc() -> (keys: [dynamic]string, ok: 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
+	}
+
+	ssh_dir, join_err := filepath.join([]string{home, ".ssh"})
+	if join_err != nil {
+		fmt.printf("Error building ssh path: %v\n", join_err)
+		return
+	}
+
+	entries, dir_err := os.read_all_directory_by_path(ssh_dir, context.allocator)
+	if dir_err != nil {
+		fmt.printf("Could not read ~/.ssh directory: %v\n", dir_err)
+		return
+	}
+	defer os.file_info_slice_delete(entries, context.allocator)
+
+	for entry in entries {
+		name := entry.name
+		if entry.type == .Directory {
+			continue
+		}
+		if strings.has_suffix(name, ".pub") {
+			continue
+		}
+		if strings.contains(name, "known_hosts") {
+			continue
+		}
+		if strings.contains(name, "config") {
+			continue
+		}
+
+		full_path, _ := filepath.join([]string{ssh_dir, name})
+		append(&keys, full_path)
+	}
+
+	ok = true
+	return
+}
+
+new_config :: proc(private_key_paths: []string) -> Config {
+	keys := make([dynamic]SshKeyPair, 0, len(private_key_paths))
+	for priv in private_key_paths {
+		pub, _ := strings.concatenate([]string{priv, ".pub"})
+		append(&keys, SshKeyPair{Private = priv, Public = pub})
+	}
+
+	exclude := make([dynamic]string, 0, 4)
+	append(&exclude, "*\\.envrc")
+	append(&exclude, "\\.local/")
+	append(&exclude, "node_modules")
+	append(&exclude, "vendor")
+
+	include := make([dynamic]string, 0, 1)
+	append(&include, "~")
+
+	scan_cfg := ScanConfig {
+		Matcher = "\\.env",
+		Exclude = exclude[:],
+		Include = include[:],
+	}
+
+	return Config{Keys = keys[:], ScanConfig = scan_cfg}
+}
+
+save_config :: proc(cfg: Config, force: bool = false) -> 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 false
+	}
+
+	config_dir, _ := filepath.join([]string{home, ".envr"})
+
+	if !os.exists(config_dir) {
+		mkdir_err := os.make_directory(config_dir)
+		if mkdir_err != nil {
+			fmt.printf("Error creating ~/.envr directory: %v\n", mkdir_err)
+			return false
+		}
+	}
+
+	config_path, _ := filepath.join([]string{config_dir, "config.json"})
+
+	if os.exists(config_path) && !force {
+		info, stat_err := os.stat(config_path, context.allocator)
+		if stat_err == nil {
+			defer os.file_info_delete(info, context.allocator)
+			if info.size > 0 {
+				fmt.println("Config file already exists. Run again with --force to reinitialize.")
+				return false
+			}
+		}
+	}
+
+	data, marshal_err := json.marshal(cfg, {pretty = true, use_spaces = true, spaces = 2})
+	if marshal_err != nil {
+		fmt.printf("Error marshaling config: %v\n", marshal_err)
+		return false
+	}
+
+	write_err := os.write_entire_file(config_path, data)
+	if write_err != nil {
+		fmt.printf("Error writing config: %v\n", write_err)
+		return false
+	}
+
+	return true
+}
+
+search_paths :: proc(cfg: Config) -> (paths: [dynamic]string) {
+	home, _ := os.user_home_dir(context.allocator)
+
+	for include in cfg.ScanConfig.Include {
+		expanded, _ := strings.replace(include, "~", home, 1)
+		cloned, _ := strings.clone(expanded)
+		if filepath.is_abs(cloned) {
+			append(&paths, cloned)
+		} else {
+			resolved, err := filepath.abs(cloned)
+			if err == nil {
+				append(&paths, resolved)
+			}
+		}
+	}
+	return
+}
+
+find_git_roots :: proc(cfg: Config) -> (roots: [dynamic]string, ok: bool) {
+	paths := search_paths(cfg)
+
+	for sp in paths {
+		args := []string{"fd", "-H", "-t", "d", "^\\.git$", sp}
+		lines, fd_ok := run_fd(args)
+		if !fd_ok {
+			return
+		}
+
+		for line in lines {
+			cleaned, _ := filepath.clean(line)
+			parent := filepath.dir(cleaned)
+			cloned, _ := strings.clone(parent)
+			append(&roots, cloned)
+		}
+	}
+
+	ok = true
+	return
+}
+

db.odin

@@ -0,0 +1,623 @@
+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"
+
+SyncResult :: enum i32 {
+    Noop = 0,
+    DirUpdated = 1,
+    Restored = 1 << 1,
+    BackedUp = 1 << 2,
+    Error = 1 << 3,
+}
+
+SyncDirection :: enum {
+    TrustDatabase,
+    TrustFilesystem,
+}
+
+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)
+
+    remotes := get_git_remotes(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 = 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
+}
+
+db_update_required :: proc(status: SyncResult) -> bool {
+    s := i32(status)
+    return (s & (i32(SyncResult.BackedUp) | i32(SyncResult.DirUpdated))) != 0
+}
+
+shares_remote :: proc(f: ^EnvFile, remotes: []string) -> bool {
+    remote_set: map[string]bool
+    for r in f.Remotes {
+        remote_set[r] = true
+    }
+    for r in remotes {
+        if r in remote_set {
+            return true
+        }
+    }
+    return false
+}
+
+update_dir :: proc(f: ^EnvFile, new_dir: string) {
+    f.Dir = new_dir
+    base := filepath.base(f.Path)
+    new_path, _ := strings.concatenate({new_dir, "/", base})
+    f.Path = new_path
+    f.Remotes = get_git_remotes(new_dir)
+}
+
+find_moved_dirs :: proc(d: ^Db, f: ^EnvFile) -> ([dynamic]string, bool) {
+    feats := check_features()
+    if .Fd not_in feats || .Git not_in feats {
+        fmt.println("Error: fd and git are required for moved dir detection")
+        return {}, false
+    }
+
+    roots, roots_ok := find_git_roots(d.cfg)
+    if !roots_ok {
+        return {}, false
+    }
+
+    moved: [dynamic]string
+    for root in roots {
+        remotes := get_git_remotes(root)
+        if shares_remote(f, remotes[:]) {
+            cloned, _ := strings.clone(root)
+            append(&moved, cloned)
+        }
+    }
+    return moved, true
+}
+
+env_file_backup :: proc(f: ^EnvFile) -> bool {
+    data, read_err := os.read_entire_file_from_path(f.Path, context.allocator)
+    if read_err != nil {
+        fmt.printf("Error reading file %s: %v\n", f.Path, read_err)
+        return false
+    }
+
+    f.contents = string(data)
+    digest := hash.hash_bytes(hash.Algorithm.SHA256, data)
+    hex_bytes, _ := hex.encode(digest)
+    f.Sha256 = string(hex_bytes)
+    return true
+}
+
+env_file_sync :: proc(f: ^EnvFile, dir: SyncDirection, d: ^Db) -> (SyncResult, string) {
+    result: SyncResult = .Noop
+    err_msg: string
+
+    _, stat_err := os.stat(f.Dir, context.allocator)
+    if stat_err != nil {
+        moved_dirs: [dynamic]string
+
+        if d != nil {
+            dirs, dirs_ok := find_moved_dirs(d, f)
+            if !dirs_ok {
+                return .Error, "failed to find moved dirs"
+            }
+            moved_dirs = dirs
+        }
+
+        if len(moved_dirs) == 0 {
+            return .Error, "directory missing"
+        } else if len(moved_dirs) == 1 {
+            update_dir(f, moved_dirs[0])
+            result = .DirUpdated
+        } else {
+            return .Error, "multiple directories found"
+        }
+    }
+
+    _, file_stat_err := os.stat(f.Path, context.allocator)
+    if file_stat_err != nil {
+        write_err := os.write_entire_file(f.Path, f.contents)
+        if write_err != nil {
+            msg, _ := strings.concatenate({"failed to write file: ", fmt.aprintf("%v", write_err)})
+            return .Error, msg
+        }
+
+        s := i32(result) | i32(SyncResult.Restored)
+        return SyncResult(s), ""
+    }
+
+    data, read_err := os.read_entire_file_from_path(f.Path, context.allocator)
+    if read_err != nil {
+        msg, _ := strings.concatenate({"failed to read file for SHA comparison: ", fmt.aprintf("%v", read_err)})
+        return .Error, msg
+    }
+
+    digest := hash.hash_bytes(hash.Algorithm.SHA256, data)
+    hex_bytes, _ := hex.encode(digest)
+    current_sha := string(hex_bytes)
+
+    if current_sha == f.Sha256 {
+        return result, ""
+    }
+
+    switch dir {
+    case .TrustDatabase:
+        write_err := os.write_entire_file(f.Path, f.contents)
+        if write_err != nil {
+            msg, _ := strings.concatenate({"failed to write file: ", fmt.aprintf("%v", write_err)})
+            return .Error, msg
+        }
+        s := i32(result) | i32(SyncResult.Restored)
+        return SyncResult(s), ""
+    case .TrustFilesystem:
+        if !env_file_backup(f) {
+            return .Error, "failed to backup file"
+        }
+        return .BackedUp, ""
+    }
+
+    return result, ""
+}
+
+db_sync :: proc(d: ^Db, f: ^EnvFile) -> (SyncResult, string) {
+    return env_file_sync(f, .TrustFilesystem, d)
+}

db_test.odin

@@ -0,0 +1,19 @@
+package main
+
+import "core:path/filepath"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_dir_slice_owns_parent :: proc(t: ^testing.T) {
+	abs_path := "/home/user/project/.env"
+	cloned_path, _ := strings.clone(abs_path)
+
+	dir := filepath.dir(cloned_path)
+
+	testing.expect(t, dir == "/home/user/project", "filepath.dir should return parent directory")
+	testing.expect(t, len(dir) > 0, "dir should not be empty")
+
+	cloned_dir, _ := strings.clone(dir)
+	testing.expect(t, cloned_dir == dir, "clone of dir should equal dir")
+}

features.odin

@@ -0,0 +1,55 @@
+package main
+
+import "base:runtime"
+import "core:mem"
+import "core:os"
+import "core:strings"
+
+Feature :: enum {
+	Git,
+	Fd,
+	Age,
+}
+
+AvailableFeatures :: bit_set[Feature]
+
+check_features :: proc() -> AvailableFeatures {
+	feats: AvailableFeatures
+
+	s: mem.Scratch
+	mem.scratch_init(&s, 4 * mem.DEFAULT_PAGE_SIZE)
+	defer mem.scratch_destroy(&s)
+
+	context.temp_allocator = mem.scratch_allocator(&s)
+
+	path_env := os.get_env("PATH", context.temp_allocator)
+	paths := strings.split(path_env, ":", context.temp_allocator)
+
+	if find_binary(paths, "git") != "" {
+		feats += {.Git}
+	}
+	if find_binary(paths, "fd") != "" {
+		feats += {.Fd}
+	}
+	if find_binary(paths, "age") != "" {
+		feats += {.Age}
+	}
+
+	return feats
+}
+
+find_binary :: proc(
+	paths: []string,
+	name: string,
+	allocator: runtime.Allocator = context.temp_allocator,
+) -> string {
+	for p in paths {
+		candidate := strings.join({strings.trim_right(p, "/"), name}, "/", allocator)
+		_, err := os.stat(candidate, allocator)
+		if err == nil {
+			return candidate
+		}
+	}
+	return ""
+}
+

features_test.odin

@@ -0,0 +1,34 @@
+package main
+
+import "core:os"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_find_binary_exists :: proc(t: ^testing.T) {
+	path := os.get_env("PATH", context.allocator)
+	paths := strings.split(path, ":")
+
+	result := find_binary(paths, "sh")
+	testing.expect(t, result != "", "sh should be found on PATH")
+}
+
+@(test)
+test_find_binary_not_exists :: proc(t: ^testing.T) {
+	old_path := os.get_env("PATH", context.allocator)
+	defer {
+		if old_path != "" {
+			os.set_env("PATH", old_path)
+		}
+	}
+
+	os.set_env("PATH", "/tmp/envr-nope")
+
+	path := os.get_env("PATH", context.allocator)
+	paths := strings.split(path, ":")
+
+
+	result := find_binary(paths, "no_such_binary_xyz")
+	testing.expect(t, result == "", "nonexistent binary should not be found")
+}
+

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,42 @@
+package main
+
+import "core:fmt"
+import "core:os"
+
+main :: proc() {
+	cmd, ok := parse_args()
+	if !ok {
+		return
+	}
+
+	switch cmd.name {
+	case "init":
+		cmd_init(&cmd)
+	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 "check":
+		cmd_check(&cmd)
+	case "scan":
+		cmd_scan(&cmd)
+	case "sync":
+		cmd_sync(&cmd)
+	case:
+		fmt.printf("Unknown command: %s\n", cmd.name)
+		print_usage()
+		os.exit(1)
+	}
+}
+
+

prompt.odin

@@ -0,0 +1,193 @@
+package main
+
+import "core:fmt"
+import "core:sys/posix"
+
+Raw_State :: struct {
+	original: posix.termios,
+	fd:       posix.FD,
+}
+
+enable_raw_mode :: proc(fd: posix.FD) -> (Raw_State, bool) {
+	state: Raw_State
+	state.fd = fd
+
+	if posix.tcgetattr(fd, &state.original) != .OK {
+		return state, false
+	}
+
+	attr: posix.termios = state.original
+	attr.c_lflag -= {.ICANON, .ECHO, .ISIG, .IEXTEN}
+	attr.c_iflag -= {.IXON, .ICRNL, .BRKINT, .INPCK, .ISTRIP}
+	attr.c_oflag -= {.OPOST}
+	attr.c_cflag += {.CS8}
+	attr.c_cc[.VMIN] = 1
+	attr.c_cc[.VTIME] = 0
+
+	if posix.tcsetattr(fd, .TCSAFLUSH, &attr) != .OK {
+		return state, false
+	}
+
+	return state, true
+}
+
+disable_raw_mode :: proc(state: ^Raw_State) {
+	posix.tcsetattr(state.fd, .TCSAFLUSH, &state.original)
+}
+
+Key :: enum {
+	Up,
+	Down,
+	Space,
+	Enter,
+	Escape,
+	Unknown,
+}
+
+read_key :: proc() -> Key {
+	buf: [3]u8
+
+	n := posix.read(posix.STDIN_FILENO, &buf[0], 1)
+	if n <= 0 {
+		return .Unknown
+	}
+
+	switch buf[0] {
+	case ' ':
+		return .Space
+	case '\n', '\r':
+		return .Enter
+	case 0x03:
+		return .Escape
+	case 0x1b:
+		tv: posix.timeval
+		tv.tv_sec = 0
+		tv.tv_usec = posix.suseconds_t(100000)
+
+		set: posix.fd_set
+		posix.FD_ZERO(&set)
+		posix.FD_SET(posix.STDIN_FILENO, &set)
+
+		ready := posix.select(1, &set, nil, nil, &tv)
+		if ready <= 0 {
+			return .Escape
+		}
+
+		n2 := posix.read(posix.STDIN_FILENO, &buf[1], 1)
+		if n2 <= 0 || buf[1] != '[' {
+			return .Escape
+		}
+
+		posix.FD_ZERO(&set)
+		posix.FD_SET(posix.STDIN_FILENO, &set)
+		tv.tv_sec = 0
+		tv.tv_usec = posix.suseconds_t(100000)
+
+		ready = posix.select(1, &set, nil, nil, &tv)
+		if ready <= 0 {
+			return .Escape
+		}
+
+		n3 := posix.read(posix.STDIN_FILENO, &buf[2], 1)
+		if n3 <= 0 {
+			return .Escape
+		}
+
+		switch buf[2] {
+		case 'A':
+			return .Up
+		case 'B':
+			return .Down
+		case:
+			return .Escape
+		}
+	case:
+		return .Unknown
+	}
+}
+
+MultiSelect_Result :: enum {
+	Confirm,
+	Cancel,
+}
+
+MAX_VISIBLE :: 7
+
+multi_select :: proc(
+	prompt: string,
+	options: []string,
+) -> (selected: [dynamic]bool, result: MultiSelect_Result) {
+	if len(options) == 0 {
+		return
+	}
+
+	selected = make([dynamic]bool, len(options))
+	cursor: int = 0
+	scroll_offset: int = 0
+
+	fmt.printf("\x1b[?25l")
+	visible := render_options(prompt, options, selected[:], cursor, scroll_offset)
+
+	raw, ok := enable_raw_mode(posix.STDIN_FILENO)
+	if !ok {
+		fmt.printf("\x1b[?25h")
+		return
+	}
+	defer disable_raw_mode(&raw)
+
+	for {
+		key := read_key()
+
+		switch key {
+		case .Up:
+			if cursor > 0 {
+				cursor -= 1
+			}
+		case .Down:
+			if cursor < len(options) - 1 {
+				cursor += 1
+			}
+		case .Space:
+			selected[cursor] = !selected[cursor]
+		case .Enter:
+			fmt.printf("\x1b[%dA\x1b[J\x1b[?25h", visible + 1)
+			result = .Confirm
+			return
+		case .Escape:
+			fmt.printf("\x1b[%dA\x1b[J\x1b[?25h", visible + 1)
+			result = .Cancel
+			return
+		case .Unknown:
+		}
+
+		scroll_offset = max(0, min(cursor - MAX_VISIBLE / 2, len(options) - MAX_VISIBLE))
+		fmt.printf("\x1b[%dA\x1b[0J", visible + 1)
+		visible = render_options(prompt, options, selected[:], cursor, scroll_offset)
+	}
+}
+
+render_options :: proc(prompt: string, options: []string, selected: []bool, cursor: int, scroll_offset: int) -> int {
+	fmt.printf(
+		"\x1b[1;36m%s\x1b[0m (↑/↓ move, space select, enter confirm)\r\n",
+		prompt,
+	)
+
+	end := scroll_offset + MAX_VISIBLE
+	if end > len(options) {
+		end = len(options)
+	}
+
+	for i in scroll_offset..<end {
+		checkbox := " "
+		if selected[i] {
+			checkbox = "x"
+		}
+		if i == cursor {
+			fmt.printf("\x1b[1;32m> \x1b[0m[\x1b[32m%s\x1b[0m] %s\r\n", checkbox, options[i])
+		} else {
+			fmt.printf("  [\x1b[2m%s\x1b[0m] %s\r\n", checkbox, options[i])
+		}
+	}
+
+	return end - scroll_offset
+}

scan.odin

@@ -0,0 +1,145 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+import "core:sync"
+
+fd_counter: sync.Atomic_Mutex
+fd_seq: int
+
+// Caller is responsible for freeing paths
+scan_path :: proc(search_path: string, cfg: Config) -> (paths: [dynamic]string, ok: bool) {
+	if is_tty() {
+		fmt.printf("Searching for all files in \"%s\"...\n", search_path)
+	}
+	all_files, all_ok := run_fd(build_fd_args(search_path, cfg, true))
+	if !all_ok {
+		return
+	}
+
+	if is_tty() {
+		fmt.printf("Search for unignored fies in \"%s\"...\n", search_path)
+	}
+	unignored_files, unignored_ok := run_fd(build_fd_args(search_path, cfg, false))
+	if !unignored_ok {
+		return
+	}
+
+	unignored_set := make(map[string]bool, len(unignored_files), context.temp_allocator)
+	for file in unignored_files {
+		unignored_set[file] = true
+	}
+
+	for file in all_files {
+		if !(file in unignored_set) {
+			append(&paths, file)
+		}
+	}
+
+	ok = true
+	return
+}
+
+@(private = "file")
+build_fd_args :: proc(search_path: string, cfg: Config, include_ignored: bool) -> []string {
+	args_len := 3 + 2 * len(cfg.ScanConfig.Exclude) + 2
+	args := make([dynamic]string, 0, args_len, context.temp_allocator)
+	append(&args, "fd")
+	append(&args, "-a")
+	append(&args, cfg.ScanConfig.Matcher)
+
+	for exclude in cfg.ScanConfig.Exclude {
+		append(&args, "-E")
+		append(&args, exclude)
+	}
+
+	if include_ignored {
+		append(&args, "-HI")
+	} else {
+		append(&args, "-H")
+	}
+
+	append(&args, search_path)
+	return args[:]
+}
+
+run_fd :: proc(args: []string) -> (lines: []string, ok: bool) {
+	tmp_path := next_fd_tmp_path()
+	tmp_file, tmp_err := os.open(tmp_path, os.O_CREATE | os.O_WRONLY | os.O_TRUNC)
+	if tmp_err != nil {
+		return
+	}
+
+	desc := os.Process_Desc {
+		command = args,
+		stdout  = tmp_file,
+		stderr  = nil,
+	}
+
+	p, start_err := os.process_start(desc)
+	os.close(tmp_file)
+	if start_err != nil {
+		os.remove(tmp_path)
+		return
+	}
+
+	state, wait_err := os.process_wait(p)
+	if wait_err != nil || state.exit_code != 0 {
+		os.remove(tmp_path)
+		return
+	}
+
+	data, read_err := os.read_entire_file_from_path(tmp_path, context.temp_allocator)
+	os.remove(tmp_path)
+	if read_err != nil {
+		return
+	}
+
+	output := string(data)
+	output = strings.trim_space(output)
+	if len(output) == 0 {
+		ok = true
+		return
+	}
+
+	raw_lines := strings.split(output, "\n", context.temp_allocator)
+	result := make([dynamic]string, 0, len(raw_lines), context.temp_allocator)
+	for line in raw_lines {
+		trimmed := strings.trim_space(line)
+		if len(trimmed) > 0 {
+			append(&result, trimmed)
+		}
+	}
+
+	return result[:], true
+}
+
+@(private = "file")
+next_fd_tmp_path :: proc() -> string {
+	sync.atomic_mutex_lock(&fd_counter)
+	n := fd_seq
+	fd_seq += 1
+	sync.atomic_mutex_unlock(&fd_counter)
+	return fmt.aprintf("/tmp/envr-fd-%d-%d", os.get_pid(), n, allocator = context.temp_allocator)
+}
+
+cant_scan :: proc(feats: AvailableFeatures) -> bool {
+	return Feature.Fd not_in feats
+}
+
+find_unbacked :: proc(local_files: []string, db_files: []EnvFile) -> []string {
+	backed_set := make(map[string]bool, len(db_files), context.temp_allocator)
+	for file in db_files {
+		backed_set[file.Path] = true
+	}
+
+	unbacked := make([dynamic]string, 0, len(db_files) / 2, context.temp_allocator)
+	for file in local_files {
+		if !(file in backed_set) {
+			append(&unbacked, file)
+		}
+	}
+	return unbacked[:]
+}
+

scan_test.odin

@@ -0,0 +1,87 @@
+package main
+
+import "core:fmt"
+import "core:os"
+import "core:path/filepath"
+import "core:testing"
+
+@(test)
+test_scan_path_finds_gitignored_env_files :: proc(t: ^testing.T) {
+	feats := check_features()
+	testing.expect(t, cant_scan(feats) == false)
+
+	base := fmt.aprintf("/tmp/envr-scan-test-%d", os.get_pid())
+	os.mkdir_all(base)
+	defer os.remove_all(base)
+
+	git_init := os.Process_Desc {
+		command     = []string{"git", "-c", "advice.defaultBranchName=false", "init"},
+		working_dir = base,
+		stdout      = os.stderr,
+		stderr      = os.stderr,
+	}
+	p, err := os.process_start(git_init)
+	if err != nil {
+		return
+	}
+	_, wait_err := os.process_wait(p)
+	if wait_err != nil {
+		return
+	}
+
+	gitignore_path := fmt.aprintf("%s/.gitignore", base)
+	_ = os.write_entire_file(gitignore_path, ".env*\n")
+
+	_ = os.write_entire_file(fmt.aprintf("%s/.env", base), "SECRET=1")
+	_ = os.write_entire_file(fmt.aprintf("%s/.env.testing", base), "TEST=1")
+	_ = os.write_entire_file(fmt.aprintf("%s/config.yaml", base), "key: value")
+
+	cfg := Config {
+		ScanConfig = ScanConfig{Matcher = "\\.env", Exclude = []string{}, Include = []string{}},
+	}
+
+	results, ok := scan_path(base, cfg)
+	defer delete(results)
+	testing.expect(t, ok, "scan_path should succeed")
+
+	found_env := false
+	found_testing := false
+	found_config := false
+
+	for path in results {
+		_, filename := filepath.split(path)
+		if filename == ".env" {
+			found_env = true
+		}
+		if filename == ".env.testing" {
+			found_testing = true
+		}
+		if filename == "config.yaml" {
+			found_config = true
+		}
+	}
+
+	testing.expect(t, found_env, "should find .env (gitignored)")
+	testing.expect(t, found_testing, "should find .env.testing (gitignored)")
+	testing.expect(t, !found_config, "should NOT find config.yaml (not gitignored)")
+}
+
+@(test)
+test_scan_path_empty_dir :: proc(t: ^testing.T) {
+	feats := check_features()
+	testing.expect(t, cant_scan(feats) == false)
+
+	base := fmt.aprintf("/tmp/envr-scan-empty-%d", os.get_pid())
+	os.mkdir_all(base)
+	defer os.remove_all(base)
+
+	cfg := Config {
+		ScanConfig = ScanConfig{Matcher = "\\.env", Exclude = []string{}, Include = []string{}},
+	}
+
+	results, ok := scan_path(base, cfg)
+	defer delete(results)
+	testing.expect(t, ok, "scan_path should succeed")
+	testing.expect(t, len(results) == 0, fmt.aprintf("expected 0 results, got %d", len(results)))
+}
+

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 ---
+}

table.odin

@@ -0,0 +1,97 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:io"
+import "core:os"
+import "core:strings"
+
+render_table :: proc(headers: []string, rows: [][]string) {
+	if !is_tty() {
+		w := io.to_writer(os.to_writer(os.stdout))
+		render_json_rows(w, headers, rows)
+		io.write_string(w, "\n")
+		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(w: io.Writer, headers: []string, rows: [][]string) {
+	entries := make([dynamic]map[string]string, 0, len(rows))
+	defer delete(entries)
+
+	for row in rows {
+		entry: map[string]string
+		for i in 0..<len(headers) {
+			entry[headers[i]] = row[i]
+		}
+		append(&entries, entry)
+	}
+
+	data, err := json.marshal(entries[:])
+	if err != nil {
+		fmt.eprintf("Error marshaling JSON: %v\n", err)
+		return
+	}
+	io.write_string(w, string(data))
+}

table_test.odin

@@ -0,0 +1,101 @@
+package main
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:io"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_render_json_rows_normal :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	headers := []string{"name", "path"}
+	rows := [][]string{{"foo", "/home/user/.env"}, {"bar", "/home/user/project/.env"}}
+
+	w := strings.to_writer(&b)
+	render_json_rows(w, headers, rows)
+
+	output := strings.to_string(b)
+
+	result: []map[string]string
+	unmarshal_err := json.unmarshal_string(output, &result)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.aprintf("json unmarshal failed: %v\noutput was: %q", unmarshal_err, output),
+	)
+	testing.expect(t, len(result) == 2, fmt.aprintf("expected 2 rows, got %d", len(result)))
+	testing.expect(
+		t,
+		result[0]["name"] == "foo",
+		fmt.aprintf("expected name=foo, got %q", result[0]["name"]),
+	)
+	testing.expect(t, result[0]["path"] == "/home/user/.env")
+	testing.expect(t, result[1]["name"] == "bar")
+	testing.expect(t, result[1]["path"] == "/home/user/project/.env")
+}
+
+@(test)
+test_render_json_rows_special_chars :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	headers := []string{"key", "value"}
+	rows := [][]string {
+		{"quote", `has "double quotes"`},
+		{"backslash", `path\to\file`},
+		{"newline", "line1\nline2"},
+		{"mixed", `a "b" c\nd`},
+	}
+
+	w := strings.to_writer(&b)
+	render_json_rows(w, headers, rows)
+
+	output := strings.to_string(b)
+
+	result: []map[string]string
+	unmarshal_err := json.unmarshal(transmute([]byte)output, &result)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.aprintf("json unmarshal failed: %v\noutput was: %q", unmarshal_err, output),
+	)
+	testing.expect(t, len(result) == 4)
+	testing.expect(
+		t,
+		result[0]["value"] == `has "double quotes"`,
+		fmt.aprintf("got %q", result[0]["value"]),
+	)
+	testing.expect(t, result[1]["value"] == `path\to\file`)
+	testing.expect(t, result[2]["value"] == "line1\nline2")
+	testing.expect(t, result[3]["value"] == `a "b" c\nd`)
+}
+
+@(test)
+test_render_json_rows_empty :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	headers := []string{"name"}
+	rows: [][]string
+
+	w := strings.to_writer(&b)
+	render_json_rows(w, headers, rows)
+
+	output := strings.to_string(b)
+
+	result: []map[string]string
+	unmarshal_err := json.unmarshal_string(output, &result)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.aprintf("json unmarshal failed: %v\noutput was: %q", unmarshal_err, output),
+	)
+	testing.expect(t, len(result) == 0)
+}
+

tty.odin

@@ -0,0 +1,8 @@
+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)
+	}
+}