.github/workflows/golang-ci.yml

@@ -1,29 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ "main" ]
-    paths:
-      - '**.go'
-  pull_request:
-    branches: [ "main" ]
-    paths:
-      - '**.go'
-jobs:
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    timeout-minutes: 3
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.24'
-      - name: Install golangci-lint
-        run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-      - name: Run golangci-lint
-        run: golangci-lint run ./...

.github/workflows/update-go-modules.yml

@@ -1,30 +0,0 @@
-name: Auto-Update Go Modules
-
-on:
-  schedule:
-    - cron: "0 0 * * 1" # Runs every Monday at midnight
-
-jobs:
-  update-go-modules:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: stable
-
-      - name: Update Dependencies
-        run: |
-          go get -u ./...
-          go mod tidy
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add go.mod go.sum
-          git commit -m "chore: auto-update Go modules"
-          git push

.gitignore

@@ -9,7 +9,6 @@
 *.dll
 *.so
 *.dylib
-bin/
 
 # Test binary, built with `go test -c`
 *.test

.golangci.yml

@@ -1,54 +0,0 @@
-run:
-  # timeout for analysis, e.g. 30s, 3m, default is 1m
-  timeout: 3m
-  # exclude test files
-  tests: true
-
-linters:
-  # Set to true runs only fast linters.
-  # Good option for 'lint on save', pre-commit hook or CI.
-  fast: true
-
-  disable-all: true
-
-  enable:
-    - gosimple
-    - govet
-    - ineffassign
-    - staticcheck
-    - unused
-    - gofmt
-    - gofumpt
-    - misspell
-    - unparam
-    - gosec
-    - asciicheck
-    - errname
-    - gci
-    - godot
-    - goimports
-    - revive
-
-linters-settings:
-  gofmt:
-    rewrite-rules:
-      - pattern: 'interface{}'
-        replacement: 'any'
-      - pattern: 'a[b:len(a)]'
-        replacement: 'a[b:]'
-
-  misspell:
-    locale: UK
-
-  errcheck:
-    check-type-assertions: true
-
-issues:
-  max-same-issues: 0
-  max-issues-per-linter: 0
-  exclude-use-default: false
-  exclude:
-    # gosec: Duplicated errcheck checks
-    - G104
-    # gosec: integer overflow conversion int -> uint32
-    - G115

CHANGELOG.md

@@ -5,39 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-# [0.5.0] - 2025-04-13
-
-### Changed
-
--   CLI component migrated to Cobra. This introduces the following changes:
-    -   `list` is now a subcommand.
-    -   `create` has been added as a subcommand, use it to create a new .gitignore file.
--   Env var `GIGNORE_TEMPLATE_DIR` changed to `GIGNORE_TEMPLATE_ROOT`
--   Env var `GIGNORE_LOGLEVEL` may now be used to set the logging level.
-
-# [0.4.0] - 2025-04-05
-
-### Changed
-
--   `-loglevel` flag is now of type string. It accepts any one of trace, debug, info, warn, error, fatal or panic.
-    -   It defaults to warn.
-
-# [0.3.0] - 2025-14-03
-
-### Added
-
--   CLI may now accept multiple template names, example `gignore go python`. One will be appended after the other.
-
-### Changed
-
--   Filewriter now opens file in append mode.
-
-# [0.2.0] - 2025-10-03
-
-### Fixed
-
--   Template .gitignore are now written concurrently.
-
 # [0.1.0] - 2025-09-03
 
 ### Added

README.md

@@ -1,19 +1,7 @@
-![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white)
+# Gignore - Generate .gitinore files
-![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)
-![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)
-
-
-# Gignore - Generate .gitignore files
 
 ## Install
 
-With Go tools:
-
-```bash
-go generate ./...
-go install ./cmd/gignore
-```
-
 With [Task][task]:
 
 ```bash
@@ -23,75 +11,43 @@ task install
 ## Usage
 
 ```bash
-Usage:
+Usage of gignore:
-  gignore [flags]
+  gignore [flags] <template>
-  gignore [command]
-
-Available Commands:
-  completion  Generate the autocompletion script for the specified shell
-  create      Create a new .gitignore file
-  help        Help about any command
-  list        List all .gitignore files in the root template repository
 
 Flags:
