feat: init command.

.envrc

@@ -1,3 +1,4 @@
 use flake
 
-export PATH=".:/home/spencer/github.com/envr-zig/deps/zig:/home/spencer/github.com/envr-zig/deps/zls:$PATH"
+ROOT="/home/spencer/github.com/envr-zig"
+export PATH=".:${ROOT}/deps/zig:${ROOT}/deps/zls:$PATH"

.gitignore

@@ -1,5 +1,6 @@
 # dev env
 .direnv
+/.env
 
 # dependencies
 deps

.tokeignore

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

TODOS.md

@@ -0,0 +1,69 @@
+# 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()`.
+
+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.
+
+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.
+
+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.

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,246 @@
+package main
+
+import "core:bufio"
+import "core:fmt"
+import "core:io"
+import "core:mem"
+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", "", {}},
+	{"nushell-completion", "envr nushell-completion", "Generate custom completions for nushell", "", {}},
+}
+
+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
+}
+
+write_command_help :: proc(name: string, w: io.Writer) -> bool {
+	info, found := find_command(name)
+	if !found {
+		return false
+	}
+
+	fmt.wprintf(w, "Usage: %s [flags]\n\n", info.usage, flush = false)
+	fmt.wprintf(w, "%s\n", info.short, flush = false)
+
+	if len(info.aliases) > 0 {
+		fmt.wprintf(w, "\nAliases:\n  %s", info.name, flush = false)
+		for a in info.aliases {
+			fmt.wprintf(w, ", %s", a, flush = false)
+		}
+		fmt.wprintf(w, "\n", flush = false)
+	}
+
+	if len(info.long) > 0 {
+		fmt.wprintf(w, "\n%s\n", info.long, flush = false)
+	}
+
+	fmt.wprintf(w, "\nFlags:\n  -h, --help   help for %s\n", info.name, flush = false)
+	return true
+}
+
+print_command_help :: proc(name: string) {
+	bw: bufio.Writer
+	bufio.writer_init(&bw, io.to_writer(os.to_writer(os.stdout)), mem.DEFAULT_PAGE_SIZE)
+	defer bufio.writer_destroy(&bw)
+
+	w := bufio.writer_to_writer(&bw)
+	ok := write_command_help(name, w)
+	if !ok {
+		fmt.printf("Unknown command: %s\n", name)
+		print_usage()
+	}
+	bufio.writer_flush(&bw)
+}
+
+write_usage :: proc(w: io.Writer) {
+	fmt.wprintf(
+		w,
+		`envr keeps your .env synced to a local, age encrypted database.
+Is a safe and easy way to gather all your .env files in one place where they can
+easily be backed by another tool such as restic or git.
+
+All your data is stored in ~/data.age
+
+Getting started is easy:
+
+1. Create your configuration file and set up encrypted storage:
+
+> envr init
+
+2. Scan for existing .env files:
+
+> envr scan
+
+Select the files you want to back up from the interactive list.
+
+3. Verify that it worked:
+
+> envr list
+
+4. After changing any of your .env files, update the backup with:
+
+> envr sync
+
+5. If you lose a repository, after re-cloning the repo into the same path it was
+at before, restore your backup with:
+
+> envr restore ~/<path to repository>/.env
+
+Usage:
+  envr [command]
+
+Available Commands:
+`,
+		flush = false,
+	)
+
+	for c in COMMANDS {
+		name_start := len(c.name)
+		fmt.wprintf(w, "%s", c.name, flush = false)
+		for a in c.aliases {
+			fmt.wprintf(w, ", %s", a, flush = false)
+			name_start += len(a) + 2
+		}
+		padding := 20 - name_start
+		if padding > 0 {
+			for _ in 0 ..< padding {
+				io.write_byte(w, ' ')
+			}
+		}
+		fmt.wprintf(w, " %s\n", c.short, flush = false)
+	}
+
+	fmt.wprintf(
+		w,
+		`
+Flags:
+  -h, --help   help for envr
+
+Use "envr [command] --help" for more information about a command.
+`,
+		flush = false,
+	)
+}
+
+// TODO: Look at usages,might want to pass a writer
+print_usage :: proc() {
+	bw: bufio.Writer
+	bufio.writer_init(&bw, io.to_writer(os.to_writer(os.stdout)), mem.DEFAULT_PAGE_SIZE)
+	defer bufio.writer_destroy(&bw)
+	defer bufio.writer_flush(&bw)
+
+	write_usage(bufio.writer_to_writer(&bw))
+}
+

cli_test.odin

@@ -0,0 +1,191 @@
+#+feature dynamic-literals
+package main
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_usage_text_contains_all_commands :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	write_usage(strings.to_writer(&b))
+	text := strings.to_string(b)
+
+	for c in COMMANDS {
+		testing.expect(
+			t,
+			strings.contains(text, c.name),
+			fmt.tprintf("usage missing command %q", c.name),
+		)
+		for a in c.aliases {
+			testing.expect(t, strings.contains(text, a), fmt.tprintf("usage missing alias %q", a))
+		}
+	}
+}
+
+@(test)
+test_usage_text_contains_steps :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	write_usage(strings.to_writer(&b))
+	text := strings.to_string(b)
+
+	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) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	write_usage(strings.to_writer(&b))
+	text := strings.to_string(b)
+
+	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) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	ok := write_command_help("backup", strings.to_writer(&b))
+	testing.expect(t, ok, "write_command_help(\"backup\") returned false")
+
+	text := strings.to_string(b)
+	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) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	ok := write_command_help("add", strings.to_writer(&b))
+	testing.expect(t, ok, "write_command_help(\"add\") returned false")
+
+	text := strings.to_string(b)
+	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) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	ok := write_command_help("init", strings.to_writer(&b))
+	testing.expect(t, ok, "write_command_help(\"init\") returned false")
+
+	text := strings.to_string(b)
+	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) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	ok := write_command_help("nonexistent", strings.to_writer(&b))
+	testing.expect(t, !ok, "write_command_help(\"nonexistent\") should return false")
+
+	text := strings.to_string(b)
+	testing.expect(t, len(text) == 0, "text should be empty for unknown command")
+}
+
+@(test)
+test_command_help_version :: proc(t: ^testing.T) {
+	b: strings.Builder
+	strings.builder_init(&b)
+	defer strings.builder_destroy(&b)
+
+	ok := write_command_help("version", strings.to_writer(&b))
+	testing.expect(t, ok, "write_command_help(\"version\") returned false")
+
+	text := strings.to_string(b)
+	testing.expect(t, strings.contains(text, "Usage:"), "missing Usage line")
+	testing.expect(
+		t,
+		!strings.contains(text, "Aliases:"),
+		"version should not have Aliases section",
+	)
+}
+
+@(test)
+test_has_flag_bool_set :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		bool_set = map[string]bool{"force" = true},
+	}
+	defer delete(cmd.bool_set)
+
+	testing.expect(t, has_flag(&cmd, "force"), "should find flag in bool_set")
+	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_value_map :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		flags = map[string]string{"output" = "/tmp/out"},
+	}
+	defer delete(cmd.flags)
+
+	testing.expect(t, has_flag(&cmd, "output"), "should find flag in flags map")
+	testing.expect(t, !has_flag(&cmd, "force"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_both_maps :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+		flags = map[string]string{"output" = "/tmp/out"},
+		bool_set = map[string]bool{"force" = true},
+	}
+	defer delete(cmd.flags)
+	defer delete(cmd.bool_set)
+
+	testing.expect(t, has_flag(&cmd, "output"), "should find in flags")
+	testing.expect(t, has_flag(&cmd, "force"), "should find in bool_set")
+	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
+}
+
+@(test)
+test_has_flag_empty_command :: proc(t: ^testing.T) {
+	cmd := Command {
+		name = "test",
+	}
+	testing.expect(t, !has_flag(&cmd, "anything"), "empty command should have no flags")
+}
+
+

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.tprintf("expected 1 unbacked, got %d", len(result)))
+	if len(result) > 0 {
+		testing.expect(
+			t,
+			result[0] == "/c/.env",
+			fmt.tprintf("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.tprintf("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.tprintf("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.tprintf("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,18 @@
+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, context.temp_allocator)
+		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_nushell_completion.odin

@@ -0,0 +1,9 @@
+package main
+
+import "core:fmt"
+
+COMPLETION_SCRIPT: string : string(#load("mod.nu"))
+
+cmd_nushell_completion :: proc(cmd: ^Command) {
+	fmt.print(COMPLETION_SCRIPT)
+}

cmd_nushell_completion_test.odin

@@ -0,0 +1,36 @@
+package main
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+@(test)
+test_nushell_completion_nonempty :: proc(t: ^testing.T) {
+	testing.expect(t, len(COMPLETION_SCRIPT) > 0, "completion script should not be empty")
+}
+
+@(test)
+test_nushell_completion_contains_externs :: proc(t: ^testing.T) {
+	expected := []string{
+		"tracked-paths",
+		"untracked-paths",
+		"envr backup",
+		"envr check",
+		"envr edit-config",
+		"envr help",
+		"envr init",
+		"envr list",
+		"envr remove",
+		"envr restore",
+		"envr scan",
+		"envr sync",
+		"envr nushell-completion",
+	}
+	for ext in expected {
+		testing.expect(
+			t,
+			strings.contains(COMPLETION_SCRIPT, ext),
+			fmt.tprintf("expected script to contain %q", ext),
+		)
+	}
+}

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,223 @@
+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: [dynamic]string `json:"exclude"`,
+	Include: [dynamic]string `json:"include"`,
+}
+
+Config :: struct {
+	Keys:       [dynamic]SshKeyPair `json:"keys"`,
+	ScanConfig: ScanConfig `json:"scan"`,
+}
+
+load_config :: proc() -> (Config, bool) {
+	home, home_err := os.user_home_dir(context.temp_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
+}
+
+delete_config :: proc(cfg: Config) {
+	delete(cfg.Keys)
+	delete(cfg.ScanConfig.Exclude)
+	delete(cfg.ScanConfig.Include)
+}
+
+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 {
+		// TODO: Is this bad?
+		pub, _ := strings.concatenate([]string{priv, ".pub"}, context.temp_allocator)
+		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
+}
+

config_test.odin

@@ -0,0 +1,63 @@
+package main
+
+import "core:testing"
+
+@(test)
+test_new_config_single_key :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 1, "should have 1 key")
+	testing.expect(t, cfg.Keys[0].Private == "/home/user/.ssh/id_ed25519", "Private path mismatch")
+	testing.expect(
+		t,
+		cfg.Keys[0].Public == "/home/user/.ssh/id_ed25519.pub",
+		"Public path mismatch",
+	)
+}
+
+@(test)
+test_new_config_multiple_keys :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519", "/home/user/.ssh/id_rsa"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 2, "should have 2 keys")
+	testing.expect(t, cfg.Keys[0].Private == "/home/user/.ssh/id_ed25519")
+	testing.expect(t, cfg.Keys[1].Private == "/home/user/.ssh/id_rsa")
+}
+
+@(test)
+test_new_config_empty_keys :: proc(t: ^testing.T) {
+	paths: []string
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, len(cfg.Keys) == 0, "should have 0 keys")
+}
+
+@(test)
+test_new_config_scan_defaults :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	testing.expect(t, cfg.ScanConfig.Matcher == "\\.env", "matcher should be \\.env")
+	testing.expect(t, len(cfg.ScanConfig.Exclude) == 4, "should have 4 exclude patterns")
+	testing.expect(t, len(cfg.ScanConfig.Include) == 1, "should have 1 include path")
+	testing.expect(t, cfg.ScanConfig.Include[0] == "~", "include should be ~")
+}
+
+@(test)
+test_new_config_exclude_patterns :: proc(t: ^testing.T) {
+	paths := []string{"/home/user/.ssh/id_ed25519"}
+	cfg := new_config(paths)
+	defer delete_config(cfg)
+
+	expected := []string{"*\\.envrc", "\\.local/", "node_modules", "vendor"}
+	for i in 0 ..< len(expected) {
+		testing.expect(t, cfg.ScanConfig.Exclude[i] == expected[i])
+	}
+}
+

