feat: Added --color flag.

refactor: Used RTTI for more sophisticated flag parsing.
nix: Fixed the nix build.
2026-08-26 18:03:32 -04:00 · 2026-06-26 14:15:20 -04:00 · 2026-06-26 13:49:01 -04:00 · 2026-06-25 18:08:08 -04:00 · 2026-06-25 18:07:31 -04:00 · 2026-06-25 18:00:54 -04:00
53 changed files with 711 additions and 1923 deletions
@@ -1,3 +1 @@
 use flake
-
-export PATH="./:$PATH"
@@ -2,7 +2,6 @@ on:
  push:
    branches:
      - main
-      - prerelease

 permissions:
  contents: write
@@ -15,6 +15,5 @@ envr-prof
 findr/findr
 findr/findr-prof
 findr/bench-*.md
-gendocs
 result
 version.odin
@@ -1,69 +1,5 @@
 # Changelog

-## [1.0.0](https://github.com/sbrow/envr/compare/v0.4.0...v1.0.0) (2026-07-27)
-
-
-### ⚠ BREAKING CHANGES
-
-* Renamed `nushell-completion` command to `completion nushell`.
-* Databases with a JSON formatted remotes column will no longer parse correctly. If you have an old database, make sure you upgrade to envr 0.4.0 and run `envr list` before upgrading to this version.
-
-### Features
-
-* Added `uninstall` command. ([222a0a3](https://github.com/sbrow/envr/commit/222a0a3452b978d9bd14d6d2b91e40cd8f4959e3))
-* Added bash completion support. ([e0a339e](https://github.com/sbrow/envr/commit/e0a339e8ec996c0e91e27357854abd9a78bd695a))
-* Brought back the docs generator. ([86a4da6](https://github.com/sbrow/envr/commit/86a4da6cbaae698379c73b8345e6d238b2a11a46))
-* Improved nushell wrapper output. ([209ec89](https://github.com/sbrow/envr/commit/209ec89addbed4718c5aed845ab20b386d1e425d))
-* Scan results can now be filtered during selection. ([ae42d53](https://github.com/sbrow/envr/commit/ae42d53f029dd185143a645fb3f3a787051c1bb4))
-
-
-### Bug Fixes
-
-* Removed irrelevent flags from `nushell-completion` command help text. ([af1860c](https://github.com/sbrow/envr/commit/af1860c970604470992182bbfe9ecb15609a0acf))
-
-
-### Performance Improvements
-
-* Added `#no_bounds_check` to ssh parsers. ([f5624e9](https://github.com/sbrow/envr/commit/f5624e91f1236eecb263f28600ce7f4b2fda149f))
-* Added a pre-alloc opportunity. ([997f11b](https://github.com/sbrow/envr/commit/997f11b257f1c981f73c6ae97d6e821147b5e2fc))
-* Removed support for JSON formatted remotes. ([5282a44](https://github.com/sbrow/envr/commit/5282a4414b9a0211604553f2cb9434025aa5296b))
-
-
-### Code Refactoring
-
-* Renamed `nushell-completion` command to `completion nushell`. ([b0635e0](https://github.com/sbrow/envr/commit/b0635e035c44fb20f9b02265cff1ed8db30aa9d0))
-
-## [0.4.0](https://github.com/sbrow/envr/compare/v0.3.0...v0.4.0) (2026-06-29)
-
-
-### Features
-
-* Added `--color` flag. ([c3e667e](https://github.com/sbrow/envr/commit/c3e667e7bca660b21b5851460691ec8bd5026f80))
-* Added `--format`, `-f` flag. ([bb84c56](https://github.com/sbrow/envr/commit/bb84c56c98bead9ce9bad3f89fb3b61b53d05a10))
-* Colorized console output. ([33cd7c4](https://github.com/sbrow/envr/commit/33cd7c4eda43287fe3dc2d2289a4e1531b524ef6))
-* Removed runtime git dependency. ([12574e1](https://github.com/sbrow/envr/commit/12574e123bdedba3aca813143e906ec5e0b95719))
-
-
-### Bug Fixes
-
-* -h short flag now works on subcommands. ([2b68617](https://github.com/sbrow/envr/commit/2b68617b5d6c17444b04307d7b4b7f4a3aefb978))
-* Databases errors are less likely to go unnoticed. ([f825bc2](https://github.com/sbrow/envr/commit/f825bc2b096632bb258d5681b1072941e9d4233d))
-* Fixed leaks. ([c7c254f](https://github.com/sbrow/envr/commit/c7c254f6f2ac871182f3fcc233766884753e2049))
-* Fixed memory leaks in the db. ([5059572](https://github.com/sbrow/envr/commit/5059572951b3ec20b3d2027032a9c3be5cb14dba))
-* Fixed some leaks in `backup` and `scan`. ([dc72ff5](https://github.com/sbrow/envr/commit/dc72ff56fd0e165930771682b2fd266eef3e7e16))
-* Fixed vet errors. ([1562fb3](https://github.com/sbrow/envr/commit/1562fb3665b8704dcffd4944047f7984b308e52e))
-* Flags in help text are now customized per command. ([fb90342](https://github.com/sbrow/envr/commit/fb903421265baa65adbbe092f6bf797639f1fb1f))
-* Handled mk_dir error. ([de1594d](https://github.com/sbrow/envr/commit/de1594d9d1fe46dd9ebc3be01fc5a5ebaf4064e5))
-* **scan:** Fixed a bug preventing TUI from working. ([0083e4e](https://github.com/sbrow/envr/commit/0083e4e0dbc5b949a3cf4cd8b64af4f698ed9d33))
-* Used os path separator rather than '/' where appropriate. ([5cc7973](https://github.com/sbrow/envr/commit/5cc79737753f0f19db2bc55304ea5f70237cbffd))
-
-
-### Performance Improvements
-
-* Improved the performance of table rendering. ([0b5bf4d](https://github.com/sbrow/envr/commit/0b5bf4db73113bdd43d8a225ec0ae53fedd25918))
-* remotes are now stored as a newline delimited list. ([96b3d63](https://github.com/sbrow/envr/commit/96b3d6340a95b67c884ba940b46461e51989fcbb))
-* Replaced `fd` with custom internals. ([2ef733f](https://github.com/sbrow/envr/commit/2ef733fe58594b0a0b6e3ef85142b74af445ccb8))
-
 ## [0.3.0](https://github.com/sbrow/envr/compare/v0.2.1...v0.3.0) (2026-06-16)

 Version 0.3.0 represents a significant departure (and improvement) for envr.
@@ -2,7 +2,7 @@
 # Builds release artifacts for GitHub releases

 APP_NAME := envr
-VERSION := $(file < version.txt)
+VERSION := $(shell grep 'version = ' flake.nix | head -1 | sed 's/.*version = "\(.*\)";/\1/')
 BUILD_DIR := builds

 # Binary names
@@ -10,8 +10,6 @@ in an encyrpted sqlite database. Changes can be effortlessly synced with
 `envr` puts all your .env files in one safe place, so you can back them up with
 the tool [of your choosing](#backup-options).

-Please read the [AI Disclosure](#ai-disclosure) if you're concerned about AI code.
-
 ## Features

 - **Encrypted Storage**: All `.env` files are encrypted using your ssh key and
@@ -127,22 +125,6 @@ location.

 [restic](https://restic.readthedocs.io/en/latest/010_introduction.html).

-## AI Disclosure
-
-This project was largely built by AI. The original project (written in go) was
-written almost entirely with AI, using libraries that I requested (i.e. cobra).
-
-I wrote it at work because I needed the tool and wanted it fast. The Odin version
-was also primarily written by AI, but I stepped in a lot more, and took care to
-architect the project in the way that I wanted, and made sure tests were written
-to catch leaks.
-
-Most of the documentation was written by hand, but I think the original `README.md`
-was at least fleshed out by AI.
-
-It is by no means perfect, but I have spent a lot of time doing code review and
-testing to make sure the program (and documentation) meet my personal standards.
-
 ## License

 This project is licensed under the [MIT License](./LICENSE).
@@ -6,14 +6,29 @@

 3. procedures should be ordered by use, main at the top, then in the order they are called from main.

-4. Test all command branches.
+4. Check for prealloc opportunities. i.e. `make([dynamic]string)` -> `make([dynamic]string, 5)`.

-6. Add tests for untested commands.
+5. Test all cmds / terminal branches.

-7. Add purge command?
+6. Generate md and man pages again.

-8. Add docs for "building from source"
+7. Shell completion

+8. Add tests for untested commands.
+
+9. Update `read_wire_string` to use a slice.
+
+10. Pass allocator to findr?
+
+11. Smarter flag parsing?
+
+12. Rewrite `write_command_help` to use text/tables
+
+13. Instead of using a writer to strip colors, just don't print the colors.
+
+14. Add a text filter to the multi_select.
+
+15. init -h doesn't show --force flag. Separate into multiple structs: Global_FLags, and Init_Flags?

 ## Double-check AI output

@@ -43,7 +58,7 @@
 - [ ] db_test.odin
 - [ ] flags.odin
 - [x] main.odin
- [ ] prompt.odin
+- [x] prompt.odin
 - [x] scan.odin
 - [ ] scan_test.odin
 - [ ] sodium.odin
@@ -1,11 +1,9 @@
 package main

-import "base:runtime"
 import "core:bufio"
 import "core:fmt"
 import "core:io"
 import "core:os"
-import "core:reflect"
 import "core:strings"
 import "core:terminal"
 import "core:text/table"
@@ -19,20 +17,13 @@ Command :: struct {
 	err:     io.Writer,
 }

+// TODO: Put help test in usage:"whatever" tag.
 Flags :: struct {
-	help:        bool `args:"short=h" usage:"show this documentation"`,
-	config_file: string `args:"name=config-file,short=c" usage:"config file" default:"~/.envr/config.json"`,
-	output:      Output_Format `args:"short=o" usage:"the format of output data" default:"table" completion:"output"`,
-	color:       Color_Mode `usage:"Whether or not to colorize output" default:"auto" completion:"color"`,
-	force:       bool `args:"short=f" usage:"Overwrite existing config"`,
-}
-
-Flag_Type :: enum {
-	Help,
-	Config_File,
-	Output,
-	Color,
-	Force,
+	help:        bool `args:"short=h"`,
+	config_file: string `args:"name=config-file,short=c"`,
+	output:      Output_Format `args:"short=o"`,
+	color:       Color_Mode,
+	force:       bool `args:"short=f"`,
 }

 Output_Format :: enum {
@@ -47,128 +38,40 @@ Color_Mode :: enum {
 	Never,
 }

-Positional_Arg :: struct {
-	name:       string,
-	ntype:      string, // nushell type: "path", "string". "" defaults to "path"
-	completion: string,
-	optional:   bool,
-	desc:       string,
-}
-
 CommandInfo :: struct {
 	name:    string,
 	usage:   string,
 	short:   string,
 	long:    string,
 	aliases: []string,
-	// Flags supported by the command
-	flags:   bit_set[Flag_Type],
-	args:    []Positional_Arg,
 }

-GLOBAL_FLAGS: bit_set[Flag_Type] = {.Help, .Config_File, .Color}
-
 COMMANDS := []CommandInfo {
 	{
-		name = "init",
-		usage = "envr init",
-		short = "Set up envr",
-		long = `The init command generates your initial config and saves it to
+		"init",
+		"envr init",
+		"Set up envr",
+		`The init command generates your initial config and saves it to
 ~/.envr/config in JSON format.\n\nDuring 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 = GLOBAL_FLAGS + {.Force},
+		{},
 	},
+	{"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", "", {}},
+	{"version", "envr version", "Show envr's version", "", {}},
+	{"edit-config", "envr edit-config", "Edit your config with your default editor", "", {}},
 	{
-		name = "scan",
-		usage = "envr scan",
-		short = "Find and select .env files for backup",
-		flags = GLOBAL_FLAGS,
-	},
-	{
-		name = "sync",
-		usage = "envr sync",
-		short = "Update or restore your env backups",
-		flags = GLOBAL_FLAGS + {.Output},
-	},
-	{
-		name = "backup",
-		usage = "envr backup <path>",
-		short = "Import a .env file into envr",
-		aliases = {"add"},
-		flags = GLOBAL_FLAGS,
-		args = {
-			{name = "path", completion = "untracked-paths", desc = "Path to .env file to backup"},
-		},
-	},
-	{
-		name = "restore",
-		usage = "envr restore <path>",
-		short = "Restore a .env file from the database",
-		flags = GLOBAL_FLAGS,
-		args = {
-			{name = "path", completion = "tracked-paths", desc = "Path to .env file to restore"},
-		},
-	},
-	{
-		name = "list",
-		usage = "envr list",
-		short = "View your tracked files",
-		flags = GLOBAL_FLAGS + {.Output},
-	},
-	{
-		name = "remove",
-		usage = "envr remove <path>",
-		short = "Remove a .env file from your database",
-		flags = GLOBAL_FLAGS,
-		args = {
-			{name = "path", completion = "tracked-paths", desc = "Path to .env file to remove"},
-		},
-	},
-	{
-		name = "check",
-		usage = "envr check [path]",
-		short = "Check if files are backed up",
-		flags = GLOBAL_FLAGS,
-		args = {
-			{
-				name = "path",
-				optional = true,
-				desc = "Path to check (defaults to current directory)",
-			},
-		},
-	},
-	{name = "version", usage = "envr version", short = "Show envr's version", flags = {.Help}},
-	{
-		name = "edit-config",
-		usage = "envr edit-config",
-		short = "Edit your config with your default editor",
-		flags = GLOBAL_FLAGS,
-	},
-	{
-		name = "completion",
-		usage = "envr completion <shell>",
-		short = "Generate shell completion scripts",
-		long = `Supported shells:
-
-  nushell
-  bash`,
-		flags = {.Help},
-		args = {
-			{
-				name = "shell",
-				ntype = "string",
-				completion = "shells",
-				desc = "Shell to generate completions for",
-			},
-		},
-	},
-	{
-		name = "uninstall",
-		usage = "envr uninstall",
-		short = "Remove envr configuration and database",
-		long = "This will remove all files generated by envr from your system.",
-		flags = GLOBAL_FLAGS + {.Force},
+		"nushell-completion",
+		"envr nushell-completion",
+		"Generate custom completions for nushell",
+		"",
+		{},
 	},
 }

@@ -188,7 +91,7 @@ parse_args :: proc(args: []string, out: io.Stream, err: io.Stream) -> (cmd: Comm
 	}

 	cmd.name = args[1]
-	cmd.args = make([dynamic]string, 0, len(args[2:]))
+	cmd.args = make([dynamic]string)

 	overflow := parse_flags(&cmd.flags, args[2:])
 	for arg in overflow {
@@ -203,7 +106,7 @@ parse_args :: proc(args: []string, out: io.Stream, err: io.Stream) -> (cmd: Comm
 		cmd.flags.color = terminal.is_terminal(os.stdout) ? .Always : .Never
 	}
 	if cmd.flags.color == .Never {
-		disable_color = true
+		cmd.out = make_ansi_strip_writer(cmd.out)
 	}

 	if cmd.flags.config_file == "" {
@@ -231,7 +134,6 @@ print_command_help :: proc(cmd: ^Command) {
 }

 write_command_help :: proc(name: string, w: io.Writer) -> bool {
-	// TODO: rename info to cmd?
 	info, found := find_command(name)
 	if !found {
 		return false
@@ -239,23 +141,36 @@ write_command_help :: proc(name: string, w: io.Writer) -> bool {

 	fmt.wprintf(
 		w,
-		"%s\n\n\n%s\n\n  %s [flags]\n\n",
+		"%s\n\n\n" +
+		COLOR_HEADINGS +
+		"Usage:" +
+		ANSI_RESET +
+		"\n\n  " +
+		COLOR_FLAGS +
+		"%s" +
+		ANSI_RESET +
+		" [flags]\n\n",
 		info.short,
-		colorize(.Heading, "Usage:"),
-		colorize(.Flag, info.usage),
+		info.usage,
 		flush = false,
 	)

 	if len(info.aliases) > 0 {
 		fmt.wprintf(
 			w,
-			"\n%s\n\n  %s",
-			colorize(.Heading, "Aliases:"),
-			colorize(.Command, info.name),
+			"\n" +
+			COLOR_HEADINGS +
+			"Aliases:" +
+			ANSI_RESET +
+			"\n\n  " +
+			COLOR_COMMANDS +
+			"%s" +
+			ANSI_RESET,
+			info.name,
 			flush = false,
 		)
 		for a in info.aliases {
-			fmt.wprintf(w, ", %s", colorize(.Command, a), flush = false)
+			fmt.wprintf(w, ", " + COLOR_COMMANDS + "%s" + ANSI_RESET, a, flush = false)
 		}
 		fmt.wprintf(w, "\n", flush = false)
 	}
@@ -264,135 +179,28 @@ write_command_help :: proc(name: string, w: io.Writer) -> bool {
 		fmt.wprintf(w, "\n%s\n", info.long, flush = false)
 	}

-	tbl: table.Table
-	table.init(&tbl, context.temp_allocator, context.temp_allocator)
-	table.padding(&tbl, 2, 0)
-	write_flags_table(&tbl, info.flags)
-	fmt.wprintf(w, "\n", flush = false)
-	write_borderless_table(w, &tbl)
-	table_reset(&tbl)
+	fmt.wprintf(
+		w,
+		"\n" +
+		COLOR_HEADINGS +
+		"Flags:" +
+		ANSI_RESET +
+		"\n\n  " +
+		COLOR_FLAGS +
+		"-h, --help" +
+		ANSI_RESET +
+		"   help for %s\n  " +
+		COLOR_FLAGS +
+		"-c, --config-file" +
+		ANSI_RESET +
+		` <path>   config file (default "~/.envr/config.json")
+`,
+		info.name,
+		flush = false,
+	)
 	return true
 }

-Flag_Kind :: enum {
-	Bool,
-	String,
-	Enum,
-}
-
-Flag_Field :: struct {
-	long_name:   string,
-	short_name:  string,
-	kind:        Flag_Kind,
-	usage:       string,
-	default_val: string,
-	enum_values: string,
-	completion:  string,
-}
-
-write_flags_table :: proc(tbl: ^table.Table, flags: bit_set[Flag_Type]) {
-	table.caption(tbl, "Flags:")
-	for ft in Flag_Type {
-		if ft not_in flags do continue
-		names, hint, desc := flag_field_info(ft)
-		if len(hint) > 0 {
-			display := table.format(
-				tbl,
-				"%s%s",
-				colorize(.Flag, names, tbl.format_allocator),
-				hint,
-			)
-			table.row(tbl, display, desc)
-		} else {
-			table.row(tbl, colorize(.Flag, names, tbl.format_allocator), desc)
-		}
-	}
-}
-
-flag_field_info :: proc(
-	ft: Flag_Type,
-) -> (
-	names: string,
-	value_hint: string,
-	description: string,
-) {
-	f := flag_field(ft)
-
-	if len(f.short_name) > 0 {
-		names = fmt.tprintf("-%s, --%s", f.short_name, f.long_name)
-	} else {
-		names = fmt.tprintf("--%s", f.long_name)
-	}
-
-	switch f.kind {
-	case .Bool:
-		value_hint = ""
-	case .String:
-		value_hint = " <value>"
-	case .Enum:
-		value_hint = fmt.tprintf(" %s", f.enum_values)
-	}
-
-	description = f.usage
-	if len(f.default_val) > 0 {
-		switch f.kind {
-		case .Bool:
-		// do nothing
-		case .String:
-			description = fmt.tprintf(`%s (default "%s")`, f.usage, f.default_val)
-		case .Enum:
-			description = fmt.tprintf("%s (default '%s')", f.usage, f.default_val)
-		}
-	}
-
-	return
-}
-
-flag_field :: proc(ft: Flag_Type) -> Flag_Field {
-	field := reflect.struct_field_at(Flags, int(ft))
-
-	args_tag := reflect.struct_tag_get(field.tag, "args")
-	long_name, _ := strings.replace(field.name, "_", "-", -1, context.temp_allocator)
-	if n, ok := get_subtag(args_tag, "name"); ok {
-		long_name = n
-	}
-
-	short, has_short := get_subtag(args_tag, "short")
-
-	base_ti := runtime.type_info_base(field.type)
-	kind: Flag_Kind
-	enum_values: string
-
-	if _, is_bool := base_ti.variant.(runtime.Type_Info_Boolean); is_bool {
-		kind = .Bool
-	} else if _, is_string := base_ti.variant.(runtime.Type_Info_String); is_string {
-		kind = .String
-	} else if enum_ti, is_enum := base_ti.variant.(runtime.Type_Info_Enum); is_enum {
-		kind = .Enum
-		parts := make([dynamic]string, 0, len(enum_ti.names), context.temp_allocator)
-		for name in enum_ti.names {
-			lower := strings.to_lower(name, context.temp_allocator)
-			append(&parts, fmt.tprintf("'%s'", lower))
-		}
-		enum_values = strings.join(parts[:], "|", context.temp_allocator)
-		delete(parts)
-	}
-
-	usage := reflect.struct_tag_get(field.tag, "usage")
-	default_val := reflect.struct_tag_get(field.tag, "default")
-	completion := reflect.struct_tag_get(field.tag, "completion")
-
-	return {
-		long_name = long_name,
-		short_name = has_short ? short : "",
-		kind = kind,
-		usage = usage,
-		default_val = default_val,
-		enum_values = enum_values,
-		completion = completion,
-	}
-}
-
 find_command :: proc(name: string) -> (CommandInfo, bool) {
 	for c in COMMANDS {
 		if c.name == name {
@@ -407,7 +215,11 @@ find_command :: proc(name: string) -> (CommandInfo, bool) {
 	return CommandInfo{}, false
 }

-ENVR_DESCRIPTION :: `envr keeps your .env synced to a local, encrypted database.
+// TODO: command args should be shown in usage.
+write_usage :: proc(w: io.Writer) {
+	fmt.wprintf(
+		w,
+		`envr keeps your .env synced to a local, 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.

@@ -436,16 +248,17 @@ Select the files you want to back up from the interactive list.
 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`
+> envr restore ~/<path to repository>/.env

-// TODO: command args should be shown in usage.
-write_usage :: proc(w: io.Writer) {
-	fmt.wprintf(
-		w,
-		"%s\n\n%s\n\n  %s [command]\n\n",
-		ENVR_DESCRIPTION,
-		colorize(.Heading, "Usage:"),
-		colorize(.Flag, "envr"),
+%sUsage:%s
+
+  %senvr%s [command]
+
+`,
+		COLOR_HEADINGS,
+		ANSI_RESET,
+		COLOR_FLAGS,
+		ANSI_RESET,
 		flush = false,
 	)

@@ -461,20 +274,37 @@ write_usage :: proc(w: io.Writer) {
 		for a in c.aliases {
 			name = strings.join([]string{name, a}, ", ", tbl.format_allocator)
 		}
-		table.row(&tbl, colorize(.Command, name, tbl.format_allocator), c.short)
+		table.row(&tbl, table.format(&tbl, "%s%s%s", COLOR_COMMANDS, name, ANSI_RESET), c.short)
 	}

 	write_borderless_table(w, &tbl)
 	table_reset(&tbl)

-	write_flags_table(&tbl, GLOBAL_FLAGS)
+	table.caption(&tbl, "Flags:")
+
+	table.row(&tbl, COLOR_FLAGS + "-h, --help" + ANSI_RESET, `show this documentation`)
+	table.row(
+		&tbl,
+		COLOR_FLAGS + "-c, --config-file" + ANSI_RESET + " <path>",
+		`config file (default "~/.envr/config.json")`,
+	)
+	table.row(
+		&tbl,
+		COLOR_FLAGS + "-o, --output" + ANSI_RESET + " 'table'|'json'",
+		`the format of output data. (default 'table')`,
+	)
+	table.row(
+		&tbl,
+		COLOR_FLAGS + "--color" + ANSI_RESET + " 'auto'|'always'|'never'",
+		`Whether or not to colorize output. (default 'auto')`,
+	)
 	write_borderless_table(w, &tbl)
-	table_reset(&tbl)

 	fmt.wprintf(
 		w,
-		`Use "%s [command] --help" for more information about a command.`,
-		colorize(.Flag, "envr", tbl.format_allocator),
+		`Use "%senvr%s [command] --help" for more information about a command.`,
+		COLOR_FLAGS,
+		ANSI_RESET,
 		flush = false,
 	)
 }
@@ -110,8 +110,7 @@ test_command_help_init_no_aliases :: proc(t: ^testing.T) {
 	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'")
-	testing.expect(t, strings.contains(text, "--force"), "missing --force flag")
-}
+}

@(test)
 test_command_help_unknown :: proc(t: ^testing.T) {
@@ -1,268 +0,0 @@
-package main
-
-import "core:fmt"
-import "core:strings"
-
-nushell_header :: `def tracked-paths [] {
-  (
-    ^envr list
-    | from json
-    | each {
-      [$in.directory $in.path] | path join
-    }
-  )
-}
-
-def untracked-paths [] {
-  (
-    ^envr scan
-    | from json
-  )
-}
-
-def color [] {
-  ['auto' 'always' 'never']
-}
-
-def output [] {
-  ['auto' 'table' 'json']
-}
-
-def shells [] {
-  ['nushell' 'bash']
-}
-
-`
-
-cmd_completion :: proc(cmd: ^Command) {
-	if len(cmd.args) == 0 {
-		print_command_help(cmd)
-		return
-	}
-
-	switch cmd.args[0] {
-	case "nushell":
-		fmt.wprint(cmd.out, generate_nushell_completion(), flush = true)
-	case "bash":
-		fmt.wprint(cmd.out, generate_bash_completion(), flush = true)
-	case:
-		fmt.wprintf(cmd.err, "Unsupported shell: %s\n", cmd.args[0])
-		fmt.wprintln(cmd.err, "Supported shells: nushell, bash")
-	}
-}
-
-generate_nushell_completion :: proc() -> string {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	fmt.sbprint(&sb, nushell_header)
-
-	for c in COMMANDS {
-		fmt.sbprintf(&sb, "# %s\n", c.short)
-		fmt.sbprintf(&sb, "export extern \"envr %s\" [\n", c.name)
-		for ft in Flag_Type {
-			if ft not_in c.flags do continue
-			f := flag_field(ft)
-			fmt.sbprintf(&sb, "  %s\n", nushell_flag_line(f))
-		}
-		for arg in c.args {
-			fmt.sbprintf(&sb, "  %s\n", nushell_positional_line(arg))
-		}
-		fmt.sbprintf(&sb, "]\n")
-
-		for a in c.aliases {
-			fmt.sbprintf(&sb, "\nexport alias \"envr %s\" = envr %s\n", a, c.name)
-		}
-		fmt.sbprintf(&sb, "\n")
-	}
-
-	return strings.to_string(sb)
-}
-
-nushell_flag_line :: proc(f: Flag_Field) -> string {
-	line: string
-	if len(f.short_name) > 0 {
-		line = fmt.tprintf("--%s(-%s)", f.long_name, f.short_name)
-	} else {
-		line = fmt.tprintf("--%s", f.long_name)
-	}
-
-	switch f.kind {
-	case .Bool:
-	case .String:
-		line = fmt.tprintf("%s: path", line)
-	case .Enum:
-		if len(f.completion) > 0 {
-			line = fmt.tprintf("%s: string@%s", line, f.completion)
-		} else {
-			line = fmt.tprintf("%s: string", line)
-		}
-	}
-
-	return fmt.tprintf("%s  # %s", line, f.usage)
-}
-
-nushell_positional_line :: proc(arg: Positional_Arg) -> string {
-	name := arg.name
-	if arg.optional {
-		name = fmt.tprintf("%s?", name)
-	}
-	ntype := len(arg.ntype) > 0 ? arg.ntype : "path"
-	if len(arg.completion) > 0 {
-		return fmt.tprintf("%s: %s@%s", name, ntype, arg.completion)
-	}
-	return fmt.tprintf("%s: %s", name, ntype)
-}
-
-bash_header :: `
-_envr() {
-    local cur prev cmd
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
-    cmd="${COMP_WORDS[1]}"
-
-`
-
-bash_footer :: `
-}
-
-complete -F _envr envr
-`
-
-generate_bash_completion :: proc() -> string {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	fmt.sbprint(&sb, bash_header)
-
-	// B: Subcommand completion
-	fmt.sbprintf(&sb, "    if [[ $COMP_CWORD -eq 1 ]]; then\n")
-	fmt.sbprintf(&sb, "        COMPREPLY=( $(compgen -W \"")
-	first := true
-	for c in COMMANDS {
-		if !first do fmt.sbprintf(&sb, " ")
-		fmt.sbprintf(&sb, "%s", c.name)
-		first = false
-		for a in c.aliases {
-			fmt.sbprintf(&sb, " %s", a)
-		}
-	}
-	fmt.sbprintf(&sb, "\" -- \"$cur\") )\n")
-	fmt.sbprintf(&sb, "        return\n")
-	fmt.sbprintf(&sb, "    fi\n\n")
-
-	// C: Flag value completion
-	fmt.sbprintf(&sb, "    case \"$prev\" in\n")
-	for ft in Flag_Type {
-		f := flag_field(ft)
-		if f.kind == .Bool do continue
-
-		pattern := fmt.tprintf("--%s", f.long_name)
-		if len(f.short_name) > 0 {
-			pattern = fmt.tprintf("%s|-%s", pattern, f.short_name)
-		}
-		fmt.sbprintf(&sb, "        %s)\n", pattern)
-
-		switch f.kind {
-		case .Enum:
-			fmt.sbprintf(
-				&sb,
-				"            COMPREPLY=( $(compgen -W \"%s\" -- \"$cur\") )\n",
-				bash_enum_values(f.enum_values),
-			)
-		case .String:
-			fmt.sbprintf(&sb, "            COMPREPLY=( $(compgen -f -- \"$cur\") )\n")
-		case .Bool:
-			panic("unexpected")
-		}
-		fmt.sbprintf(&sb, "            return\n")
-		fmt.sbprintf(&sb, "            ;;\n")
-	}
-	fmt.sbprintf(&sb, "    esac\n\n")
-
-	// D: Flag name completion per command
-	fmt.sbprintf(&sb, "    case \"$cur\" in -*)\n")
-	fmt.sbprintf(&sb, "        case \"$cmd\" in\n")
-	for c in COMMANDS {
-		if c.flags == {} do continue
-
-		cmd_pattern := c.name
-		for a in c.aliases {
-			cmd_pattern = fmt.tprintf("%s|%s", cmd_pattern, a)
-		}
-		fmt.sbprintf(&sb, "            %s)\n", cmd_pattern)
-		fmt.sbprintf(&sb, "                COMPREPLY=( $(compgen -W \"")
-
-		flag_first := true
-		for ft in Flag_Type {
-			if ft not_in c.flags do continue
-			f := flag_field(ft)
-			if !flag_first do fmt.sbprintf(&sb, " ")
-			fmt.sbprintf(&sb, "--%s", f.long_name)
-			if len(f.short_name) > 0 {
-				fmt.sbprintf(&sb, " -%s", f.short_name)
-			}
-			flag_first = false
-		}
-		fmt.sbprintf(&sb, "\" -- \"$cur\") )\n")
-		fmt.sbprintf(&sb, "                return\n")
-		fmt.sbprintf(&sb, "                ;;\n")
-	}
-	fmt.sbprintf(&sb, "        esac\n")
-	fmt.sbprintf(&sb, "        ;;\n")
-	fmt.sbprintf(&sb, "    esac\n\n")
-
-	// E: Positional completion
-	fmt.sbprintf(&sb, "    case \"$cmd\" in\n")
-	for c in COMMANDS {
-		has_comp := false
-		for arg in c.args {
-			if len(arg.completion) > 0 {
-				has_comp = true
-				break
-			}
-		}
-		if !has_comp do continue
-
-		cmd_pattern := c.name
-		for a in c.aliases {
-			cmd_pattern = fmt.tprintf("%s|%s", cmd_pattern, a)
-		}
-		fmt.sbprintf(&sb, "        %s)\n", cmd_pattern)
-
-		for arg in c.args {
-			if len(arg.completion) == 0 do continue
-
-			comp: string
-			switch arg.completion {
-			case "tracked-paths":
-				comp = "$(envr list --output json 2>/dev/null)"
-			case "untracked-paths":
-				comp = "$(envr scan --output json 2>/dev/null)"
-			case "shells":
-				comp = "nushell bash"
-			case:
-				continue
-			}
-
-			fmt.sbprintf(&sb, "            COMPREPLY=( $(compgen -W \"%s\" -- \"$cur\") )\n", comp)
-		}
-		fmt.sbprintf(&sb, "            return\n")
-		fmt.sbprintf(&sb, "            ;;\n")
-	}
-	fmt.sbprintf(&sb, "    esac\n")
-
-	fmt.sbprint(&sb, bash_footer)
-
-	return strings.to_string(sb)
-}
-
-bash_enum_values :: proc(enum_values: string) -> string {
-	s, _ := strings.replace(enum_values, "'", "", -1, context.temp_allocator)
-	s, _ = strings.replace(s, "|", " ", -1, context.temp_allocator)
-	return s
-}
-
@@ -1,133 +0,0 @@
-#+test
-package main
-
-import "core:fmt"
-import "core:strings"
-import "core:testing"
-
-@(test)
-test_nushell_completion_nonempty :: proc(t: ^testing.T) {
-	script := generate_nushell_completion()
-	testing.expect(t, len(script) > 0, "completion script should not be empty")
-}
-
-@(test)
-test_nushell_completion_contains_commands :: proc(t: ^testing.T) {
-	script := generate_nushell_completion()
-	expected := []string{
-		"tracked-paths",
-		"untracked-paths",
-		"envr backup",
-		"envr check",
-		"envr edit-config",
-		"envr init",
-		"envr list",
-		"envr remove",
-		"envr restore",
-		"envr scan",
-		"envr sync",
-		"envr version",
-		"envr completion",
-	}
-	for ext in expected {
-		testing.expect(
-			t,
-			strings.contains(script, ext),
-			fmt.tprintf("expected script to contain %q", ext),
-		)
-	}
-}
-
-@(test)
-test_nushell_completion_contains_flags :: proc(t: ^testing.T) {
-	script := generate_nushell_completion()
-	expected_flags := []string{
-		"--help(-h)",
-		"--config-file(-c)",
-		"--color",
-		"--force(-f)",
-		"--output(-o)",
-	}
-	for flag in expected_flags {
-		testing.expect(
-			t,
-			strings.contains(script, flag),
-			fmt.tprintf("expected script to contain %q", flag),
-		)
-	}
-}
-
-@(test)
-test_nushell_completion_contains_aliases :: proc(t: ^testing.T) {
-	script := generate_nushell_completion()
-	testing.expect(
-		t,
-		strings.contains(script, "envr add"),
-		"expected script to contain 'envr add' alias",
-	)
-}
-
-@(test)
-test_nushell_completion_no_help_command :: proc(t: ^testing.T) {
-	script := generate_nushell_completion()
-	testing.expect(
-		t,
-		!strings.contains(script, "envr help"),
-		"script should not contain 'envr help' (not a real command)",
-	)
-}
-
-@(test)
-test_bash_completion_nonempty :: proc(t: ^testing.T) {
-	script := generate_bash_completion()
-	testing.expect(t, len(script) > 0, "bash completion script should not be empty")
-}
-
-@(test)
-test_bash_completion_contains_registration :: proc(t: ^testing.T) {
-	script := generate_bash_completion()
-	testing.expect(
-		t,
-		strings.contains(script, "complete -F _envr envr"),
-		"expected bash script to register completion function",
-	)
-}
-
-@(test)
-test_bash_completion_contains_commands :: proc(t: ^testing.T) {
-	script := generate_bash_completion()
-	expected := []string{
-		"init", "scan", "sync", "backup", "add",
-		"restore", "list", "remove", "check",
-		"version", "edit-config", "completion",
-	}
-	for cmd in expected {
-		testing.expect(
-			t,
-			strings.contains(script, cmd),
-			fmt.tprintf("expected bash script to contain %q", cmd),
-		)
-	}
-}
-
-@(test)
-test_bash_completion_contains_flags :: proc(t: ^testing.T) {
-	script := generate_bash_completion()
-	expected := []string{
-		"--help", "--config-file", "--color", "--force", "--output",
-	}
-	for flag in expected {
-		testing.expect(
-			t,
-			strings.contains(script, flag),
-			fmt.tprintf("expected bash script to contain %q", flag),
-		)
-	}
-}
-
-@(test)
-test_bash_completion_contains_enum_values :: proc(t: ^testing.T) {
-	script := generate_bash_completion()
-	testing.expect(t, strings.contains(script, "auto table json"), "missing output enum values")
-	testing.expect(t, strings.contains(script, "auto always never"), "missing color enum values")
-}
@@ -1,6 +1,7 @@
 package main

 import "core:fmt"
+import "core:terminal/ansi"

 cmd_init :: proc(cmd: ^Command) {
 	force := cmd.flags.force
@@ -37,7 +38,11 @@ Generate one with: ssh-keygen -t ed25519`,
 	selected, result := multi_select("Select SSH private keys:", keys[:])
 	defer delete(selected)
 	if result == .Cancel {
-		fmt.wprintln(cmd.out, colorize(.Message, "Cancelled."), flush = false)
+		fmt.wprintln(
+			cmd.out,
+			ansi.CSI + ansi.FAINT + ansi.SGR + "Cancelled." + ANSI_RESET,
+			flush = false,
+		)
 		return
 	}

@@ -32,8 +32,8 @@ cmd_list :: proc(cmd: ^Command) {
 		table.aligned_header_of_values(
 			&t,
 			.Center,
-			colorize(.Table_Heading, "Directory"),
-			colorize(.Table_Heading, "Path"),
+			COLOR_TABLE_HEADING + "Directory" + ANSI_RESET,
+			COLOR_TABLE_HEADING + "Path" + ANSI_RESET,
 		)

 		for row in rows {
@@ -0,0 +1,10 @@
+package main
+
+import "core:fmt"
+
+COMPLETION_SCRIPT: string : string(#load("mod.nu"))
+
+cmd_nushell_completion :: proc(cmd: ^Command) {
+	fmt.wprint(cmd.out, COMPLETION_SCRIPT, flush = false)
+}
+
@@ -0,0 +1,37 @@
+#+test
+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),
+		)
+	}
+}
@@ -4,6 +4,7 @@ import "core:encoding/json"
 import "core:fmt"
 import "core:os"
 import "core:terminal"
+import "core:terminal/ansi"

 cmd_scan :: proc(cmd: ^Command) {
 	db, db_ok := db_open(cmd.flags.config_file)
@@ -71,7 +72,11 @@ cmd_scan :: proc(cmd: ^Command) {
 	selected, result := multi_select("Select .env files to backup:", files[:])
 	defer delete(selected)
 	if result == .Cancel {
-		fmt.wprintln(cmd.out, colorize(.Message, "Cancelled."), flush = false)
+		fmt.wprintln(
+			cmd.out,
+			ansi.CSI + ansi.FAINT + ansi.SGR + "Cancelled." + ANSI_RESET,
+			flush = false,
+		)
 		return
 	}

@@ -95,16 +100,25 @@ cmd_scan :: proc(cmd: ^Command) {
 	}

 	if added_count > 0 {
-		fmt.wprintln(
+		fmt.wprintf(
 			cmd.out,
-			colorize(
-				.Sucess,
-				fmt.tprintf("Successfully added %d file(s) to backup.", added_count),
-			),
+			ansi.CSI +
+			ansi.BOLD +
+			";" +
+			ansi.FG_GREEN +
+			ansi.SGR +
+			"Successfully added %d file(s) to backup." +
+			ANSI_RESET +
+			"\n",
+			added_count,
 			flush = false,
 		)
 	} else {
-		fmt.wprintln(cmd.out, colorize(.Message, "No files were added."), flush = false)
+		fmt.wprintln(
+			cmd.out,
+			ansi.CSI + ansi.FAINT + ansi.SGR + "No files were added." + ANSI_RESET,
+			flush = false,
+		)
 	}
 }

@@ -54,8 +54,8 @@ cmd_sync :: proc(cmd: ^Command) {
 		table.aligned_header_of_values(
 			&t,
 			.Center,
-			colorize(.Table_Heading, "File"),
-			colorize(.Table_Heading, "Status"),
+			COLOR_TABLE_HEADING + "File" + ANSI_RESET,
+			COLOR_TABLE_HEADING + "Status" + ANSI_RESET,
 		)

 		for res in results {
@@ -1,64 +0,0 @@
-package main
-
-import "core:bufio"
-import "core:fmt"
-import "core:os"
-import "core:path/filepath"
-import "core:strings"
-import "core:terminal"
-
-cmd_uninstall :: proc(cmd: ^Command) {
-	envr_d := envr_dir(cmd.flags.config_file)
-
-	if !os.exists(envr_d) {
-		fmt.wprintln(cmd.out, "Nothing to remove.", flush = false)
-		return
-	}
-
-	entries, err := os.read_all_directory_by_path(envr_d, context.temp_allocator)
-	if err != nil {
-		fmt.wprintf(cmd.err, "Error reading %s: %v\n", envr_d, err, flush = false)
-		return
-	}
-
-	paths := make([]string, len(entries), context.temp_allocator)
-	for entry, i in entries {
-		paths[i], _ = filepath.join([]string{envr_d, entry.name}, context.temp_allocator)
-	}
-
-	fmt.wprintln(cmd.out, "This will remove:", flush = false)
-	for path in paths {
-		fmt.wprintf(cmd.out, "  %s\n", path, flush = false)
-	}
-	fmt.wprintf(cmd.out, "  %s\n", envr_d, flush = false)
-
-	if !cmd.flags.force {
-		if !terminal.is_terminal(os.stdin) {
-			fmt.wprintln(cmd.err, "Run with --force to skip confirmation.", flush = false)
-			return
-		}
-
-		fmt.wprintf(cmd.out, "\nAre you sure? [y/N] ", flush = false)
-		bufio.writer_flush(cmd.out_buf)
-
-		buf: [128]u8
-		n, _ := os.read(os.stdin, buf[:])
-		response := strings.trim_space(string(buf[:n]))
-
-		if response != "y" && response != "Y" {
-			fmt.wprintln(cmd.out, "Aborted.", flush = false)
-			return
-		}
-	}
-
-	remove_err := os.remove_all(envr_d)
-	if remove_err != nil {
-		fmt.wprintf(cmd.err, "Error removing %s: %v\n", envr_d, remove_err, flush = false)
-		return
-	}
-
-	for path in paths {
-		fmt.wprintf(cmd.out, "Removed %s\n", path, flush = false)
-	}
-	fmt.wprintf(cmd.out, "Removed %s\n", envr_d, flush = false)
-}
@@ -1,97 +0,0 @@
-#+test
-package main
-
-import "core:bufio"
-import "core:os"
-import "core:path/filepath"
-import "core:strings"
-import "core:testing"
-
-@(test)
-test_cmd_uninstall_force :: proc(t: ^testing.T) {
-	base := test_temp_dir(t, "envr-test-uninstall-*")
-
-	cfg_path, _ := filepath.join([]string{base, ".envr", "config.json"}, context.temp_allocator)
-	cfg := new_config([]string{"fixtures/keys/insecure-test-key"}, cfg_path)
-	testing.expect(t, save_config(cfg, force = true), "save should succeed")
-	delete_config(&cfg)
-
-	db, db_ok := db_open(cfg_path)
-	testing.expect(t, db_ok, "db should open")
-	if !db_ok do return
-	f := make_test_env_file("/project/.env", "abc123", "SECRET=value")
-	defer delete(f.remotes)
-	db_insert(&db, f)
-	db_close(&db)
-
-	envr_d := filepath.dir(cfg_path)
-	testing.expect(t, os.exists(envr_d), ".envr directory should exist before uninstall")
-
-	out_b: strings.Builder
-	strings.builder_init(&out_b)
-	defer strings.builder_destroy(&out_b)
-	err_b: strings.Builder
-	strings.builder_init(&err_b)
-	defer strings.builder_destroy(&err_b)
-
-	cmd, ok := parse_args(
-		[]string{"envr", "uninstall", "--force", "--config-file", cfg_path},
-		strings.to_stream(&out_b),
-		strings.to_stream(&err_b),
-	)
-	testing.expect(t, ok, "parse_args should succeed")
-	if !ok do return
-	defer delete_command(&cmd)
-
-	cmd_uninstall(&cmd)
-	bufio.writer_flush(cmd.out_buf)
-
-	testing.expect(t, !os.exists(envr_d), ".envr directory should be removed")
-
-	output := strings.to_string(out_b)
-	testing.expect(t, strings.contains(output, "Removed"), "output should list removed files")
-	testing.expect(
-		t,
-		strings.contains(output, "config.json"),
-		"output should mention config.json",
-	)
-	testing.expect(
-		t,
-		strings.contains(output, "data.envr"),
-		"output should mention data.envr",
-	)
-}
-
-@(test)
-test_cmd_uninstall_nothing_to_remove :: proc(t: ^testing.T) {
-	base := test_temp_dir(t, "envr-test-uninstall-empty-*")
-	defer os.remove_all(base)
-
-	cfg_path, _ := filepath.join([]string{base, ".envr", "config.json"}, context.temp_allocator)
-
-	out_b: strings.Builder
-	strings.builder_init(&out_b)
-	defer strings.builder_destroy(&out_b)
-	err_b: strings.Builder
-	strings.builder_init(&err_b)
-	defer strings.builder_destroy(&err_b)
-
-	cmd, ok := parse_args(
-		[]string{"envr", "uninstall", "--force", "--config-file", cfg_path},
-		strings.to_stream(&out_b),
-		strings.to_stream(&err_b),
-	)
-	testing.expect(t, ok, "parse_args should succeed")
-	if !ok do return
-	defer delete_command(&cmd)
-
-	cmd_uninstall(&cmd)
-	bufio.writer_flush(cmd.out_buf)
-
-	output := strings.to_string(out_b)
-	testing.expect(
-		t,
-		strings.contains(output, "Nothing to remove"),
-		"output should say nothing to remove",
-	)
-}
@@ -1,66 +1,86 @@
 package main

-import "base:runtime"
-import "core:strings"
+import "core:io"
 import "core:terminal/ansi"

-Color_Code :: enum {
-	Heading,
-	Command,
-	// Example
-	Flag,
-	Table_Heading,
-	Message,
-	Sucess,
-	Caret,
-	Option_Label,
-}
+COLOR_HEADINGS ::
+	ansi.CSI + ansi.FG_BRIGHT_GREEN + ";" + ansi.BOLD + ";" + ansi.UNDERLINE + ansi.SGR

-// COLOR_EXAMPLE :: ansi.CSI + ansi.ITALIC + ansi.SGR
+COLOR_COMMANDS :: ansi.CSI + ansi.FG_BRIGHT_CYAN + ";" + ansi.BOLD + ansi.SGR
+
+COLOR_EXAMPLE :: ansi.CSI + ansi.ITALIC + ansi.SGR
+
+COLOR_FLAGS :: ansi.CSI + ansi.BOLD + ";" + ansi.FG_BRIGHT_WHITE + ansi.SGR
+
+COLOR_TABLE_HEADING :: ansi.CSI + ansi.FG_BRIGHT_GREEN + ansi.SGR

-@(private = "file")
 ANSI_RESET :: ansi.CSI + ansi.RESET + ansi.SGR

-disable_color := false
+ANSI_Strip_State :: enum { Normal, GotESC, InCSI }

-colorize :: proc(
-	color: Color_Code,
-	text: string,
-	allocator := context.temp_allocator,
-	disable := disable_color,
-) -> (
-	string,
-	runtime.Allocator_Error,
-) #optional_allocator_error {
-	if disable {
-		return text, nil
-	} else {
-		return strings.concatenate(
-			{ansi.CSI, color_code(color), ansi.SGR, text, ANSI_RESET},
-			allocator,
-		)
-	}
+ANSI_Strip_Data :: struct {
+	inner: io.Writer,
+	state: ANSI_Strip_State,
 }

-@(private = "file")
-color_code :: proc(code: Color_Code) -> string {
-	switch code {
-	case .Heading:
-		return ansi.BOLD + ";" + ansi.UNDERLINE + ";" + ansi.FG_BRIGHT_GREEN
-	case .Command:
-		return ansi.BOLD + ";" + ansi.FG_BRIGHT_CYAN
-	case .Flag:
-		return ansi.BOLD + ";" + ansi.FG_BRIGHT_WHITE
-	case .Table_Heading:
-		return ansi.FG_BRIGHT_GREEN
-	case .Message:
-		return ansi.FAINT
-	case .Sucess, .Caret:
-		return ansi.BOLD + ";" + ansi.FG_GREEN
-	case .Option_Label:
-		return ansi.BOLD + ";" + ansi.FG_CYAN
+ansi_strip_proc :: proc(
+	stream_data: rawptr,
+	mode:        io.Stream_Mode,
+	p:           []byte,
+	offset:      i64,
+	whence:      io.Seek_From,
+) -> (n: i64, err: io.Error) {
+	data := cast(^ANSI_Strip_Data) stream_data
+
+	#partial switch mode {
+	case .Write:
+		start := 0
+		for i in 0..<len(p) {
+			b := p[i]
+
+			switch data.state {
+			case .Normal:
+				if b == 0x1b {
+					if i > start {
+						io.write(data.inner, p[start:i])
+					}
+					data.state = .GotESC
+				}
+
+			case .GotESC:
+				if b == '[' {
+					data.state = .InCSI
+				} else {
+					start = i
+					data.state = .Normal
+				}
+
+			case .InCSI:
+				if b >= 0x40 && b <= 0x7E {
+					start = i + 1
+					data.state = .Normal
+				}
+			}
+		}
+
+		if data.state == .Normal && len(p) > start {
+			io.write(data.inner, p[start:])
+		}
+
+		n = i64(len(p))
+		return
+
+	case .Flush:
+		return 0, io.flush(data.inner)
+	case .Close:
+		return 0, io.close(data.inner)
 	case:
-		panic("Unknown case")
+		return data.inner.procedure(data.inner.data, mode, p, offset, whence)
 	}
 }

+make_ansi_strip_writer :: proc(inner: io.Writer) -> io.Writer {
+	data := new(ANSI_Strip_Data, context.temp_allocator)
+	data.inner = inner
+	return io.Writer{procedure = ansi_strip_proc, data = rawptr(data)}
+}
@@ -201,7 +201,8 @@ find_git_roots :: proc(
 	ok: bool,
 ) {
 	paths := search_paths(cfg, allocator)
-	findr.find_repos(paths[:], &roots, os.get_processor_core_count(), allocator)
+	// TODO: Pass allocator to findr
+	findr.find_repos(paths[:], &roots, os.get_processor_core_count())
 	ok = true
 	return
 }
@@ -213,7 +214,6 @@ search_paths :: proc(cfg: Config, allocator := context.allocator) -> [dynamic]st
 	}

 	paths := new_clone(cfg.scan_config.include, allocator)
-	defer free(paths, allocator)

 	for &include in paths {
 		expanded, _ := strings.replace(include, "~", home, 1, allocator)
@@ -221,15 +221,17 @@ search_paths :: proc(cfg: Config, allocator := context.allocator) -> [dynamic]st
 			include = expanded
 		} else {
 			// TODO: show errors?
-			resolved: string
-			resolved, err = filepath.abs(expanded, allocator)
+			resolved, err := filepath.abs(expanded, allocator)
 			if err == nil {
 				include = resolved
 			}
 		}
 	}
-	result := paths^
-	return result
+	return paths^
+}
+
+envr_dir :: proc(config_path: string) -> string {
+	return filepath.dir(config_path)
 }

 // User is responsible for freeing the path
@@ -243,7 +245,3 @@ data_path :: proc(
 	return filepath.join([]string{envr_dir(config_path), "data.envr"}, allocator)
 }

-envr_dir :: proc(config_path: string) -> string {
-	return filepath.dir(config_path)
-}
-
@@ -2,7 +2,6 @@
 package main

 import "core:fmt"
-import "core:mem"
 import "core:os"
 import "core:path/filepath"
 import "core:strings"
@@ -195,14 +194,3 @@ test_search_paths_expands_tilde :: proc(t: ^testing.T) {
 	}
 }

-@(test)
-test_search_paths_no_leak :: proc(t: ^testing.T) {
-	cfg := Config {
-		scan_config = ScanConfig{include = make([dynamic]string, 0, 1)},
-	}
-	defer delete(cfg.scan_config.include)
-	append(&cfg.scan_config.include, "/tmp")
-
-	_ = search_paths(cfg, context.allocator)
-}
-
@@ -5,7 +5,7 @@ import "core:mem"
 import "core:os"

 MAGIC :: "ENVR"
-MAGIC_BYTES: [4]u8 = MAGIC
+MAGIC_BYTES := [4]u8{u8('E'), u8('N'), u8('V'), u8('R')}

 RECIPIENT_ENTRY_SIZE ::
 	CRYPTO_BOX_PUBLICKEY_BYTES +
@@ -1,8 +1,10 @@
 package main

+import "base:runtime"
 import "core:crypto/hash"
 import "core:encoding/hex"
 import "core:encoding/ini"
+import "core:encoding/json"
 import "core:fmt"
 import "core:mem"
 import "core:os"
@@ -220,6 +222,7 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 	allocator := db_allocator(db)
 	results := make([dynamic]EnvFile, 0, 10, allocator)

+	migrate := false
 	for {
 		rc = sqlite.step(stmt)
 		if rc == sqlite.DONE {
@@ -230,13 +233,24 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 			#no_bounds_check return results[:], false
 		}

+		// TODO: Remove json support after next major release
+		remotes: [dynamic]string = ---
 		remotes_raw := string(sqlite.column_text(stmt, 1))
-		split := strings.split_lines(remotes_raw, context.temp_allocator)
-		remotes := make([dynamic]string, 0, len(split), allocator = allocator)
-		for s in split {
-			append(&remotes, strings.clone(s, allocator))
+		if len(remotes_raw) > 0 {
+			if remotes_raw[0] == '[' {
+				err := json.unmarshal_string(remotes_raw, &remotes, allocator = allocator)
+				if err != nil {
+					fmt.eprintf("Warning: malformed remotes JSON: %v\n", err)
+				}
+				migrate = true
+			} else {
+				split := strings.split_lines(remotes_raw, context.temp_allocator)
+				remotes = make([dynamic]string, 0, len(split), allocator = allocator)
+				for s in split {
+					append(&remotes, strings.clone(s, allocator))
+				}
+			}
 		}
-
 		path := clone_cstring(sqlite.column_text(stmt, 0), allocator)

 		append(
@@ -251,6 +265,10 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 		)
 	}

+	if migrate {
+		migrate_remotes(db)
+	}
+
 	#no_bounds_check return results[:], true
 }

@@ -346,15 +364,33 @@ db_fetch :: proc(db: ^Db, path: string) -> (EnvFile, bool) {
 		return EnvFile{}, false
 	}

+	// TODO: Remove json support after next major release
+	migrate := false
+	remotes: [dynamic]string = ---
 	remotes_raw := string(sqlite.column_text(stmt, 1))
-	split := strings.split_lines(remotes_raw, context.temp_allocator)
-	remotes := make([dynamic]string, 0, len(split), allocator = allocator)
-	for s in split {
-		append(&remotes, strings.clone(s, allocator))
+	if len(remotes_raw) > 0 {
+		if remotes_raw[0] == '[' {
+			err := json.unmarshal_string(remotes_raw, &remotes, allocator = allocator)
+			if err != nil {
+				fmt.eprintf("Warning: malformed remotes JSON: %v\n", err)
+			}
+
+			migrate = true
+		} else {
+			split := strings.split_lines(remotes_raw, context.temp_allocator)
+			remotes = make([dynamic]string, 0, len(split), allocator = allocator)
+			for s in split {
+				append(&remotes, strings.clone(s, allocator))
+			}
+		}
 	}

 	file_path := clone_cstring(sqlite.column_text(stmt, 0), allocator)

+	if migrate {
+		migrate_remotes(db)
+	}
+
 	return EnvFile {
 			path = file_path,
 			dir = filepath.dir(file_path),
@@ -489,8 +525,29 @@ db_persist :: proc(db: ^Db, f: ^EnvFile, old_path: string) -> bool {
 	return db_insert(db, f^)
 }

+// TODO: Remove after the next major release
+migrate_remotes :: proc(db: ^Db) {
+	sql ::
+		"UPDATE envr_env_files " +
+		"SET remotes = COALESCE((" +
+		"  SELECT group_concat(atom, char(10)) " +
+		"  FROM json_each(envr_env_files.remotes)" +
+		"), '') " +
+		"WHERE remotes LIKE '[%'"
+
+	rc := sqlite.exec(db.conn, sql, nil, nil, nil)
+	if rc != sqlite.OK {
+		fmt.eprintf("Warning: failed to migrate remotes: %s\n", sqlite.errmsg(db.conn))
+		return
+	}
+
+	if sqlite.changes(db.conn) > 0 {
+		db.changed = true
+	}
+}
+
 try_move_dir :: proc(db: ^Db, f: ^EnvFile, allocator: mem.Allocator) -> (bool, SyncError) {
-	roots, ok := find_git_roots(db.cfg, context.allocator)
+	roots, ok := find_git_roots(db.cfg)
 	if !ok {
 		return false, .GitRootFailed
 	}
@@ -7,7 +7,6 @@ import "core:fmt"
 import "core:os"
 import "core:path/filepath"
 import "core:strings"
-import "core:sys/posix"
 import "core:testing"

 import "sqlite"
@@ -560,69 +559,3 @@ test_db_sync_moved :: proc(t: ^testing.T) {
 	}
 }

-@(test)
-test_db_close_preserves_inodes :: proc(t: ^testing.T) {
-	base := test_temp_dir(t, "envr-test-inode-*")
-	defer os.remove_all(base)
-
-	envr_dir, _ := filepath.join([]string{base, ".envr"}, context.temp_allocator)
-	config_path, _ := filepath.join([]string{envr_dir, "config.json"}, context.temp_allocator)
-	os.mkdir_all(envr_dir)
-
-	key_abs, _ := filepath.abs("fixtures/keys/insecure-test-key", context.temp_allocator)
-
-	cfg := new_config([]string{key_abs}, config_path)
-	defer delete_config(&cfg)
-	testing.expect(t, save_config(cfg, force = true), "save_config should succeed")
-
-	// Create database
-	{
-		db, ok := db_open(config_path)
-		defer db_close(&db)
-		testing.expect(t, ok, "first db_open should succeed")
-		if !ok do return
-
-		env_path, _ := filepath.join([]string{base, ".env"}, context.temp_allocator)
-		f := make_test_env_file(env_path, "sha", "KEY=value")
-		db_insert(&db, f)
-	}
-
-	// Record inode of data.envr
-	data_file, _ := data_path(config_path, context.temp_allocator)
-	cdata := strings.clone_to_cstring(data_file)
-	defer delete(cdata)
-
-	sb1: posix.stat_t
-	testing.expect(t, posix.stat(cdata, &sb1) == .OK, "stat should succeed")
-	inode_before := sb1.st_ino
-
-	// Create hardlink
-	link_path, _ := filepath.join([]string{envr_dir, "data.envr.link"}, context.temp_allocator)
-	clink := strings.clone_to_cstring(link_path)
-	defer delete(clink)
-	testing.expect(t, posix.link(cdata, clink) == .OK, "hardlink should succeed")
-
-	// Update database
-	{
-		db, ok2 := db_open(config_path)
-		defer db_close(&db)
-		testing.expect(t, ok2, "second db_open should succeed")
-		if !ok2 do return
-
-		env_path2, _ := filepath.join([]string{base, ".env2"}, context.temp_allocator)
-		f2 := make_test_env_file(env_path2, "sha2", "KEY2=value2")
-		db_insert(&db, f2)
-	}
-
-	// Verify inode preserved
-	sb2: posix.stat_t
-	testing.expect(t, posix.stat(cdata, &sb2) == .OK, "stat should succeed after rewrite")
-	testing.expect(t, sb2.st_ino == inode_before, "data.envr inode should be unchanged")
-
-	// Verify hardlink still valid
-	sb_link: posix.stat_t
-	testing.expect(t, posix.stat(clink, &sb_link) == .OK, "stat on hardlink should succeed")
-	testing.expect(t, sb_link.st_ino == inode_before, "hardlink inode should match")
-	testing.expect(t, sb_link.st_nlink == 2, "hardlink count should still be 2")
-}
-
@@ -5,7 +5,7 @@ Manage your .env files.
 ### Synopsis

 envr keeps your .env synced to a local, encrypted database.
-Is a safe and easy way to gather all your .env files in one place where they can
+Is a safe and eay 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 ~/.envr/data.envr
@@ -33,26 +33,25 @@ Select the files you want to back up from the interactive list.
 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
+> envr restore ~/&lt;path to repository&gt;/.env

 ### Options

 ```
-  -h, --help   show this documentation
+  -h, --help   help for envr
 ```

 ### SEE ALSO

+* [envr backup](envr_backup.md)	 - Import a .env file into envr
+* [envr check](envr_check.md)	 - check if files in the current directory are backed up
+* [envr edit-config](envr_edit-config.md)	 - Edit your config with your default editor
 * [envr init](envr_init.md)	 - Set up envr
+* [envr list](envr_list.md)	 - View your tracked files
+* [envr nushell-completion](envr_nushell-completion.md)	 - Generate custom completions for nushell
+* [envr remove](envr_remove.md)	 - Remove a .env file from your database
+* [envr restore](envr_restore.md)	 - Install a .env file from the database into your file system
 * [envr scan](envr_scan.md)	 - Find and select .env files for backup
 * [envr sync](envr_sync.md)	 - Update or restore your env backups
-* [envr backup](envr_backup.md)	 - Import a .env file into envr
-* [envr restore](envr_restore.md)	 - Restore a .env file from the database
-* [envr list](envr_list.md)	 - View your tracked files
-* [envr remove](envr_remove.md)	 - Remove a .env file from your database
-* [envr check](envr_check.md)	 - Check if files are backed up
 * [envr version](envr_version.md)	 - Show envr's version
-* [envr edit-config](envr_edit-config.md)	 - Edit your config with your default editor
-* [envr completion](envr_completion.md)	 - Generate shell completion scripts
-* [envr uninstall](envr_uninstall.md)	 - Remove envr configuration and database

@@ -6,20 +6,13 @@ Import a .env file into envr
 envr backup <path> [flags]
 ```

-**Arguments:**
-
-* `path` — Path to .env file to backup
-
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for backup
 ```

-*Alias: `add`*
-
 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -1,23 +1,18 @@
 ## envr check

-Check if files are backed up
+check if files in the current directory are backed up

 ```
 envr check [path] [flags]
 ```

-**Arguments:**
-
-* `path` — Path to check (defaults to current directory) (optional)
-
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for check
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -1,28 +0,0 @@
-## envr completion
-
-Generate shell completion scripts
-
-### Synopsis
-
-Supported shells:
-
-  nushell
-  bash
-
-```
-envr completion <shell> [flags]
-```
-
-**Arguments:**
-
-* `shell` — Shell to generate completions for
-
-### Options
-
-```
-  -h, --help   show this documentation
-```
-
-### SEE ALSO
-
-* [envr](envr.md)	 - Manage your .env files.
@@ -9,11 +9,10 @@ envr edit-config [flags]
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for edit-config
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -5,7 +5,9 @@ Set up envr
 ### Synopsis

 The init command generates your initial config and saves it to
-~/.envr/config in JSON format.\n\nDuring setup, you will be prompted to select one or more ssh keys with which 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.

@@ -16,12 +18,11 @@ envr init [flags]
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
-  -f, --force         Overwrite existing config
+  -f, --force   Overwrite an existing config
+  -h, --help    help for init
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -9,12 +9,10 @@ envr list [flags]
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-  -o, --output        the format of output data (default 'table')
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for list
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -0,0 +1,23 @@
+## envr nushell-completion
+
+Generate custom completions for nushell
+
+### Synopsis
+
+At time of writing, cobra does not natively support nushell,
+so a custom command had to be written
+
+```
+envr nushell-completion [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for nushell-completion
+```
+
+### SEE ALSO
+
+* [envr](envr.md)	 - Manage your .env files.
+
@@ -3,21 +3,16 @@
 Remove a .env file from your database

 ```
-envr remove <path> [flags]
+envr remove [flags]
 ```

-**Arguments:**
-
-* `path` — Path to .env file to remove
-
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for remove
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -1,23 +1,18 @@
 ## envr restore

-Restore a .env file from the database
+Install a .env file from the database into your file system

 ```
-envr restore <path> [flags]
+envr restore [flags]
 ```

-**Arguments:**
-
-* `path` — Path to .env file to restore
-
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for restore
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -9,11 +9,10 @@ envr scan [flags]
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for scan
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -9,12 +9,10 @@ envr sync [flags]
 ### Options

 ```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-  -o, --output        the format of output data (default 'table')
-      --color         Whether or not to colorize output (default 'auto')
+  -h, --help   help for sync
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -1,24 +0,0 @@
-## envr uninstall
-
-Remove envr configuration and database
-
-### Synopsis
-
-This will remove all files generated by envr from your system.
-
-```
-envr uninstall [flags]
-```
-
-### Options
-
-```
-  -h, --help          show this documentation
-  -c, --config-file   config file (default "~/.envr/config.json")
-      --color         Whether or not to colorize output (default 'auto')
-  -f, --force         Overwrite existing config
-```
-
-### SEE ALSO
-
-* [envr](envr.md)	 - Manage your .env files.
@@ -9,9 +9,11 @@ envr version [flags]
 ### Options

 ```
-  -h, --help   show this documentation
+  -h, --help   help for version
+  -l, --long   Show all version information
 ```

 ### SEE ALSO

 * [envr](envr.md)	 - Manage your .env files.
+
@@ -16,14 +16,7 @@ RepoPool :: struct {
 	threads:      []^thread.Thread,
 }

-find_repos :: proc(
-	roots: []string,
-	results: ^[dynamic]string,
-	thread_count: int,
-	allocator := context.allocator,
-) {
-	// TODO: This may be a code smell
-	context.allocator = allocator
+find_repos :: proc(roots: []string, results: ^[dynamic]string, thread_count: int) {
 	if len(roots) == 0 do return

 	pool := new(RepoPool)
@@ -133,4 +126,3 @@ process_repo_dir :: proc(pool: ^RepoPool, dir_path: string) {
 		}
 	}
 }
-
@@ -78,15 +78,7 @@ collect_worker :: proc(t: ^thread.Thread) {
 	}
 }

-walk :: proc(
-	roots: []string,
-	results: ^[dynamic]string,
-	opts: WalkOptions,
-	thread_count: int,
-	allocator := context.allocator,
-) {
-	// TODO: This may be a code smell
-	context.allocator = allocator
+walk :: proc(roots: []string, results: ^[dynamic]string, opts: WalkOptions, thread_count: int) {
 	if len(roots) == 0 do return

 	ch, _ := chan.create(chan.Chan([]u8), max(2 * thread_count, 2), context.allocator)
@@ -4,12 +4,64 @@ import "base:runtime"
 import "core:reflect"
 import "core:strings"

+get_subtag :: proc(tag: string, id: string) -> (value: string, ok: bool) {
+	parts := strings.split(tag, ",", context.temp_allocator)
+	for part in parts {
+		trimmed := strings.trim_space(part)
+		if strings.has_prefix(trimmed, id) && len(trimmed) > len(id) && trimmed[len(id)] == '=' {
+			return trimmed[len(id) + 1:], true
+		}
+		if trimmed == id {
+			return "", true
+		}
+	}
+	return "", false
+}
+
+is_bool_type :: proc(field: reflect.Struct_Field) -> bool {
+	base_ti := runtime.type_info_base(field.type)
+	_, is_bool := base_ti.variant.(runtime.Type_Info_Boolean)
+	return is_bool
+}
+
+set_field :: proc(model: rawptr, field: reflect.Struct_Field, value: string) -> bool {
+	ptr := rawptr(uintptr(model) + field.offset)
+	base_ti := runtime.type_info_base(field.type)
+
+	if _, is_bool := base_ti.variant.(runtime.Type_Info_Boolean); is_bool {
+		(cast(^bool)ptr)^ = true
+		return true
+	}
+
+	if _, is_string := base_ti.variant.(runtime.Type_Info_String); is_string {
+		(cast(^string)ptr)^ = value
+		return true
+	}
+
+	if enum_ti, is_enum := base_ti.variant.(runtime.Type_Info_Enum); is_enum {
+		for name, i in enum_ti.names {
+			if strings.equal_fold(value, name) {
+				v := enum_ti.values[i]
+				switch base_ti.size {
+				case 1: (cast(^u8)ptr)^  = cast(u8)v
+				case 2: (cast(^u16)ptr)^ = cast(u16)v
+				case 4: (cast(^u32)ptr)^ = cast(u32)v
+				case 8: (cast(^u64)ptr)^ = cast(u64)v
+				}
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 parse_flags :: proc(model: ^$T, args: []string) -> (overflow: []string) {
 	field_count := reflect.struct_field_count(T)
 	long_map := make(map[string]reflect.Struct_Field, field_count, context.temp_allocator)
 	short_map := make(map[string]reflect.Struct_Field, field_count, context.temp_allocator)

-	for i in 0 ..< field_count {
+	for i in 0..<field_count {
 		field := reflect.struct_field_at(T, i)

 		name, _ := strings.replace(field.name, "_", "-", -1, context.temp_allocator)
@@ -80,60 +132,3 @@ parse_flags :: proc(model: ^$T, args: []string) -> (overflow: []string) {

 	return overflow_dyn[:]
 }
-
-get_subtag :: proc(tag: string, id: string) -> (value: string, ok: bool) {
-	parts := strings.split(tag, ",", context.temp_allocator)
-	for part in parts {
-		trimmed := strings.trim_space(part)
-		if strings.has_prefix(trimmed, id) && len(trimmed) > len(id) && trimmed[len(id)] == '=' {
-			return trimmed[len(id) + 1:], true
-		}
-		if trimmed == id {
-			return "", true
-		}
-	}
-	return "", false
-}
-
-is_bool_type :: proc(field: reflect.Struct_Field) -> bool {
-	base_ti := runtime.type_info_base(field.type)
-	_, is_bool := base_ti.variant.(runtime.Type_Info_Boolean)
-	return is_bool
-}
-
-set_field :: proc(model: rawptr, field: reflect.Struct_Field, value: string) -> bool {
-	ptr := rawptr(uintptr(model) + field.offset)
-	base_ti := runtime.type_info_base(field.type)
-
-	if _, is_bool := base_ti.variant.(runtime.Type_Info_Boolean); is_bool {
-		(cast(^bool)ptr)^ = true
-		return true
-	}
-
-	if _, is_string := base_ti.variant.(runtime.Type_Info_String); is_string {
-		(cast(^string)ptr)^ = value
-		return true
-	}
-
-	if enum_ti, is_enum := base_ti.variant.(runtime.Type_Info_Enum); is_enum {
-		for name, i in enum_ti.names {
-			if strings.equal_fold(value, name) {
-				v := enum_ti.values[i]
-				switch base_ti.size {
-				case 1:
-					(cast(^u8)ptr)^ = cast(u8)v
-				case 2:
-					(cast(^u16)ptr)^ = cast(u16)v
-				case 4:
-					(cast(^u32)ptr)^ = cast(u32)v
-				case 8:
-					(cast(^u64)ptr)^ = cast(u64)v
-				}
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
@@ -66,7 +66,7 @@

          packages.default = pkgs.stdenv.mkDerivation rec {
            pname = "envr";
-            version = nixpkgs.lib.trim (builtins.readFile ./version.txt);
+            version = "0.3.0";
            src = ./.;

            nativeBuildInputs = [
@@ -91,11 +91,6 @@
            buildPhase = ''
              runHook preBuild
              echo '${version}' > version.txt
-
-              # Generate man pages before main build (binary gets clobbered)
-              odin build . -define:GENDOCS=true -out:gendocs
-              ./gendocs --man
-              
              odin build . -o:speed -out:${pname}
              runHook postBuild
            '';
@@ -103,9 +98,6 @@
            installPhase = ''
              runHook preInstall
              install -Dm755 ${pname} $out/bin/${pname}
-
-              mkdir -p $out/share/man/man1
-              cp docs/man/*.1 $out/share/man/man1/
              runHook postInstall
            '';
          };
@@ -1,289 +0,0 @@
-package main
-
-import "core:fmt"
-import "core:os"
-import "core:strings"
-import "core:time"
-
-when #config(GENDOCS, false) {
-	main :: proc() {
-		args := os.args
-		if len(args) < 2 {
-			fmt.eprintln("Usage: gendocs --man | --md")
-			os.exit(1)
-		}
-
-		switch args[1] {
-		case "--man":
-			generate_man_pages()
-		case "--md":
-			generate_markdown()
-		case:
-			fmt.eprintf("Unknown format: %s\n", args[1])
-			os.exit(1)
-		}
-	}
-}
-
-generate_man_pages :: proc() {
-	os.mkdir_all("docs/man")
-
-	now := time.now()
-	month_year := fmt.tprintf("%s %d", time.month(now), time.year(now))
-
-	generate_man_main(month_year)
-
-	for &c in COMMANDS {
-		generate_man_command(&c, month_year)
-	}
-
-	fmt.println("Generated man pages in docs/man/")
-}
-
-generate_man_main :: proc(month_year: string) {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	fmt.sbprintf(&sb, ".TH ENVR 1 \"%s\" \"envr\" \"envr Manual\"\n", month_year)
-	fmt.sbprintf(&sb, ".SH NAME\nenvr \\- keep your .env files synced to an encrypted database\n")
-	fmt.sbprintf(&sb, ".SH SYNOPSIS\n\\fBenvr\\fR [\\fIcommand\\fR] [\\fIflags\\fR]\n")
-	fmt.sbprintf(
-		&sb,
-		".SH DESCRIPTION\nenvr keeps your .env synced to a local, encrypted database.\n",
-	)
-	fmt.sbprintf(
-		&sb,
-		"Is a safe and easy way to gather all your .env files in one place where they can\n",
-	)
-	fmt.sbprintf(&sb, "easily be backed by another tool such as restic or git.\n")
-	fmt.sbprintf(&sb, ".PP\nAll your data is stored in ~/.envr/data.envr\n")
-	fmt.sbprintf(&sb, ".SH COMMANDS\n")
-	for c in COMMANDS {
-		fmt.sbprintf(&sb, ".TP\n\\fB%s\\fR\n%s\n", c.name, c.short)
-		for a in c.aliases {
-			fmt.sbprintf(&sb, ".TP\n\\fB%s\\fR (alias for %s)\n%s\n", a, c.name, c.short)
-		}
-	}
-	fmt.sbprintf(&sb, ".SH GLOBAL OPTIONS\n")
-	for ft in Flag_Type {
-		if ft not_in GLOBAL_FLAGS do continue
-		write_man_flag(&sb, ft)
-	}
-	fmt.sbprintf(&sb, ".SH SEE ALSO\n")
-	for c, i in COMMANDS {
-		if i > 0 do fmt.sbprintf(&sb, ",\n")
-		fmt.sbprintf(&sb, ".BR envr-%s (1)", c.name)
-	}
-	fmt.sbprintf(&sb, "\n")
-
-	path := "docs/man/envr.1"
-	err := os.write_entire_file(path, transmute([]u8)strings.to_string(sb))
-	if err != nil {
-		fmt.eprintf("Error writing %s: %v\n", path, err)
-	}
-}
-
-generate_man_command :: proc(c: ^CommandInfo, month_year: string) {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	upper_name := strings.to_upper(fmt.tprintf("envr-%s", c.name))
-
-	fmt.sbprintf(&sb, ".TH %s 1 \"%s\" \"envr\" \"envr Manual\"\n", upper_name, month_year)
-	fmt.sbprintf(&sb, ".SH NAME\nenvr-%s \\- %s\n", c.name, c.short)
-	fmt.sbprintf(&sb, ".SH SYNOPSIS\n\\fB%s\\fR", c.usage)
-
-	has_positionals := false
-	for arg in c.args {
-		has_positionals = true
-		if arg.optional {
-			fmt.sbprintf(&sb, " [\\fI%s\\fR]", arg.name)
-		} else {
-			fmt.sbprintf(&sb, " \\fI%s\\fR", arg.name)
-		}
-	}
-	fmt.sbprintf(&sb, "\n")
-
-	if len(c.long) > 0 {
-		fmt.sbprintf(&sb, ".SH DESCRIPTION\n%s\n", c.long)
-	}
-
-	if has_positionals {
-		fmt.sbprintf(&sb, ".SH ARGUMENTS\n")
-		for arg in c.args {
-			fmt.sbprintf(&sb, ".TP\n\\fB%s\\fR\n%s\n", arg.name, arg.desc)
-		}
-	}
-
-	fmt.sbprintf(&sb, ".SH OPTIONS\n")
-	for ft in Flag_Type {
-		if ft not_in c.flags do continue
-		write_man_flag(&sb, ft)
-	}
-
-	path := fmt.tprintf("docs/man/envr-%s.1", c.name)
-	err := os.write_entire_file(path, transmute([]u8)strings.to_string(sb))
-	if err != nil {
-		fmt.eprintf("Error writing %s: %v\n", path, err)
-	}
-}
-
-write_man_flag :: proc(sb: ^strings.Builder, ft: Flag_Type) {
-	f := flag_field(ft)
-
-	fmt.sbprintf(sb, ".TP\n")
-	if len(f.short_name) > 0 {
-		fmt.sbprintf(sb, "\\fB-%s\\fR, \\fB--%s\\fR", f.short_name, f.long_name)
-	} else {
-		fmt.sbprintf(sb, "\\fB--%s\\fR", f.long_name)
-	}
-
-	#partial switch f.kind {
-	case .String:
-		fmt.sbprintf(sb, " \\fIvalue\\fR")
-	case .Enum:
-		values, _ := strings.replace(f.enum_values, "'", "", -1)
-		fmt.sbprintf(sb, " \\fI%s\\fR", values)
-	}
-
-	fmt.sbprintf(sb, "\n%s\n", f.usage)
-
-	if len(f.default_val) > 0 {
-		#partial switch f.kind {
-		case .String:
-			fmt.sbprintf(sb, "(default \"%s\")\n", f.default_val)
-		case .Enum:
-			fmt.sbprintf(sb, "(default '%s')\n", f.default_val)
-		}
-	}
-}
-
-generate_markdown :: proc() {
-	os.mkdir_all("docs/cli")
-
-	generate_md_main()
-
-	for &c in COMMANDS {
-		generate_md_command(&c)
-	}
-
-	fmt.println("Generated markdown in docs/cli/")
-}
-
-generate_md_main :: proc() {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	fmt.sbprintf(&sb, "## envr\n\n")
-	fmt.sbprintf(&sb, "Manage your .env files.\n\n")
-	fmt.sbprintf(&sb, "### Synopsis\n\n")
-	fmt.sbprint(&sb, ENVR_DESCRIPTION)
-	fmt.sbprintf(&sb, "\n\n### Options\n\n")
-	write_md_options(&sb, {.Help})
-	fmt.sbprintf(&sb, "\n### SEE ALSO\n\n")
-	for c in COMMANDS {
-		fmt.sbprintf(&sb, "* [envr %s](envr_%s.md)\t - %s\n", c.name, c.name, c.short)
-	}
-	fmt.sbprintf(&sb, "\n")
-
-	write_file("docs/cli/envr.md", strings.to_string(sb))
-}
-
-generate_md_command :: proc(c: ^CommandInfo) {
-	sb: strings.Builder
-	strings.builder_init(&sb, context.temp_allocator)
-	defer strings.builder_destroy(&sb)
-
-	fmt.sbprintf(&sb, "## envr %s\n\n", c.name)
-	fmt.sbprintf(&sb, "%s\n\n", c.short)
-
-	if len(c.long) > 0 {
-		fmt.sbprintf(&sb, "### Synopsis\n\n")
-		fmt.sbprint(&sb, c.long)
-		fmt.sbprintf(&sb, "\n\n")
-	}
-
-	fmt.sbprintf(&sb, "```\n%s [flags]\n```\n\n", c.usage)
-
-	if len(c.args) > 0 {
-		fmt.sbprintf(&sb, "**Arguments:**\n\n")
-		for arg in c.args {
-			optional := arg.optional ? " (optional)" : ""
-			fmt.sbprintf(&sb, "* `%s` — %s%s\n", arg.name, arg.desc, optional)
-		}
-		fmt.sbprintf(&sb, "\n")
-	}
-
-	fmt.sbprintf(&sb, "### Options\n\n")
-	write_md_options(&sb, c.flags)
-
-	for a in c.aliases {
-		fmt.sbprintf(&sb, "\n*Alias: `%s`*\n", a)
-	}
-
-	fmt.sbprintf(&sb, "\n### SEE ALSO\n\n")
-	fmt.sbprintf(&sb, "* [envr](envr.md)\t - Manage your .env files.\n")
-
-	path := fmt.tprintf("docs/cli/envr_%s.md", c.name)
-	write_file(path, strings.to_string(sb))
-}
-
-write_md_options :: proc(sb: ^strings.Builder, flags: bit_set[Flag_Type]) {
-	displays := make([dynamic]string, 0, 5, context.temp_allocator)
-	defer delete(displays)
-
-	descs := make([dynamic]string, 0, 5, context.temp_allocator)
-	defer delete(descs)
-
-	max_width := 0
-
-	for ft in Flag_Type {
-		if ft not_in flags do continue
-		f := flag_field(ft)
-
-		display: string
-		if len(f.short_name) > 0 {
-			display = fmt.tprintf("-%s, --%s", f.short_name, f.long_name)
-		} else {
-			display = fmt.tprintf("    --%s", f.long_name)
-		}
-
-		desc := f.usage
-		if len(f.default_val) > 0 {
-			#partial switch f.kind {
-			case .String:
-				desc = fmt.tprintf(`%s (default "%s")`, f.usage, f.default_val)
-			case .Enum:
-				desc = fmt.tprintf("%s (default '%s')", f.usage, f.default_val)
-			}
-		}
-
-		append(&displays, display)
-		append(&descs, desc)
-		if len(display) > max_width {
-			max_width = len(display)
-		}
-	}
-
-	fmt.sbprintf(sb, "```\n")
-	pad_buf: [64]u8
-	for i in 0..<len(displays) {
-		padding := max_width - len(displays[i]) + 3
-		for j in 0..<padding {
-			pad_buf[j] = ' '
-		}
-		fmt.sbprintf(sb, "  %s%s%s\n", displays[i], string(pad_buf[:padding]), descs[i])
-	}
-	fmt.sbprintf(sb, "```\n")
-}
-
-write_file :: proc(path: string, content: string) {
-	err := os.write_entire_file(path, transmute([]u8)content)
-	if err != nil {
-		fmt.eprintf("Error writing %s: %v\n", path, err)
-	}
-}
-
@@ -1,100 +0,0 @@
-
-_envr() {
-    local cur prev cmd
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
-    cmd="${COMP_WORDS[1]}"
-
-    if [[ $COMP_CWORD -eq 1 ]]; then
-        COMPREPLY=( $(compgen -W "init scan sync backup add restore list remove check version edit-config completion" -- "$cur") )
-        return
-    fi
-
-    case "$prev" in
-        --config-file|-c)
-            COMPREPLY=( $(compgen -f -- "$cur") )
-            return
-            ;;
-        --output|-o)
-            COMPREPLY=( $(compgen -W "auto table json" -- "$cur") )
-            return
-            ;;
-        --color)
-            COMPREPLY=( $(compgen -W "auto always never" -- "$cur") )
-            return
-            ;;
-    esac
-
-    case "$cur" in -*)
-        case "$cmd" in
-            init)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color --force -f" -- "$cur") )
-                return
-                ;;
-            scan)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            sync)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --output -o --color" -- "$cur") )
-                return
-                ;;
-            backup|add)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            restore)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            list)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --output -o --color" -- "$cur") )
-                return
-                ;;
-            remove)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            check)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            version)
-                COMPREPLY=( $(compgen -W "--help -h" -- "$cur") )
-                return
-                ;;
-            edit-config)
-                COMPREPLY=( $(compgen -W "--help -h --config-file -c --color" -- "$cur") )
-                return
-                ;;
-            completion)
-                COMPREPLY=( $(compgen -W "--help -h" -- "$cur") )
-                return
-                ;;
-        esac
-        ;;
-    esac
-
-    case "$cmd" in
-        backup|add)
-            COMPREPLY=( $(compgen -W "$(envr scan --output json 2>/dev/null)" -- "$cur") )
-            return
-            ;;
-        restore)
-            COMPREPLY=( $(compgen -W "$(envr list --output json 2>/dev/null)" -- "$cur") )
-            return
-            ;;
-        remove)
-            COMPREPLY=( $(compgen -W "$(envr list --output json 2>/dev/null)" -- "$cur") )
-            return
-            ;;
-        completion)
-            COMPREPLY=( $(compgen -W "nushell bash" -- "$cur") )
-            return
-            ;;
-    esac
-
-}
-
-complete -F _envr envr
@@ -14,81 +14,77 @@ when SPALL {
 	spall_buffer: spall.Buffer
 }

-when !#config(GENDOCS, false) {
-	main :: proc() {
-		when SPALL {
-			ctx, spall_ok := spall.context_create_with_scale("envr.spall", false, 1.0)
-			if !spall_ok {
-				fmt.eprintln("Failed to create spall trace file")
-				os.exit(1)
-			}
-			spall_ctx = ctx
-			defer spall.context_destroy(&spall_ctx)
-
-			spall_backing := make([]u8, spall.BUFFER_DEFAULT_SIZE)
-			defer delete(spall_backing)
-
-			spall_buffer = spall.buffer_create(spall_backing, u32(sync.current_thread_id()))
-			defer spall.buffer_destroy(&spall_ctx, &spall_buffer)
-		}
-
-		when ODIN_DEBUG {
-			heap_track: mem.Tracking_Allocator
-			mem.tracking_allocator_init(&heap_track, context.allocator)
-			defer mem.tracking_allocator_destroy(&heap_track)
-			defer if len(heap_track.allocation_map) > 0 {
-				for _, leak in heap_track.allocation_map {
-					fmt.eprintf("LEAK: %v leaked %m\n", leak.location, leak.size)
-				}
-			}
-			context.allocator = mem.tracking_allocator(&heap_track)
-
-			temp_track: mem.Tracking_Allocator
-			mem.tracking_allocator_init(&temp_track, context.temp_allocator)
-			defer mem.tracking_allocator_destroy(&temp_track)
-			context.temp_allocator = mem.tracking_allocator(&temp_track)
-		}
-
-		defer free_all(context.temp_allocator)
-
-		cmd, ok := parse_args(os.args, os.to_writer(os.stdout), os.to_writer(os.stderr))
-		defer delete_command(&cmd) // delete flushes automatically
-		if !ok {
-			return
-		}
-
-		switch cmd.name {
-		case "init":
-			cmd_init(&cmd)
-		case "version":
-			cmd_version(&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 "completion":
-			cmd_completion(&cmd)
-		case "uninstall":
-			cmd_uninstall(&cmd)
-		case:
-			fmt.wprintf(cmd.err, "Unknown command: %s\n", cmd.name)
-			write_usage(cmd.out)
+main :: proc() {
+	when SPALL {
+		ctx, spall_ok := spall.context_create_with_scale("envr.spall", false, 1.0)
+		if !spall_ok {
+			fmt.eprintln("Failed to create spall trace file")
 			os.exit(1)
 		}
+		spall_ctx = ctx
+		defer spall.context_destroy(&spall_ctx)
+
+		spall_backing := make([]u8, spall.BUFFER_DEFAULT_SIZE)
+		defer delete(spall_backing)
+
+		spall_buffer = spall.buffer_create(spall_backing, u32(sync.current_thread_id()))
+		defer spall.buffer_destroy(&spall_ctx, &spall_buffer)
 	}
-} // !GENDOCS
+
+	when ODIN_DEBUG {
+		heap_track: mem.Tracking_Allocator
+		mem.tracking_allocator_init(&heap_track, context.allocator)
+		defer mem.tracking_allocator_destroy(&heap_track)
+		defer if len(heap_track.allocation_map) > 0 {
+			for _, leak in heap_track.allocation_map {
+				fmt.eprintf("LEAK: %v leaked %m\n", leak.location, leak.size)
+			}
+		}
+		context.allocator = mem.tracking_allocator(&heap_track)
+
+		temp_track: mem.Tracking_Allocator
+		mem.tracking_allocator_init(&temp_track, context.temp_allocator)
+		defer mem.tracking_allocator_destroy(&temp_track)
+		context.temp_allocator = mem.tracking_allocator(&temp_track)
+	}
+
+	defer free_all(context.temp_allocator)
+
+	cmd, ok := parse_args(os.args, os.to_writer(os.stdout), os.to_writer(os.stderr))
+	defer delete_command(&cmd) // delete flushes automatically
+	if !ok {
+		return
+	}
+
+	switch cmd.name {
+	case "init":
+		cmd_init(&cmd)
+	case "version":
+		cmd_version(&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.wprintf(cmd.err, "Unknown command: %s\n", cmd.name)
+		write_usage(cmd.out)
+		os.exit(1)
+	}
+}

 when SPALL {
 	@(instrumentation_enter)
@@ -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
+]
@@ -1,7 +1,6 @@
 package main

 import "core:fmt"
-import "core:strings"
 import "core:sys/posix"
 import "core:terminal/ansi"

@@ -16,8 +15,6 @@ Key :: enum {
 	Space,
 	Enter,
 	Escape,
-	Backspace,
-	Char,
 	Unknown,
 }

@@ -41,17 +38,11 @@ multi_select :: proc(
 	}

 	selected = make([dynamic]bool, len(options))
-	filter: [dynamic]u8
-	defer delete(filter)
-	filtered: [dynamic]int
-	defer delete(filtered)
-	rebuild_filtered(options, filter[:], &filtered)
-
 	cursor: int = 0
 	scroll_offset: int = 0

 	fmt.printf(ansi.CSI + ansi.DECTCEM_HIDE)
-	visible := render_options(prompt, options, selected[:], filtered[:], string(filter[:]), cursor, scroll_offset)
+	visible := render_options(prompt, options, selected[:], cursor, scroll_offset)

 	raw, ok := enable_raw_mode(posix.STDIN_FILENO)
 	if !ok {
@@ -61,63 +52,33 @@ multi_select :: proc(
 	defer disable_raw_mode(&raw)

 	for {
-		key, ch := read_key()
+		key := read_key()

 		switch key {
-		case .Char:
-			append(&filter, u8(ch))
-			rebuild_filtered(options, filter[:], &filtered)
-			cursor = clamp(cursor, 0, max(0, len(filtered) - 1))
-		case .Backspace:
-			if len(filter) > 0 {
-				pop(&filter)
-				rebuild_filtered(options, filter[:], &filtered)
-				cursor = clamp(cursor, 0, max(0, len(filtered) - 1))
-			}
 		case .Up:
 			if cursor > 0 {
 				cursor -= 1
 			}
 		case .Down:
-			if cursor < len(filtered) - 1 {
+			if cursor < len(options) - 1 {
 				cursor += 1
 			}
 		case .Space:
-			if len(filtered) > 0 {
-				selected[filtered[cursor]] = !selected[filtered[cursor]]
-			}
+			selected[cursor] = !selected[cursor]
 		case .Enter:
-			fmt.printf(
-				ansi.CSI + "%d" + ansi.CUU + ansi.CSI + ansi.ED + ansi.CSI + ansi.DECTCEM_SHOW,
-				visible + 1,
-			)
+			fmt.printf(ansi.CSI + "%d" + ansi.CUU + ansi.CSI + ansi.ED + ansi.CSI + ansi.DECTCEM_SHOW, visible + 1)
 			result = .Confirm
 			return
 		case .Escape:
-			fmt.printf(
-				ansi.CSI + "%d" + ansi.CUU + ansi.CSI + ansi.ED + ansi.CSI + ansi.DECTCEM_SHOW,
-				visible + 1,
-			)
+			fmt.printf(ansi.CSI + "%d" + ansi.CUU + ansi.CSI + ansi.ED + ansi.CSI + ansi.DECTCEM_SHOW, visible + 1)
 			result = .Cancel
 			return
 		case .Unknown:
 		}

-		scroll_offset = max(0, min(cursor - MAX_VISIBLE / 2, len(filtered) - MAX_VISIBLE))
+		scroll_offset = max(0, min(cursor - MAX_VISIBLE / 2, len(options) - MAX_VISIBLE))
 		fmt.printf(ansi.CSI + "%d" + ansi.CUU + ansi.CSI + ansi.RESET + ansi.ED, visible + 1)
-		visible = render_options(prompt, options, selected[:], filtered[:], string(filter[:]), cursor, scroll_offset)
-	}
-}
-
-rebuild_filtered :: proc(options: []string, filter: []u8, filtered: ^[dynamic]int) {
-	clear(filtered)
-	filter_str := string(filter)
-	filter_lower := strings.to_lower(filter_str, context.temp_allocator)
-	for opt, i in options {
-		opt_lower := strings.to_lower(opt, context.temp_allocator)
-		if strings.contains(opt_lower, filter_lower) {
-			append(filtered, i)
-		}
+		visible = render_options(prompt, options, selected[:], cursor, scroll_offset)
 	}
 }

@@ -125,49 +86,29 @@ render_options :: proc(
 	prompt: string,
 	options: []string,
 	selected: []bool,
-	filtered: []int,
-	filter_text: string,
 	cursor: int,
 	scroll_offset: int,
 ) -> int {
-	fmt.printf(
-		"%s (type to filter, ↑/↓ move, space select, enter confirm)\r\n",
-		colorize(.Option_Label, prompt),
-	)
-
-	fmt.printf("filter: %s\r\n", filter_text)
-
-	line_count := 1
-
-	if len(filtered) == 0 {
-		fmt.printf("  No matches\r\n")
-		return line_count + 1
-	}
+	fmt.printf(ansi.CSI + ansi.BOLD + ";" + ansi.FG_CYAN + ansi.SGR + "%s" + ANSI_RESET + " (↑/↓ move, space select, enter confirm)\r\n", prompt)

 	end := scroll_offset + MAX_VISIBLE
-	if end > len(filtered) {
-		end = len(filtered)
+	if end > len(options) {
+		end = len(options)
 	}

 	for i in scroll_offset ..< end {
-		original := filtered[i]
 		checkbox := " "
-		if selected[original] {
+		if selected[i] {
 			checkbox = "x"
 		}
 		if i == cursor {
-			fmt.printf(
-				"%s [%s] %s\r\n",
-				colorize(.Caret, ">"),
-				colorize(.Sucess, checkbox),
-				options[original],
-			)
+			fmt.printf(ansi.CSI + ansi.BOLD + ";" + ansi.FG_GREEN + ansi.SGR + "> " + ANSI_RESET + "[" + ansi.CSI + ansi.FG_GREEN + ansi.SGR + "%s" + ANSI_RESET + "] %s\r\n", checkbox, options[i])
 		} else {
-			fmt.printf("  [%s] %s\r\n", colorize(.Sucess, checkbox), options[original])
+			fmt.printf("  [" + ansi.CSI + ansi.FAINT + ansi.SGR + "%s" + ANSI_RESET + "] %s\r\n", checkbox, options[i])
 		}
 	}

-	return line_count + (end - scroll_offset)
+	return end - scroll_offset
 }

 enable_raw_mode :: proc(fd: posix.FD) -> (Raw_State, bool) {
@@ -197,23 +138,21 @@ disable_raw_mode :: proc(state: ^Raw_State) {
 	posix.tcsetattr(state.fd, .TCSAFLUSH, &state.original)
 }

-read_key :: proc() -> (key: Key, ch: rune) {
+read_key :: proc() -> Key {
 	buf: [3]u8

 	n := posix.read(posix.STDIN_FILENO, &buf[0], 1)
 	if n <= 0 {
-		return .Unknown, 0
+		return .Unknown
 	}

 	switch buf[0] {
 	case ' ':
-		return .Space, 0
+		return .Space
 	case '\n', '\r':
-		return .Enter, 0
+		return .Enter
 	case 0x03:
-		return .Escape, 0
-	case 0x08, 0x7F:
-		return .Backspace, 0
+		return .Escape
 	case 0x1b:
 		tv: posix.timeval
 		tv.tv_sec = 0
@@ -225,12 +164,12 @@ read_key :: proc() -> (key: Key, ch: rune) {

 		ready := posix.select(1, &set, nil, nil, &tv)
 		if ready <= 0 {
-			return .Escape, 0
+			return .Escape
 		}

 		n2 := posix.read(posix.STDIN_FILENO, &buf[1], 1)
 		if n2 <= 0 || buf[1] != '[' {
-			return .Escape, 0
+			return .Escape
 		}

 		posix.FD_ZERO(&set)
@@ -240,27 +179,24 @@ read_key :: proc() -> (key: Key, ch: rune) {

 		ready = posix.select(1, &set, nil, nil, &tv)
 		if ready <= 0 {
-			return .Escape, 0
+			return .Escape
 		}

 		n3 := posix.read(posix.STDIN_FILENO, &buf[2], 1)
 		if n3 <= 0 {
-			return .Escape, 0
+			return .Escape
 		}

 		switch buf[2] {
 		case 'A':
-			return .Up, 0
+			return .Up
 		case 'B':
-			return .Down, 0
+			return .Down
 		case:
-			return .Escape, 0
+			return .Escape
 		}
 	case:
-		if buf[0] >= 0x20 && buf[0] <= 0x7E {
-			return .Char, rune(buf[0])
-		}
-		return .Unknown, 0
+		return .Unknown
 	}
 }

@@ -35,18 +35,18 @@ parse_ssh_public_key :: proc(pub_path: string) -> (pub: [32]u8, ok: bool) {
 		return
 	}

-	rest := decoded
-	key_type, type_ok := read_wire_string(&rest)
-	if !type_ok || string(key_type) != SSH_ED25519 {
+	offset := 0
+	key_type, type_ok := read_wire_string(decoded, &offset)
+	if !type_ok || key_type != SSH_ED25519 {
 		return
 	}

-	pk_data, pk_ok := read_wire_string(&rest)
+	pk_data, pk_ok := read_wire_string(decoded, &offset)
 	if !pk_ok || len(pk_data) != 32 {
 		return
 	}

-	mem.copy_non_overlapping(&pub[0], &pk_data[0], 32)
+	mem.copy_non_overlapping(&pub[0], raw_data(pk_data), 32)

 	ok = true
 	return
@@ -91,63 +91,81 @@ parse_ssh_private_key :: proc(priv_path: string) -> (kp: Ed25519Keypair, ok: boo
 		return
 	}

-	rest := decoded[len(magic):]
+	offset := len(magic)

-	ciphername, cipher_ok := read_wire_string(&rest)
-	if !cipher_ok || string(ciphername) != "none" {
+	ciphername, cipher_ok := read_wire_string(decoded, &offset)
+	if !cipher_ok || ciphername != "none" {
 		return
 	}

-	kdfname, kdf_ok := read_wire_string(&rest)
-	if !kdf_ok || string(kdfname) != "none" {
+	kdfname, kdf_ok := read_wire_string(decoded, &offset)
+	if !kdf_ok || kdfname != "none" {
 		return
 	}

-	_, opts_ok := read_wire_string(&rest)
+	_, opts_ok := read_wire_string(decoded, &offset)
 	if !opts_ok {
 		return
 	}

-	num_keys, nkeys_ok := read_wire_u32(&rest)
-	if !nkeys_ok || num_keys != 1 {
+	if offset + 4 > len(decoded) {
 		return
 	}

-	_, pub_blob_ok := read_wire_string(&rest)
+	num_keys := endian.get_u32(decoded[offset:offset + 4], .Big) or_return
+	offset += 4
+
+	if num_keys != 1 {
+		return
+	}
+
+	_, pub_blob_ok := read_wire_string(decoded, &offset)
 	if !pub_blob_ok {
 		return
 	}

-	priv_blob, priv_blob_ok := read_wire_string(&rest)
+	priv_blob, priv_blob_ok := read_wire_string(decoded, &offset)
 	if !priv_blob_ok {
 		return
 	}

-	inner := priv_blob
-
-	check1, c1_ok := read_wire_u32(&inner)
-	check2, c2_ok := read_wire_u32(&inner)
-	if !c1_ok || !c2_ok || check1 != check2 {
+	inner_offset := 0
+	if inner_offset + 8 > len(priv_blob) {
 		return
 	}

-	priv_type, type_ok := read_wire_string(&inner)
-	if !type_ok || string(priv_type) != SSH_ED25519 {
+	check1 := endian.get_u32(
+		transmute([]u8)(priv_blob)[inner_offset:inner_offset + 4],
+		.Big,
+	) or_return
+	inner_offset += 4
+	check2 := endian.get_u32(
+		transmute([]u8)(priv_blob)[inner_offset:inner_offset + 4],
+		.Big,
+	) or_return
+	inner_offset += 4
+
+	if check1 != check2 {
 		return
 	}

-	pub_wire, pub_ok := read_wire_string(&inner)
+	priv_type, type_ok := read_wire_string(transmute([]u8)priv_blob, &inner_offset)
+	if !type_ok || priv_type != SSH_ED25519 {
+		return
+	}
+
+	pub_wire, pub_ok := read_wire_string(transmute([]u8)priv_blob, &inner_offset)
 	if !pub_ok || len(pub_wire) != 32 {
 		return
 	}
-	mem.copy_non_overlapping(&kp.Public[0], &pub_wire[0], 32)
+	mem.copy_non_overlapping(&kp.Public[0], raw_data(pub_wire), 32)

-	priv_wire, priv_ok := read_wire_string(&inner)
+	priv_wire, priv_ok := read_wire_string(transmute([]u8)priv_blob, &inner_offset)
 	if !priv_ok || len(priv_wire) != 64 {
 		return
 	}

-	mem.copy_non_overlapping(&kp.Private[0], &priv_wire[0], 32)
+	mem.copy_non_overlapping(&kp.Private[0], raw_data(priv_wire), 32)

 	ok = true
 	return
@@ -164,28 +182,19 @@ is_ed25519_key :: proc(
 	return ok, nil
 }

-read_wire_string :: proc(data: ^[]u8) -> (s: []u8, ok: bool) #no_bounds_check {
-	if len(data^) < 4 {
+read_wire_string :: proc(data: []u8, offset: ^int) -> (s: string, ok: bool) {
+	if offset^ + 4 > len(data) {
 		return
 	}
-	length := endian.get_u32(data^[:4], .Big) or_return
-	data^ = data^[4:]
+	length := endian.get_u32(data[offset^:offset^ + 4], .Big) or_return
+	offset^ += 4

-	if len(data^) < int(length) {
+	if offset^ + int(length) > len(data) {
 		return
 	}
-	s = data^[:int(length)]
-	data^ = data^[int(length):]
-	ok = true
-	return
-}

-read_wire_u32 :: proc(data: ^[]u8) -> (v: u32, ok: bool) #no_bounds_check {
-	if len(data^) < 4 {
-		return
-	}
-	v = endian.get_u32(data^[:4], .Big) or_return
-	data^ = data^[4:]
+	s = string(data[offset^:offset^ + int(length)])
+	offset^ += int(length)
 	ok = true
 	return
 }
@@ -52,15 +52,15 @@ test_private_key_pub_matches_public_key :: proc(t: ^testing.T) {
@(test)
 test_read_wire_string :: proc(t: ^testing.T) {
 	data := []u8{0, 0, 0, 5, u8('h'), u8('e'), u8('l'), u8('l'), u8('o'), 0, 0, 0, 0}
+	offset := 0

-	buf := data
-	s, ok := read_wire_string(&buf)
+	s, ok := read_wire_string(data, &offset)
 	testing.expect(t, ok, "expected read_wire_string to succeed")
-	testing.expect_value(t, string(s), "hello")
-	testing.expect_value(t, len(data) - len(buf), 9)
+	testing.expect_value(t, s, "hello")
+	testing.expect_value(t, offset, 9)

-	s2, ok2 := read_wire_string(&buf)
+	s2, ok2 := read_wire_string(data, &offset)
 	testing.expect(t, ok2, "expected second read to succeed")
-	testing.expect_value(t, len(s2), 0)
+	testing.expect_value(t, s2, "")
 }

@@ -1,5 +1,6 @@
 package main

+import "core:fmt"
 import "core:io"
 import "core:text/table"

@@ -17,6 +18,20 @@ decorations := table.Decorations {
 	"─",
 }

+ansi_aware_width :: proc(str: string) -> int #no_bounds_check {
+	width := 0
+	for i := 0; i < len(str); {
+		if i + 1 < len(str) && str[i] == 0x1b && str[i + 1] == '[' {
+			i += 2
+			for i < len(str) {c := str[i]; i += 1; if c >= 0x40 && c <= 0x7E {break}}
+		} else {
+			width += 1
+			i += 1
+		}
+	}
+	return width
+}
+
 write_borderless_table :: proc(w: io.Writer, t: ^table.Table) {
 	table.build(t, ansi_aware_width)

@@ -27,7 +42,7 @@ write_borderless_table :: proc(w: io.Writer, t: ^table.Table) {
 	if t.caption != "" {
 		table.write_text_align(
 			w,
-			colorize(.Heading, t.caption),
+			fmt.tprintf("%s%s%s", COLOR_HEADINGS, t.caption, ANSI_RESET),
 			.Left,
 			0, //t.lpad,
 			0, //t.rpad,
@@ -49,21 +64,6 @@ write_borderless_table :: proc(w: io.Writer, t: ^table.Table) {
 	write_table_separator(w, t)
 }

-ansi_aware_width :: proc(str: string) -> int #no_bounds_check {
-	width := 0
-	for i := 0; i < len(str); {
-		if i + 1 < len(str) && str[i] == 0x1b && str[i + 1] == '[' {
-			i += 2
-			for i < len(str) {c := str[i]; i += 1; if c >= 0x40 && c <= 0x7E {break}}
-		} else {
-			width += 1
-			i += 1
-		}
-	}
-	return width
-}
-
-
 table_reset :: proc(t: ^table.Table) {
 	clear(&t.cells)
 	clear(&t.colw)
@@ -2,7 +2,6 @@

 package main

-import "core:strings"
 import "core:testing"

@(test)
@@ -17,7 +16,7 @@ test_ansi_aware_width_empty :: proc(t: ^testing.T) {

@(test)
 test_ansi_aware_width_with_color_codes :: proc(t: ^testing.T) {
-	colored := colorize(.Heading, "Directory", disable = false)
+	colored := COLOR_TABLE_HEADING + "Directory" + ANSI_RESET
 	testing.expect_value(t, ansi_aware_width(colored), 9)
 }

@@ -29,14 +28,6 @@ test_ansi_aware_width_multibyte :: proc(t: ^testing.T) {

@(test)
 test_ansi_aware_width_multiple_escape_sequences :: proc(t: ^testing.T) {
-	colored := strings.concatenate(
-		{
-			colorize(.Heading, "a", disable = false),
-			colorize(.Heading, "b", disable = false),
-			colorize(.Heading, "c", disable = false),
-		},
-		context.temp_allocator,
-	)
+	colored := COLOR_TABLE_HEADING + "a" + ANSI_RESET + "b" + COLOR_TABLE_HEADING + "c" + ANSI_RESET
 	testing.expect_value(t, ansi_aware_width(colored), 3)
 }
-
@@ -1 +1 @@
-1.0.0
+0.3.0
Author	SHA1	Message	Date
spencer	ac6c734722	feat: Added --color flag.	2026-06-26 14:15:20 -04:00
spencer	a4f4b10a7b	refactor: Used RTTI for more sophisticated flag parsing.	2026-06-26 13:49:01 -04:00
spencer	581967a58d	nix: Fixed the nix build.	2026-06-25 18:08:08 -04:00
spencer	6ec09309dd	fix: -h short flag now works on subcommands.	2026-06-25 18:07:31 -04:00
spencer	c5020bd6a6	chore: Re-numbered todos.	2026-06-25 18:00:54 -04:00
spencer	d5981d7b88	feat: Added `--format, -f` flag. Allows printing data in tabular or json format.	2026-06-25 17:53:44 -04:00
@@ -1 +1 @@
 .0.0
 .3.0