-  -h, --help              help for gignore
+  -dir string
-  -l, --loglevel string   Log level (trace, debug, info, warn, error, fatal, panic) (default "warn")
+        directory containing .gitignore templates (default "gitignoreio")
-  -r, --root string       Root directory to search for .gitignore files (default "gitignoreio")
+  -list
+        list available templates
+  -ls
+        list available templates (shorthand)
 
-Use "gignore [command] --help" for more information about a command.
+Example:
-```
+  gignore go
-
-For example:
-
-```bash
-gignore create go
 ```
 
 ## Custom Templates
 
-It's possible to add your own custom templates, simply create a directory in `internal/registry/templates`. You'll need to [reinstall](https://github.com/onyx-and-iris/gignore?tab=readme-ov-file#install) the project before you can load the new templates.
+It's possible to add your own custom templates, simply create a directory in `internal/registry/templates`. You'll need to rebuild the project before you can load the new templates.
 
 Then pass the dir name as a flag, for example:
 
 ```bash
-gignore -root=custom create go
+gignore -dir=custom go
 ```
 
-You may set an environment variable `GIGNORE_TEMPLATE_ROOT` to avoid passing the `-root` flag each time.
+You may set an environment variable `GIGNORE_TEMPLATE_DIR` to avoid passing the `-dir` flag each time.
 
 If a template is requested but not found in the custom directory then the gitignoreio registry will act as a fallback.
 
-## Logging
-
-The `-loglevel` flag allows you to control the verbosity of the application's logging output. 
-
-Acceptable values for this flag are:
-
-- `trace`
-- `debug`
-- `info`
-- `warn`
-- `error`
-- `fatal`
-- `panic`
-
-For example, to set the log level to `debug`, you can use:
-
-```bash
-gignore -loglevel=debug create python
-```
-
-The default log level is `warn` if the flag is not specified.
-
 ## Special Thanks
 
 [gitignore.io][gitignoreio] For providing such a useful .gitignore service
 
-[cuonglm][cuonglm] For writing the [gogi][gogi] client library for gitignore.io
+[gigo][gigo] For writing the Go client library for gitignore.io
 
 
 [task]: https://taskfile.dev/
 [gitignoreio]: https://www.toptal.com/developers/gitignore
-[cuonglm]: https://github.com/cuonglm
+[gigo]: https://github.com/mh-cbon/gigo
-[gogi]: https://github.com/cuonglm/gogi
 [ignore]: https://github.com/neptship/ignore

Taskfile.yaml

@@ -23,6 +23,13 @@ tasks:
       - task: build-windows
       - task: build-linux
 
+  release:
+    desc: Generate the gitignore.io templates and then build the gignore project for Windows and Linux
+    deps: [generate]
+    cmds:
+      - task: build-windows
+      - task: build-linux
+
   vet:
     desc: Vet the code
     deps: [fmt]
@@ -35,26 +42,19 @@ tasks:
       - go fmt ./...
 
   generate:
-    desc: |
+    desc: Generate the gitignore.io templates
-      Generate the gitignore.io templates. 
-      This task will be skipped if the templates already exist.
-      You may use the `--force` flag to regenerate the templates.
     cmds:
-      - go generate ./...
+      - go generate .
-    status:
-      - ls internal/registry/templates/gitignoreio/*.gitignore >/dev/null
 
   build-windows:
     desc: Build the gignore project for Windows
     cmds:
       - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}
-    internal: true
 
   build-linux:
     desc: Build the gignore project for Linux
     cmds:
       - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}
-    internal: true
 
   test:
     desc: Run tests
@@ -71,8 +71,3 @@ tasks:
     desc: Clean the build artifacts
     cmds:
       - '{{.SHELL}} rm -r {{.BIN_DIR}}'
-
-  prune:
-    desc: Empty the gitignoreio template registry
-    cmds:
-      - '{{.SHELL}} rm internal/registry/templates/gitignoreio/*.gitignore'

cmd/gen/gen.go

@@ -1,17 +1,16 @@
-// Package main generates gitignore.io templates using the gogi library.
 package main
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"strings"
 
 	"github.com/cuonglm/gogi"
-	log "github.com/sirupsen/logrus"
 )
 
 func main() {
-	log.Info("Generating gitignore.io templates...")
+	fmt.Println("Generating gitignore.io templates...")
 
 	gogiClient, _ := gogi.NewHTTPClient()
 
@@ -20,22 +19,10 @@ func main() {
 		log.Fatal(err)
 	}
 
-	errChan := make(chan error)
-
 	for _, template := range templates {
-		go func() {
+		err := createTemplate(template)
-			err := createTemplate(template)
+		if err != nil {
-			if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to create template %s: %v\n", template.Name, err)
-				errChan <- fmt.Errorf("Failed to create template %s: %v", template.Name, err)
-				return
-			}
-			errChan <- nil
-		}()
-	}
-
-	for range templates {
-		if err := <-errChan; err != nil {
-			log.Error(err)
 		}
 	}
 }

cmd/gignore/context.go

@@ -1,22 +0,0 @@
-// Package main provides the entry point for the gignore CLI tool,
-// including commands like listing available .gitignore templates.
-package main
-
-import (
-	"context"
-
-	"github.com/onyx-and-iris/gignore"
-	log "github.com/sirupsen/logrus"
-)
-
-type contextKey string
-
-const clientKey contextKey = "client"
-
-func getClientFromContext(ctx context.Context) *gignore.Client {
-	client, ok := ctx.Value(clientKey).(*gignore.Client)
-	if !ok {
-		log.Fatal("Client not found in context")
-	}
-	return client
-}

cmd/gignore/create.go

@@ -1,50 +0,0 @@
-// Package main provides the entry point for the gignore CLI tool,
-// including commands like listing available .gitignore templates.
-package main
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-// createCmd is the command to create a new .gitignore file.
-var createCmd = &cobra.Command{
-	Use:   "create",
-	Short: "Create a new .gitignore file",
-	Long: `Create a new .gitignore file in the current directory.
-At least one template must be specified.
-Multiple templates can be specified, and they will be combined into a single .gitignore file.
-Example:
-  gignore create python
-  gignore create python go`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if len(args) == 0 {
-			cmd.Help()
-			return
-		}
-
-		for _, arg := range args {
-			err := createTemplate(cmd.Context(), arg)
-			cobra.CheckErr(err)
-		}
-	},
-}
-
-// init initialises the create command and adds it to the root command.
-func init() {
-	rootCmd.AddCommand(createCmd)
-}
-
-// createTemplate creates a new .gitignore file using the specified template.
-func createTemplate(ctx context.Context, template string) error {
-	client := getClientFromContext(ctx)
-	err := client.Create(template)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("√ created %s .gitignore file\n", template)
-	return nil
-}

cmd/gignore/list.go

@@ -1,49 +0,0 @@
-// Package main provides the entry point for the gignore CLI tool,
-// including commands like listing available .gitignore templates.
-package main
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/spf13/cobra"
-)
-
-// listCmd is the command to list all .gitignore templates.
-var listCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List all .gitignore files in the root template repository",
-	Long: `List all .gitignore files in the root template repository.
-This command will search the root template repository for .gitignore files and print their paths to the console.
-The root template repository can be specified using the --root flag.
-You can use this command to quickly find all available .gitignore templates.
-Example:
-  gignore --root=<path> list`,
-	Run: func(cmd *cobra.Command, _ []string) {
-		err := listTemplates(cmd.Context())
-		cobra.CheckErr(err)
-	},
-}
-
-// init initialises the list command and adds it to the root command.
-func init() {
-	rootCmd.AddCommand(listCmd)
-}
-
-// listTemplates retrieves and prints all .gitignore templates available from the gignore client.
-func listTemplates(ctx context.Context) error {
-	client := getClientFromContext(ctx)
-	templates, err := client.List()
-	if err != nil {
-		return err
-	}
-
-	var output strings.Builder
-	for _, template := range templates {
-		output.WriteString(template + "\n")
-	}
-	fmt.Print(output.String())
-
-	return nil
-}

cmd/gignore/main.go

@@ -1,65 +1,79 @@
-// Package main provides the entry point for the gignore CLI tool,
-// including commands like listing available .gitignore templates.
 package main
 
 import (
-	"context"
+	"flag"
-	"os"
+	"fmt"
+	"slices"
 
 	"github.com/onyx-and-iris/gignore"
 	log "github.com/sirupsen/logrus"
-	"github.com/spf13/cobra"
 )
 
-// rootCmd is the root command for the gignore CLI tool.
-var rootCmd = &cobra.Command{
-	Use:   "gignore",
-	Short: "A command line tool to manage .gitignore files",
-	Long: `gignore is a command line tool that helps you manage your .gitignore files.
-You can use it to list available templates and create new .gitignore files.
-It supports various programming languages.
-	Example:
-		gignore list
-		gignore create python`,
-	PersistentPreRun: func(cmd *cobra.Command, _ []string) {
-		// Initialise the logger
-		loglevel, err := log.ParseLevel(cmd.Flag("loglevel").Value.String())
-		cobra.CheckErr(err)
-		log.SetLevel(loglevel)
-
-		// Initialise the gignore client
-		client := gignore.New(
-			gignore.WithTemplateDirectory(cmd.Flag("root").Value.String()),
-		)
-
-		// Set the client in the context
-		// This allows us to access the client in the command handlers
-		ctx := context.WithValue(context.Background(), clientKey, client)
-		cmd.SetContext(ctx)
-	},
-	Run: func(cmd *cobra.Command, _ []string) {
-		cmd.Help()
-	},
-}
-
-// init initialises the root command and adds global flags.
-func init() {
-	getEnv := func(key, defaultValue string) string {
-		value := os.Getenv(key)
-		if value == "" {
-			return defaultValue
-		}
-		return value
-	}
-
-	rootCmd.PersistentFlags().
-		StringP("root", "r", getEnv("GIGNORE_TEMPLATE_ROOT", gignore.DefaultTemplateDirectory), "Root directory to search for .gitignore files")
-	rootCmd.PersistentFlags().
-		StringP("loglevel", "l", getEnv("GIGNORE_LOGLEVEL", "warn"), "Log level (trace, debug, info, warn, error, fatal, panic)")
-}
-
 func main() {
-	if err := rootCmd.Execute(); err != nil {
+	flag.Usage = func() {
-		log.Fatal(err)
+		w := flag.CommandLine.Output()
+
+		fmt.Fprint(w, "Usage of gignore:\n")
+		fmt.Fprintf(w, "  gignore [flags] <template>\n")
+		fmt.Fprint(w, "\n")
+
+		fmt.Fprint(w, "Flags:\n")
+		flag.PrintDefaults()
+
+		fmt.Fprint(w, "\n")
+		fmt.Fprintf(w, "Example:\n")
+		fmt.Fprint(w, "  gignore go\n")
+	}
+
+	var (
+		list        bool
+		templateDir string
+		loglevel    int
+	)
+
+	flag.BoolVar(&list, "list", false, "list available templates")
+	flag.BoolVar(&list, "ls", false, "list available templates (shorthand)")
+	flag.StringVar(
+		&templateDir,
+		"dir",
+		getEnv("GIGNORE_TEMPLATE_DIR", "gitignoreio"),
+		"directory containing .gitignore templates",
+	)
+	flag.IntVar(&loglevel, "loglevel", int(log.WarnLevel), "log level")
+	flag.IntVar(&loglevel, "l", int(log.WarnLevel), "log level (shorthand)")
+	flag.Parse()
+
+	if slices.Contains(log.AllLevels, log.Level(loglevel)) {
+		log.SetLevel(log.Level(loglevel))
+	}
+
+	client := gignore.New(gignore.WithTemplateDirectory(templateDir))
+
+	if list {
+		listTemplates(client)
+		return
+	}
+
+	args := flag.Args()
+	if len(args) != 1 {
+		flag.Usage()
+		return
+	}
+
+	err := client.Create(args[0])
+	if err != nil {
+		log.Fatalf("failed to create .gitignore file: %v", err)
+	}
+
+	fmt.Printf("√ created %s .gitignore file\n", args[0])
+}
+
+func listTemplates(client *gignore.GignoreClient) {
+	templates, err := client.List()
+	if err != nil {
+		log.Fatalf("failed to list templates: %v", err)
+	}
+	for _, template := range templates {
+		fmt.Println(template)
 	}
 }

cmd/gignore/util.go

@@ -0,0 +1,11 @@
+package main
+
+import "os"
+
+func getEnv(key, defaultValue string) string {
+	value := os.Getenv(key)
+	if len(value) == 0 {
+		return defaultValue
+	}
+	return value
+}

error.go

@@ -1,16 +1,16 @@
-// Package gignore provides a way to manage .gitignore files and templates.
 package gignore
 
 import (
 	"fmt"
-	"strings"
+
+	"github.com/onyx-and-iris/gignore/internal/registry"
 )
 
 type templateNotFoundError struct {
-	template          string
+	template string
-	templatesSearched []string
+	registry *registry.TemplateRegistry
 }
 
 func (e *templateNotFoundError) Error() string {
-	return fmt.Sprintf("template '%s' not found in %s registry", e.template, strings.Join(e.templatesSearched, ", "))
+	return fmt.Sprintf("template '%s' not found in %s registry", e.template, e.registry.Directory)
 }

gignore.go

@@ -3,73 +3,65 @@ package gignore
 import (
 	"io"
 
+	log "github.com/sirupsen/logrus"
+
 	"github.com/onyx-and-iris/gignore/internal/filewriter"
 	"github.com/onyx-and-iris/gignore/internal/registry"
-	log "github.com/sirupsen/logrus"
 )
 
-//go:generate go run cmd/gen/main.go
+//go:generate go run cmd/gen/gen.go
 
-// DefaultTemplateDirectory is the default directory for .gitignore templates.
+type GignoreClient struct {
-const DefaultTemplateDirectory = "gitignoreio"
-
-// Client is a client for managing .gitignore templates.
-type Client struct {
 	registry *registry.TemplateRegistry
 	writer   io.Writer
 }
 
-// New creates a new Client with the provided options.
+func New(options ...Option) *GignoreClient {
-func New(options ...Option) *Client {
+	gc := &GignoreClient{
-	c := &Client{
+		registry.NewTemplateRegistry(),
-		registry.New(),
+		filewriter.New()}
-		filewriter.New(),
-	}
 
 	for _, option := range options {
-		option(c)
+		option(gc)
 	}
 
-	return c
+	return gc
 }
 
-// List returns a list of available .gitignore templates.
+func (g *GignoreClient) List() ([]string, error) {
-func (c *Client) List() ([]string, error) {
+	return g.registry.ListTemplates()
-	return c.registry.List()
 }
 
-// Create generates a .gitignore file from the specified template.
+func (g *GignoreClient) Create(template string) error {
-func (c *Client) Create(template string) error {
+	ok, err := g.registry.Contains(template)
-	ok, err := c.registry.Contains(template)
 	if err != nil {
 		return err
 	}
 	if !ok {
-		templateNotFoundErr := &templateNotFoundError{template, []string{c.registry.Directory}}
+		templateNotFoundErr := &templateNotFoundError{template, g.registry}
-		if c.registry.Directory == DefaultTemplateDirectory {
+		if g.registry.Directory == "gitignoreio" {
 			return templateNotFoundErr
 		}
 
-		c.registry.Directory = DefaultTemplateDirectory
+		log.Errorf("%s. Checking default registry...", templateNotFoundErr)
-		ok, err = c.registry.Contains(template)
+
+		g.registry.Directory = "gitignoreio"
+		ok, err = g.registry.Contains(template)
 		if err != nil {
 			return err
 		}
 		if !ok {
-			templateNotFoundErr.templatesSearched = append(templateNotFoundErr.templatesSearched, c.registry.Directory)
 			return templateNotFoundErr
 		}
-		log.Debugf("template '%s' found in gitignoreio registry", template)
+		log.Infof("template '%s' found in default gitignoreio registry", template)
-	} else {
-		log.Debugf("template '%s' found in %s registry", template, c.registry.Directory)
 	}
 
-	content, err := c.registry.Get(template)
+	content, err := g.registry.GetTemplate(template)
 	if err != nil {
 		return err
 	}
 
-	_, err = c.writer.Write(content)
+	_, err = g.writer.Write(content)
 	if err != nil {
 		return err
 	}

go.mod

@@ -5,11 +5,6 @@ go 1.24.0
 require (
 	github.com/cuonglm/gogi v1.0.1
 	github.com/sirupsen/logrus v1.9.3
-	github.com/spf13/cobra v1.9.1
 )
 
-require (
+require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.6 // indirect
-	golang.org/x/sys v0.32.0 // indirect
-)

go.sum

@@ -1,27 +1,17 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/cuonglm/gogi v1.0.1 h1:Jotx6uAfFK6YHFOOek37R9y3Ae9qp/nUt/3mYGCl+44=
 github.com/cuonglm/gogi v1.0.1/go.mod h1:ZLU5wl3d+FSSkiYYDpmPJI2dWdAGj8q28rFjpeWv1g4=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
-github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
-github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
-github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
-github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
-golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/filewriter/filewriter.go

@@ -1,4 +1,3 @@
-// Package filewriter provides functionality to write content to a .gitignore file.
 package filewriter
 
 import (
@@ -7,14 +6,11 @@ import (
 	"os"
 )
 
-// FileWriter provides functionality to write content to a .gitignore file.
 type FileWriter struct {
-	targetFileName string
 }
 
-// New creates a new FileWriter with the default target file name.
 func New() *FileWriter {
-	return &FileWriter{".gitignore"}
+	return &FileWriter{}
 }
 
 func (fw *FileWriter) writeContent(content []byte, dst io.Writer) (int64, error) {
@@ -29,14 +25,14 @@ func (fw *FileWriter) writeContent(content []byte, dst io.Writer) (int64, error)
 }
 
 func (fw *FileWriter) Write(content []byte) (int, error) {
-	f, err := os.OpenFile(fw.targetFileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o600)
+	f, err := os.Create(".gitignore")
 	if err != nil {
 		return 0, err
 	}
 	defer f.Close()
 
-	const header = "# Auto-generated .gitignore by gignore: github.com/onyx-and-iris/gignore\n"
+	const header = `# Auto-generated .gitignore by gignore: github.com/onyx-and-iris/gignore`
-	const footer = "\n# End of gignore: github.com/onyx-and-iris/gignore\n"
+	const footer = `# End of gignore: github.com/onyx-and-iris/gignore`
 
 	var sz int64
 	n, err := fw.writeContent([]byte(header), f)

