chore(main): release 0.2.0

BREAKING CHANGE: Dir is now derived from Path rather than stored in the
DB. Your DB will need to be updated.

.github/workflows/go.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v4
       with:
-        go-version: '1.20'
+        go-version: '1.24.6'
 
     - name: Build
       run: go build -v ./...

.github/workflows/release-please.yml

@@ -0,0 +1,25 @@
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+name: release-please
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@v4
+        with:
+          # this assumes that you have created a personal access token
+          # (PAT) and configured it as a GitHub action secret named
+          # `MY_RELEASE_PLEASE_TOKEN` (this secret name is not important).
+          token: ${{ secrets.MY_RELEASE_PLEASE_TOKEN }}
+          # this is a built-in strategy in release-please, see "Action Inputs"
+          # for more options
+          release-type: go

.gitignore

@@ -5,5 +5,6 @@
 man 
 
 # build artifacts
+builds
 envr
 result

CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+## [0.2.0](https://github.com/sbrow/envr/compare/v0.1.1...v0.2.0) (2025-11-10)
+
+
+### ⚠ 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
+
+* **check:** `fd` now correctly gets marked as found. ([17ce49c](https://github.com/sbrow/envr/commit/17ce49cd2d33942282c6f54ce819ac25978f6b7c))
+
+
+### 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)
+
+
+### Features
+
+* **sync:** Results are now displayed in a table. ([42796ec](https://github.com/sbrow/envr/commit/42796ec77b1817e1b9f09068d76a7b6e30da246b))
+
+
+### Bug Fixes
+
+* **sync:** Fixed an issue where deleted folders would be restored. ([9ab72a2](https://github.com/sbrow/envr/commit/9ab72a25faf1af0eedb2f4574166c6ee47450ebb))

Makefile

@@ -0,0 +1,92 @@
+# Makefile for envr - Environment file manager
+# Builds release artifacts for GitHub releases
+
+APP_NAME := envr
+VERSION := $(shell grep 'version = ' flake.nix | head -1 | sed 's/.*version = "\(.*\)";/\1/')
+BUILD_DIR := builds
+LDFLAGS := -X github.com/sbrow/envr/cmd.version=v$(VERSION) -s -w
+
+# Binary names
+LINUX_AMD64_BIN := $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-amd64
+LINUX_ARM64_BIN := $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-arm64
+DARWIN_ARM64_BIN := $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-darwin-arm64
+
+.PHONY: all clean cleanall build-linux build-darwin compress release help
+
+# Default target
+all: release clean
+
+# Create build directory
+$(BUILD_DIR):
+	@mkdir -p $(BUILD_DIR)
+
+# Build Linux AMD64
+$(LINUX_AMD64_BIN): $(BUILD_DIR)
+	@echo "Building for Linux AMD64..."
+	GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o $(LINUX_AMD64_BIN) .
+	@echo "Built $(LINUX_AMD64_BIN)"
+
+# Build Linux ARM64
+$(LINUX_ARM64_BIN): $(BUILD_DIR)
+	@echo "Building for Linux ARM64..."
+	GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o $(LINUX_ARM64_BIN) .
+	@echo "Built $(LINUX_ARM64_BIN)"
+
+# Build Darwin ARM64 (Mac)
+$(DARWIN_ARM64_BIN): $(BUILD_DIR)
+	@echo "Building for Darwin ARM64..."
+	GOOS=darwin GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o $(DARWIN_ARM64_BIN) .
+	@echo "Built $(DARWIN_ARM64_BIN)"
+
+# Build all binaries
+build-linux: $(LINUX_AMD64_BIN) $(LINUX_ARM64_BIN)
+build-darwin: $(DARWIN_ARM64_BIN)
+
+# Compress Linux artifacts with gzip
+$(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-amd64.tar.gz: $(LINUX_AMD64_BIN)
+	@echo "Compressing Linux AMD64 artifact..."
+	cd $(BUILD_DIR) && tar -czf $(APP_NAME)-$(VERSION)-linux-amd64.tar.gz --transform 's|.*|$(APP_NAME)|' $(shell basename $(LINUX_AMD64_BIN))
+
+$(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-arm64.tar.gz: $(LINUX_ARM64_BIN)
+	@echo "Compressing Linux ARM64 artifact..."
+	cd $(BUILD_DIR) && tar -czf $(APP_NAME)-$(VERSION)-linux-arm64.tar.gz --transform 's|.*|$(APP_NAME)|' $(shell basename $(LINUX_ARM64_BIN))
+
+# Compress Darwin artifacts with zip
+$(BUILD_DIR)/$(APP_NAME)-$(VERSION)-darwin-arm64.zip: $(DARWIN_ARM64_BIN)
+	@echo "Compressing Darwin ARM64 artifact..."
+	cd $(BUILD_DIR) && cp $(shell basename $(DARWIN_ARM64_BIN)) $(APP_NAME) && zip $(APP_NAME)-$(VERSION)-darwin-arm64.zip $(APP_NAME) && rm $(APP_NAME)
+
+# Compress all artifacts
+compress: $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-amd64.tar.gz \
+          $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-linux-arm64.tar.gz \
+          $(BUILD_DIR)/$(APP_NAME)-$(VERSION)-darwin-arm64.zip
+
+# Build and compress all release artifacts
+release: build-linux build-darwin compress
+	@echo "Release artifacts created:"
+	@ls -la $(BUILD_DIR)/*.tar.gz $(BUILD_DIR)/*.zip 2>/dev/null || echo "No compressed artifacts found"
+
+# Clean binary files only
+clean:
+	@echo "Cleaning binary files..."
+	@rm -f $(LINUX_AMD64_BIN) $(LINUX_ARM64_BIN) $(DARWIN_ARM64_BIN)
+
+# Clean everything in build directory
+cleanall:
+	@echo "Cleaning build directory..."
+	@rm -rf $(BUILD_DIR)
+
+# Show available targets
+help:
+	@echo "Available targets:"
+	@echo "  all        - Build all release artifacts (default)"
+	@echo "  release    - Build and compress all release artifacts"
+	@echo "  build-linux - Build Linux binaries only"
+	@echo "  build-darwin - Build Darwin binaries only"
+	@echo "  compress   - Compress all built binaries"
+	@echo "  clean      - Remove binary files only"
+	@echo "  cleanall   - Remove entire build directory"
+	@echo "  help       - Show this help message"
+	@echo ""
+	@echo "Release artifacts will be created in $(BUILD_DIR)/"
+	@echo "Version: $(VERSION)"

README.md

@@ -19,10 +19,11 @@ 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
-
-- [ ] 🗂️ **Rename Detection**: Automatically handle renamed repositories.
+- [x] Rename Detection: automatically update moved files.
 - [ ] Allow use of keys from `ssh-agent`
 - [x] Allow configuration of ssh key.
 - [x] Allow multiple ssh keys.

app/config.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"strings"
 
@@ -18,15 +19,17 @@ 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
 }
 
 type scanConfig struct {
+	// TODO: Support multiple matchers
 	Matcher string   `json:"matcher"`
-	Exclude string `json:"exclude"`
-	Include string `json:"include"`
+	Exclude []string `json:"exclude"`
+	Include []string `json:"include"`
 }
 
 // Create a fresh config with sensible defaults.
@@ -46,8 +49,13 @@ func NewConfig(privateKeyPaths []string) Config {
 		Keys: keys,
 		ScanConfig: scanConfig{
 			Matcher: "\\.env",
-			Exclude: "*.envrc",
-			Include: "~",
+			Exclude: []string{
+				"*\\.envrc",
+				"\\.local/",
+				"node_modules",
+				"vendor",
+			},
+			Include: []string{"~"},
 		},
 	}
 }
@@ -107,19 +115,39 @@ 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) {
-	searchPath, err := c.searchPath()
+	searchPaths, err := c.searchPaths()
 	if err != nil {
 		return []string{}, err
 	}
 
+	for _, searchPath := range searchPaths {
 		// Find all files (including ignored ones)
 		fmt.Printf("Searching for all files in \"%s\"...\n", searchPath)
-	allCmd := exec.Command("fd", "-a", c.ScanConfig.Matcher, "-E", c.ScanConfig.Exclude, "-HI", searchPath)
+		allCmd := exec.Command("fd", c.buildFdArgs(searchPath, true)...)
 		allOutput, err := allCmd.Output()
 		if err != nil {
-		return []string{}, err
+			return paths, err
 		}
 
 		allFiles := strings.Split(strings.TrimSpace(string(allOutput)), "\n")
@@ -129,7 +157,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", "-a", c.ScanConfig.Matcher, "-E", c.ScanConfig.Exclude, "-H", searchPath)
+		unignoredCmd := exec.Command("fd", c.buildFdArgs(searchPath, false)...)
 		unignoredOutput, err := unignoredCmd.Output()
 		if err != nil {
 			return []string{}, err
@@ -154,30 +182,34 @@ func (c Config) scan() (paths []string, err error) {
 			}
 		}
 
-	return ignoredFiles, nil
+		paths = append(paths, ignoredFiles...)
+	}
+
+	return paths, nil
 }
 
-func (c Config) searchPath() (path string, err error) {
-	include := c.ScanConfig.Include
-
-	if include == "~" {
+func (c Config) searchPaths() (paths []string, err error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
-			return "", err
-		}
-		return homeDir, nil
+		return paths, err
 	}
 
-	absPath, err := filepath.Abs(include)
+	includes := c.ScanConfig.Include
+
+	for _, include := range includes {
+		path := strings.Replace(include, "~", homeDir, 1)
+		absPath, err := filepath.Abs(path)
 		if err != nil {
-		return "", err
+			return paths, err
 		}
 
-	return absPath, nil
+		paths = append(paths, absPath)
+	}
+
+	return paths, nil
 }
 
-// TODO: Should this be private?
-func (s SshKeyPair) Identity() (age.Identity, error) {
+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)
@@ -191,8 +223,7 @@ func (s SshKeyPair) Identity() (age.Identity, error) {
 	return id, nil
 }
 
-// TODO: Should this be private?
-func (s SshKeyPair) Recipient() (age.Recipient, error) {
+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)
@@ -205,3 +236,32 @@ 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
+}

app/db.go

@@ -1,5 +1,6 @@
 package app
 
+// TODO: app/db.go should be reviewed.
 import (
 	"database/sql"
 	"encoding/json"
@@ -13,19 +14,12 @@ 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) {
@@ -37,7 +31,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}, err
+		return &Db{db, *cfg, nil, true}, err
 	} else {
 		// Open the existing DB
 		tmpFile, err := os.CreateTemp("", "envr-*.db")
@@ -59,7 +53,7 @@ func Open() (*Db, error) {
 
 		restoreDB(tmpFile.Name(), memDb)
 
-		return &Db{memDb, *cfg, nil}, nil
+		return &Db{memDb, *cfg, nil, false}, nil
 	}
 }
 
@@ -72,7 +66,6 @@ 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
@@ -108,7 +101,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
@@ -150,7 +143,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 * from envr_env_files")
+	rows, err := db.db.Query("select path, remotes, sha256, contents from envr_env_files")
 
 	if err != nil {
 		return nil, err
@@ -159,14 +152,18 @@ func (db *Db) List() (results []EnvFile, err error) {
 
 	for rows.Next() {
 		var envFile EnvFile
-		var remotesJSON string
-
-		err := rows.Scan(&envFile.Path, &envFile.Dir, &remotesJSON, &envFile.Sha256, &envFile.contents)
+		var remotesJson []byte
+		err := rows.Scan(&envFile.Path, &remotesJson, &envFile.Sha256, &envFile.contents)
 		if err != nil {
 			return nil, err
 		}
 
-		// TODO: unmarshal remotesJSON into envFile.remotes
+		// Populate Dir from Path
+		envFile.Dir = filepath.Dir(envFile.Path)
+
+		if err := json.Unmarshal(remotesJson, &envFile.Remotes); err != nil {
+			return nil, err
+		}
 
 		results = append(results, envFile)
 	}
@@ -178,10 +175,10 @@ func (db *Db) List() (results []EnvFile, err error) {
 	return results, nil
 }
 
-func (db *Db) Close(mode CloseMode) error {
+func (db *Db) Close() error {
 	defer db.db.Close()
 
-	if mode == Write {
+	if db.changed {
 		// Create tmp file
 		tmpFile, err := os.CreateTemp("", "envr-*.db")
 		if err != nil {
@@ -197,6 +194,8 @@ func (db *Db) Close(mode CloseMode) error {
 		if err := encryptDb(tmpFile.Name(), db.cfg.Keys); err != nil {
 			return err
 		}
+
+		db.changed = false
 	}
 
 	return nil
@@ -242,7 +241,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
@@ -278,14 +277,16 @@ func (db *Db) Insert(file EnvFile) error {
 
 	// Insert into database
 	_, err = db.db.Exec(`
-		INSERT OR REPLACE INTO envr_env_files (path, dir, remotes, sha256, contents)
-		VALUES (?, ?, ?, ?, ?)
-	`, file.Path, file.Dir, string(remotesJSON), file.Sha256, file.contents)
+		INSERT OR REPLACE INTO envr_env_files (path, remotes, sha256, contents)
+		VALUES (?, ?, ?, ?)
+	`, file.Path, string(remotesJSON), file.Sha256, file.contents)
 
 	if err != nil {
 		return fmt.Errorf("failed to insert env file: %w", err)
 	}
 
+	db.changed = true
+
 	return nil
 }
 
@@ -293,12 +294,15 @@ 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, dir, remotes, sha256, contents FROM envr_env_files WHERE path = ?", path)
-	err = row.Scan(&envFile.Path, &envFile.Dir, &remotesJSON, &envFile.Sha256, &envFile.contents)
+	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)
 	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)
 	}
@@ -322,12 +326,21 @@ 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.
-func (db *Db) Scan() ([]string, error) {
-	all_paths, err := db.cfg.scan()
+// 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()
 	if err != nil {
 		return []string{}, err
 	}
@@ -374,3 +387,35 @@ 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
+	}
+}

app/env_file.go

@@ -2,15 +2,19 @@ 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
@@ -21,16 +25,30 @@ type EnvFile struct {
 type EnvFileSyncResult int
 
 const (
-	// The struct has been updated from the filesystem
-	// and should be updated in the database.
-	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
+	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
 )
 
 func NewEnvFile(path string) EnvFile {
@@ -95,62 +113,119 @@ func getGitRemotes(dir string) []string {
 	return remotes
 }
 
-// Install the file into the file system
-func (file EnvFile) Restore() error {
-	// TODO: Handle restores more cleanly
-	// Ensure the directory exists
-	if err := os.MkdirAll(filepath.Dir(file.Path), 0755); err != nil {
-		return fmt.Errorf("failed to create directory: %w", err)
+// 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")
 	}
 
-	// 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.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")
+			}
+		}
 	}
 
-	// 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)
+	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)
 			}
 
-	return nil
+			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)
 }
 
 // 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) {
-	// 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)
-		}
-
-		// 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
-		}
-	}
+	return file.sync(TrustFilesystem, nil)
 }
 
-// Update the EnvFile using the file system
+// 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
+}
+
+// Update the EnvFile using the file system.
 func (file *EnvFile) Backup() error {
 	// Read the contents of the file
 	contents, err := os.ReadFile(file.Path)

app/features.go

@@ -1,9 +1,20 @@
 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
@@ -13,7 +24,7 @@ const (
 	// fd
 	Fd AvailableFeatures = 2
 	// All features are present
-	All AvailableFeatures = Git & Fd
+	All AvailableFeatures = Git | Fd
 )
 
 // Checks for available features.
@@ -30,3 +41,20 @@ 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}
+	}
+}

cmd/backup.go

@@ -27,11 +27,11 @@ var backupCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close(app.Write)
+			defer db.Close()
 			record := app.NewEnvFile(path)
 
 			if err := db.Insert(record); err != nil {
-				panic(err)
+				return err
 			} else {
 				fmt.Printf("Saved %s into the database", path)
 				return nil

cmd/check.go

@@ -1,48 +1,106 @@
 package cmd
 
 import (
+	"fmt"
 	"os"
+	"path/filepath"
 
-	"github.com/olekukonko/tablewriter"
 	"github.com/sbrow/envr/app"
 	"github.com/spf13/cobra"
 )
 
 var checkCmd = &cobra.Command{
-	Use:   "check",
-	Short: "Check for missing binaries",
-	Long: `envr relies on external binaries for certain functionality.
-
-The check command reports on which binaries are available and which are not.`,
+	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
-		} else {
-			defer db.Close(app.ReadOnly)
-			features := db.Features()
-
-			table := tablewriter.NewWriter(os.Stdout)
-			table.Header([]string{"Feature", "Status"})
-
-			// Check Git
-			if features&app.Git == 1 {
-				table.Append([]string{"Git", "✓ Available"})
-			} else {
-				table.Append([]string{"Git", "✗ Missing"})
 			}
 
-			// Check fd
-			if features&app.Fd == 1 {
-				table.Append([]string{"fd", "✓ Available"})
+			// 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 {
-				table.Append([]string{"fd", "✗ Missing"})
+			// Path is a file, just check this specific file
+			filesInPath = []string{absPath}
 		}
 
-			table.Render()
+		// 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
-		}
 	},
 }
 

cmd/deps.go

@@ -0,0 +1,51 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/olekukonko/tablewriter"
+	"github.com/sbrow/envr/app"
+	"github.com/spf13/cobra"
+)
+
+var depsCmd = &cobra.Command{
+	Use:   "deps",
+	Short: "Check for missing binaries",
+	Long: `envr relies on external binaries for certain functionality.
+
+The check command reports on which binaries are available and which are not.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		db, err := app.Open()
+		if err != nil {
+			return err
+		} else {
+			defer db.Close()
+			features := db.Features()
+
+			table := tablewriter.NewWriter(os.Stdout)
+			table.Header([]string{"Feature", "Status"})
+
+			// Check Git
+			if features&app.Git == 1 {
+				table.Append([]string{"Git", "✓ Available"})
+			} else {
+				table.Append([]string{"Git", "✗ Missing"})
+			}
+
+			// Check fd
+			if features&app.Fd == app.Fd {
+				table.Append([]string{"fd", "✓ Available"})
+			} else {
+				table.Append([]string{"fd", "✗ Missing"})
+			}
+
+			table.Render()
+
+			return nil
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(depsCmd)
+}

cmd/init.go

@@ -11,10 +11,8 @@ 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.
@@ -23,11 +21,10 @@ 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 {
-			return fmt.Errorf("You have already initialized envr")
-		} else {
+		if config == nil || force {
 			keys, err := selectSSHKeys()
 			if err != nil {
 				return fmt.Errorf("Error selecting SSH keys: %v", err)
@@ -43,13 +40,17 @@ 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.
+`)
+		}
 	},
 }
 
 func init() {
+	initCmd.Flags().BoolP("force", "f", false, "Overwrite an existing config")
 	rootCmd.AddCommand(initCmd)
 }
 

cmd/list.go

@@ -24,7 +24,7 @@ var listCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		defer db.Close(app.ReadOnly)
+		defer db.Close()
 
 		rows, err := db.List()
 		if err != nil {

cmd/remove.go

@@ -25,7 +25,7 @@ var removeCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close(app.Write)
+			defer db.Close()
 			if err := db.Delete(path); err != nil {
 				return err
 			} else {

cmd/restore.go

@@ -27,7 +27,7 @@ var restoreCmd = &cobra.Command{
 		if err != nil {
 			return err
 		} else {
-			defer db.Close(app.ReadOnly)
+			defer db.Close()
 			record, err := db.Fetch(path)
 
 			if err != nil {

cmd/scan.go

@@ -28,7 +28,7 @@ var scanCmd = &cobra.Command{
 			return err
 		}
 
-		files, err := db.Scan()
+		files, err := db.Scan(nil)
 		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(app.Write)
+				err = db.Close()
 				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(app.ReadOnly)
+				err = db.Close()
 				if err != nil {
 					return fmt.Errorf("Error closing database: %v\n", err)
 				}

cmd/sync.go

@@ -1,54 +1,93 @@
 package cmd
 
 import (
-	"fmt"
+	"encoding/json"
+	"os"
 
+	"github.com/mattn/go-isatty"
+	"github.com/olekukonko/tablewriter"
 	"github.com/sbrow/envr/app"
 	"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(app.Write)
+			defer db.Close()
 			files, err := db.List()
 
 			if err != nil {
 				return err
 			} else {
+				type syncResult struct {
+					Path   string `json:"path"`
+					Status string `json:"status"`
+				}
+				var results []syncResult
+
 				for _, file := range files {
-					fmt.Printf("%s\n", file.Path)
-
 					// Syncronize the filesystem with the database.
-					changed, err := file.Sync()
+					oldPath := file.Path
+					changed, err := db.Sync(&file)
 
+					var status string
 					switch changed {
-					case app.Updated:
-						fmt.Printf("File updated - changes saved\n")
+					case app.BackedUp:
+						status = "Backed Up"
 						if err := db.Insert(file); err != nil {
 							return err
 						}
 					case app.Restored:
-						fmt.Printf("File missing - restored backup\n")
+						fallthrough
+					case app.RestoredAndDirUpdated:
+						status = "Restored"
 					case app.Error:
 						if err == nil {
 							panic("err cannot be nil when Sync returns Error")
-						} else {
-							fmt.Printf("%s\n", err)
 						}
+						status = err.Error()
 					case app.Noop:
-						fmt.Println("Nothing to do")
+						status = "OK"
+					case app.DirUpdated:
+						status = "Moved"
 					default:
 						panic("Unknown result")
 					}
 
-					fmt.Println("")
+					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,
+					})
+				}
+
+				if isatty.IsTerminal(os.Stdout.Fd()) {
+					table := tablewriter.NewWriter(os.Stdout)
+					table.Header([]string{"File", "Status"})
+
+					for _, result := range results {
+						table.Append([]string{result.Path, result.Status})
+					}
+					table.Render()
+				} else {
+					encoder := json.NewEncoder(os.Stdout)
+					return encoder.Encode(results)
 				}
 
 				return nil

docs/cli/envr.md

@@ -44,7 +44,8 @@ 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 for missing binaries
+* [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
 * [envr list](envr_list.md)	 - View your tracked files

docs/cli/envr_check.md

@@ -1,15 +1,9 @@
 ## envr check
 
-Check for missing binaries
-
-### Synopsis
-
-envr relies on external binaries for certain functionality.
-
-The check command reports on which binaries are available and which are not.
+check if files in the current directory are backed up
 
 ```
-envr check [flags]
+envr check [path] [flags]
 ```
 
 ### Options

docs/cli/envr_deps.md

@@ -0,0 +1,24 @@
+## envr deps
+
+Check for missing binaries
+
+### Synopsis
+
+envr relies on external binaries for certain functionality.
+
+The check command reports on which binaries are available and which are not.
+
+```
+envr deps [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for deps
+```
+
+### SEE ALSO
+
+* [envr](envr.md)	 - Manage your .env files.
+

docs/cli/envr_init.md

@@ -12,12 +12,13 @@ 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
+envr init [flags]
 ```
 
 ### Options
 
 ```
+  -f, --force   Overwrite an existing config
   -h, --help    help for init
 ```
 

flake.nix

@@ -21,7 +21,12 @@
       imports = [
         inputs.treefmt-nix.flakeModule
       ];
-      systems = [ "x86_64-linux" ];
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+
+        "aarch64-darwin"
+      ];
 
       perSystem =
         { pkgs, system, inputs', ... }: {
@@ -56,7 +61,7 @@
 
           packages.default = pkgs.buildGoModule rec {
             pname = "envr";
-            version = "0.1.0";
+            version = "0.2.0";
             src = ./.;
             # If the build complains, uncomment this line
             # vendorHash = "sha256:0000000000000000000000000000000000000000000000000000";
@@ -92,6 +97,9 @@
                 gotools
                 cobra-cli
 
+                # Build tools
+                zip
+
                 # IDE
                 unstable.helix
                 typescript-language-server