first implementation

Author: vinitkumar

Makefile

@@ -0,0 +1,49 @@
+.PHONY: build test clean install all
+
+# Binary name
+BINARY_NAME=pdf-joiner
+
+# Go parameters
+GOCMD=go
+GOBUILD=$(GOCMD) build
+GOTEST=$(GOCMD) test
+GOGET=$(GOCMD) get
+GOMOD=$(GOCMD) mod
+GOCLEAN=$(GOCMD) clean
+
+# Build flags
+LDFLAGS=-ldflags "-s -w"
+
+all: test build
+
+build:
+	$(GOBUILD) $(LDFLAGS) -o $(BINARY_NAME) -v
+
+test:
+	$(GOTEST) -v ./...
+
+clean:
+	$(GOCLEAN)
+	rm -f $(BINARY_NAME)
+	rm -f $(BINARY_NAME).exe
+
+run:
+	$(GOBUILD) -o $(BINARY_NAME) -v
+	./$(BINARY_NAME)
+
+install: build
+	mv $(BINARY_NAME) /usr/local/bin/
+
+# Dependencies
+deps:
+	$(GOMOD) tidy
+
+# Cross compilation
+build-darwin:
+	GOOS=darwin GOARCH=amd64 $(GOBUILD) $(LDFLAGS) -o $(BINARY_NAME)-darwin-amd64 -v
+	GOOS=darwin GOARCH=arm64 $(GOBUILD) $(LDFLAGS) -o $(BINARY_NAME)-darwin-arm64 -v
+
+# Universal binary for macOS (both Intel and Apple Silicon)
+build-universal-darwin: build-darwin
+	lipo -create -output $(BINARY_NAME) $(BINARY_NAME)-darwin-amd64 $(BINARY_NAME)-darwin-arm64
+	rm $(BINARY_NAME)-darwin-amd64 $(BINARY_NAME)-darwin-arm64 

README.md

@@ -0,0 +1,91 @@
+# PDF Joiner
+
+A simple command-line utility for joining multiple PDF files into a single PDF document on macOS.
+
+## Requirements
+
+- macOS (This tool uses the built-in macOS PDF joining utility)
+- Go 1.18 or later (for building from source)
+
+## Installation
+
+### From Source
+
+1. Clone this repository:
+   ```
+   git clone https://github.com/vinitkumar/pdf-joiner.git
+   cd pdf-joiner
+   ```
+
+2. Build the binary:
+   ```
+   make build
+   ```
+
+3. (Optional) Install the binary to your system:
+   ```
+   make install
+   ```
+
+## Usage
+
+```
+pdf-joiner [-o output.pdf] file1.pdf file2.pdf [file3.pdf ...]
+```
+
+### Options
+
+- `-o`: Specify the output file path. If not provided, the output will be saved as `joined-pdf-YYYY-MM-DD-HHMMSS.pdf` in the current directory.
+
+### Examples
+
+Join two PDF files:
+```
+pdf-joiner file1.pdf file2.pdf
+```
+
+Join multiple PDF files with a specific output path:
+```
+pdf-joiner -o merged.pdf file1.pdf file2.pdf file3.pdf
+```
+
+Join all PDF files in a directory:
+```
+pdf-joiner -o merged.pdf /path/to/directory/*.pdf
+```
+
+## How It Works
+
+This tool is a wrapper around the macOS built-in PDF joining utility located at:
+```
+/System/Library/Automator/Combine PDF Pages.action/Contents/MacOS/join
+```
+
+## Development
+
+### Running Tests
+
+```
+make test
+```
+
+### Building for Different Architectures
+
+Build for both Intel and Apple Silicon Macs:
+```
+make build-universal-darwin
+```
+
+### Cleaning Up
+
+```
+make clean
+```
+
+## License
+
+MIT
+
+## Author
+
+Vinit Kumar 

go.mod

@@ -0,0 +1,3 @@
+module github.com/vinitkumar/pdf-joiner
+
+go 1.24.0