internal/registry/registry.go

@@ -1,4 +1,3 @@
-// Package registry provides functionality to manage and retrieve gitignore templates.
 package registry
 
 import (
@@ -11,14 +10,12 @@ import (
 //go:embed templates
 var templates embed.FS
 
-// TemplateRegistry provides methods to manage and retrieve gitignore templates.
 type TemplateRegistry struct {
 	templates fs.FS
 	Directory string
 }
 
-// New creates a new instance of TemplateRegistry.
+func NewTemplateRegistry() *TemplateRegistry {
-func New() *TemplateRegistry {
 	return &TemplateRegistry{
 		templates: templates,
 	}
@@ -28,7 +25,6 @@ func (t *TemplateRegistry) filePath(name string) string {
 	return fmt.Sprintf("templates/%s/%s.gitignore", t.Directory, name)
 }
 
-// Contains checks if a template with the given name exists in the registry.
 func (t *TemplateRegistry) Contains(name string) (bool, error) {
 	_, err := fs.Stat(t.templates, t.filePath(name))
 	if err != nil {
@@ -41,8 +37,7 @@ func (t *TemplateRegistry) Contains(name string) (bool, error) {
 	return true, nil
 }
 
-// Get retrieves the content of the gitignore template with the given name.
+func (t *TemplateRegistry) GetTemplate(name string) ([]byte, error) {
-func (t *TemplateRegistry) Get(name string) ([]byte, error) {
 	data, err := fs.ReadFile(t.templates, t.filePath(name))
 	if err != nil {
 		return nil, err
@@ -50,8 +45,7 @@ func (t *TemplateRegistry) Get(name string) ([]byte, error) {
 	return data, nil
 }
 
-// List lists all the gitignore templates in the registry.
+func (t *TemplateRegistry) ListTemplates() ([]string, error) {
-func (t *TemplateRegistry) List() ([]string, error) {
 	var paths []string
 
 	err := fs.WalkDir(

option.go

@@ -1,11 +1,9 @@
 package gignore
 
-// Option is a function that configures a GignoreClient.
+type Option func(*GignoreClient)
-type Option func(*Client)
 
-// WithTemplateDirectory sets the template directory for the GignoreClient.
 func WithTemplateDirectory(directory string) Option {
-	return func(c *Client) {
+	return func(g *GignoreClient) {
-		c.registry.Directory = directory
+		g.registry.Directory = directory
 	}
 }