fix: anchor csvops binary ignore so pkg/csvops directory is tracked

Previous unanchored 'csvops' pattern also matched the pkg/csvops library
directory, silently dropping it from the last commit.

Author: maherelgamil

.gitignore

@@ -2,5 +2,5 @@
 /.idea
 *.csv
 /dist
-csvops
+/csvops
 *.db

pkg/csvops/count.go

@@ -0,0 +1,38 @@
+package csvops
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"os"
+)
+
+// CountDataRows counts non-header data rows in a CSV file, treating the first
+// line as a header. Returns 0 for an empty file or a header-only file.
+func CountDataRows(path string, delim rune) (int64, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return 0, fmt.Errorf("open %s: %w", path, err)
+	}
+	defer f.Close()
+
+	r := csv.NewReader(f)
+	r.Comma = delim
+	r.FieldsPerRecord = -1
+
+	var total int64
+	for {
+		_, err := r.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			continue
+		}
+		total++
+	}
+	if total > 0 {
+		total-- // exclude header
+	}
+	return total, nil
+}

pkg/csvops/csvops.go

@@ -0,0 +1,15 @@
+// Package csvops provides reusable CSV operations (split, dedupe, filter, merge,
+// stats, preview, to-sqlite) as a library. Both the csvops CLI and the desktop
+// app depend on this package.
+package csvops
+
+// Progress is an optional callback invoked during long-running operations.
+// total may be 0 when not known in advance; done monotonically increases.
+type Progress func(done, total int64)
+
+// safeProgress is a no-op if p is nil.
+func safeProgress(p Progress, done, total int64) {
+	if p != nil {
+		p(done, total)
+	}
+}

pkg/csvops/split.go

@@ -0,0 +1,140 @@
+package csvops
+
+import (
+	"context"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+// SplitOptions configures a Split operation.
+type SplitOptions struct {
+	Input       string
+	OutputDir   string
+	RowsPerFile int
+	WithHeader  bool
+	Delimiter   rune
+	Progress    Progress
+}
+
+// SplitResult is returned from Split.
+type SplitResult struct {
+	RowsProcessed int64
+	FilesCreated  int
+}
+
+// Split streams the CSV at opts.Input and writes chunks of RowsPerFile rows
+// into opts.OutputDir as part_1.csv, part_2.csv, ...
+func Split(ctx context.Context, opts SplitOptions) (SplitResult, error) {
+	var res SplitResult
+
+	if opts.Input == "" {
+		return res, fmt.Errorf("input is required")
+	}
+	if opts.RowsPerFile <= 0 {
+		return res, fmt.Errorf("RowsPerFile must be > 0")
+	}
+	if opts.Delimiter == 0 {
+		opts.Delimiter = ','
+	}
+	if opts.OutputDir == "" {
+		opts.OutputDir = "."
+	}
+
+	if err := os.MkdirAll(opts.OutputDir, 0o755); err != nil {
+		return res, fmt.Errorf("create output dir: %w", err)
+	}
+
+	total, err := CountDataRows(opts.Input, opts.Delimiter)
+	if err != nil {
+		return res, err
+	}
+
+	f, err := os.Open(opts.Input)
+	if err != nil {
+		return res, fmt.Errorf("open input: %w", err)
+	}
+	defer f.Close()
+
+	r := csv.NewReader(f)
+	r.Comma = opts.Delimiter
+	r.FieldsPerRecord = -1
+
+	var header []string
+	if opts.WithHeader {
+		h, err := r.Read()
+		if err != nil {
+			return res, fmt.Errorf("read header: %w", err)
+		}
+		header = h
+	}
+
+	buf := make([][]string, 0, opts.RowsPerFile)
+	part := 1
+
+	flush := func() error {
+		if len(buf) == 0 {
+			return nil
+		}
+		if err := writeSplitChunk(opts.OutputDir, part, header, buf, opts.Delimiter, opts.WithHeader); err != nil {
+			return err
+		}
+		part++
+		buf = buf[:0]
+		return nil
+	}
+
+	for {
+		if err := ctx.Err(); err != nil {
+			return res, err
+		}
+		row, err := r.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return res, fmt.Errorf("read row: %w", err)
+		}
+		buf = append(buf, row)
+		res.RowsProcessed++
+		safeProgress(opts.Progress, res.RowsProcessed, total)
+
+		if len(buf) == opts.RowsPerFile {
+			if err := flush(); err != nil {
+				return res, err
+			}
+		}
+	}
+	if err := flush(); err != nil {
+		return res, err
+	}
+	res.FilesCreated = part - 1
+	return res, nil
+}
+
+func writeSplitChunk(dir string, part int, header []string, rows [][]string, delim rune, withHeader bool) error {
+	path := filepath.Join(dir, fmt.Sprintf("part_%d.csv", part))
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("create %s: %w", path, err)
+	}
+	defer f.Close()
+
+	w := csv.NewWriter(f)
+	w.Comma = delim
+
+	if withHeader && len(header) > 0 {
+		if err := w.Write(header); err != nil {
+			return err
+		}
+	}
+	for _, row := range rows {
+		if err := w.Write(row); err != nil {
+			return err
+		}
+	}
+	w.Flush()
+	return w.Error()
+}