db.odin

@@ -0,0 +1,635 @@
+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 {
+	for r1 in f.Remotes {
+		for r2 in remotes {
+			if r1 == r2 {
+				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.tprintf("%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.tprintf("%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.tprintf("%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,90 @@
+package main
+
+import "core:testing"
+
+@(test)
+test_db_update_required_noop :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Noop), "Noop should not require update")
+}
+
+@(test)
+test_db_update_required_backed_up :: proc(t: ^testing.T) {
+	testing.expect(t, db_update_required(.BackedUp), "BackedUp should require update")
+}
+
+@(test)
+test_db_update_required_dir_updated :: proc(t: ^testing.T) {
+	testing.expect(t, db_update_required(.DirUpdated), "DirUpdated should require update")
+}
+
+@(test)
+test_db_update_required_restored :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Restored), "Restored alone should not require update")
+}
+
+@(test)
+test_db_update_required_error :: proc(t: ^testing.T) {
+	testing.expect(t, !db_update_required(.Error), "Error alone should not require update")
+}
+
+@(test)
+test_db_update_required_combined :: proc(t: ^testing.T) {
+	s := i32(SyncResult.DirUpdated) | i32(SyncResult.Restored)
+	combined := SyncResult(s)
+	testing.expect(t, db_update_required(combined), "DirUpdated|Restored should require update")
+}
+
+@(test)
+test_shares_remote_overlap :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 2, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+	append(&f.Remotes, "git@gitlab.com:user/repo.git")
+
+	remotes := []string{"git@github.com:user/repo.git"}
+	testing.expect(t, shares_remote(&f, remotes), "should share remote")
+}
+
+@(test)
+test_shares_remote_no_overlap :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 1, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+
+	remotes := []string{"git@github.com:other/repo.git"}
+	testing.expect(t, !shares_remote(&f, remotes), "should not share remote")
+}
+
+@(test)
+test_shares_remote_empty_file_remotes :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 0, context.temp_allocator),
+	}
+
+	remotes := []string{"git@github.com:user/repo.git"}
+	testing.expect(t, !shares_remote(&f, remotes), "empty file remotes should not share")
+}
+
+@(test)
+test_shares_remote_empty_check_remotes :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 1, context.temp_allocator),
+	}
+	append(&f.Remotes, "git@github.com:user/repo.git")
+
+	remotes: []string
+	testing.expect(t, !shares_remote(&f, remotes), "empty check remotes should not share")
+}
+
+@(test)
+test_shares_remote_both_empty :: proc(t: ^testing.T) {
+	f := EnvFile {
+		Remotes = make([dynamic]string, 0),
+	}
+
+	remotes: []string
+	testing.expect(t, !shares_remote(&f, remotes), "both empty should not share")
+}
+

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.temp_allocator)
+	paths := strings.split(path, ":", context.temp_allocator)
+
+	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.temp_allocator)
+	defer {
+		if old_path != "" {
+			os.set_env("PATH", old_path)
+		}
+	}
+
+	os.set_env("PATH", "/tmp/envr-nope")
+
+	path := os.get_env("PATH", context.temp_allocator)
+	paths := strings.split(path, ":", context.temp_allocator)
+
+
+	result := find_binary(paths, "no_such_binary_xyz")
+	testing.expect(t, result == "", "nonexistent binary should not be found")
+}
+

fixtures/default_config.json

@@ -1,8 +1,9 @@
 {
+  "db_path": "~/.envr/data.age",
   "keys": [
     {
-      "private": "/home/spencer/.ssh/id_ed25519",
+      "private": "~/.ssh/id_ed25519",
-      "public": "/home/spencer/.ssh/id_ed25519.pub"
+      "public": "~/.ssh/id_ed25519.pub"
     }
   ],
   "scan": {

flake.lock

@@ -5,11 +5,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1768135262,
+        "lastModified": 1778716662,
-        "narHash": "sha256-PVvu7OqHBGWN16zSi6tEmPwwHQ4rLPU9Plvs8/1TUBY=",
+        "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,
+        "lastModified": 1777168982,
-        "narHash": "sha256-k00uTP4JNfmejrCLJOwdObYC9jHRrr/5M/a/8L2EIdo=",
+        "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,
+        "lastModified": 1781173989,
-        "narHash": "sha256-kz/F6mhESPvU1diB7tOM3nLcBfQe7GU7GQCymRlTi/s=",
+        "narHash": "sha256-fnzKKPvS+oieI/pTzotA5tkoM47EB1NpaBcgk4R97hE=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3fbab70c6e69c87ea2b6e48aa6629da2aa6a23b0",
+        "rev": "8c91a71d13451abc40eb9dae8910f972f979852f",
         "type": "github"
       },
       "original": {
@@ -80,11 +80,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1768158989,
+        "lastModified": 1780220602,
-        "narHash": "sha256-67vyT1+xClLldnumAzCTBvU0jLZ1YBcf4vANRWP3+Ak=",
+        "narHash": "sha256-eynAfOmbmxJnkp7YewvCEbShNnnYJ9gLLqkzsYtBPeM=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "e96d59dff5c0d7fddb9d113ba108f03c3ef99eca",
+        "rev": "db947814a175b7ca6ded66e21383d938df01c227",
         "type": "github"
       },
       "original": {

flake.nix

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

main.odin

@@ -0,0 +1,44 @@
+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 "nushell-completion":
+		cmd_nushell_completion(&cmd)
+	case:
+		fmt.printf("Unknown command: %s\n", cmd.name)
+		print_usage()
+		os.exit(1)
+	}
+}
+
+

mod.nu

