fix: file counting, same-path safety, overwrite prompt, and release 0.1.1

Author: programmersd21

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 all notable changes to this project will be documented in this file.
 
+## [0.1.1] - 2026-08-15
+
+### fixes
+- fixed delete operations reporting 0 files in completion summary
+- fixed same-path operations (copy/move to self) potentially destroying files
+- overwrite prompt now defaults to yes on enter (`[Y/n]`)
+- improved error and cancellation handling in progress ui
+
 ## [0.1.0] - 2026-08-14
 
 ### features
@@ -12,4 +20,5 @@ all notable changes to this project will be documented in this file.
 - safe overwrite prompts and directory delete validation
 - non-tty fallback for script pipelines
 
+[0.1.1]: https://github.com/programmersd21/zap/releases/tag/v0.1.1
 [0.1.0]: https://github.com/programmersd21/zap/releases/tag/v0.1.0

README.md

@@ -1,4 +1,4 @@
-### zap
+# zap
 
 fast file operations with real-time progress.
 
@@ -11,8 +11,8 @@ fast file operations with real-time progress.
 - **fast** — 1 mb buffered streaming io for large file copies
 - **real-time progress** — transfer speeds, file counts, and estimated time remaining
 - **terminal aware** — dynamic width adjustments and automatic path truncation
-- **safe defaults** — confirmation on overwrites and protection for recursive deletes
-- **script friendly** — automatically falls back to quiet/direct output when stdout is not a tty
+- **safe defaults** — same-path identity protection, overwrite confirmations (`[Y/n]`), and recursive delete checks
+- **script friendly** — automatically falls back to direct output when stdout is not a tty
 
 ## install
 

assets/demo.gif

@@ -20,7 +20,7 @@ import (
 	"github.com/programmersd21/zap/internal/walk"
 )
 
