add more tests

Author: atomikpanda

.gitignore

@@ -1,2 +1,3 @@
 .claude/
-build/
+build/
+coverage.out

CLAUDE.md

@@ -0,0 +1,42 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build & Test
+
+```bash
+make build                    # Build binary to ./build/dotular
+go test ./...                 # Run all tests
+go test -race ./...           # Run tests with race detector (CI default)
+go test ./internal/config/    # Run tests for a single package
+go test -run TestLoad ./internal/config/  # Run a single test
+go vet ./...                  # Lint (only linter used)
+```
+
+CI enforces 80% code coverage minimum (`go test -race -coverprofile=coverage.out -covermode=atomic ./...`).
+
+## Architecture
+
+Go CLI dotfile manager using Cobra. Module path: `github.com/atomikpanda/dotular`, requires Go 1.22+.
+
+**Config-driven**: A `dotular.yaml` file defines modules, each containing items (package installs, file syncs, scripts, settings, binaries, directory trees, inline commands). The config supports both a mapping format (with `modules:` key) and a legacy bare-sequence format.
+
+**Key flow**: `cmd/dotular/main.go` parses CLI flags and loads config → `internal/registry/` resolves any remote module references → `internal/runner/runner.go` orchestrates applying modules with hooks/snapshots/audit → `internal/actions/` executes each item type.
+
+**File/directory items**: The repo acts as the managed store. Each module's files live in a directory named after the module (e.g., `nvim/init.lua`). The runner's `buildAction` prepends the module name to the item's filename via `sourcePrefix`. `PlatformMap` handles per-OS destination paths.
+
+**Action types** (in `internal/actions/`): `package`, `script`, `file`, `directory`, `binary`, `run`, `setting` — each implements the `Action` interface (`Describe()`, `Run()`). Some also implement `Idempotent` (`IsApplied()`).
+
+**Cross-cutting concerns**: `internal/snapshot/` provides atomic rollback per module. `internal/audit/` logs all actions. `internal/tags/` filters modules by machine tags. `internal/ageutil/` handles age encryption for sensitive files.
+
+## YAML Config Schema
+
+Items are polymorphic — the type is determined by which primary field is set (`package`, `script`, `file`, `directory`, `binary`, `run`, `setting`). Shared fields: `via`, `skip_if`, `verify`, `hooks`.
+
+`PlatformMap` accepts either a scalar (all platforms) or a `macos`/`windows`/`linux` mapping. It has custom YAML marshal/unmarshal methods.
+
+## Dependencies
+
+- `github.com/spf13/cobra` — CLI framework
+- `gopkg.in/yaml.v3` — YAML parsing
+- `filippo.io/age` — age encryption

cmd/dotular/main_test.go

