chore(main): release 0.2.0

2025-12-29 23:47:39 -05:00 · 2025-11-06 17:13:02 -05:00
21 changed files with 118 additions and 565 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,24 +1,16 @@
 # Changelog

-## [0.2.0](https://github.com/sbrow/envr/compare/v0.1.1...v0.2.0) (2025-11-10)
+## [0.2.0](https://github.com/sbrow/envr/compare/v0.1.1...v0.2.0) (2025-11-06)


 ### ⚠ BREAKING CHANGES

-* Dir is now derived from Path rather than stored in the DB. Your DB will need to be updated.
-* **scan:** The config value `scan.Exclude` is now a list rather than a string.
 * **check:** Renamed the `check` command to `deps`.
 * The config value `scan.Include` is now a list rather than a string.

 ### Features

-* Added new `check` command. ([cbd74f3](https://github.com/sbrow/envr/commit/cbd74f387e2e330b2557d07dd82ba05cc91300ac))
-* **config:** The default config now filters out more junk. ([15be62b](https://github.com/sbrow/envr/commit/15be62b5a2a5a735b90b074497d645c5a2cfced8))
-* **init:** Added a `--force` flag for overwriting an existing config. ([169653d](https://github.com/sbrow/envr/commit/169653d7566f63730fb9da80a18330a566223be9))
 * Multiple scan includes are now supported. ([4273fa5](https://github.com/sbrow/envr/commit/4273fa58956d8736271a0af66202dca481126fe4))
-* **scan:** Added support for multiple exports. ([f43705c](https://github.com/sbrow/envr/commit/f43705cd53c6d87aef1f69df4e474441f25c1dc7))
-* **sync:** envr can now detect if directories have moved. ([4db0a4d](https://github.com/sbrow/envr/commit/4db0a4d33d2b6a79d13b36a8e8631f895e8fef8d))
-* **sync:** Now checks files for mismatched hashes before replacing. ([8074f7a](https://github.com/sbrow/envr/commit/8074f7ae6dfa54e931a198257f3f8e6d0cfe353a))


 ### Bug Fixes
@@ -29,7 +21,6 @@
 ### Code Refactoring

 * **check:** Renamed the `check` command to `deps`. ([c9c34ce](https://github.com/sbrow/envr/commit/c9c34ce771653da214635f1df1fef1f23265c552))
-* Dir is no longer stored in the database. ([0fef74a](https://github.com/sbrow/envr/commit/0fef74a9bba0fbf3c34b66c2095955e6eee7047b))

 ## [0.1.1](https://github.com/sbrow/envr/compare/v0.1.0...v0.1.1) (2025-11-05)

--- a/README.md
+++ b/README.md
@@ -19,11 +19,10 @@ be run on a cron.
 - 🔍 **Smart Scanning**: Automatically discover and import `.env` files in your
 home directory.
 - ✨ **Interactive CLI**: User-friendly prompts for file selection and management.
- 🗂️ **Rename Detection**: Automatically finds and updates renamed/moved
-repositories.

 ## TODOS
- [x] Rename Detection: automatically update moved files.
+
+- [ ] 🗂️ **Rename Detection**: Automatically handle renamed repositories.
 - [ ] Allow use of keys from `ssh-agent`
 - [x] Allow configuration of ssh key.
 - [x] Allow multiple ssh keys.
--- a/WINDOWS.md
+++ b/WINDOWS.md
@@ -1,92 +0,0 @@
-# Windows Compatibility Guide
-
-This document outlines Windows compatibility issues and solutions for the envr project.
-
-## Critical Issues
-
-### 1. Path Handling Bug (MUST FIX)
-
-**File:** `app/env_file.go:209`
-
-**Issue:** Uses `path.Join` instead of `filepath.Join`, which won't work correctly on Windows due to different path separators.
-
-**Current code:**
-```go
-f.Path = path.Join(newDir, path.Base(f.Path))
-```
-
-**Fixed code:**
-```go
-f.Path = filepath.Join(newDir, filepath.Base(f.Path))
-```
-
-## External Dependencies
-
-The application relies on external tools that need to be installed separately on Windows:
-
-### Required Tools
-
-1. **fd** - Fast file finder
-   - Install via: `winget install sharkdp.fd` or `choco install fd`
-   - Alternative: `scoop install fd`
-
-2. **git** - Version control system
-   - Install via: `winget install Git.Git` or download from git-scm.com
-   - Usually already available on most development machines
-
-## Minor Compatibility Notes
-
-### File Permissions
- Unix file permissions (`0755`, `0644`) are used throughout the codebase
- These are safely ignored on Windows - no changes needed
-
-### Editor Configuration
-**File:** `cmd/edit_config.go:20-24`
-
-**Issue:** Relies on `$EDITOR` environment variable which is less common on Windows.
-
-**Current behavior:** Fails if `$EDITOR` is not set
-
-**Recommended improvement:** Add fallback detection for Windows editors:
-```go
-editor := os.Getenv("EDITOR")
-if editor == "" {
-    if runtime.GOOS == "windows" {
-        editor = "notepad.exe"  // or "code.exe" for VS Code
-    } else {
-        fmt.Println("Error: $EDITOR environment variable is not set")
-        return
-    }
-}
-```
-
-## Installation Instructions for Windows
-
-1. Install required dependencies:
-   ```powershell
-   winget install sharkdp.fd
-   winget install Git.Git
-   ```
-
-2. Fix the path handling bug in `app/env_file.go:209`
-
-3. Build and run as normal:
-   ```powershell
-   go build
-   .\envr.exe init
-   ```
-
-## Testing on Windows
-
-After applying the critical path fix, the core functionality should work correctly on Windows. The application has been designed with cross-platform compatibility in mind, using:
-
- `filepath` package for path operations (mostly)
- `os.UserHomeDir()` for home directory detection
- Standard Go file operations
-
-## Summary
-
- **1 critical bug** must be fixed for Windows compatibility
- **2 external tools** need to be installed
- **1 minor enhancement** recommended for better Windows UX
- Overall architecture is Windows-compatible
--- a/app/config.go
+++ b/app/config.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path"
 	"path/filepath"
 	"strings"

@@ -19,7 +18,6 @@ type Config struct {
 	ScanConfig scanConfig   `json:"scan"`
 }

-// Used by age to encrypt and decrypt the database.
 type SshKeyPair struct {
 	Private string `json:"private"` // Path to the private key file
 	Public  string `json:"public"`  // Path to the public key file
@@ -28,7 +26,8 @@ type SshKeyPair struct {
 type scanConfig struct {
 	// TODO: Support multiple matchers
 	Matcher string `json:"matcher"`
-	Exclude []string `json:"exclude"`
+	// TODO: Support multiple excludes
+	Exclude string   `json:"exclude"`
 	Include []string `json:"include"`
 }

@@ -49,12 +48,7 @@ func NewConfig(privateKeyPaths []string) Config {
 		Keys: keys,
 		ScanConfig: scanConfig{
 			Matcher: "\\.env",
-			Exclude: []string{
-				"*\\.envrc",
-				"\\.local/",
-				"node_modules",
-				"vendor",
-			},
+			Exclude: "*.envrc",
 			Include: []string{"~"},
 		},
 	}
@@ -115,25 +109,6 @@ func (c *Config) Save() error {
 	return os.WriteFile(configPath, data, 0644)
 }

-// buildFdArgs builds the fd command arguments with multiple exclude patterns
-func (c Config) buildFdArgs(searchPath string, includeIgnored bool) []string {
-	args := []string{"-a", c.ScanConfig.Matcher}
-
-	// Add exclude patterns
-	for _, exclude := range c.ScanConfig.Exclude {
-		args = append(args, "-E", exclude)
-	}
-
-	if includeIgnored {
-		args = append(args, "-HI")
-	} else {
-		args = append(args, "-H")
-	}
-
-	args = append(args, searchPath)
-	return args
-}
-
 // Use fd to find all ignored .env files that match the config's parameters
 func (c Config) scan() (paths []string, err error) {
 	searchPaths, err := c.searchPaths()
@@ -144,7 +119,7 @@ func (c Config) scan() (paths []string, err error) {
 	for _, searchPath := range searchPaths {
 		// Find all files (including ignored ones)
 		fmt.Printf("Searching for all files in \"%s\"...\n", searchPath)
-		allCmd := exec.Command("fd", c.buildFdArgs(searchPath, true)...)
+		allCmd := exec.Command("fd", "-a", c.ScanConfig.Matcher, "-E", c.ScanConfig.Exclude, "-HI", searchPath)
 		allOutput, err := allCmd.Output()
 		if err != nil {
 			return paths, err
@@ -157,7 +132,7 @@ func (c Config) scan() (paths []string, err error) {

 		// Find unignored files
 		fmt.Printf("Search for unignored fies in \"%s\"...\n", searchPath)
-		unignoredCmd := exec.Command("fd", c.buildFdArgs(searchPath, false)...)
+		unignoredCmd := exec.Command("fd", "-a", c.ScanConfig.Matcher, "-E", c.ScanConfig.Exclude, "-H", searchPath)
 		unignoredOutput, err := unignoredCmd.Output()
 		if err != nil {
 			return []string{}, err
@@ -209,7 +184,8 @@ func (c Config) searchPaths() (paths []string, err error) {
 	return paths, nil
 }

-func (s SshKeyPair) identity() (age.Identity, error) {
+// TODO: Should this be private?
+func (s SshKeyPair) Identity() (age.Identity, error) {
 	sshKey, err := os.ReadFile(s.Private)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read SSH key: %w", err)
@@ -223,7 +199,8 @@ func (s SshKeyPair) identity() (age.Identity, error) {
 	return id, nil
 }

-func (s SshKeyPair) recipient() (age.Recipient, error) {
+// TODO: Should this be private?
+func (s SshKeyPair) Recipient() (age.Recipient, error) {
 	sshKey, err := os.ReadFile(s.Public)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read SSH key: %w", err)
@@ -236,32 +213,3 @@ func (s SshKeyPair) recipient() (age.Recipient, error) {

 	return id, nil
 }
-
-// Use fd to find all git roots in the config's search paths
-func (c Config) findGitRoots() (paths []string, err error) {
-	searchPaths, err := c.searchPaths()
-	if err != nil {
-		return []string{}, err
-	}
-
-	for _, searchPath := range searchPaths {
-		allCmd := exec.Command("fd", "-H", "-t", "d", "^\\.git$", searchPath)
-		allOutput, err := allCmd.Output()
-		if err != nil {
-			return paths, err
-		}
-
-		allFiles := strings.Split(strings.TrimSpace(string(allOutput)), "\n")
-		if len(allFiles) == 1 && allFiles[0] == "" {
-			allFiles = []string{}
-		}
-
-		for i, file := range allFiles {
-			allFiles[i] = path.Dir(path.Clean(file))
-		}
-
-		paths = append(paths, allFiles...)
-	}
-
-	return paths, nil
-}
--- a/app/db.go
+++ b/app/db.go
@@ -1,6 +1,5 @@
 package app

-// TODO: app/db.go should be reviewed.
 import (
 	"database/sql"
 	"encoding/json"
@@ -14,12 +13,19 @@ import (
 	_ "modernc.org/sqlite"
 )

+// CloseMode determines whether or not the in-memory DB should be saved to disk
+// before closing the connection.
+type CloseMode int
+
+const (
+	ReadOnly CloseMode = iota
+	Write
+)
+
 type Db struct {
 	db       *sql.DB
 	cfg      Config
 	features *AvailableFeatures
-	// If true, the database will be saved to disk before closing
-	changed bool
 }

 func Open() (*Db, error) {
@@ -31,7 +37,7 @@ func Open() (*Db, error) {
 	if _, err := os.Stat("/home/spencer/.envr/data.age"); err != nil {
 		// Create a new DB
 		db, err := newDb()
-		return &Db{db, *cfg, nil, true}, err
+		return &Db{db, *cfg, nil}, err
 	} else {
 		// Open the existing DB
 		tmpFile, err := os.CreateTemp("", "envr-*.db")
@@ -53,7 +59,7 @@ func Open() (*Db, error) {

 		restoreDB(tmpFile.Name(), memDb)

-		return &Db{memDb, *cfg, nil, false}, nil
+		return &Db{memDb, *cfg, nil}, nil
 	}
 }

@@ -66,6 +72,7 @@ func newDb() (*sql.DB, error) {
 	} else {
 		_, err := db.Exec(`create table envr_env_files (
      path text primary key not null
+    , dir text not null
    , remotes text -- JSON
    , sha256 text not null
    , contents text not null
@@ -101,7 +108,7 @@ func decryptDb(tmpFilePath string, keys []SshKeyPair) error {
 	identities := make([]age.Identity, 0, len(keys))

 	for _, key := range keys {
-		id, err := key.identity()
+		id, err := key.Identity()

 		if err != nil {
 			return err
@@ -143,7 +150,7 @@ func restoreDB(path string, destDB *sql.DB) error {

 // Returns all the EnvFiles present in the database.
 func (db *Db) List() (results []EnvFile, err error) {
-	rows, err := db.db.Query("select path, remotes, sha256, contents from envr_env_files")
+	rows, err := db.db.Query("select * from envr_env_files")

 	if err != nil {
 		return nil, err
@@ -152,18 +159,14 @@ func (db *Db) List() (results []EnvFile, err error) {

 	for rows.Next() {
 		var envFile EnvFile
-		var remotesJson []byte
-		err := rows.Scan(&envFile.Path, &remotesJson, &envFile.Sha256, &envFile.contents)
+		var remotesJSON string
+
+		err := rows.Scan(&envFile.Path, &envFile.Dir, &remotesJSON, &envFile.Sha256, &envFile.contents)
 		if err != nil {
 			return nil, err
 		}

-		// Populate Dir from Path
-		envFile.Dir = filepath.Dir(envFile.Path)
-
-		if err := json.Unmarshal(remotesJson, &envFile.Remotes); err != nil {
-			return nil, err
-		}
+		// TODO: unmarshal remotesJSON into envFile.remotes

 		results = append(results, envFile)
 	}
@@ -175,10 +178,10 @@ func (db *Db) List() (results []EnvFile, err error) {
 	return results, nil
 }

-func (db *Db) Close() error {
+func (db *Db) Close(mode CloseMode) error {
 	defer db.db.Close()

-	if db.changed {
+	if mode == Write {
 		// Create tmp file
 		tmpFile, err := os.CreateTemp("", "envr-*.db")
 		if err != nil {
@@ -194,8 +197,6 @@ func (db *Db) Close() error {
 		if err := encryptDb(tmpFile.Name(), db.cfg.Keys); err != nil {
 			return err
 		}
-
-		db.changed = false
 	}

 	return nil
@@ -241,7 +242,7 @@ func encryptDb(tmpFilePath string, keys []SshKeyPair) error {

 	recipients := make([]age.Recipient, 0, len(keys))
 	for _, key := range keys {
-		recipient, err := key.recipient()
+		recipient, err := key.Recipient()

 		if err != nil {
 			return err
@@ -277,16 +278,14 @@ func (db *Db) Insert(file EnvFile) error {

 	// Insert into database
 	_, err = db.db.Exec(`
-		INSERT OR REPLACE INTO envr_env_files (path, remotes, sha256, contents)
-		VALUES (?, ?, ?, ?)
-	`, file.Path, string(remotesJSON), file.Sha256, file.contents)
+		INSERT OR REPLACE INTO envr_env_files (path, dir, remotes, sha256, contents)
+		VALUES (?, ?, ?, ?, ?)
+	`, file.Path, file.Dir, string(remotesJSON), file.Sha256, file.contents)

 	if err != nil {
 		return fmt.Errorf("failed to insert env file: %w", err)
 	}

-	db.changed = true
-
 	return nil
 }

@@ -294,15 +293,12 @@ func (db *Db) Insert(file EnvFile) error {
 func (db *Db) Fetch(path string) (envFile EnvFile, err error) {
 	var remotesJSON string

-	row := db.db.QueryRow("SELECT path, remotes, sha256, contents FROM envr_env_files WHERE path = ?", path)
-	err = row.Scan(&envFile.Path, &remotesJSON, &envFile.Sha256, &envFile.contents)
+	row := db.db.QueryRow("SELECT path, dir, remotes, sha256, contents FROM envr_env_files WHERE path = ?", path)
+	err = row.Scan(&envFile.Path, &envFile.Dir, &remotesJSON, &envFile.Sha256, &envFile.contents)
 	if err != nil {
 		return EnvFile{}, fmt.Errorf("failed to fetch env file: %w", err)
 	}

-	// Populate Dir from Path
-	envFile.Dir = filepath.Dir(envFile.Path)
-
 	if err = json.Unmarshal([]byte(remotesJSON), &envFile.Remotes); err != nil {
 		return EnvFile{}, fmt.Errorf("failed to unmarshal remotes: %w", err)
 	}
@@ -326,21 +322,12 @@ func (db *Db) Delete(path string) error {
 		return fmt.Errorf("no file found with path: %s", path)
 	}

-	db.changed = true
-
 	return nil
 }

 // Finds .env files in the filesystem that aren't present in the database.
-// path overrides the already configured
-func (db *Db) Scan(paths []string) ([]string, error) {
-	cfg := db.cfg
-
-	if paths != nil {
-		cfg.ScanConfig.Include = paths
-	}
-
-	all_paths, err := cfg.scan()
+func (db *Db) Scan() ([]string, error) {
+	all_paths, err := db.cfg.scan()
 	if err != nil {
 		return []string{}, err
 	}
@@ -387,35 +374,3 @@ func (db *Db) CanScan() error {
 		return nil
 	}
 }
-
-// If true, [Db.Insert] should be called on the [EnvFile] that generated
-// the given result
-func (db Db) UpdateRequired(status EnvFileSyncResult) bool {
-	return status&(BackedUp|DirUpdated) != 0
-}
-
-func (db *Db) Sync(file *EnvFile) (result EnvFileSyncResult, err error) {
-	// TODO: This results in findMovedDirs being called multiple times.
-	return file.sync(TrustFilesystem, db)
-}
-
-// Looks for git directories that share one or more git remotes with
-// the given file.
-func (db Db) findMovedDirs(file *EnvFile) (movedDirs []string, err error) {
-	if err = db.Features().validateFeatures(Fd, Git); err != nil {
-		return movedDirs, err
-	}
-
-	gitRoots, err := db.cfg.findGitRoots()
-	if err != nil {
-		return movedDirs, err
-	} else {
-		for _, dir := range gitRoots {
-			if file.sharesRemote(getGitRemotes(dir)) {
-				movedDirs = append(movedDirs, dir)
-			}
-		}
-
-		return movedDirs, nil
-	}
-}
--- a/app/env_file.go
+++ b/app/env_file.go
@@ -2,19 +2,15 @@ package app

 import (
 	"crypto/sha256"
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
-	"path"
 	"path/filepath"
 	"strings"
 )

 type EnvFile struct {
-	// TODO: Should use FileName in the struct and derive from the path.
 	Path     string
-	// Dir is derived from Path, and is not stored in the database.
 	Dir      string
 	Remotes  []string // []string
 	Sha256   string
@@ -25,30 +21,16 @@ type EnvFile struct {
 type EnvFileSyncResult int

 const (
-	// The filesystem contents matches the struct
-	// no further action is required.
-	Noop EnvFileSyncResult = 0
-	// The directory changed, but the file contents matched.
-	// The database must be updated.
-	DirUpdated EnvFileSyncResult = 1
-	// The filesystem has been restored to match the struct
-	// no further action is required.
-	Restored EnvFileSyncResult = 1 << 1
-	// The filesystem has been restored to match the struct.
-	// The directory changed, so the database must be updated
-	RestoredAndDirUpdated EnvFileSyncResult = Restored | DirUpdated
 	// The struct has been updated from the filesystem
 	// and should be updated in the database.
-	BackedUp EnvFileSyncResult = 1 << 2
-	Error    EnvFileSyncResult = 1 << 3
-)
-
-// Determines the source of truth when calling [EnvFile.Sync] or [EnvFile.Restore]
-type syncDirection int
-
-const (
-	TrustDatabase syncDirection = iota
-	TrustFilesystem
+	Updated EnvFileSyncResult = iota
+	// The filesystem has been restored to match the struct
+	// no further action is required.
+	Restored
+	Error
+	// The filesystem contents matches the struct
+	// no further action is required.
+	Noop
 )

 func NewEnvFile(path string) EnvFile {
@@ -113,119 +95,62 @@ func getGitRemotes(dir string) []string {
 	return remotes
 }

-// Reconcile the state of the database with the state of the filesystem, using
-// dir to determine which side to use a the source of truth.
-func (f *EnvFile) sync(dir syncDirection, db *Db) (result EnvFileSyncResult, err error) {
-	if result != Noop {
-		panic("Invalid state")
+// Install the file into the file system
+func (file EnvFile) Restore() error {
+	// TODO: Handle restores more cleanly
+	// Ensure the directory exists
+	if _, err := os.Stat(file.Dir); err != nil {
+		return fmt.Errorf("directory missing")
 	}

-	if _, err := os.Stat(f.Dir); err != nil {
-		// Directory doesn't exist
-
-		var movedDirs []string
-
-		if db != nil {
-			movedDirs, err = db.findMovedDirs(f)
-		}
-		if err != nil {
-			return Error, err
-		} else {
-			switch len(movedDirs) {
-			case 0:
-				return Error, fmt.Errorf("directory missing")
-			case 1:
-				f.updateDir(movedDirs[0])
-				result |= DirUpdated
-			default:
-				return Error, fmt.Errorf("multiple directories found")
-			}
-		}
+	// Check if file already exists
+	if _, err := os.Stat(file.Path); err == nil {
+		return fmt.Errorf("file already exists: %s", file.Path)
 	}

-	if _, err := os.Stat(f.Path); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			if err := os.WriteFile(f.Path, []byte(f.contents), 0644); err != nil {
-				return Error, fmt.Errorf("failed to write file: %w", err)
+	// Write the contents to the file
+	if err := os.WriteFile(file.Path, []byte(file.contents), 0644); err != nil {
+		return fmt.Errorf("failed to write file: %w", err)
 	}

-			return result | Restored, nil
-		} else {
-			return Error, err
-		}
-	} else {
-		// File exists, check its hash
-		contents, err := os.ReadFile(f.Path)
-		if err != nil {
-			return Error, fmt.Errorf("failed to read file for SHA comparison: %w", err)
-		}
-
-		hash := sha256.Sum256(contents)
-		currentSha := fmt.Sprintf("%x", hash)
-
-		// Compare the hashes
-		if currentSha == f.Sha256 {
-			// No op, or DirUpdated
-			return result, nil
-		} else {
-			switch dir {
-			case TrustDatabase:
-				if err := os.WriteFile(f.Path, []byte(f.contents), 0644); err != nil {
-					return Error, fmt.Errorf("failed to write file: %w", err)
-				}
-
-				return result | Restored, nil
-			case TrustFilesystem:
-				// Overwrite the database
-				if err = f.Backup(); err != nil {
-					return Error, err
-				} else {
-					return BackedUp, nil
-				}
-			default:
-				panic("unknown sync direction")
-			}
-		}
-	}
-}
-
-func (f *EnvFile) sharesRemote(remotes []string) bool {
-	rMap := make(map[string]bool)
-	for _, remote := range f.Remotes {
-		rMap[remote] = true
-	}
-
-	for _, remote := range remotes {
-		if rMap[remote] {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (f *EnvFile) updateDir(newDir string) {
-	f.Dir = newDir
-	f.Path = path.Join(newDir, path.Base(f.Path))
-	f.Remotes = getGitRemotes(newDir)
+	return nil
 }

 // Try to reconcile the EnvFile with the filesystem.
 //
 // If Updated is returned, [Db.Insert] should be called on file.
 func (file *EnvFile) Sync() (result EnvFileSyncResult, err error) {
-	return file.sync(TrustFilesystem, nil)
+	// Check if the path exists in the file system
+	_, err = os.Stat(file.Path)
+	if err == nil {
+		contents, err := os.ReadFile(file.Path)
+		if err != nil {
+			return Error, fmt.Errorf("failed to read file for SHA comparison: %w", err)
 		}

-// Install the file into the file system. If the file already exists,
-// it will be overwritten.
-func (file EnvFile) Restore() error {
-	_, err := file.sync(TrustDatabase, nil)
-
-	return err
+		// Check if sha matches by reading the current file and calculating its hash
+		hash := sha256.Sum256(contents)
+		currentSha := fmt.Sprintf("%x", hash)
+		if file.Sha256 == currentSha {
+			// Nothing to do
+			return Noop, nil
+		} else {
+			if err = file.Backup(); err != nil {
+				return Error, err
+			} else {
+				return Updated, nil
+			}
+		}
+	} else {
+		if err = file.Restore(); err != nil {
+			return Error, err
+		} else {
+			return Restored, nil
+		}
+	}
 }

-// Update the EnvFile using the file system.
+// Update the EnvFile using the file system
 func (file *EnvFile) Backup() error {
 	// Read the contents of the file
 	contents, err := os.ReadFile(file.Path)
--- a/app/features.go
+++ b/app/features.go
@@ -1,20 +1,9 @@
 package app

 import (
-	"fmt"
 	"os/exec"
 )

-type MissingFeatureError struct {
-	feature AvailableFeatures
-}
-
-func (m *MissingFeatureError) Error() string {
-	return fmt.Sprintf("Missing \"%s\" feature", m.feature)
-}
-
-// TODO: Features should really be renamed to Binaries
-
 // Represents which binaries are present in $PATH.
 // Used to fail safely when required features are unavailable
 type AvailableFeatures int
@@ -41,20 +30,3 @@ func checkFeatures() (feats AvailableFeatures) {

 	return feats
 }
-
-// Returns a MissingFeature error if the given features aren't present.
-func (a AvailableFeatures) validateFeatures(features ...AvailableFeatures) error {
-	var missing AvailableFeatures
-
-	for _, feat := range features {
-		if a&feat == 0 {
-			missing |= feat
-		}
-	}
-
-	if missing == 0 {
-		return nil
-	} else {
-		return &MissingFeatureError{missing}
-	}
-}
--- a/cmd/backup.go
+++ b/cmd/backup.go
@@ -27,11 +27,11 @@ var backupCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close()
+			defer db.Close(app.Write)
 			record := app.NewEnvFile(path)

 			if err := db.Insert(record); err != nil {
-				return err
+				panic(err)
 			} else {
 				fmt.Printf("Saved %s into the database", path)
 				return nil
--- a/cmd/check.go
+++ b/cmd/check.go
@@ -1,109 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/sbrow/envr/app"
-	"github.com/spf13/cobra"
-)
-
-var checkCmd = &cobra.Command{
-	Use:   "check [path]",
-	Short: "check if files in the current directory are backed up",
-	// TODO: Long description for new check command
-	Args: cobra.MaximumNArgs(1),
-	RunE: func(cmd *cobra.Command, args []string) error {
-		// Accept an optional path arg, default to current working directory
-		var checkPath string
-		if len(args) > 0 {
-			checkPath = args[0]
-		} else {
-			cwd, err := os.Getwd()
-			if err != nil {
-				return fmt.Errorf("failed to get current working directory: %w", err)
-			}
-			checkPath = cwd
-		}
-
-		// Get absolute path
-		absPath, err := filepath.Abs(checkPath)
-		if err != nil {
-			return fmt.Errorf("failed to get absolute path: %w", err)
-		}
-
-		// Open database
-		db, err := app.Open()
-		if err != nil {
-			return fmt.Errorf("failed to open database: %w", err)
-		}
-		defer db.Close()
-
-		// Check if the path is a file or directory
-		info, err := os.Stat(absPath)
-		if err != nil {
-			return fmt.Errorf("failed to stat path: %w", err)
-		}
-
-		var filesInPath []string
-
-		if info.IsDir() {
-			// Find .env files in the specified directory
-			if err := db.CanScan(); err != nil {
-				return err
-			}
-
-			// Scan only the specified path for .env files
-			filesInPath, err = db.Scan([]string{absPath})
-			if err != nil {
-				return fmt.Errorf("failed to scan path for env files: %w", err)
-			}
-		} else {
-			// Path is a file, just check this specific file
-			filesInPath = []string{absPath}
-		}
-
-		// Get all backed up files from the database
-		envFiles, err := db.List()
-		if err != nil {
-			return fmt.Errorf("failed to list files from database: %w", err)
-		}
-
-		// Check which files are not backed up
-		var notBackedUp []string
-		for _, file := range filesInPath {
-			isBackedUp := false
-			for _, envFile := range envFiles {
-				if envFile.Path == file {
-					isBackedUp = true
-					break
-				}
-			}
-			if !isBackedUp {
-				notBackedUp = append(notBackedUp, file)
-			}
-		}
-
-		// Display results
-		if len(notBackedUp) == 0 {
-			if len(filesInPath) == 0 {
-				fmt.Println("No .env files found in the specified directory.")
-			} else {
-				fmt.Println("✓ All .env files in the directory are backed up.")
-			}
-		} else {
-			fmt.Printf("Found %d .env file(s) that are not backed up:\n", len(notBackedUp))
-			for _, file := range notBackedUp {
-				fmt.Printf("  %s\n", file)
-			}
-			fmt.Println("\nRun 'envr sync' to back up these files.")
-		}
-
-		return nil
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(checkCmd)
-}
--- a/cmd/deps.go
+++ b/cmd/deps.go
@@ -19,7 +19,7 @@ The check command reports on which binaries are available and which are not.`,
 		if err != nil {
 			return err
 		} else {
-			defer db.Close()
+			defer db.Close(app.ReadOnly)
 			features := db.Features()

 			table := tablewriter.NewWriter(os.Stdout)
--- a/cmd/init.go
+++ b/cmd/init.go
@@ -11,8 +11,10 @@ import (
 	"github.com/spf13/cobra"
 )

+// TODO: Add --force (-f) flag.
 var initCmd = &cobra.Command{
 	Use:                   "init",
+	DisableFlagsInUseLine: true,
 	Short:                 "Set up envr",
 	Long: `The init command generates your initial config and saves it to
 ~/.envr/config in JSON format.
@@ -21,10 +23,11 @@ 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.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		force, _ := cmd.Flags().GetBool("force")
 		config, _ := app.LoadConfig()

-		if config == nil || force {
+		if config != nil {
+			return fmt.Errorf("You have already initialized envr")
+		} else {
 			keys, err := selectSSHKeys()
 			if err != nil {
 				return fmt.Errorf("Error selecting SSH keys: %v", err)
@@ -40,17 +43,13 @@ key somewhere, otherwise your data could be lost forever.`,
 			}

 			fmt.Printf("Config initialized with %d SSH key(s). You are ready to use envr.\n", len(keys))
-			return nil
-		} else {
-			return fmt.Errorf(`You have already initialized envr.
-Run again with the --force flag if you want to reinitialize.
-`)
 		}
+
+		return nil
 	},
 }

 func init() {
-	initCmd.Flags().BoolP("force", "f", false, "Overwrite an existing config")
 	rootCmd.AddCommand(initCmd)
 }

--- a/cmd/list.go
+++ b/cmd/list.go
@@ -24,7 +24,7 @@ var listCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		defer db.Close()
+		defer db.Close(app.ReadOnly)

 		rows, err := db.List()
 		if err != nil {
--- a/cmd/remove.go
+++ b/cmd/remove.go
@@ -25,7 +25,7 @@ var removeCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close()
+			defer db.Close(app.Write)
 			if err := db.Delete(path); err != nil {
 				return err
 			} else {
--- a/cmd/restore.go
+++ b/cmd/restore.go
@@ -27,7 +27,7 @@ var restoreCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close()
+			defer db.Close(app.ReadOnly)
 			record, err := db.Fetch(path)

 			if err != nil {
--- a/cmd/scan.go
+++ b/cmd/scan.go
@@ -28,7 +28,7 @@ var scanCmd = &cobra.Command{
 			return err
 		}

-		files, err := db.Scan(nil)
+		files, err := db.Scan()
 		if err != nil {
 			return err
 		}
@@ -57,7 +57,7 @@ var scanCmd = &cobra.Command{

 			// Close database with write mode to persist changes
 			if addedCount > 0 {
-				err = db.Close()
+				err = db.Close(app.Write)
 				if err != nil {
 					return fmt.Errorf("Error saving changes: %v\n", err)
 				} else {
@@ -65,7 +65,7 @@ var scanCmd = &cobra.Command{
 					return nil
 				}
 			} else {
-				err = db.Close()
+				err = db.Close(app.ReadOnly)
 				if err != nil {
 					return fmt.Errorf("Error closing database: %v\n", err)
 				}
--- a/cmd/sync.go
+++ b/cmd/sync.go
@@ -10,16 +10,16 @@ import (
 	"github.com/spf13/cobra"
 )

+// TODO: Detect when file paths have moved and update accordingly.
 var syncCmd = &cobra.Command{
 	Use:   "sync",
 	Short: "Update or restore your env backups",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		db, err := app.Open()
-
 		if err != nil {
 			return err
 		} else {
-			defer db.Close()
+			defer db.Close(app.Write)
 			files, err := db.List()

 			if err != nil {
@@ -33,19 +33,16 @@ var syncCmd = &cobra.Command{

 				for _, file := range files {
 					// Syncronize the filesystem with the database.
-					oldPath := file.Path
-					changed, err := db.Sync(&file)
+					changed, err := file.Sync()

 					var status string
 					switch changed {
-					case app.BackedUp:
+					case app.Updated:
 						status = "Backed Up"
 						if err := db.Insert(file); err != nil {
 							return err
 						}
 					case app.Restored:
-						fallthrough
-					case app.RestoredAndDirUpdated:
 						status = "Restored"
 					case app.Error:
 						if err == nil {
@@ -54,23 +51,10 @@ var syncCmd = &cobra.Command{
 						status = err.Error()
 					case app.Noop:
 						status = "OK"
-					case app.DirUpdated:
-						status = "Moved"
 					default:
 						panic("Unknown result")
 					}

-					if changed&app.DirUpdated == app.DirUpdated {
-						if err := db.Delete(oldPath); err != nil {
-							return err
-						}
-					}
-					if db.UpdateRequired(changed) {
-						if err := db.Insert(file); err != nil {
-							return err
-						}
-					}
-
 					results = append(results, syncResult{
 						Path:   file.Path,
 						Status: status,
--- a/docs/cli/envr.md
+++ b/docs/cli/envr.md
@@ -44,7 +44,6 @@ at before, restore your backup with:
 ### 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 deps](envr_deps.md)	 - Check for missing binaries
 * [envr edit-config](envr_edit-config.md)	 - Edit your config with your default editor
 * [envr init](envr_init.md)	 - Set up envr
--- a/docs/cli/envr_check.md
+++ b/docs/cli/envr_check.md
@@ -1,18 +0,0 @@
-## envr check
-
-check if files in the current directory are backed up
-
-```
-envr check [path] [flags]
-```
-
-### Options
-
-```
-  -h, --help   help for check
-```
-
-### SEE ALSO
-
-* [envr](envr.md)	 - Manage your .env files.
-
--- a/docs/cli/envr_init.md
+++ b/docs/cli/envr_init.md
@@ -12,13 +12,12 @@ encrypt your databse. **Make 100% sure** that you have **a remote copy** of this
 key somewhere, otherwise your data could be lost forever.

 ```
-envr init [flags]
+envr init
 ```

 ### Options

 ```
-  -f, --force   Overwrite an existing config
  -h, --help   help for init
 ```

--- a/flake.nix
+++ b/flake.nix
@@ -61,7 +61,7 @@

          packages.default = pkgs.buildGoModule rec {
            pname = "envr";
-            version = "0.2.0";
+            version = "0.1.1";
            src = ./.;
            # If the build complains, uncomment this line
            # vendorHash = "sha256:0000000000000000000000000000000000000000000000000000";
--- a/main.go
+++ b/main.go
@@ -2,6 +2,7 @@ package main

 import "github.com/sbrow/envr/cmd"

+// TODO: `envr check` command that looks in cwd and tells you if it's backed up or not.
 func main() {
 	cmd.Execute()
 }