@@ -0,0 +1,71 @@
+# envr command extern definitions for Nushell
+# A tool for managing environment files and backups
+
+export def tracked-paths [] {
+  (
+    ^envr list
+    | from json
+    | each {
+      [$in.directory $in.path] | path join
+    }
+  )
+}
+
+export def untracked-paths [] {
+  (
+    ^envr scan
+    | from json
+  )
+}
+
+export extern envr [
+  ...args: any
+  --help(-h)              # Show help information
+]
+
+export extern "envr backup" [
+  --help(-h) # Show help for backup command
+  path: path@untracked-paths # Path to .env file to backup
+]
+
+export extern "envr check" [
+  --help(-h)              # Show help for check command
+]
+
+export extern "envr edit-config" [
+  --help(-h)              # Show help for edit-config command
+]
+
+export extern "envr help" [
+  command?: string        # Show help for specific command
+]
+
+export extern "envr init" [
+  --help(-h)              # Show help for init command
+]
+
+export extern "envr list" [
+  --help(-h)              # Show help for list command
+]
+
+export extern "envr remove" [
+  --help(-h)              # Show help for remove command
+  path: path@tracked-paths
+]
+
+export extern "envr restore" [
+  --help(-h)              # Show help for restore command
+  path: path@tracked-paths
+]
+
+export extern "envr scan" [
+  --help(-h)              # Show help for scan command
+]
+
+export extern "envr sync" [
+  --help(-h)              # Show help for sync command
+]
+
+export extern "envr nushell-completion" [
+  --help(-h)              # Show help for nushell-completion command
+]

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,146 @@
+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.tprintf("/tmp/envr-fd-%d-%d", os.get_pid(), n)
+}
+
+cant_scan :: proc(feats: AvailableFeatures) -> bool {
+	return Feature.Fd not_in feats
+}
+
+find_unbacked :: proc(local_files: []string, db_files: []EnvFile) -> []string {
+	// Lives until the end of the function
+	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.tprintf("/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", "-q"},
+		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.tprintf("%s/.gitignore", base)
+	_ = os.write_entire_file(gitignore_path, ".env*\n")
+
+	_ = os.write_entire_file(fmt.tprintf("%s/.env", base), "SECRET=1")
+	_ = os.write_entire_file(fmt.tprintf("%s/.env.testing", base), "TEST=1")
+	_ = os.write_entire_file(fmt.tprintf("%s/config.yaml", base), "key: value")
+
+	cfg := Config {
+		ScanConfig = ScanConfig{Matcher = "\\.env"},
+	}
+
+	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.tprintf("/tmp/envr-scan-empty-%d", os.get_pid())
+	os.mkdir_all(base)
+	defer os.remove_all(base)
+
+	cfg := Config {
+		ScanConfig = ScanConfig{Matcher = "\\.env"},
+	}
+
+	results, ok := scan_path(base, cfg)
+	defer delete(results)
+	testing.expect(t, ok, "scan_path should succeed")
+	testing.expect(t, len(results) == 0, fmt.tprintf("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 ---
+}

src/Config.zig

@@ -1,22 +1,30 @@
 const std = @import("std");
 
+db_path: []const u8 = "~/.envr/data.age",
+
 /// Keys that are available for encryption
-keys: []const SSHKeyPair,
+keys: []const SSHKeyPair = &.{
+    .from_pub_path("~/.ssh/id_ed25519.pub"),
+},
 
 /// Rules for how to match the scan command
 scan: ScanConfig = .default,
 
+// TODO: Allow incomplete pairs
 pub const SSHKeyPair = struct {
     private: []const u8,
     public: []const u8,
 
     /// Caller owns the returned memory
-    pub fn from_path(gpa: std.mem.Allocator, path: []const u8) !SSHKeyPair {
+    pub fn from_path(
-        if (std.mem.eql(u8, std.fs.path.extension(path), ".pub")){
+        gpa: std.mem.Allocator,
+        path: []const u8,
+    ) error{OutOfMemory}!SSHKeyPair {
+        if (std.mem.eql(u8, std.fs.path.extension(path), ".pub")) {
             return from_pub_path(path);
         } else {
             return .{
-                .public = try std.mem.concat(gpa, u8, &.{path, ".pub"}),
+                .public = try std.mem.concat(gpa, u8, &.{ path, ".pub" }),
                 .private = path,
             };
         }
@@ -27,7 +35,7 @@ pub const SSHKeyPair = struct {
 
         return .{
             .public = path,
-            .private = path[0..path.len - 4],
+            .private = path[0 .. path.len - 4],
         };
     }
 };
@@ -56,6 +64,7 @@ pub const ScanConfig = struct {
 };
 
 /// Load the Config from the file at path
+/// TODO: Use a concrete error set
 pub fn load(
     io: std.Io,
     gpa: std.mem.Allocator,
@@ -117,11 +126,7 @@ test "loading the default config from disk matches expected values" {
 test "saving to a new file upserts the file" {
     const io = std.testing.io;
 
-    var cfg: @This() = .{
+    var cfg: @This() = .{};
-        .keys = &.{
-          .from_pub_path("~/.ssh/id_ed25519.pub"),
-        },
-    };
 
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
@@ -145,6 +150,7 @@ test "saving to a new file upserts the file" {
 
     const want =
         \\{
+        \\  "db_path": "~/.envr/data.age",
         \\  "keys": [
         \\    {
         \\      "private": "~/.ssh/id_ed25519",
@@ -172,11 +178,7 @@ test "saving to a new file upserts the file" {
 test "saving to an existing file updates the file" {
     const io = std.testing.io;
 
-    var cfg: @This() = .{
+    var cfg: @This() = .{};
-        .keys = &.{
-            .from_pub_path("~/.ssh/id_ed25519.pub"),
-        },
-    };
 
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
@@ -198,6 +200,7 @@ test "saving to an existing file updates the file" {
 
     const want =
         \\{
+        \\  "db_path": "~/.envr/data.age",
         \\  "keys": [
         \\    {
         \\      "private": "~/.ssh/id_ed25519",

src/Db.zig

@@ -1,7 +1,13 @@
+//! Db interacts with an age encrypted sqlite database.
+//!
 const std = @import("std");
 const sqlite = @import("sqlite");
 
 const age = @import("age.zig");
+const Config = @import("Config.zig");
+
+/// controls the keys and filepaths used for saving
+opts: OpenOptions,
 
 /// The underlying data store.
 sql_db: sqlite.Db,
@@ -15,46 +21,81 @@ changed: bool = false,
 pub fn open(
     io: std.Io,
     gpa: std.mem.Allocator,
-    /// The path to the home directory
+    opts: OpenOptions,
-    home: []const u8,
-    /// The path to the /tmp directory
-    tmp: []const u8,
 ) !@This() {
-    // TODO: Check if database already exists
+    // FIXME: cheating here
-    const db_path = try std.fs.path.join(gpa, &.{ home, ".envr", "data.age" });
+    const db_path = try std.fs.path.join(gpa, &.{
+        opts.home,
+        opts.config.db_path[2..],
+    });
     defer gpa.free(db_path);
 
-    var db = try new();
+    // const tmp_dir = try std.Io.Dir.cwd().openDir(io, tmp, .{});
+    // defer tmp_dir.deleteFile(io, "envr.db");
+
+    const tmp_db_path = try std.fs.path.joinZ(gpa, &.{ opts.tmp, "envr.db" });
+    defer gpa.free(tmp_db_path);
 
     if (db_exists(io, db_path)) {
-        // const tmp_dir = try std.Io.Dir.cwd().openDir(io, tmp, .{});
+        // TODO: Use std.MultiArrayList? Had json issues
-        // defer tmp_dir.deleteFile(io, "envr.db");
+        {
+            var private_keys: std.ArrayList([]const u8) = try .initCapacity(
+                gpa,
+                opts.config.keys.len,
+            );
+            defer private_keys.deinit(gpa);
 
-        const tmp_db_path = try std.fs.path.join(gpa, &.{ tmp, "envr.db" });
+            for (opts.config.keys) |key| {
-        defer gpa.free(tmp_db_path);
+                // FIXME: cheating here
+                if (std.mem.startsWith(u8, key.private, "~/")) {
+                    const key_path = try std.fs.path.join(gpa, &.{
+                        opts.home,
+                        key.private[2..],
+                    });
+                    private_keys.appendAssumeCapacity(key_path);
+                    // defer gpa.free(key_path);
+                } else {
+                    private_keys.appendAssumeCapacity(key.private);
+                }
+            }
 
-        // TODO: Fix key
+            // TODO: Pass key(s) from Config
-        try age.decrypt(io, gpa, "~/.ssh/id_ed25519", db_path, tmp_db_path);
+            try age.decrypt(io, gpa, private_keys.items, db_path, tmp_db_path);
 
-        try db.restore(tmp_db_path);
+            for (opts.config.keys, 0..) |key, i| {
-        try std.Io.Dir.cwd().deleteFile(io, tmp_db_path);
+                if (std.mem.startsWith(u8, key.private, "~/")) {
-
+                    gpa.free(private_keys.items[i]);
-        return db;
+                }
-    } else {
+            }
-        return db;
+        }
     }
+
+    return open_decrypted(opts, tmp_db_path);
 }
 
-/// Create a new instance of the database in-memory
+const OpenOptions = struct {
-fn new() !@This() {
+    config: Config = .{},
+
+    /// The path to the home directory
+    home: []const u8 = "~/",
+    /// The path to the /tmp directory
+    // FIXME: Support windows
+    tmp: []const u8 = "/tmp",
+};
+
+/// Create a new instance of the database
+fn open_decrypted(opts: OpenOptions, tmp_db_path: [:0]const u8) !@This() {
     var db = try sqlite.Db.init(.{
-        .mode = .Memory,
+        .mode = .{ .File = tmp_db_path },
-        .open_flags = .{ .write = true, .create = true },
+        .open_flags = .{
+            .write = true,
+            .create = true,
+        },
         .threading_mode = .MultiThread,
     });
 
     try db.exec(
-        \\create table envr_env_files (
+        \\create table if not exists envr_env_files (
         \\  path text primary key not null
         \\, remotes text -- JSON
         \\, sha256 text not null
@@ -62,7 +103,10 @@ fn new() !@This() {
         \\)
     , .{}, .{});
 
-    return .{ .sql_db = db };
+    return .{
+        .sql_db = db,
+        .opts = opts,
+    };
 }
 
 /// Returns true if a file exists at ~/.envr/data.age
@@ -74,26 +118,6 @@ fn db_exists(io: std.Io, path: []const u8) bool {
     }
 }
 
-/// Loads the unencrypted sqlite db at filepath path into the datbase
-/// FIXME: Test me
-fn restore(
-    self: *@This(),
-    path: []const u8,
-) !void {
-    try self.sql_db.exec(
-        "ATTACH DATABASE ? AS source",
-        .{},
-        .{path},
-    );
-    defer self.sql_db.exec("DETACH DATABASE source", .{}, .{}) catch unreachable;
-
-    try self.sql_db.exec(
-        "INSERT INTO main.envr_env_files SELECT * FROM source.envr_env_files",
-        .{},
-        .{},
-    );
-}
-
 // TODO: Finish
 // pub fn tmpDir(opts: std.fs.Dir.OpenDirOptions) TmpDir {
 //     var random_bytes: [TmpDir.random_bytes_count]u8 = undefined;
@@ -111,27 +135,68 @@ pub fn close(
     self: *@This(),
     io: std.Io,
     gpa: std.mem.Allocator,
-    home: []const u8,
-    tmp: []const u8,
 ) !void {
     defer self.sql_db.deinit();
 
     if (self.changed) {
-        const tmp_db_path = try std.fs.path.join(gpa, &.{ tmp, "envr.db" });
+        const tmp_db_path = try std.fs.path.join(gpa, &.{ self.opts.tmp, "envr.db" });
         defer gpa.free(tmp_db_path);
 
         try self.sql_db.exec("VACUUM INTO ?", .{}, .{tmp_db_path});
 
-        const db_path = try std.fs.path.join(gpa, &.{ home, ".envr", "data.age" });
+        const db_path = try std.fs.path.join(gpa, &.{ self.opts.home, ".envr", "data.age" });
         defer gpa.free(db_path);
 
-        // FIXME: Use real key
+        {
-        try age.encrypt(io, gpa, "~/.ssh/id_ed25519.pub", tmp_db_path, db_path);
+            // TODO: Use std.MultiArrayList? Had json issues
+            var public_keys: std.ArrayList([]const u8) = try .initCapacity(
+                gpa,
+                self.opts.config.keys.len,
+            );
+            defer public_keys.deinit(gpa);
+
+            for (self.opts.config.keys) |key| {
+                public_keys.appendAssumeCapacity(key.private);
+            }
+
+            try age.encrypt(io, gpa, public_keys.items, tmp_db_path, db_path);
+        }
 
         self.changed = false;
     }
 }
 
+/// Returns a list of all the .env files present in the database.
+/// The caller is responsible for freeing memory
+pub fn list(self: *@This(), gpa: std.mem.Allocator) ![]EnvFile {
+    var stmt = try self.sql_db.prepare(
+        "select path, remotes, sha256, contents from envr_env_files",
+    );
+    defer stmt.deinit();
+
+    return stmt.all(EnvFile, gpa, .{}, .{});
+}
+
+pub const EnvFile = struct {
+    // TODO: Should use file_name in the struct and derive from the path.
+    path: []const u8,
+
+    // /// dir is derived from Path, and is not stored in the database.
+    // dir: []const u8,
+
+    /// JSON encoded list of strings
+    remotes: []const u8,
+    sha256: []const u8,
+    contents: []const u8,
+
+    pub fn deinit(self: *EnvFile, alloc: std.mem.Allocator) void {
+        alloc.free(self.path);
+        alloc.free(self.remotes);
+        alloc.free(self.sha256);
+        alloc.free(self.contents);
+    }
+};
+
 test {
     std.testing.refAllDecls(@import("age.zig"));
 }
@@ -176,7 +241,7 @@ test "encrypted database can be opened" {
     try age.decrypt(
         io,
         gpa,
-        "./fixtures/insecure-test-key",
+        &.{"./fixtures/insecure-test-key"},
         "./fixtures/encrypted-example.db.age",
         decrypted_path,
     );
@@ -211,7 +276,6 @@ test "Closing a fresh database does not create a file" {
     var tmp_dir = std.testing.tmpDir(.{});
     defer tmp_dir.cleanup();
 
-    // @compileLog(@typeInfo(std.Io.File.Permissions));
     try tmp_dir.dir.createDir(io, "home", .default_dir);
     try tmp_dir.dir.createDir(io, "tmp", .default_dir);
 
@@ -223,8 +287,10 @@ test "Closing a fresh database does not create a file" {
     const tmp = try std.fs.path.join(gpa, &.{ tmp_dir_path, "tmp" });
     defer gpa.free(tmp);
 
-    var db: @This() = try .open(io, gpa, home, tmp);
+    // TODO: Pass testing keys
+    var db: @This() = try .open(io, gpa, .{ .home = home, .tmp = tmp });
 
+    // TODO: Get rid of direct access
     const db_path = try std.fs.path.join(gpa, &.{ home, ".envr", "data.age" });
     defer gpa.free(db_path);
 
@@ -233,10 +299,190 @@ test "Closing a fresh database does not create a file" {
         tmp_dir.dir.access(io, db_path, .{ .read = true }),
     );
 
-    try db.close(io, gpa, home, tmp);
+    try db.close(io, gpa);
 
     try std.testing.expectError(
         error.FileNotFound,
         tmp_dir.dir.access(io, db_path, .{ .read = true }),
     );
 }
+
+test "single-file.db has envr_env_files table" {
+    const io = std.testing.io;
+    const gpa = std.testing.allocator;
+
+    const dir_path = try std.Io.Dir.cwd().realPathFileAlloc(io, ".", gpa);
+    defer gpa.free(dir_path);
+
+    const path = try std.fs.path.joinZ(
+        gpa,
+        &.{ dir_path, "fixtures", "single-file.db" },
+    );
+    defer gpa.free(path);
+
+    var db = try sqlite.Db.init(.{
+        .mode = .{ .File = path },
+        .open_flags = .{
+            .write = false,
+            .create = false,
+        },
+        .threading_mode = .MultiThread,
+    });
+
+    var diags: sqlite.Diagnostics = .{};
+    var stmt = db.prepareDynamicWithDiags(
+        "select name from sqlite_master where type='table'",
+        .{ .diags = &diags },
+    ) catch |err| {
+        std.log.err(
+            "unable to prepare statement, got error {}. diagnostics: {f}",
+            .{ err, diags },
+        );
+        return err;
+    };
+    defer stmt.deinit();
+
+    const tables = (try stmt.oneAlloc(
+        []const u8,
+        gpa,
+        .{ .diags = &diags },
+        .{},
+    )).?;
+    defer gpa.free(tables);
+
+    try std.testing.expectEqualSlices(u8, "envr_env_files", tables);
+}
+
+// test "raw restore works" {
+//     const io = std.testing.io;
+//     const gpa = std.testing.allocator;
+
+//     var db = try sqlite.Db.init(.{
+//         .mode = .Memory,
+//         .open_flags = .{
+//             .write = true,
+//             .create = true,
+//         },
+//         .threading_mode = .MultiThread,
+//     });
+
+//     try db.exec(
+//         \\create table envr_env_files (
+//         \\  path text primary key not null
+//         \\, remotes text -- JSON
+//         \\, sha256 text not null
+//         \\, contents text not null
+//         \\)
+//     , .{}, .{});
+
+//     const dir_path = try std.Io.Dir.cwd().realPathFileAlloc(io, ".", gpa);
+//     defer gpa.free(dir_path);
+
+//     const path = try std.fs.path.join(
+//         gpa,
+//         &.{ dir_path, "fixtures", "single-file.db" },
+//     );
+//     defer gpa.free(path);
+
+//     std.debug.print("path: {s}\n", .{path});
+//     try db.exec(
+//         "ATTACH DATABASE ? AS source",
+//         .{},
+//         .{path},
+//     );
+//     defer db.exec("DETACH DATABASE source", .{}, .{}) catch unreachable;
+
+//     var diags: sqlite.Diagnostics = .{};
+//     db.exec(
+//         "INSERT INTO main.envr_env_files SELECT * FROM source.envr_env_files",
+//         .{ .diags = &diags },
+//         .{},
+//     ) catch |err| {
+//         std.log.err(
+//             "unable to prepare statement, got error {}. diagnostics: {f}",
+//             .{ err, diags },
+//         );
+//         return err;
+//     };
+// }
+
+// test "Closing a modified database does create a file" {}
+
+test "list displays the database's keys" {
+    const io = std.testing.io;
+    const gpa = std.testing.allocator;
+
+    var tmp_dir = std.testing.tmpDir(.{});
+    defer tmp_dir.cleanup();
+
+    try tmp_dir.dir.createDir(io, "home", .default_dir);
+    try tmp_dir.dir.createDir(io, "home/.envr", .default_dir);
+    try tmp_dir.dir.createDir(io, "tmp", .default_dir);
+
+    const tmp_dir_path = try tmp_dir.dir.realPathFileAlloc(io, ".", gpa);
+    defer gpa.free(tmp_dir_path);
+
+    const home = try std.fs.path.join(gpa, &.{ tmp_dir_path, "home" });
+    defer gpa.free(home);
+    const tmp = try std.fs.path.join(gpa, &.{ tmp_dir_path, "tmp" });
+    defer gpa.free(tmp);
+
+    // TODO: Get rid of direct access
+    const db_path = try std.fs.path.join(gpa, &.{ home, ".envr", "data.age" });
+    defer gpa.free(db_path);
+
+    try std.Io.Dir.cwd().copyFile(
+        "fixtures/encrypted-single-file.db.age",
+        tmp_dir.dir,
+        "home/.envr/data.age",
+        io,
+        .{},
+    );
+
+    // Asserts file existence
+    try tmp_dir.dir.access(io, db_path, .{ .read = true });
+
+    // TODO: Pass testing keys
+    const config: Config = .{
+        .keys = &.{.from_pub_path("fixtures/insecure-test-key.pub")},
+    };
+    var db: @This() = try .open(io, gpa, .{
+        .config = config,
+        .home = home,
+        .tmp = tmp,
+    });
+
+    const env_files = try db.list(gpa);
+    defer gpa.free(env_files);
+    try std.testing.expectEqual(1, env_files.len);
+
+    var hasher = std.crypto.hash.sha2.Sha256.init(.{});
+
+    try std.testing.expectEqual(1, env_files.len);
+
+    for (env_files) |*file| {
+        defer file.deinit(gpa);
+
+        try std.testing.expectEqualSlices(
+            u8,
+            "~/project/.env.example",
+            file.path,
+        );
+        try std.testing.expectEqualSlices(
+            u8,
+            "API_KEY=\\\"sk_my_api_key\\\"\\nAPP_ENV=testing",
+            file.contents,
+        );
+        try std.testing.expectEqualSlices(
+            u8,
+            "[\"git@github.com:user/project.git\"]",
+            file.remotes,
+        );
+
+        hasher.update(file.contents);
+        const hash = hasher.finalResult();
+        try std.testing.expectEqualStrings(&std.fmt.bytesToHex(&hash, .lower), file.sha256);
+    }
+
+    try db.close(io, gpa);
+}

src/age.zig

@@ -1,24 +1,32 @@
 const std = @import("std");
 
-/// Returns the decrypted contents of the file.
+/// Decrypts the file into output path
-/// Caller is responsible for freeing the memory.
 pub fn decrypt(
     io: std.Io,
     gpa: std.mem.Allocator,
-    private_key: []const u8,
+    private_keys: []const []const u8,
     input_path: []const u8,
     output_path: []const u8,
 ) !void {
+    // TODO: use raw array?
+    var argv: std.ArrayList([]const u8) = try .initCapacity(gpa, 2 + (2 * private_keys.len) + 3);
+    defer argv.deinit(gpa);
+
+    argv.appendAssumeCapacity("age");
+    argv.appendAssumeCapacity("-d");
+
+    for (private_keys) |key| {
+        argv.appendAssumeCapacity("-i");
+        argv.appendAssumeCapacity(key);
+    }
+
+    argv.appendAssumeCapacity("-o");
+    argv.appendAssumeCapacity(output_path);
+
+    argv.appendAssumeCapacity(input_path);
+
     const result = try std.process.run(gpa, io, .{
-        .argv = &.{
+        .argv = argv.items,
-            "age",
-            "-d",
-            "-i",
-            private_key,
-            "-o",
-            output_path,
-            input_path,
-        },
     });
     defer gpa.free(result.stderr);
     defer gpa.free(result.stdout);
@@ -34,25 +42,33 @@ pub fn decrypt(
     }
 }
 
-/// Returns the encrypted contents of the file.
+/// Encrypts the file into output path
-/// Caller is responsible for freeing the memory.
 pub fn encrypt(
     io: std.Io,
     gpa: std.mem.Allocator,
-    public_key: []const u8,
+    // TODO: Accept multiple keys
+    public_keys: []const []const u8,
     input_path: []const u8,
     output_path: []const u8,
 ) !void {
+    var argv: std.ArrayList([]const u8) = try .initCapacity(gpa, 2 + (2 * public_keys.len) + 3);
+    defer argv.deinit(gpa);
+
+    argv.appendAssumeCapacity("age");
+    argv.appendAssumeCapacity("-e");
+
+    for (public_keys) |key| {
+        argv.appendAssumeCapacity("-R");
+        argv.appendAssumeCapacity(key);
+    }
+
+    argv.appendAssumeCapacity("-o");
+    argv.appendAssumeCapacity(output_path);
+
+    argv.appendAssumeCapacity(input_path);
+
     const result = try std.process.run(gpa, io, .{
-        .argv = &.{
+        .argv = argv.items,
-            "age",
-            "-e",
-            "-R",
-            public_key,
-            "-o",
-            output_path,
-            input_path,
-        },
     });
     defer gpa.free(result.stderr);
     defer gpa.free(result.stdout);
@@ -84,7 +100,7 @@ test "sample file can be decrypted" {
     try decrypt(
         io,
         gpa,
-        "./fixtures/insecure-test-key",
+        &.{"./fixtures/insecure-test-key"},
         "./fixtures/hello-world.age",
         output_path,
     );
@@ -111,7 +127,7 @@ test "sample file can be encrypted" {
     try encrypt(
         io,
         gpa,
-        "./fixtures/insecure-test-key.pub",
+        &.{"./fixtures/insecure-test-key.pub"},
         "./fixtures/hello-world.txt",
         output_path,
     );

src/main.zig

@@ -2,7 +2,6 @@ const std = @import("std");
 const Io = std.Io;
 
 const config = @import("config");
-
 const comma = @import("comma");
 const envr = @import("envr");
 
@@ -24,15 +23,58 @@ fn run(
     arena: std.mem.Allocator,
     args: []const [:0]const u8,
 ) !void {
+    const page_size = std.heap.pageSize();
+
     const cmd = envr.root.parse(args[1..]);
     switch (cmd) {
         .envr => {
-            var stdout_buffer: [4096]u8 = undefined;
+            var stdout_buffer: [page_size]u8 = undefined;
             var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
             const stdout_writer = &stdout_file_writer.interface;
 
             return envr.root.help(stdout_writer);
         },
+        .deps => {
+            var stdout_buffer: [1024]u8 = undefined;
+            var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
+            const stdout_writer = &stdout_file_writer.interface;
+
+            return envr.deps(
+                io,
+                stdout_writer,
+                environ_map.get("PATH").?,
+            );
+        },
+        .init => {
+            var stdout_buffer: [1024]u8 = undefined;
+            var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
+            const stdout_writer = &stdout_file_writer.interface;
+
+            try envr.init_cmd(
+                io,
+                arena,
+                stdout_writer,
+                environ_map.get("HOME").?,
+                .{
+                    // TODO: Actually parse this
+                    .force = true,
+                },
+            );
+        },
+        .list => {
+            var stdout_buffer: [page_size]u8 = undefined;
+            var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
+            const stdout_writer = &stdout_file_writer.interface;
+
+            return envr.list(
+                io,
+                arena,
+                stdout_writer,
+                environ_map.get("HOME").?,
+                // TODO: Don't hardcode this?
+                "/tmp",
+            );
+        },
         .version => {
             var stdout_buffer: [1024]u8 = undefined;
             var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
@@ -40,17 +82,6 @@ fn run(
 
             return version(stdout_writer);
         },
-        .deps => {
-            var stdout_buffer: [1024]u8 = undefined;
-            var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
-            const stdout_writer = &stdout_file_writer.interface;
-
-            return deps(
-                io,
-                stdout_writer,
-                environ_map.get("PATH").?,
-            );
-        },
         .unknown => {
             return fallback_to_go(io, arena, args);
         },
@@ -62,63 +93,6 @@ fn version(writer: *Io.Writer) !void {
     try writer.flush();
 }
 
-// Display dependency statuses
-fn deps(
-    io: Io,
-    writer: *Io.Writer,
-    path: []const u8,
-) !void {
-    const feats: Features = try .scan(io, path);
-
-    // FIXME: Draw as a table
-    try writer.print("features: {}", .{feats});
-    try writer.flush();
-}
-
-const Features = packed struct {
-    git: bool = false,
-    fd: bool = false,
-    const all_features: Features = .{
-        .git = true,
-        .fd = true,
-    };
-
-    /// Scans your PATH variable for programs.
-    pub fn scan(io: Io, path: []const u8) !@This() {
-        var feats: Features = .{};
-
-        var dirs = std.mem.splitScalar(u8, path, std.fs.path.delimiter);
-
-        loop: while (dirs.next()) |dir| {
-            const dirt = Io.Dir.openDir(Io.Dir.cwd(), io, dir, .{ .follow_symlinks = true, .iterate = true }) catch continue;
-            defer dirt.close(io);
-
-            var dir_paths = dirt.iterate();
-
-            while (try dir_paths.next(io)) |file| {
-                // FIXME: Check if executable
-                if (std.mem.eql(u8, std.fs.path.basename(file.name), "git")) {
-                    feats.git = true;
-
-                    if (feats == Features.all_features) {
-                        break :loop;
-                    }
-                }
-
-                if (std.mem.eql(u8, std.fs.path.basename(file.name), "fd")) {
-                    feats.fd = true;
-
-                    if (feats == Features.all_features) {
-                        break :loop;
-                    }
-                }
-            }
-        }
-
-        return feats;
-    }
-};
-
 fn fallback_to_go(
     io: Io,
     arena: std.mem.Allocator,
@@ -137,10 +111,10 @@ fn fallback_to_go(
 
 test "simple test" {
     const gpa = std.testing.allocator;
-    var list: std.ArrayList(i32) = .empty;
+    var alist: std.ArrayList(i32) = .empty;
-    defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
+    defer alist.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
-    try list.append(gpa, 42);
+    try alist.append(gpa, 42);
-    try std.testing.expectEqual(@as(i32, 42), list.pop());
+    try std.testing.expectEqual(@as(i32, 42), alist.pop());
 }
 
 test "fuzz example" {
@@ -152,23 +126,23 @@ fn testOne(context: void, smith: *std.testing.Smith) !void {
     // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
 
     const gpa = std.testing.allocator;
-    var list: std.ArrayList(u8) = .empty;
+    var alist: std.ArrayList(u8) = .empty;
-    defer list.deinit(gpa);
+    defer alist.deinit(gpa);
     while (!smith.eos()) switch (smith.value(enum { add_data, dup_data })) {
         .add_data => {
-            const slice = try list.addManyAsSlice(gpa, smith.value(u4));
+            const slice = try alist.addManyAsSlice(gpa, smith.value(u4));
             smith.bytes(slice);
         },
         .dup_data => {
-            if (list.items.len == 0) continue;
+            if (alist.items.len == 0) continue;
-            if (list.items.len > std.math.maxInt(u32)) return error.SkipZigTest;
+            if (alist.items.len > std.math.maxInt(u32)) return error.SkipZigTest;
-            const len = smith.valueRangeAtMost(u32, 1, @min(32, list.items.len));
+            const len = smith.valueRangeAtMost(u32, 1, @min(32, alist.items.len));
-            const off = smith.valueRangeAtMost(u32, 0, @intCast(list.items.len - len));
+            const off = smith.valueRangeAtMost(u32, 0, @intCast(alist.items.len - len));
-            try list.appendSlice(gpa, list.items[off..][0..len]);
+            try alist.appendSlice(gpa, alist.items[off..][0..len]);
             try std.testing.expectEqualSlices(
                 u8,
-                list.items[off..][0..len],
+                alist.items[off..][0..len],
-                list.items[list.items.len - len ..],
+                alist.items[alist.items.len - len ..],
             );
         },
     };

src/root.zig

@@ -2,8 +2,11 @@
 const std = @import("std");
 const Io = std.Io;
 
-const comma = @import("comma");
+const Command = @import("comma").Command;
-const Command = comma.Command;
+
+const Config = @import("Config.zig");
+const Db = @import("Db.zig");
+const tabula = @import("./tabula.zig");
 
 pub const root: Command = .new(.{
     .name = "envr",
@@ -49,6 +52,23 @@ pub const root: Command = .new(.{
             \\ The deps command reports which binaries are available and which are not."
             ,
         },
+        .{
+            .name = "init",
+            .short = "Set up envr",
+            .long =
+            \\The init command generates your initial config and saves it to
+            \\~/.envr/config in JSON format.
+            \\
+            \\During setup, you will be prompted to select one or more ssh keys with which to
+            \\encrypt your databse. **Make 100% sure** that you have **a remote copy** of this
+            \\key somewhere, otherwise your data could be lost forever.
+            ,
+            //.flags =  struct { force: bool }
+        },
+        .{
+            .name = "list",
+            .short = "View your tracked files",
+        },
         .{
             .name = "version",
             .short = "Show envr's version",
@@ -56,17 +76,260 @@ pub const root: Command = .new(.{
     },
 });
 
+// Display dependency statuses
+pub fn deps(
+    io: Io,
+    writer: *Io.Writer,
+    path: []const u8,
+) !void {
+    const feats: Features = try .scan(io, path);
+
+    // FIXME: Draw as a table
+    try writer.print("features: {}", .{feats});
+    try writer.flush();
+}
+
+const Features = packed struct {
+    git: bool = false,
+    fd: bool = false,
+    const all_features: Features = .{
+        .git = true,
+        .fd = true,
+    };
+
+    /// Scans your PATH variable for programs.
+    pub fn scan(io: Io, path: []const u8) !@This() {
+        var feats: Features = .{};
+
+        var dirs = std.mem.splitScalar(u8, path, std.fs.path.delimiter);
+
+        loop: while (dirs.next()) |dir| {
+            const dirt = Io.Dir.openDir(Io.Dir.cwd(), io, dir, .{ .follow_symlinks = true, .iterate = true }) catch continue;
+            defer dirt.close(io);
+
+            var dir_paths = dirt.iterate();
+
+            while (try dir_paths.next(io)) |file| {
+                // FIXME: Check if executable
+                if (std.mem.eql(u8, std.fs.path.basename(file.name), "git")) {
+                    feats.git = true;
+
+                    if (feats == Features.all_features) {
+                        break :loop;
+                    }
+                }
+
+                if (std.mem.eql(u8, std.fs.path.basename(file.name), "fd")) {
+                    feats.fd = true;
+
+                    if (feats == Features.all_features) {
+                        break :loop;
+                    }
+                }
+            }
+        }
+
+        return feats;
+    }
+};
+
+pub fn init_cmd(
+    io: Io,
+    arena: std.mem.Allocator,
+    out: *std.Io.Writer,
+    home: []const u8,
+    flags: struct { force: bool },
+) !void {
+    defer out.flush() catch unreachable;
+
+    // TODO: Don't hardcode
+    const cfgPath = try std.fs.path.join(arena, &.{ home, ".envr", "config.json" });
+    defer arena.free(cfgPath);
+
+    if (flags.force or !file_exists(io, cfgPath)) {
+        const keys = try select_ssh_keys(io, arena, home, out);
+
+        // defer {
+        // for (keys) |*key| {
+        // arena.destroy(key);
+        // }
+        // arena.free(&keys);
+        // }
+
+        // const cfg: Config = .{ .keys = keys };
+        // TODO: How to handle this error?
+        // try cfg.save(io, cfgPath);
+
+        try out.print(
+            "Config initialized with {} SSH key(s). You are ready to use envr.\n",
+            .{keys.len},
+        );
+    } else {
+        try out.writeAll(
+            \\You have already initialized envr.
+            \\Run again with the --force flag if you want to reinitialize.
+            \\
+            ,
+        );
+    }
+}
+
+/// Returns true if the file exists
+fn file_exists(io: std.Io, path: []const u8) bool {
+    if (std.Io.Dir.cwd().access(io, path, .{ .read = true })) {
+        return true;
+    } else |_| {
+        return false;
+    }
+}
+
+/// Returns a list of keys that the user has selected to add to their config.
+/// Caller owns the returned memory
+// TODO: Write a test for this
+fn select_ssh_keys(
+    io: std.Io,
+    alloc: std.mem.Allocator,
+    home_path: []const u8,
+    out: *std.Io.Writer,
+) ![]Config.SSHKeyPair {
+    const ssh_path = try std.fs.path.join(alloc, &.{ home_path, ".ssh" });
+    defer alloc.free(ssh_path);
+
+    // TODO: Arbitrary capacity chosen
+    var keys: std.ArrayList(Config.SSHKeyPair) = try .initCapacity(alloc, 3);
+
+    {
+        const ssh_dir = try std.Io.Dir.cwd().openDir(io, ssh_path, .{ .iterate = true });
+        defer ssh_dir.close(io);
+
+        var itr = ssh_dir.iterate();
+
+        const expect1 =
+            \\-----BEGIN OPENSSH PRIVATE KEY-----
+            \\
+        ;
+
+        const expect2 =
+            \\-----BEGIN RSA PRIVATE KEY-----
+            \\
+        ;
+
+        var buf: [expect1.len]u8 = undefined;
+
+        while (try itr.next(io)) |entry| {
+            switch (entry.kind) {
+                .file => {
+                    var file = try ssh_dir.openFile(io, entry.name, .{});
+                    _ = try file.readPositionalAll(io, &buf, 0);
+
+                    // TODO: Faster to use hash or something?
+                    if ( // zig fmt: off
+                        std.mem.eql(u8, expect1, &buf) or 
+                        std.mem.eql(u8, expect2, buf[0..expect2.len])
+                       ) { // zig fmt: on
+                        // File is a private ssh key
+
+                        const full_path = try ssh_dir.realPathFileAlloc(
+                            io,
+                            entry.name,
+                            alloc,
+                        );
+
+                        try keys.append(alloc, try .from_path(alloc, full_path));
+                    }
+                },
+                .sym_link => {
+                    // TODO: Handle symlinks
+                },
+                .block_device,
+                .character_device,
+                .directory,
+                .named_pipe,
+                .unix_domain_socket,
+                .whiteout,
+                .door,
+                .event_port,
+                .unknown,
+                => continue,
+            }
+        }
+    }
+
+    for (keys.items, 1..) |key, n| {
+        try out.print("{d}. {s}\n", .{ n, key.private });
+    }
+    try out.writeAll(
+        "\nPlease enter the number(s) of SSH keys you'd like to use for encryption:\n> ",
+    );
+    try out.flush();
+    defer out.writeAll("\n\n") catch unreachable;
+
+    // TODO: ask user for number(s) to use.
+    // TODO: confirm with a y/n prompt
+    // TODO: only return selected keys
+
+    return keys.toOwnedSlice(alloc);
+}
+
+pub fn list(
+    io: Io,
+    arena: std.mem.Allocator,
+    out: *std.Io.Writer,
+    home: []const u8,
+    tmp: []const u8,
+) !void {
+    // TODO: Don't hardcode
+    const cfgPath = try std.fs.path.join(arena, &.{ home, ".envr", "config.json" });
+    defer arena.free(cfgPath);
+
+    var cfg = (try Config.load(io, arena, cfgPath));
+    defer cfg.deinit();
+
+    var db: Db = try .open(io, arena, .{
+        .config = cfg.value,
+        .home = home,
+        .tmp = tmp,
+    });
+
+    const files = try db.list(arena);
+    defer arena.free(files);
+
+    const table: tabula.Table(Db.EnvFile, .initOne(.path)) = .{ .items = files };
+    try out.print("{f}", .{table});
+    try out.flush();
+
+    try db.close(io, arena); // TODO: Defer this
+
+    for (files) |*file| {
+        file.deinit(arena);
+    }
+}
+
 test {
     std.testing.refAllDecls(@import("Config.zig"));
     std.testing.refAllDecls(@import("Db.zig"));
 }
 
 test "enum type" {
-    const got: root.Type = @enumFromInt(2);
+    const got: root.Type = @enumFromInt(3);
 
     try std.testing.expectEqual(.version, got);
 }
 
+test "parse deps" {
+    const args = &[_][]const u8{"deps"};
+    const cmd = root.parse(args);
+
+    try std.testing.expectEqual(.deps, cmd);
+}
+
+test "parse list" {
+    const args = &[_][]const u8{"list"};
+    const cmd = root.parse(args);
+
+    try std.testing.expectEqual(.list, cmd);
+}
+
 test "parse version" {
     const args = &[_][]const u8{"version"};
     const cmd = root.parse(args);
@@ -80,3 +343,81 @@ test "parse unknown" {
 
     try std.testing.expectEqual(.unknown, cmd);
 }
+
+test "list returns a table" {
+    const io = std.testing.io;
+    const gpa = std.testing.allocator;
+
+    var tmp_dir = std.testing.tmpDir(.{});
+    defer tmp_dir.cleanup();
+
+    try tmp_dir.dir.createDir(io, "home", .default_dir);
+    try tmp_dir.dir.createDir(io, "home/.envr", .default_dir);
+    try tmp_dir.dir.createDir(io, "home/.ssh", .default_dir);
+    try tmp_dir.dir.createDir(io, "tmp", .default_dir);
+
+    const tmp_dir_path = try tmp_dir.dir.realPathFileAlloc(io, ".", gpa);
+    defer gpa.free(tmp_dir_path);
+
+    const home = try std.fs.path.join(gpa, &.{ tmp_dir_path, "home" });
+    defer gpa.free(home);
+    const tmp = try std.fs.path.join(gpa, &.{ tmp_dir_path, "tmp" });
+    defer gpa.free(tmp);
+
+    try std.Io.Dir.cwd().copyFile(
+        "fixtures/encrypted-single-file.db.age",
+        tmp_dir.dir,
+        "home/.envr/data.age",
+        io,
+        .{},
+    );
+
+    try std.Io.Dir.cwd().copyFile(
+        "fixtures/default_config.json",
+        tmp_dir.dir,
+        "home/.envr/config.json",
+        io,
+        .{},
+    );
+
+    try std.Io.Dir.cwd().copyFile(
+        "fixtures/insecure-test-key",
+        tmp_dir.dir,
+        "home/.ssh/id_ed25519",
+        io,
+        .{},
+    );
+
+    try std.Io.Dir.cwd().copyFile(
+        "fixtures/insecure-test-key.pub",
+        tmp_dir.dir,
+        "home/.ssh/id_ed25519.pub",
+        io,
+        .{},
+    );
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    // Run Test
+
+    try list(
+        io,
+        std.testing.allocator,
+        &out.writer,
+        home,
+        tmp,
+    );
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌────────────────────────┐
+        \\│          path          │
+        \\├────────────────────────┤
+        \\│ ~/project/.env.example │
+        \\└────────────────────────┘
+        \\
+    , got);
+}

src/tabula.zig

@@ -0,0 +1,311 @@
+const std = @import("std");
+
+const hor = "─";
+const tl = "┌";
+const tm = "┬";
+const tr = "┐";
+const sep = "│";
+const ml = "├";
+const mm = "┼";
+const mr = "┤";
+const bl = "└";
+const bm = "┴";
+const br = "┘";
+
+/// Prepare a TUI table to be written to a writer.
+pub fn Table(
+    comptime T: type,
+    comptime fields: std.EnumSet(std.meta.FieldEnum(T)),
+) type {
+    return struct {
+        items: []const T,
+
+        pub fn format(self: @This(), writer: *std.Io.Writer) !void {
+            const max_column_widths = determine_col_widths(T, self.items);
+
+            try header(T, fields, &max_column_widths, writer);
+
+            // Print body
+            for (self.items) |item| {
+                try writer.writeAll(sep);
+
+                comptime var itr = fields.iterator();
+                comptime var i: usize = 0;
+                inline while (comptime itr.next()) |c| : (i += 1) {
+                    try writer.writeByte(' ');
+                    try write_aligned(writer, @field(item, @tagName(c)), max_column_widths[i], .left);
+                    try writer.print(" {s}", .{sep});
+                }
+
+                try writer.writeAll("\n");
+            }
+
+            // Print post-body
+            {
+                try writer.writeAll(bl);
+
+                var itr = fields.iterator();
+                var i: usize = 0;
+                while (itr.next()) |_| : (i += 1) {
+                    if (i > 0) {
+                        try writer.writeAll(bm);
+                    }
+
+                    const padding = max_column_widths[i] + 2;
+                    for (0..padding) |_| {
+                        try writer.writeAll(hor);
+                    }
+                }
+
+                try writer.writeAll(br ++ "\n");
+            }
+        }
+    };
+}
+
+fn determine_col_widths(
+    T: type,
+    items: []const T,
+) [@typeInfo(T).@"struct".fields.len]usize {
+    const all_fields = @typeInfo(T).@"struct".fields;
+
+    var max_column_widths: [all_fields.len]usize = @splat(0);
+    for (items) |item| {
+        inline for (all_fields, 0..) |field, i| {
+            // TODO: Get str len of item
+            const value_len = @field(item, field.name).len;
+            max_column_widths[i] = @max(
+                max_column_widths[i],
+                field.name.len,
+                value_len,
+            );
+        }
+    }
+
+    return max_column_widths;
+}
+
+// Print the header of a table
+fn header(
+    T: type,
+    comptime fields: std.EnumSet(std.meta.FieldEnum(T)),
+    max_column_widths: []const usize,
+    writer: *std.Io.Writer,
+) !void {
+
+    // Print Pre-Header
+    {
+        try writer.writeAll(tl);
+
+        inline for (0..comptime fields.count()) |i| {
+            if (i > 0) {
+                try writer.writeAll(tm);
+            }
+            const padding = max_column_widths[i] + 2;
+            for (0..padding) |_| {
+                try writer.writeAll(hor);
+            }
+        }
+
+        try writer.writeAll(tr ++ "\n");
+    }
+
+    // Main Header
+    {
+        try writer.writeAll(sep);
+
+        comptime var itr = fields.iterator();
+        comptime var i: usize = 0;
+        inline while (comptime itr.next()) |field| : (i += 1) {
+            try writer.writeByte(' ');
+            try write_aligned(
+                writer,
+                @tagName(field),
+                max_column_widths[i],
+                .center,
+            );
+            try writer.print(" {s}", .{sep});
+        }
+
+        try writer.writeByte('\n');
+    }
+
+    // Print post-header
+    {
+        try writer.writeAll(ml);
+
+        inline for (0..comptime fields.count()) |i| {
+            if (i > 0) {
+                try writer.writeAll(mm);
+            }
+            const padding = max_column_widths[i] + 2;
+            for (0..padding) |_| {
+                try writer.writeAll(hor);
+            }
+        }
+
+      try writer.writeAll(mr ++ "\n");
+    }
+}
+
+fn write_aligned(
+    writer: *std.Io.Writer,
+    data: []const u8,
+    max_width: usize,
+    alignment: Alignment,
+) !void {
+    std.debug.assert(data.len > 0);
+    std.debug.assert(max_width >= data.len);
+
+    const padding: [2]usize = switch (alignment) {
+        .left => .{ 0, max_width - data.len },
+        .right => .{ max_width - data.len, 0 },
+        .center => blk: {
+            // Faster to inline the divFloor?
+            const half = @divFloor(max_width - data.len, 2);
+            break :blk .{ half, max_width - data.len - half };
+        },
+    };
+
+    for (0..padding[0]) |_| {
+        try writer.writeByte(' ');
+    }
+
+    try writer.writeAll(data);
+
+    for (0..padding[1]) |_| {
+        try writer.writeByte(' ');
+    }
+}
+
+const Alignment = enum { left, center, right };
+
+test "can print a simple table" {
+    const gpa = std.testing.allocator;
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const F = struct { foo: []const u8, bar: []const u8 };
+    const table: Table(F, .full) = .{
+        .items = &.{.{ .foo = "bat", .bar = "baz" }},
+    };
+
+    try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬─────┐
+        \\│ foo │ bar │
+        \\├─────┼─────┤
+        \\│ bat │ baz │
+        \\└─────┴─────┘
+        \\
+    , got);
+}
+
+test "can print a table with varying header widths" {
+    const gpa = std.testing.allocator;
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const F = struct { foo: []const u8, abart: []const u8 };
+    const table: Table(F, .full) = .{
+        .items = &.{.{ .foo = "bat", .abart = "baz" }},
+    };
+    try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬───────┐
+        \\│ foo │ abart │
+        \\├─────┼───────┤
+        \\│ bat │ baz   │
+        \\└─────┴───────┘
+        \\
+    , got);
+}
+
+test "can print a table with varying column widths" {
+    const gpa = std.testing.allocator;
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const F = struct { foo: []const u8, bar: []const u8 };
+    const table: Table(F, .full) = .{ .items = &.{.{ .foo = "bat", .bar = "bazzar" }} };
+
+    try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬────────┐
+        \\│ foo │  bar   │
+        \\├─────┼────────┤
+        \\│ bat │ bazzar │
+        \\└─────┴────────┘
+        \\
+    , got);
+}
+
+test "can print a multi row table with varying column widths" {
+    const gpa = std.testing.allocator;
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const F = struct { foo: []const u8, bar: []const u8 };
+    const table: Table(F, .full) = .{
+        .items = &.{
+            .{ .foo = "baz", .bar = "quz" },
+            .{ .foo = "bat", .bar = "bazzar" },
+        },
+    };
+    try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬────────┐
+        \\│ foo │  bar   │
+        \\├─────┼────────┤
+        \\│ baz │ quz    │
+        \\│ bat │ bazzar │
+        \\└─────┴────────┘
+        \\
+    , got);
+}
+
+test "can print a table with limited columns" {
+    const gpa = std.testing.allocator;
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const F = struct { foo: []const u8, bar: []const u8 };
+    const table: Table(F, .initOne(.foo)) = .{
+        .items = &.{.{ .foo = "bat", .bar = "baz" }},
+    };
+
+    try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┐
+        \\│ foo │
+        \\├─────┤
+        \\│ bat │
+        \\└─────┘
+        \\
+    , got);
+}

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), context.temp_allocator)
+
+	for row in rows {
+		entry := make(map[string]string, len(headers), context.temp_allocator)
+		for i in 0 ..< len(headers) {
+			entry[headers[i]] = row[i]
+		}
+		append(&entries, entry)
+	}
+
+	data, err := json.marshal(entries[:], allocator = context.temp_allocator)
+	if err != nil {
+		fmt.eprintf("Error marshaling JSON: %v\n", err)
+		return
+	}
+	fmt.wprintf(w, "%s", data, flush = false)
+}
+

table_test.odin

@@ -0,0 +1,105 @@
+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, allocator = context.temp_allocator)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.tprintf("json unmarshal failed: %v\noutput was: %q", unmarshal_err, output),
+	)
+	testing.expect(t, len(result) == 2, fmt.tprintf("expected 2 rows, got %d", len(result)))
+	testing.expect(
+		t,
+		result[0]["name"] == "foo",
+		fmt.tprintf("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,
+		allocator = context.temp_allocator,
+	)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.tprintf("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.tprintf("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, allocator = context.temp_allocator)
+	testing.expect(
+		t,
+		unmarshal_err == nil,
+		fmt.tprintf("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)
+	}
+}

zig-vendor/zig-sqlite/query.zig

@@ -226,6 +226,7 @@ fn ParseType(comptime type_info: []const u8) type {
         const signedness = switch (type_info[0]) {
             'u' => .unsigned,
             'i' => .signed,
+            else => unreachable,
         };
         return @Int(signedness, std.fmt.parseInt(usize, type_info[1..type_info.len], 10) catch {
             @compileError("invalid type info " ++ type_info);

zig-vendor/zig-sqlite/sqlite.zig

@@ -3,7 +3,7 @@ const builtin = @import("builtin");
 const build_options = @import("build_options");
 const debug = std.debug;
 const heap = std.heap;
-const io = std.io;
+const io = std.Io;
 const mem = std.mem;
 const testing = std.testing;
 
@@ -1967,7 +1967,7 @@ pub const DynamicStatement = struct {
     pub fn all(self: *Self, comptime Type: type, allocator: mem.Allocator, options: QueryOptions, values: anytype) ![]Type {
         var iter = try self.iteratorAlloc(Type, allocator, values);
 
-        var rows: std.ArrayList(Type) = .{};
+        var rows: std.ArrayList(Type) = .empty;
         while (try iter.nextAlloc(allocator, options)) |row| {
             try rows.append(allocator, row);
         }
@@ -2257,7 +2257,7 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: anytype) type
         pub fn all(self: *Self, comptime Type: type, allocator: mem.Allocator, options: QueryOptions, values: anytype) ![]Type {
             var iter = try self.iteratorAlloc(Type, allocator, values);
 
-            var rows: std.ArrayList(Type) = .{};
+            var rows: std.ArrayList(Type) = .empty;
             while (try iter.nextAlloc(allocator, options)) |row| {
                 try rows.append(allocator, row);
             }
@@ -3020,7 +3020,7 @@ test "sqlite: statement iterator" {
     var stmt = try db.prepare("INSERT INTO user(name, id, age, weight, favorite_color) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32}, ?{[]const u8})");
     defer stmt.deinit();
 
-    var expected_rows: std.ArrayList(TestUser) = .{};
+    var expected_rows: std.ArrayList(TestUser) = .empty;
     var i: usize = 0;
     while (i < 20) : (i += 1) {
         const name = try std.fmt.allocPrint(allocator, "Vincent {d}", .{i});
@@ -3047,7 +3047,7 @@ test "sqlite: statement iterator" {
 
         var iter = try stmt2.iterator(RowType, .{});
 
-        var rows: std.ArrayList(RowType) = .{};
+        var rows: std.ArrayList(RowType) = .empty;
         while (try iter.next(.{})) |row| {
             try rows.append(allocator, row);
         }
@@ -3074,7 +3074,7 @@ test "sqlite: statement iterator" {
 
         var iter = try stmt2.iterator(RowType, .{});
 
-        var rows: std.ArrayList(RowType) = .{};
+        var rows: std.ArrayList(RowType) = .empty;
         while (try iter.nextAlloc(allocator, .{})) |row| {
             try rows.append(allocator, row);
         }
@@ -3459,7 +3459,7 @@ test "sqlite: bind runtime slice" {
     const allocator = arena.allocator();
 
     // creating array list on heap so that it's deemed runtime size
-    var list: std.ArrayList([]const u8) = .{};
+    var list: std.ArrayList([]const u8) = .empty;
     defer list.deinit(allocator);
     try list.append(allocator, "this is some data");
     const args = try list.toOwnedSlice(allocator);
@@ -3749,7 +3749,11 @@ test "sqlite: create aggregate function with no aggregate context" {
     var db = try getTestDb();
     defer db.deinit();
 
-    var rand = std.Random.DefaultPrng.init(@intCast(std.time.milliTimestamp()));
+    const test_io = testing.io;
+
+    var rand = std.Random.DefaultPrng.init(@intCast(
+        std.Io.Timestamp.now(test_io, .real).toMilliseconds(),
+    ));
 
     // Create an aggregate function working with a MyContext
 
@@ -3810,7 +3814,11 @@ test "sqlite: create aggregate function with an aggregate context" {
     var db = try getTestDb();
     defer db.deinit();
 
-    var rand = std.Random.DefaultPrng.init(@intCast(std.time.milliTimestamp()));
+    const test_io = std.testing.io;
+
+    var rand = std.Random.DefaultPrng.init(
+        @intCast(std.Io.Timestamp.now(test_io, .real).toMilliseconds()),
+    );
 
     try db.createAggregateFunction(
         "mySum",
@@ -3877,7 +3885,7 @@ test "sqlite: empty slice" {
     defer db.deinit();
     try addTestData(&db);
 
-    var list: std.ArrayList(u8) = .{};
+    var list: std.ArrayList(u8) = .empty;
     const ptr = try list.toOwnedSlice(allocator);
 
     try db.exec("INSERT INTO article(author_id, data) VALUES(?, ?)", .{}, .{ 1, ptr });
@@ -4054,7 +4062,7 @@ test "reuse same field twice in query string" {
 
 test "fuzzing" {
     const Context = struct {
-        fn testOne(_: @This(), input: []const u8) anyerror!void {
+        fn testOne(_: @This(), input: *testing.Smith) anyerror!void {
             var db = try Db.init(.{
                 .mode = .Memory,
                 .open_flags = .{
@@ -4066,7 +4074,7 @@ test "fuzzing" {
 
             try db.exec("CREATE TABLE test(id integer primary key, name text, data blob)", .{}, .{});
 
-            db.execDynamic(input, .{}, .{}) catch |err| switch (err) {
+            db.execDynamic(input.value([]const u8), .{}, .{}) catch |err| switch (err) {
                 error.SQLiteError => return,
                 error.ExecReturnedData => return,
                 error.EmptyQuery => return,

zig-vendor/zig-sqlite/vtab.zig

@@ -766,7 +766,8 @@ pub fn VirtualTable(
 
             //
 
-            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab);
+            const vtab_ptr: *c.sqlite3_vtab = @ptrCast(vtab);
+            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab_ptr);
             const state = nullable_state orelse unreachable;
 
             var arena = heap.ArenaAllocator.init(state.module_context.allocator);
@@ -789,7 +790,8 @@ pub fn VirtualTable(
         }
 
         fn xDisconnect(vtab: [*c]c.sqlite3_vtab) callconv(.c) c_int {
-            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab);
+            const vtab_ptr: *c.sqlite3_vtab = @ptrCast(vtab);
+            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab_ptr);
             const state = nullable_state orelse unreachable;
 
             state.deinit();
@@ -806,7 +808,8 @@ pub fn VirtualTable(
         }
 
         fn xOpen(vtab: [*c]c.sqlite3_vtab, vtab_cursor: [*c][*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
-            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab);
+            const vtab_ptr: *c.sqlite3_vtab = @ptrCast(vtab);
+            const nullable_state: ?*State = @fieldParentPtr("vtab", vtab_ptr);
             const state = nullable_state orelse unreachable;
 
             const cursor_state = CursorState.init(state.module_context, state.table) catch |err| {
@@ -819,7 +822,8 @@ pub fn VirtualTable(
         }
 
         fn xClose(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
 
             cursor_state.deinit();
@@ -828,7 +832,8 @@ pub fn VirtualTable(
         }
 
         fn xEof(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
 
@@ -866,7 +871,8 @@ pub fn VirtualTable(
         }
 
         fn xFilter(vtab_cursor: [*c]c.sqlite3_vtab_cursor, idx_num: c_int, idx_str: [*c]const u8, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
 
@@ -892,7 +898,8 @@ pub fn VirtualTable(
         }
 
         fn xNext(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
 
@@ -911,7 +918,8 @@ pub fn VirtualTable(
         }
 
         fn xColumn(vtab_cursor: [*c]c.sqlite3_vtab_cursor, ctx: ?*c.sqlite3_context, n: c_int) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
 
@@ -955,7 +963,8 @@ pub fn VirtualTable(
         }
 
         fn xRowid(vtab_cursor: [*c]c.sqlite3_vtab_cursor, row_id_ptr: [*c]c.sqlite3_int64) callconv(.c) c_int {
-            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
+            const vtab_cursor_ptr: *c.sqlite3_vtab_cursor = @ptrCast(vtab_cursor);
+            const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor_ptr);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
 
@@ -1023,7 +1032,9 @@ const TestVirtualTable = struct {
             //
 
             const data = &[_][]const u8{
-                "Vincent", "José", "Michel",
+                "Vincent",
+                "José",
+                "Michel",
             };
 
             var rand = std.Random.DefaultPrng.init(204882485);
@@ -1064,13 +1075,18 @@ const TestVirtualTable = struct {
         debug.print("connect\n", .{});
     }
 
-    pub const BuildBestIndexError = error{} || mem.Allocator.Error;
+    pub const BuildBestIndexError = error{} || mem.Allocator.Error || error{WriteFailed};
 
-    pub fn buildBestIndex(self: *TestVirtualTable, diags: *VTabDiagnostics, builder: *BestIndexBuilder) BuildBestIndexError!void {
+    pub fn buildBestIndex(
+        self: *TestVirtualTable,
+        diags: *VTabDiagnostics,
+        builder: *BestIndexBuilder,
+    ) BuildBestIndexError!void {
         _ = self;
         _ = diags;
 
-        var id_str_writer = builder.id_str_buffer.writer(builder.allocator);
+        // var id_str_writer = builder.id_str_buffer.writer(builder.allocator);
+        var id_str_writer = std.Io.Writer.fromArrayList(&builder.id_str_buffer);
 
         var argv_index: i32 = 0;
         for (builder.constraints) |*constraint| {
@@ -1174,7 +1190,7 @@ const TestVirtualTableCursor = struct {
             // 3 chars for the '=' marker
             // 6 chars because we format all columns in a 6 char wide string
             const col_str = id[pos + 1 .. pos + 1 + 6];
-            const col = try fmt.parseInt(i32, mem.trimRight(u8, col_str, " "), 10);
+            const col = try fmt.parseInt(i32, mem.trimEnd(u8, col_str, " "), 10);
 
             id = id[pos + 1 + 6 ..];