@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/atomikpanda/dotular/internal/config"
 )
 
 func writeTestConfig(t *testing.T, content string) string {
@@ -32,7 +34,7 @@ func TestBuildRoot(t *testing.T) {
 		names[cmd.Name()] = true
 	}
 
-	expected := []string{"apply", "push", "pull", "sync", "list", "status", "platform", "verify", "encrypt", "decrypt", "tag", "log", "registry"}
+	expected := []string{"add", "apply", "push", "pull", "sync", "list", "status", "platform", "verify", "encrypt", "decrypt", "tag", "log", "registry"}
 	for _, name := range expected {
 		if !names[name] {
 			t.Errorf("missing subcommand %q", name)
@@ -509,3 +511,258 @@ func TestRegistryUpdateCmdExecute(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+// --- add command tests -------------------------------------------------------
+
+func TestAddCmdDef(t *testing.T) {
+	cmd := addCmd()
+	if cmd.Use != "add <module> <path>" {
+		t.Errorf("Use = %q", cmd.Use)
+	}
+}
+
+func TestAddCmdFile(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte("modules: []\n"), 0o644)
+
+	// Create a source file.
+	srcFile := filepath.Join(dir, "myfile.txt")
+	os.WriteFile(srcFile, []byte("hello"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "mymod", srcFile})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify the file was copied into the module store.
+	stored := filepath.Join(dir, "mymod", "myfile.txt")
+	data, err := os.ReadFile(stored)
+	if err != nil {
+		t.Fatalf("stored file not found: %v", err)
+	}
+	if string(data) != "hello" {
+		t.Errorf("stored content = %q", string(data))
+	}
+
+	// Verify the config was updated.
+	cfg, err := loadConfigFrom(cfgPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod := cfg.Module("mymod")
+	if mod == nil {
+		t.Fatal("module 'mymod' not found in config")
+	}
+	if len(mod.Items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(mod.Items))
+	}
+	if mod.Items[0].File != "myfile.txt" {
+		t.Errorf("item file = %q", mod.Items[0].File)
+	}
+}
+
+func TestAddCmdDirectory(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte("modules: []\n"), 0o644)
+
+	// Create a source directory.
+	srcDir := filepath.Join(dir, "mydir")
+	os.MkdirAll(filepath.Join(srcDir, "sub"), 0o755)
+	os.WriteFile(filepath.Join(srcDir, "a.txt"), []byte("aaa"), 0o644)
+	os.WriteFile(filepath.Join(srcDir, "sub", "b.txt"), []byte("bbb"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "mymod", srcDir})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify the directory was copied.
+	data, err := os.ReadFile(filepath.Join(dir, "mymod", "mydir", "sub", "b.txt"))
+	if err != nil {
+		t.Fatalf("stored file not found: %v", err)
+	}
+	if string(data) != "bbb" {
+		t.Errorf("stored content = %q", string(data))
+	}
+
+	// Verify the config.
+	cfg, err := loadConfigFrom(cfgPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod := cfg.Module("mymod")
+	if mod == nil {
+		t.Fatal("module 'mymod' not found")
+	}
+	if mod.Items[0].Directory != "mydir" {
+		t.Errorf("item directory = %q", mod.Items[0].Directory)
+	}
+}
+
+func TestAddCmdToExistingModule(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte(`
+modules:
+  - name: existing
+    items:
+      - package: git
+        via: brew
+`), 0o644)
+
+	srcFile := filepath.Join(dir, "extra.txt")
+	os.WriteFile(srcFile, []byte("extra"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "existing", srcFile})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg, err := loadConfigFrom(cfgPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod := cfg.Module("existing")
+	if mod == nil {
+		t.Fatal("module 'existing' not found")
+	}
+	if len(mod.Items) != 2 {
+		t.Fatalf("expected 2 items, got %d", len(mod.Items))
+	}
+}
+
+func TestAddCmdWithLink(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte("modules: []\n"), 0o644)
+
+	srcFile := filepath.Join(dir, "linkme.txt")
+	os.WriteFile(srcFile, []byte("data"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "--link", "linkmod", srcFile})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg, err := loadConfigFrom(cfgPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod := cfg.Module("linkmod")
+	if mod == nil {
+		t.Fatal("module not found")
+	}
+	if !mod.Items[0].Link {
+		t.Error("expected link=true")
+	}
+}
+
+func TestAddCmdWithDirection(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte("modules: []\n"), 0o644)
+
+	srcFile := filepath.Join(dir, "syncme.txt")
+	os.WriteFile(srcFile, []byte("data"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "--direction", "sync", "syncmod", srcFile})
+	if err := root.Execute(); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg, err := loadConfigFrom(cfgPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod := cfg.Module("syncmod")
+	if mod == nil {
+		t.Fatal("module not found")
+	}
+	if mod.Items[0].Direction != "sync" {
+		t.Errorf("direction = %q, want sync", mod.Items[0].Direction)
+	}
+}
+
+func TestAddCmdMissingPath(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := filepath.Join(dir, "dotular.yaml")
+	os.WriteFile(cfgPath, []byte("modules: []\n"), 0o644)
+
+	root := buildRoot()
+	root.SetArgs([]string{"add", "--config", cfgPath, "mymod", "/nonexistent/path"})
+	if err := root.Execute(); err == nil {
+		t.Error("expected error for nonexistent source path")
+	}
+}
+
+func TestAddCmdRequiresArgs(t *testing.T) {
+	root := buildRoot()
+	root.SetArgs([]string{"add"})
+	if err := root.Execute(); err == nil {
+		t.Error("expected error for missing args")
+	}
+}
+
+func TestCopyFileSimple(t *testing.T) {
+	dir := t.TempDir()
+	src := filepath.Join(dir, "src.txt")
+	dst := filepath.Join(dir, "dst.txt")
+	os.WriteFile(src, []byte("content"), 0o644)
+
+	if err := copyFileSimple(src, dst); err != nil {
+		t.Fatal(err)
+	}
+
+	data, _ := os.ReadFile(dst)
+	if string(data) != "content" {
+		t.Errorf("copied = %q", string(data))
+	}
+
+	// Verify permissions are preserved.
+	srcInfo, _ := os.Stat(src)
+	dstInfo, _ := os.Stat(dst)
+	if srcInfo.Mode().Perm() != dstInfo.Mode().Perm() {
+		t.Errorf("permissions: src=%o, dst=%o", srcInfo.Mode().Perm(), dstInfo.Mode().Perm())
+	}
+}
+
+func TestCopyDirRecursive(t *testing.T) {
+	dir := t.TempDir()
+	src := filepath.Join(dir, "src")
+	dst := filepath.Join(dir, "dst")
+	os.MkdirAll(filepath.Join(src, "sub"), 0o755)
+	os.WriteFile(filepath.Join(src, "a.txt"), []byte("aaa"), 0o644)
+	os.WriteFile(filepath.Join(src, "sub", "b.txt"), []byte("bbb"), 0o644)
+
+	if err := copyDirRecursive(src, dst); err != nil {
+		t.Fatal(err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(dst, "a.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "aaa" {
+		t.Errorf("a.txt = %q", string(data))
+	}
+
+	data, err = os.ReadFile(filepath.Join(dst, "sub", "b.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "bbb" {
+		t.Errorf("sub/b.txt = %q", string(data))
+	}
+}
+
+// loadConfigFrom is a helper that loads config from a specific path.
+func loadConfigFrom(path string) (config.Config, error) {
+	return config.Load(path)
+}