fix: fixing leaks.

.tokeignore

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

TODOS.md

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

app/config.go

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

cli.odin

@@ -12,38 +12,29 @@ Command :: struct {
 }
 
 CommandInfo :: struct {
-	name:  string,
+	name:    string,
-	usage: string,
+	usage:   string,
-	short: string,
+	short:   string,
-	long:  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."},
+		"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", ""},
+	{"scan", "envr scan", "Find and select .env files for backup", "", {}},
-	{"backup", "envr backup <path>", "Import a .env file into envr", ""},
+	{"sync", "envr sync", "Update or restore your env backups", "", {}},
-	{"add", "envr add <path>", "Import a .env file into envr", ""},
+	{"backup", "envr backup <path>", "Import a .env file into envr", "", {"add"}},
-	{"restore", "envr restore <path>", "Restore a .env file from the database", ""},
+	{"restore", "envr restore <path>", "Restore a .env file from the database", "", {}},
-	{"list", "envr list", "View your tracked files", ""},
+	{"list", "envr list", "View your tracked files", "", {}},
-	{"remove", "envr remove <path>", "Remove a .env file from your database", ""},
+	{"remove", "envr remove <path>", "Remove a .env file from your database", "", {}},
-	{"check", "envr check [path]", "Check if files are backed up", ""},
+	{"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."},
+		"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", ""},
+	{"version", "envr version", "Show envr's version", "", {}},
-}
+	{"edit-config", "envr edit-config", "Edit your config with your default editor", "", {}},
-
-IMPLEMENTED_COMMANDS := []string{
-	"version",
-	"deps",
-	"list",
-	"backup",
-	"add",
-	"remove",
-	"restore",
-	"edit-config",
 }
 
 parse_args :: proc() -> (cmd: Command, ok: bool) {
@@ -99,15 +90,6 @@ parse_args :: proc() -> (cmd: Command, ok: bool) {
 	return cmd, true
 }
 
-is_implemented :: proc(name: string) -> bool {
-	for c in IMPLEMENTED_COMMANDS {
-		if c == name {
-			return true
-		}
-	}
-	return false
-}
-
 has_flag :: proc(cmd: ^Command, name: string) -> bool {
 	_, ok := cmd.flags[name]
 	if ok {
@@ -122,60 +104,123 @@ find_command :: proc(name: string) -> (CommandInfo, bool) {
 		if c.name == name {
 			return c, true
 		}
+		for a in c.aliases {
+			if a == name {
+				return c, true
+			}
+		}
 	}
 	return CommandInfo{}, false
 }
 
-print_command_help :: proc(name: string) {
+command_help_text :: proc(name: string) -> (string, bool) {
 	info, found := find_command(name)
 	if !found {
+		return "", false
+	}
+
+	b: strings.Builder
+	strings.builder_init(&b)
+
+	fmt.sbprintf(&b, "Usage: %s [flags]\n\n", info.usage)
+	fmt.sbprintf(&b, "%s\n", info.short)
+
+	if len(info.aliases) > 0 {
+		fmt.sbprintf(&b, "\nAliases:\n  %s", info.name)
+		for a in info.aliases {
+			fmt.sbprintf(&b, ", %s", a)
+		}
+		fmt.sbprintf(&b, "\n")
+	}
+
+	if len(info.long) > 0 {
+		fmt.sbprintf(&b, "\n%s\n", info.long)
+	}
+
+	fmt.sbprintf(&b, "\nFlags:\n  -h, --help   help for %s\n", info.name)
+
+	s := strings.clone(strings.to_string(b))
+	strings.builder_destroy(&b)
+	return s, true
+}
+
+print_command_help :: proc(name: string) {
+	text, ok := command_help_text(name)
+	if !ok {
 		fmt.printf("Unknown command: %s\n", name)
 		print_usage()
 		return
 	}
-	fmt.printf("Usage: %s\n\n%s\n", info.usage, info.short)
+	fmt.println(text)
-	if len(info.long) > 0 {
+}
-		fmt.printf("\n%s\n", info.long)
+
+usage_text :: proc() -> string {
+	b: strings.Builder
+	strings.builder_init(&b)
+
+	fmt.sbprintf(&b, "envr keeps your .env synced to a local, age encrypted database.\n")
+	fmt.sbprintf(&b, "Is a safe and easy way to gather all your .env files in one place where they can\n")
+	fmt.sbprintf(&b, "easily be backed by another tool such as restic or git.\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "All your data is stored in ~/data.age\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Getting started is easy:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "1. Create your configuration file and set up encrypted storage:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr init\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "2. Scan for existing .env files:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr scan\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Select the files you want to back up from the interactive list.\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "3. Verify that it worked:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr list\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "4. After changing any of your .env files, update the backup with:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr sync\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "5. If you lose a repository, after re-cloning the repo into the same path it was\n")
+	fmt.sbprintf(&b, "at before, restore your backup with:\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "> envr restore ~/<path to repository>/.env\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Usage:\n")
+	fmt.sbprintf(&b, "  envr [command]\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Available Commands:\n")
+
+	for c in COMMANDS {
+		name_start := len(b.buf)
+		fmt.sbprintf(&b, "%s", c.name)
+		for a in c.aliases {
+			fmt.sbprintf(&b, ", %s", a)
+		}
+		name_len := len(b.buf) - name_start
+		padding := 20 - name_len
+		if padding > 0 {
+			for _ in 0..<padding {
+				strings.write_byte(&b, ' ')
+			}
+		}
+		fmt.sbprintf(&b, " %s\n", c.short)
 	}
+
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Flags:\n")
+	fmt.sbprintf(&b, "  -h, --help   help for envr\n")
+	fmt.sbprintf(&b, "\n")
+	fmt.sbprintf(&b, "Use \"envr [command] --help\" for more information about a command.\n")
+
+	s := strings.clone(strings.to_string(b))
+	strings.builder_destroy(&b)
+	return s
 }
 
 print_usage :: proc() {
-	fmt.println("envr - Manage your .env files.")
+	fmt.print(usage_text())
-	fmt.println("")
-	fmt.println("envr keeps your .env synced to a local, age encrypted database.")
-	fmt.println("Is a safe and easy way to gather all your .env files in one place where they can")
-	fmt.println("easily be backed by another tool such as restic or git.")
-	fmt.println("")
-	fmt.println("All your data is stored in ~/data.age")
-	fmt.println("")
-	fmt.println("Getting started is easy:")
-	fmt.println("")
-	fmt.println("1. Create your configuration file and set up encrypted storage:")
-	fmt.println("")
-	fmt.println("> envr init")
-	fmt.println("")
-	fmt.println("2. Scan for existing .env files:")
-	fmt.println("")
-	fmt.println("> envr scan")
-	fmt.println("")
-	fmt.println("Select the files you want to back up from the interactive list.")
-	fmt.println("")
-	fmt.println("3. Verify that it worked:")
-	fmt.println("")
-	fmt.println("> envr list")
-	fmt.println("")
-	fmt.println("Usage: envr <command> [args]")
-	fmt.println("")
-	fmt.println("Commands:")
-	fmt.println("  init          Set up envr")
-	fmt.println("  scan          Find and select .env files for backup")
-	fmt.println("  sync          Update or restore your env backups")
-	fmt.println("  backup <path> Import a .env file into envr")
-	fmt.println("  restore <path> Restore a .env file from the database")
-	fmt.println("  list          View your tracked files")
-	fmt.println("  remove <path> Remove a .env file from your database")
-	fmt.println("  check [path]  Check if files are backed up")
-	fmt.println("  deps          Check for missing binaries")
-	fmt.println("  version       Show envr's version")
-	fmt.println("  edit-config   Edit your config with your default editor")
 }

cli_test.odin

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

cmd_backup.odin

@@ -5,7 +5,7 @@ import "core:strings"
 
 cmd_backup :: proc(cmd: ^Command) {
 	if len(cmd.args) != 1 {
-		fmt.println("Usage: envr backup <path>")
+		print_command_help("backup")
 		return
 	}
 

cmd_check.odin

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

cmd_check_test.odin

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

cmd_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

@@ -28,21 +28,11 @@ cmd_list :: proc(cmd: ^Command) {
         table_rows := make([dynamic][]string, 0, len(rows))
 
         for row in rows {
-            b: strings.Builder
+            dir_str := strings.concatenate({row.Dir, "/"})
-            strings.builder_init(&b)
+            filename := filepath.base(row.Path)
-            strings.write_string(&b, row.Dir)
-            strings.write_string(&b, "/")
-            dir_str, _ := strings.clone(strings.to_string(b))
-
-            rel, rel_err := filepath.rel(row.Dir, row.Path)
-            if rel_err != nil {
-                fmt.printf("Error getting relative path: %v\n", rel_err)
-                return
-            }
-            cloned_rel, _ := strings.clone(rel)
             row_slice := make([]string, 2)
             row_slice[0] = dir_str
-            row_slice[1] = cloned_rel
+            row_slice[1] = filename
             append(&table_rows, row_slice)
         }
 
@@ -50,18 +40,10 @@ cmd_list :: proc(cmd: ^Command) {
     } else {
         entries: [dynamic]ListEntry
         for row in rows {
-            rel, rel_err := filepath.rel(row.Dir, row.Path)
+            filename := filepath.base(row.Path)
-            if rel_err != nil {
-                fmt.printf("Error getting relative path: %v\n", rel_err)
-                return
-            }
-            b: strings.Builder
-            strings.builder_init(&b)
-            strings.write_string(&b, row.Dir)
-            strings.write_string(&b, "/")
             append(&entries, ListEntry{
-                Directory = strings.to_string(b),
+                Directory = strings.concatenate({row.Dir, "/"}),
-                Path = rel,
+                Path = filename,
             })
         }
 

cmd_list_test.odin

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

cmd_remove.odin

@@ -6,7 +6,7 @@ import "core:strings"
 
 cmd_remove :: proc(cmd: ^Command) {
     if len(cmd.args) != 1 {
-        fmt.println("Usage: envr remove <path>")
+		print_command_help("remove")
         return
     }
 

cmd_restore.odin

@@ -7,7 +7,7 @@ import "core:strings"
 
 cmd_restore :: proc(cmd: ^Command) {
     if len(cmd.args) != 1 {
-        fmt.println("Usage: envr restore <path>")
+		print_command_help("restore")
         return
     }
 

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

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

db.odin

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

db_test.odin

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

features.odin

@@ -1,5 +1,7 @@
 package main
 
+import "base:runtime"
+import "core:mem"
 import "core:os"
 import "core:strings"
 
@@ -14,25 +16,36 @@ AvailableFeatures :: bit_set[Feature]
 check_features :: proc() -> AvailableFeatures {
 	feats: AvailableFeatures
 
-	if find_binary("git") != "" {
+	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("fd") != "" {
+	if find_binary(paths, "fd") != "" {
 		feats += {.Fd}
 	}
-	if find_binary("age") != "" {
+	if find_binary(paths, "age") != "" {
 		feats += {.Age}
 	}
 
 	return feats
 }
 
-find_binary :: proc(name: string) -> string {
+find_binary :: proc(
-	path_env := os.get_env("PATH", context.allocator)
+	paths: []string,
-	paths := strings.split(path_env, ":")
+	name: string,
+	allocator: runtime.Allocator = context.temp_allocator,
+) -> string {
 	for p in paths {
-		candidate := strings.join({strings.trim_right(p, "/"), name}, "/")
+		candidate := strings.join({strings.trim_right(p, "/"), name}, "/", allocator)
-		_, err := os.stat(candidate, context.allocator)
+		_, err := os.stat(candidate, allocator)
 		if err == nil {
 			return candidate
 		}
@@ -40,6 +53,3 @@ find_binary :: proc(name: string) -> string {
 	return ""
 }
 
-has_feature :: proc(feats: AvailableFeatures, f: Feature) -> bool {
-	return f in feats
-}

features_test.odin

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

main.odin

@@ -3,20 +3,15 @@ package main
 import "core:fmt"
 import "core:os"
 
-GO_BINARY :: "./envr-go"
-
 main :: proc() {
 	cmd, ok := parse_args()
 	if !ok {
 		return
 	}
 
-	if !is_implemented(cmd.name) {
-		fallback_to_go()
-		return
-	}
-
 	switch cmd.name {
+	case "init":
+		cmd_init(&cmd)
 	case "version":
 		cmd_version(&cmd)
 	case "deps":
@@ -31,6 +26,12 @@ main :: proc() {
 		cmd_restore(&cmd)
 	case "edit-config":
 		cmd_edit_config(&cmd)
+	case "check":
+		cmd_check(&cmd)
+	case "scan":
+		cmd_scan(&cmd)
+	case "sync":
+		cmd_sync(&cmd)
 	case:
 		fmt.printf("Unknown command: %s\n", cmd.name)
 		print_usage()
@@ -38,31 +39,4 @@ main :: proc() {
 	}
 }
 
-fallback_to_go :: proc() {
-	args := make([dynamic]string)
-	append(&args, "./envr-go")
-	for i in 1..<len(os.args) {
-		append(&args, os.args[i])
-	}
 
-	desc := os.Process_Desc{
-		command = args[:],
-		stdin = os.stdin,
-		stdout = os.stdout,
-		stderr = os.stderr,
-	}
-
-	p, err1 := os.process_start(desc)
-	if err1 != nil {
-		fmt.printf("Error: failed to run envr-go: %v\n", err1)
-		os.exit(1)
-	}
-
-	state, err2 := os.process_wait(p)
-	if err2 != nil {
-		fmt.printf("Error waiting for envr-go: %v\n", err2)
-		os.exit(1)
-	}
-
-	os.exit(int(state.exit_code))
-}

prompt.odin

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

scan.odin

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

scan_test.odin

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

stubs.odin

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

table.odin

@@ -1,11 +1,16 @@
 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() {
-		render_json_rows(headers, rows)
+		w := io.to_writer(os.to_writer(os.stdout))
+		render_json_rows(w, headers, rows)
+		io.write_string(w, "\n")
 		return
 	}
 
@@ -71,20 +76,22 @@ render_table :: proc(headers: []string, rows: [][]string) {
 	hline(&b, "\u2514", "\u2534", "\u2518", col_widths)
 }
 
-render_json_rows :: proc(headers: []string, rows: [][]string) {
+render_json_rows :: proc(w: io.Writer, headers: []string, rows: [][]string) {
-	fmt.print("[")
+	entries := make([dynamic]map[string]string, 0, len(rows))
-	for i in 0..<len(rows) {
+	defer delete(entries)
-		if i > 0 {
+
-			fmt.print(",")
+	for row in rows {
+		entry: map[string]string
+		for i in 0..<len(headers) {
+			entry[headers[i]] = row[i]
 		}
-		fmt.print("{")
+		append(&entries, entry)
-		for j in 0..<len(headers) {
-			if j > 0 {
-				fmt.print(",")
-			}
-			fmt.printf("\"%s\":\"%s\"", headers[j], rows[i][j])
-		}
-		fmt.print("}")
 	}
-	fmt.println("]")
+
+	data, err := json.marshal(entries[:])
+	if err != nil {
+		fmt.eprintf("Error marshaling JSON: %v\n", err)
+		return
+	}
+	io.write_string(w, string(data))
 }

table_test.odin

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

tty.odin

@@ -5,3 +5,4 @@ import "core:sys/posix"
 is_tty :: proc() -> bool {
 	return bool(posix.isatty(1))
 }
+