feat: Added new check command.

BREAKING CHANGE: The config value `scan.Include` is now a list rather than
a string.

Release-As: 0.2.0

app/config.go

@@ -24,9 +24,11 @@ type SshKeyPair struct {
 }
 
 type scanConfig struct {
+	// TODO: Support multiple matchers
 	Matcher string `json:"matcher"`
-	Exclude string `json:"exclude"`
-	Include string `json:"include"`
+	// TODO: Support multiple excludes
+	Exclude string   `json:"exclude"`
+	Include []string `json:"include"`
 }
 
 // Create a fresh config with sensible defaults.
@@ -47,7 +49,7 @@ func NewConfig(privateKeyPaths []string) Config {
 		ScanConfig: scanConfig{
 			Matcher: "\\.env",
 			Exclude: "*.envrc",
-			Include: "~",
+			Include: []string{"~"},
 		},
 	}
 }
@@ -109,71 +111,77 @@ func (c *Config) Save() error {
 
 // 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
 	}
 
-	// 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)
-	allOutput, err := allCmd.Output()
-	if err != nil {
-		return []string{}, err
-	}
-
-	allFiles := strings.Split(strings.TrimSpace(string(allOutput)), "\n")
-	if len(allFiles) == 1 && allFiles[0] == "" {
-		allFiles = []string{}
-	}
-
-	// 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)
-	unignoredOutput, err := unignoredCmd.Output()
-	if err != nil {
-		return []string{}, err
-	}
-
-	unignoredFiles := strings.Split(strings.TrimSpace(string(unignoredOutput)), "\n")
-	if len(unignoredFiles) == 1 && unignoredFiles[0] == "" {
-		unignoredFiles = []string{}
-	}
-
-	// Create a map for faster lookup
-	unignoredMap := make(map[string]bool)
-	for _, file := range unignoredFiles {
-		unignoredMap[file] = true
-	}
-
-	// Filter to get only ignored files
-	var ignoredFiles []string
-	for _, file := range allFiles {
-		if !unignoredMap[file] {
-			ignoredFiles = append(ignoredFiles, file)
+	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)
+		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{}
+		}
+
+		// 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)
+		unignoredOutput, err := unignoredCmd.Output()
+		if err != nil {
+			return []string{}, err
+		}
+
+		unignoredFiles := strings.Split(strings.TrimSpace(string(unignoredOutput)), "\n")
+		if len(unignoredFiles) == 1 && unignoredFiles[0] == "" {
+			unignoredFiles = []string{}
+		}
+
+		// Create a map for faster lookup
+		unignoredMap := make(map[string]bool)
+		for _, file := range unignoredFiles {
+			unignoredMap[file] = true
+		}
+
+		// Filter to get only ignored files
+		var ignoredFiles []string
+		for _, file := range allFiles {
+			if !unignoredMap[file] {
+				ignoredFiles = append(ignoredFiles, file)
+			}
+		}
+
+		paths = append(paths, ignoredFiles...)
 	}
 
-	return ignoredFiles, nil
+	return paths, nil
 }
 
-func (c Config) searchPath() (path string, err error) {
-	include := c.ScanConfig.Include
-
-	if include == "~" {
-		homeDir, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-		return homeDir, nil
-	}
-
-	absPath, err := filepath.Abs(include)
+func (c Config) searchPaths() (paths []string, err error) {
+	homeDir, err := os.UserHomeDir()
 	if err != nil {
-		return "", err
+		return paths, err
 	}
 
-	return absPath, nil
+	includes := c.ScanConfig.Include
+
+	for _, include := range includes {
+		path := strings.Replace(include, "~", homeDir, 1)
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return paths, err
+		}
+
+		paths = append(paths, absPath)
+	}
+
+	return paths, nil
 }
 
 // TODO: Should this be private?

app/db.go

@@ -326,8 +326,15 @@ func (db *Db) Delete(path string) error {
 }
 
 // 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
 	}

app/features.go

@@ -13,7 +13,7 @@ const (
 	// fd
 	Fd AvailableFeatures = 2
 	// All features are present
-	All AvailableFeatures = Git & Fd
+	All AvailableFeatures = Git | Fd
 )
 
 // Checks for available features.

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 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"})
-			} else {
-				table.Append([]string{"fd", "✗ Missing"})
-			}
-
-			table.Render()
-
-			return nil
+			return fmt.Errorf("failed to open database: %w", err)
 		}
+		defer db.Close(app.ReadOnly)
+
+		// 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
 	},
 }
 

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(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 == app.Fd {
+				table.Append([]string{"fd", "✓ Available"})
+			} else {
+				table.Append([]string{"fd", "✗ Missing"})
+			}
+
+			table.Render()
+
+			return nil
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(depsCmd)
+}

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
 		}

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.
+

flake.nix

@@ -61,7 +61,7 @@
 
           packages.default = pkgs.buildGoModule rec {
             pname = "envr";
-            version = "0.1.0";
+            version = "0.1.1";
             src = ./.;
             # If the build complains, uncomment this line
             # vendorHash = "sha256:0000000000000000000000000000000000000000000000000000";