main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+const (
+	// Path to the Mac PDF joiner utility
+	pdfJoinerPath = "/System/Library/Automator/Combine PDF Pages.action/Contents/MacOS/join"
+)
+
+func main() {
+	// Define command-line flags
+	outputPath := flag.String("o", "", "Output path for the joined PDF")
+	flag.Parse()
+
+	// Get the PDF files to join from the remaining arguments
+	pdfFiles := flag.Args()
+	if len(pdfFiles) < 2 {
+		fmt.Println("Error: At least two PDF files are required for joining")
+		fmt.Println("Usage: pdf-joiner [-o output.pdf] file1.pdf file2.pdf [file3.pdf ...]")
+		os.Exit(1)
+	}
+
+	// Validate that all input files exist and are PDFs
+	for _, file := range pdfFiles {
+		if !fileExists(file) {
+			fmt.Printf("Error: File '%s' does not exist\n", file)
+			os.Exit(1)
+		}
+		
+		if filepath.Ext(file) != ".pdf" {
+			fmt.Printf("Warning: File '%s' may not be a PDF file\n", file)
+		}
+	}
+
+	// If no output path is provided, create a default one with the current date
+	if *outputPath == "" {
+		currentTime := time.Now().Format("2006-01-02-150405")
+		*outputPath = fmt.Sprintf("joined-pdf-%s.pdf", currentTime)
+	}
+
+	// Ensure the output directory exists
+	outputDir := filepath.Dir(*outputPath)
+	if outputDir != "." && outputDir != "" {
+		if err := os.MkdirAll(outputDir, 0755); err != nil {
+			fmt.Printf("Error creating output directory: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	// Check if the Mac PDF joiner utility exists
+	if !fileExists(pdfJoinerPath) {
+		fmt.Printf("Error: PDF joiner utility not found at '%s'\n", pdfJoinerPath)
+		fmt.Println("This tool only works on macOS systems.")
+		os.Exit(1)
+	}
+
+	// Prepare the command to join PDFs
+	args := []string{"-o", *outputPath}
+	args = append(args, pdfFiles...)
+
+	// Execute the command
+	cmd := exec.Command(pdfJoinerPath, args...)
+	output, err := cmd.CombinedOutput()
+	
+	if err != nil {
+		fmt.Printf("Error joining PDFs: %v\n", err)
+		fmt.Printf("Command output: %s\n", output)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Successfully joined %d PDF files into '%s'\n", len(pdfFiles), *outputPath)
+}
+
+// fileExists checks if a file exists and is not a directory
+func fileExists(path string) bool {
+	info, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return !info.IsDir()
+} 

main_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFileExists(t *testing.T) {
+	// Create a temporary file for testing
+	tempFile, err := os.CreateTemp("", "test-*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+	defer os.Remove(tempFile.Name())
+	defer tempFile.Close()
+
+	// Test cases
+	tests := []struct {
+		name     string
+		path     string
+		expected bool
+	}{
+		{
+			name:     "Existing file",
+			path:     tempFile.Name(),
+			expected: true,
+		},
+		{
+			name:     "Non-existing file",
+			path:     "non-existing-file.pdf",
+			expected: false,
+		},
+		{
+			name:     "Directory",
+			path:     ".",
+			expected: false, // fileExists returns false for directories
+		},
+	}
+
+	// Run test cases
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := fileExists(tc.path)
+			if result != tc.expected {
+				t.Errorf("fileExists(%s) = %v, expected %v", tc.path, result, tc.expected)
+			}
+		})
+	}
+}
+
+func TestOutputPathGeneration(t *testing.T) {
+	// This is a mock test to demonstrate how we would test the output path generation
+	// In a real test, we would need to mock time.Now() or use dependency injection
+	
+	// Create a temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "pdf-joiner-test")
+	if err != nil {
+		t.Fatalf("Failed to create temporary directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+	
+	// Test that we can create directories for output
+	testOutputPath := filepath.Join(tempDir, "subdir", "output.pdf")
+	outputDir := filepath.Dir(testOutputPath)
+	
+	err = os.MkdirAll(outputDir, 0755)
+	if err != nil {
+		t.Errorf("Failed to create output directory: %v", err)
+	}
+	
+	// Verify the directory was created
+	if _, err := os.Stat(outputDir); os.IsNotExist(err) {
+		t.Errorf("Output directory was not created: %v", err)
+	}
+}