pkg/csvops/split_test.go

@@ -0,0 +1,119 @@
+package csvops
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func writeCSV(t *testing.T, path, body string) {
+	t.Helper()
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func readFile(t *testing.T, path string) string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(b)
+}
+
+func TestSplit_BasicWithHeader(t *testing.T) {
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.csv")
+	out := filepath.Join(dir, "parts")
+	writeCSV(t, in, "id,name\n1,a\n2,b\n3,c\n4,d\n5,e\n")
+
+	res, err := Split(context.Background(), SplitOptions{
+		Input:       in,
+		OutputDir:   out,
+		RowsPerFile: 2,
+		WithHeader:  true,
+		Delimiter:   ',',
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.RowsProcessed != 5 {
+		t.Errorf("RowsProcessed = %d, want 5", res.RowsProcessed)
+	}
+	if res.FilesCreated != 3 {
+		t.Errorf("FilesCreated = %d, want 3", res.FilesCreated)
+	}
+
+	got := readFile(t, filepath.Join(out, "part_1.csv"))
+	if !strings.HasPrefix(got, "id,name\n") {
+		t.Errorf("part_1.csv missing header: %q", got)
+	}
+
+	got3 := readFile(t, filepath.Join(out, "part_3.csv"))
+	if !strings.Contains(got3, "5,e") {
+		t.Errorf("part_3.csv missing trailing row: %q", got3)
+	}
+}
+
+func TestSplit_ProgressCallbackInvoked(t *testing.T) {
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.csv")
+	writeCSV(t, in, "h\n1\n2\n3\n")
+
+	var calls int
+	var lastDone, lastTotal int64
+	_, err := Split(context.Background(), SplitOptions{
+		Input:       in,
+		OutputDir:   filepath.Join(dir, "out"),
+		RowsPerFile: 1,
+		WithHeader:  true,
+		Delimiter:   ',',
+		Progress: func(done, total int64) {
+			calls++
+			lastDone, lastTotal = done, total
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if calls != 3 {
+		t.Errorf("progress called %d times, want 3", calls)
+	}
+	if lastDone != 3 || lastTotal != 3 {
+		t.Errorf("final progress = (%d,%d), want (3,3)", lastDone, lastTotal)
+	}
+}
+
+func TestSplit_CancelledContext(t *testing.T) {
+	dir := t.TempDir()
+	in := filepath.Join(dir, "in.csv")
+	writeCSV(t, in, "h\n1\n2\n3\n")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	_, err := Split(ctx, SplitOptions{
+		Input:       in,
+		OutputDir:   filepath.Join(dir, "out"),
+		RowsPerFile: 1,
+		WithHeader:  true,
+		Delimiter:   ',',
+	})
+	if err != context.Canceled {
+		t.Errorf("err = %v, want context.Canceled", err)
+	}
+}
+
+func TestSplit_ValidatesInputs(t *testing.T) {
+	_, err := Split(context.Background(), SplitOptions{RowsPerFile: 10})
+	if err == nil {
+		t.Error("expected error for missing input")
+	}
+	_, err = Split(context.Background(), SplitOptions{Input: "x", RowsPerFile: 0})
+	if err == nil {
+		t.Error("expected error for RowsPerFile=0")
+	}
+}