-const version = "0.1.0"
+const version = "0.1.1"
 
 var (
 	flagMove      bool
@@ -155,6 +155,9 @@ func runCopyWithProgress(ctx context.Context, sources []string, dest string, sta
 		defer close(done)
 		var cumulBytes, cumulFiles int64
 		for _, src := range sources {
+			if ctx.Err() != nil {
+				return
+			}
 			dst := destPath(dest, src)
 			opts := ops.CopyOptions{
 				Force:      true,
@@ -167,7 +170,13 @@ func runCopyWithProgress(ctx context.Context, sources []string, dest string, sta
 				ec.Add(src, err)
 			}
 		}
-		p.Send(ui.CompletedMsg{})
+		if ctx.Err() == nil {
+			if ec.HasErrors() {
+				p.Send(ui.ErrorMsg{Err: fmt.Errorf("%d error(s)", ec.Count())})
+			} else {
+				p.Send(ui.CompletedMsg{})
+			}
+		}
 	}()
 
 	if _, err := p.Run(); err != nil {
@@ -241,23 +250,38 @@ func runDeleteWithProgress(ctx context.Context, paths []string, stats walk.Stats
 	model := ui.NewModel(ui.ThemeMocha, ui.OpDelete, flagVerbose, 0, stats.TotalFiles)
 	p := tea.NewProgram(model)
 
+	done := make(chan struct{})
 	go func() {
+		defer close(done)
+		var cumulFiles int64
 		for _, path := range paths {
+			if ctx.Err() != nil {
+				return
+			}
 			opts := ops.DeleteOptions{
-				Recursive: flagRecursive,
-				Program:   p,
-				Errors:    ec,
+				Recursive:  flagRecursive,
+				Program:    p,
+				Errors:     ec,
+				CumulFiles: &cumulFiles,
 			}
 			if err := ops.Delete(path, opts); err != nil && !flagForce {
 				ec.Add(path, err)
 			}
 		}
-		p.Send(ui.CompletedMsg{})
+		if ctx.Err() == nil {
+			if ec.HasErrors() {
+				p.Send(ui.ErrorMsg{Err: fmt.Errorf("%d error(s)", ec.Count())})
+			} else {
+				p.Send(ui.CompletedMsg{})
+			}
+		}
 	}()
 
 	if _, err := p.Run(); err != nil {
+		<-done
 		return fmt.Errorf("ui error: %w", err)
 	}
+	<-done
 
 	if ctx.Err() != nil {
 		printInterrupted("delete", stats.TotalFiles)
@@ -276,13 +300,14 @@ func destPath(dest, src string) string {
 
 func promptYN(r *bufio.Reader, msg string) bool {
 	styles := ui.NewStyles(ui.ThemeMocha)
-	fmt.Fprintf(os.Stderr, "%s %s ",
+	fmt.Fprintf(os.Stderr, "%s %s %s ",
 		styles.Warning.Bold(true).Render("?"),
 		styles.Primary.Render(msg),
+		styles.Muted.Render("[Y/n]"),
 	)
 	resp, _ := r.ReadString('\n')
 	resp = strings.ToLower(strings.TrimSpace(resp))
-	return resp == "y" || resp == "yes"
+	return resp == "" || resp == "y" || resp == "yes"
 }
 
 func summarizeErrors(ec *errs.Collector) error {

cmd/zap/main.go

@@ -28,8 +28,8 @@ func TestVersion(t *testing.T) {
 		t.Fatalf("failed to run --version: %v", err)
 	}
 
-	if !strings.Contains(string(output), "0.1.0") {
-		t.Errorf("expected version 0.1.0, got: %s", output)
+	if !strings.Contains(string(output), "0.1.1") {
+		t.Errorf("expected version 0.1.1, got: %s", output)
 	}
 }
 

cmd/zap/main_test.go

@@ -20,12 +20,34 @@ type CopyOptions struct {
 	CumulFiles *int64
 }
 
+func samePath(a, b string) bool {
+	absA, errA := filepath.Abs(a)
+	absB, errB := filepath.Abs(b)
+	if errA != nil || errB != nil {
+		return a == b
+	}
+	if filepath.Clean(absA) == filepath.Clean(absB) {
+		return true
+	}
+	// check filesystem identity via inode
+	infoA, errA := os.Stat(absA)
+	infoB, errB := os.Stat(absB)
+	if errA != nil || errB != nil {
+		return false
+	}
+	return os.SameFile(infoA, infoB)
+}
+
 func Copy(src, dst string, opts CopyOptions) error {
 	srcInfo, err := os.Lstat(src)
 	if err != nil {
 		return fmt.Errorf("stat %s: %w", src, err)
 	}
 
+	if samePath(src, dst) {
+		return fmt.Errorf("%s and %s are the same file", src, dst)
+	}
+
 	if dstInfo, err := os.Lstat(dst); err == nil {
 		if !opts.Force {
 			return fmt.Errorf("destination %s exists", dst)

internal/ops/copy.go

@@ -0,0 +1,151 @@
+package ops
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/programmersd21/zap/internal/errs"
+	"github.com/programmersd21/zap/internal/walk"
+)
+
+func TestCopyFileCount(t *testing.T) {
+	srcDir := t.TempDir()
+	dstDir := filepath.Join(t.TempDir(), "dst")
+
+	// create a tree resembling the reported structure:
+	// src/file1.txt, src/sub/file2.txt, src/sub/deep/file3.txt
+	paths := []string{
+		filepath.Join(srcDir, "file1.txt"),
+		filepath.Join(srcDir, "sub", "file2.txt"),
+		filepath.Join(srcDir, "sub", "deep", "file3.txt"),
+	}
+	for _, p := range paths {
+		if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte("data"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// verify pre-scan count matches
+	stats, err := walk.ComputeStats([]string{srcDir})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stats.TotalFiles != 3 {
+		t.Errorf("ComputeStats: expected 3 files, got %d", stats.TotalFiles)
+	}
+
+	// verify copy operation count matches
+	var cumulFiles int64
+	var cumulBytes int64
+	ec := errs.NewCollector()
+	opts := CopyOptions{
+		Force:      false,
+		Errors:     ec,
+		CumulBytes: &cumulBytes,
+		CumulFiles: &cumulFiles,
+	}
+	if err := Copy(srcDir, dstDir, opts); err != nil {
+		t.Fatal(err)
+	}
+	if cumulFiles != 3 {
+		t.Errorf("CumulFiles after copy: expected 3, got %d", cumulFiles)
+	}
+	if cumulFiles != stats.TotalFiles {
+		t.Errorf("count mismatch: pre-scan=%d, actual=%d", stats.TotalFiles, cumulFiles)
+	}
+}
+
+func TestCopyFileCountLargerTree(t *testing.T) {
+	srcDir := t.TempDir()
+	dstDir := filepath.Join(t.TempDir(), "dst")
+
+	// create exactly 10 files in a nested structure
+	files := []string{
+		"build/please",
+		"justfile",
+		"src/cli.odin",
+		"src/main.odin",
+		"src/pam/context.odin",
+		"src/pam/ffi.odin",
+		"src/pam/pam.odin",
+		"src/ticket.odin",
+		"src/timestamp.odin",
+		"src/utils.odin",
+	}
+	for _, f := range files {
+		p := filepath.Join(srcDir, f)
+		if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte("content"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	stats, err := walk.ComputeStats([]string{srcDir})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stats.TotalFiles != 10 {
+		t.Errorf("ComputeStats: expected 10 files, got %d", stats.TotalFiles)
+	}
+
+	var cumulFiles int64
+	var cumulBytes int64
+	ec := errs.NewCollector()
+	opts := CopyOptions{
+		Force:      false,
+		Errors:     ec,
+		CumulBytes: &cumulBytes,
+		CumulFiles: &cumulFiles,
+	}
+	if err := Copy(srcDir, dstDir, opts); err != nil {
+		t.Fatal(err)
+	}
+	if cumulFiles != 10 {
+		t.Errorf("CumulFiles: expected 10, got %d", cumulFiles)
+	}
+}
+
+func TestDeleteFileCount(t *testing.T) {
+	dir := t.TempDir()
+
+	// create dir with 1 file (the exact reported bug scenario)
+	subdir := filepath.Join(dir, "something")
+	if err := os.MkdirAll(subdir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(subdir, "meow"), []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	stats, err := walk.ComputeStats([]string{subdir})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stats.TotalFiles != 1 {
+		t.Errorf("ComputeStats: expected 1 file, got %d", stats.TotalFiles)
+	}
+
+	// verify delete counts the file
+	var cumulFiles int64
+	ec := errs.NewCollector()
+	opts := DeleteOptions{
+		Recursive:  true,
+		Errors:     ec,
+		CumulFiles: &cumulFiles,
+	}
+	if err := Delete(subdir, opts); err != nil {
+		t.Fatal(err)
+	}
+	// should count the file + subdir + root dir = 3 entries
+	// but the summary shows filesDone which is cumulFiles
+	// sendDeleteProgress increments for files, dirs, and root
+	if cumulFiles < 1 {
+		t.Errorf("CumulFiles after delete: expected >= 1, got %d", cumulFiles)
+	}
+}

internal/ops/count_test.go

@@ -41,7 +41,7 @@ func deleteFile(path string, opts DeleteOptions) error {
 	if err := os.Remove(path); err != nil {
 		return err
 	}
-	sendDeleteProgress(opts, path)
+	sendDeleteProgress(opts, path, true)
 	return nil
 }
 
@@ -74,7 +74,7 @@ func deleteDir(path string, opts DeleteOptions) error {
 				opts.Errors.Add(f, err)
 			}
 		} else {
-			sendDeleteProgress(opts, f)
+			sendDeleteProgress(opts, f, true)
 		}
 	}
 
@@ -85,27 +85,29 @@ func deleteDir(path string, opts DeleteOptions) error {
 				opts.Errors.Add(d, err)
 			}
 		} else {
-			sendDeleteProgress(opts, d)
+			sendDeleteProgress(opts, d, false)
 		}
 	}
 
 	if err := os.Remove(path); err != nil {
 		return err
 	}
-	sendDeleteProgress(opts, path)
+	sendDeleteProgress(opts, path, false)
 
 	return nil
 }
 
-func sendDeleteProgress(opts DeleteOptions, path string) {
-	if opts.Program == nil {
-		return
-	}
+func sendDeleteProgress(opts DeleteOptions, path string, isFile bool) {
 	var files int64
 	if opts.CumulFiles != nil {
-		*opts.CumulFiles++
+		if isFile {
+			*opts.CumulFiles++
+		}
 		files = *opts.CumulFiles
 	}
+	if opts.Program == nil {
+		return
+	}
 	opts.Program.Send(ui.ProgressMsg{
 		FilesDone:   files,
 		CurrentFile: path,

internal/ops/delete.go

@@ -19,6 +19,9 @@ type MoveOptions struct {
 }
 
 func Move(src, dst string, opts MoveOptions) error {
+	if samePath(src, dst) {
+		return fmt.Errorf("%s and %s are the same file", src, dst)
+	}
 	err := os.Rename(src, dst)
 	if err == nil {
 		return nil