refactor: Cleanup

.github/workflows/go.yml

@@ -40,3 +40,6 @@ jobs:
 
     - name: Test
       run: make test
+
+    - name: Check coverage
+      run: make check-coverage

AGENTS.md

@@ -0,0 +1,92 @@
+# Project Guidelines
+
+## Overview
+
+CLI tool for managing local backups using `rsync` as the engine.
+Built in Go with `cobra` for CLI, `afero` for filesystem abstraction, and YAML for configuration. Local-only — no remote rsync support.
+
+## Code Style
+
+- Go 1.25; follow idiomatic Go conventions
+- Format with `go fmt`; lint with `golangci-lint` (config in `.golangci.yml`)
+- All linters enabled by default — check `.golangci.yml` for disabled ones
+- Keep packages focused: `cmd/` for CLI wiring, `internal/` for core logic
+- Prefer dependency injection over global state for testability
+- Use interfaces at consumption boundaries (see `internal/exec.go`, `internal/job_command.go`)
+- All output in commands routed through `cmd.OutOrStdout()` or injected `io.Writer` — never raw `fmt.Printf`
+- All commands use `RunE` with wrapped errors
+
+## Architecture
+
+```
+backup/
+  main.go                # Entrypoint — calls cmd.BuildRootCommand().Execute()
+  cmd/                   # Cobra commands: list, run, simulate, config (show/validate), check-coverage, version
+    root.go              # BuildRootCommand() / BuildRootCommandWithFs(fs) — injects afero.Fs
+    test/                # Cobra command integration tests
+  internal/              # Core logic: config, job execution, rsync wrapper, coverage checker
+    test/                # Unit tests + mockery-generated mocks
+```
+
+### Key Types & Interfaces
+
+- **`Exec`** (interface): Command execution abstraction (`OsExec` for real, `MockExec` for tests)
+- **`JobCommand`** (interface): `Run(job Job) JobStatus` + `GetVersionInfo()` — implemented by `ListCommand`, `SimulateCommand`, `SyncCommand`
+- **`SharedCommand`** (struct): Base for all commands — holds `BinPath`, `BaseLogPath`, `Shell Exec`, `Output io.Writer`
+- **`CoverageChecker`** (struct): Analyzes path coverage with injected `*log.Logger` and `afero.Fs`
+- **`Config`**: YAML-based (`Config`, `Job`, `Path`, variables with `${var}` substitution)
+
+### Dependency Injection
+
+- `Exec` injected into all command constructors (`NewListCommand`, `NewSimulateCommand`, `NewSyncCommand`)
+- `io.Writer` injected into `SharedCommand` for output capture
+- `afero.Fs` injected into `BuildRootCommandWithFs()` → `buildCheckCoverageCommand(fs)`
+- `*log.Logger` injected into `CoverageChecker` and `Config.Apply()`
+- Commands use `cmd.OutOrStdout()` for testable output
+
+## Build and Test
+
+```sh
+make build            # Build to dist/backup
+make test             # go test -race ./... -v
+make lint             # golangci-lint run ./...
+make lint-fix         # Auto-fix lint issues
+make format           # go fmt ./...
+make tidy             # gofmt -s + go mod tidy
+make sanity-check     # format + clean + tidy
+make check-coverage   # Fail if coverage < 90%
+make report-coverage  # Generate HTML coverage report
+```
+
+## Testing Conventions
+
+- See `TESTING_GUIDE.md` for patterns and examples
+- Use **dependency injection** — inject interfaces, not concrete types
+- **Mocks**: Generated with [mockery](https://github.com/vektra/mockery) (config: `.mockery.yml`)
+  - Mock files live in `internal/test/` as `mock_<interface>_test.go`
+  - Mock structs named `Mock<Interface>` (e.g., `MockExec`, `MockJobCommand`)
+  - See `MOCKERY_INTEGRATION.md` for setup details
+- Use `testify` for assertions (`require` / `assert`)
+- Test files live in `<package>/test/` subdirectories
+- Prefer table-driven tests for multiple input scenarios
+- Use `afero.NewMemMapFs()` in tests — never hit the real filesystem
+- Use `bytes.Buffer` or `io.Discard` for output capture in tests
+- CI enforces coverage threshold via `make check-coverage`
+
+## CI Pipeline
+
+CI runs on every push/PR to `main` (`.github/workflows/go.yml`):
+1. Sanity check (format + clean + mod tidy)
+2. Lint (golangci-lint)
+3. Build
+4. Test (with `-race` flag)
+5. Coverage threshold enforcement (90%)
+
+## Conventions
+
+- No remote rsync — only locally mounted paths
+- Job-level granularity: each backup job can be listed, simulated, or run independently
+- Dry-run/simulate mode available for all operations
+- Logging goes to both an injected `io.Writer` (user output) and `*log.Logger` (file logging) under `logs/`
+- Custom YAML unmarshaling handles job defaults (see `internal/job.go`)
+- CI runs sanity checks, lint, and build on every push/PR (`.github/workflows/go.yml`)

MOCKERY_INTEGRATION.md

@@ -0,0 +1,114 @@
+# Mockery Integration Guide
+
+This document explains how mockery is integrated for generating mocks from interfaces.
+
+## Installation
+
+```bash
+go install github.com/vektra/mockery/v3@latest
+```
+
+## Configuration
+
+The project uses `.mockery.yml` to control mock generation:
+
+```yaml
+all: false
+dir: '{{.InterfaceDir}}/test'
+filename: mock_{{.InterfaceName | lower}}_test.go
+force-file-write: true
+formatter: goimports
+generate: true
+include-auto-generated: false
+log-level: info
+structname: 'Mock{{.InterfaceName}}'
+pkgname: 'internal_test'
+recursive: false
+template: testify
+packages:
+  backup-rsync/backup/internal:
+    interfaces:
+      Exec:
+      JobCommand:
+```
+
+Key points:
+- **Output directory**: `<InterfaceDir>/test/` (alongside other test files)
+- **Filename**: `mock_<interface>_test.go`
+- **Struct naming**: `Mock<Interface>` (e.g., `MockExec`, `MockJobCommand`)
+- **Package**: `internal_test` (external test package)
+- **Template**: `testify` for expectation-based mocking
+
+## Generated Mocks
+
+| Mock | Source Interface | File |
+|---|---|---|
+| `MockExec` | `Exec` | `backup/internal/test/mock_exec_test.go` |
+| `MockJobCommand` | `JobCommand` | `backup/internal/test/mock_jobcommand_test.go` |
+
+## Usage Examples
+
+### MockJobCommand — Testing Config.Apply
+
+```go
+func TestConfigApply_VersionInfoSuccess(t *testing.T) {
+    mockCmd := NewMockJobCommand(t)
+    var output bytes.Buffer
+    logger := log.New(&bytes.Buffer{}, "", 0)
+
+    cfg := Config{
+        Jobs: []Job{
+            {Name: "job1", Source: "/src/", Target: "/dst/", Enabled: true},
+            {Name: "job2", Source: "/src2/", Target: "/dst2/", Enabled: false},
+        },
+    }
+
+    mockCmd.EXPECT().GetVersionInfo().Return("rsync version 3.2.3", "/usr/bin/rsync", nil).Once()
+    mockCmd.EXPECT().Run(mock.AnythingOfType("internal.Job")).Return(Success).Once()
+
+    err := cfg.Apply(mockCmd, logger, &output)
+    require.NoError(t, err)
+    assert.Contains(t, output.String(), "Status [job1]: SUCCESS")
+}
+```
+
+### MockExec — Testing Command Execution
+
+```go
+func TestSyncCommand_Run_Success(t *testing.T) {
+    mockExec := NewMockExec(t)
+    var output bytes.Buffer
+
+    cmd := NewSyncCommand("/usr/bin/rsync", "/tmp/logs", mockExec, &output)
+    job := Job{Name: "docs", Source: "/src/", Target: "/dst/", Enabled: true, Delete: true}
+
+    mockExec.EXPECT().Execute("/usr/bin/rsync", mock.Anything).Return([]byte("done"), nil).Once()
+
+    status := cmd.Run(job)
+    assert.Equal(t, Success, status)
+}
+```
+
+### Testing Disabled Jobs (no mock expectations needed)
+
+```go
+func TestJobApply_DisabledJob(t *testing.T) {
+    mockCmd := NewMockJobCommand(t)
+    disabledJob := Job{Name: "skip_me", Enabled: false}
+
+    // No expectations set — Run should NOT be called
+    status := disabledJob.Apply(mockCmd)
+    assert.Equal(t, Skipped, status)
+    // MockJobCommand automatically verifies Run was not called
+}
+```
+
+## Regenerating Mocks
+
+When interfaces change, regenerate with:
+
+```bash
+mockery
+```
+
+This updates all mocks according to `.mockery.yml`. Generated files are committed to the repository.

Makefile

@@ -3,8 +3,9 @@
 # Build command with common flags
 BUILD_CMD = CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -tags=prod
 PACKAGE = ./backup/main.go
+COVERAGE_THRESHOLD = 98
 
-.PHONY: build clean test lint tidy checksums release sanity-check check-mod-tidy lint-config-check  lint-fix format check-clean
+.PHONY: build clean test lint tidy checksums release sanity-check check-mod-tidy lint-config-check  lint-fix format check-clean check-coverage
 
 format:
 	go fmt ./...
@@ -33,7 +34,7 @@ sanity-check: format check-clean check-mod-tidy
 	@echo "OK: All sanity checks passed."
 
 test:
-	go test ./... -v
+	go test -race ./... -v
 
 tidy:
 	gofmt -s -w .
@@ -73,6 +74,17 @@ report-size: build
 	go install github.com/Zxilly/go-size-analyzer/cmd/gsa@latest
 	gsa --web --listen=":8910" --open dist/backup
 
+check-coverage:
+	@go test ./... -count=1 -coverprofile=/tmp/coverage.out -coverpkg=./backup/...
+	@COVERAGE=$$(go tool cover -func=/tmp/coverage.out | grep '^total:' | awk '{print int($$3)}'); \
+	echo "Total coverage: $${COVERAGE}%"; \
+	if [ "$${COVERAGE}" -lt "$(COVERAGE_THRESHOLD)" ]; then \
+		echo "FAIL: Coverage $${COVERAGE}% is below threshold $(COVERAGE_THRESHOLD)%"; \
+		exit 1; \
+	else \
+		echo "OK: Coverage $${COVERAGE}% meets threshold $(COVERAGE_THRESHOLD)%"; \
+	fi
+
 report-coverage:
 	@mkdir -p coverage
 	@go test ./... -count=1 -coverprofile=coverage/coverage.out -coverpkg=./backup/...