refactor(split): extract core logic into pkg/csvops library

First step of desktop-app preparation. Split now lives in pkg/csvops as a
pure function taking a SplitOptions struct and returning a SplitResult, with
an optional Progress callback and context cancellation. cmd/split.go becomes
a thin wrapper that parses flags, wires a progress bar, and delegates.

Also moves CountDataRows into the library; cmd/helpers.go's countDataRows is
now a one-line delegate so the other commands keep compiling unchanged.

Library has its own unit tests (basic split, progress callback, ctx cancel,
input validation).

Author: maherelgamil

cmd/helpers.go

@@ -1,11 +1,10 @@
 package cmd
 
 import (
-	"encoding/csv"
 	"fmt"
-	"io"
-	"os"
 	"unicode/utf8"
+
+	"github.com/maherelgamil/csvops/pkg/csvops"
 )
 
 // parseDelimiter validates that the delimiter string is exactly one rune
@@ -24,32 +23,7 @@ func parseDelimiter(s string) (rune, error) {
 	return r, nil
 }
 
-// countDataRows counts the number of non-header data rows in a CSV file.
-// Returns 0 if the file is empty.
+// countDataRows delegates to the library implementation.
 func countDataRows(path string, delim rune) (int64, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return 0, fmt.Errorf("failed to open file for counting: %w", 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
+	return csvops.CountDataRows(path, delim)
 }

cmd/split.go

@@ -1,12 +1,10 @@
 package cmd
 
 import (
-	"encoding/csv"
+	"context"
 	"fmt"
-	"io"
-	"os"
-	"path/filepath"
 
+	"github.com/maherelgamil/csvops/pkg/csvops"
 	"github.com/schollz/progressbar/v3"
 	"github.com/spf13/cobra"
 )
@@ -26,106 +24,34 @@ var splitCmd = &cobra.Command{
 		if inputPath == "" {
 			return fmt.Errorf("please provide an input CSV file using --input")
 		}
-		if rowsPerFile <= 0 {
-			return fmt.Errorf("--rows must be > 0")
-		}
 		delim, err := parseDelimiter(delimiter)
 		if err != nil {
 			return err
 		}
 
-		if err := os.MkdirAll(outputDir, 0755); err != nil {
-			return fmt.Errorf("failed to create output directory: %w", err)
-		}
-
-		total, err := countDataRows(inputPath, delim)
+		var bar *progressbar.ProgressBar
+		res, err := csvops.Split(context.Background(), csvops.SplitOptions{
+			Input:       inputPath,
+			OutputDir:   outputDir,
+			RowsPerFile: rowsPerFile,
+			WithHeader:  withHeader,
+			Delimiter:   delim,
+			Progress: func(done, total int64) {
+				if bar == nil {
+					bar = progressbar.Default(total, "Splitting")
+				}
+				_ = bar.Set64(done)
+			},
+		})
 		if err != nil {
 			return err
 		}
 
-		file, err := os.Open(inputPath)
-		if err != nil {
-			return fmt.Errorf("failed to open input file: %w", err)
-		}
-		defer file.Close()
-
-		reader := csv.NewReader(file)
-		reader.Comma = delim
-		reader.FieldsPerRecord = -1
-
-		var header []string
-		if withHeader {
-			h, err := reader.Read()
-			if err != nil {
-				return fmt.Errorf("failed to read header: %w", err)
-			}
-			header = h
-		}
-
-		rowBuffer := [][]string{}
-		rowCount := 0
-		part := 1
-		bar := progressbar.Default(total, "Splitting")
-
-		for {
-			row, err := reader.Read()
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				return fmt.Errorf("failed to read row: %w", err)
-			}
-			rowBuffer = append(rowBuffer, row)
-			rowCount++
-			_ = bar.Add(1)
-
-			if len(rowBuffer) == rowsPerFile {
-				if err := writeChunk(rowBuffer, header, part, delim); err != nil {
-					return err
-				}
-				part++
-				rowBuffer = rowBuffer[:0]
-			}
-		}
-
-		if len(rowBuffer) > 0 {
-			if err := writeChunk(rowBuffer, header, part, delim); err != nil {
-				return err
-			}
-		} else {
-			part-- // no partial final chunk
-		}
-
-		fmt.Printf("\n✅ Finished splitting %d rows into %d file(s).\n", rowCount, part)
+		fmt.Printf("\n✅ Finished splitting %d rows into %d file(s).\n", res.RowsProcessed, res.FilesCreated)
 		return nil
 	},
 }
 
-func writeChunk(rows [][]string, header []string, part int, delim rune) error {
-	filename := filepath.Join(outputDir, fmt.Sprintf("part_%d.csv", part))
-	outFile, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("failed to create file %s: %w", filename, err)
-	}
-	defer outFile.Close()
-
-	writer := csv.NewWriter(outFile)
-	writer.Comma = delim
-
-	if withHeader && len(header) > 0 {
-		if err := writer.Write(header); err != nil {
-			return err
-		}
-	}
-	for _, row := range rows {
-		if err := writer.Write(row); err != nil {
-			return err
-		}
-	}
-	writer.Flush()
-	return writer.Error()
-}
-
 func init() {
 	rootCmd.AddCommand(splitCmd)