chore: improve install script (#23)

- improved script to either install or update when version is lower than
  release version.

chore: update release-please github action

- deleted the scripts/build script
- moved the logic from the scripts/build script to the release-please
  action

chore: use defaults for go dependency checking

- removed settings for day, time, and timezone from dependency checking
  for go mod

  The dependabot now uses the default weekly time settings.

chore: fix pre-commit git hook

- removed adding all files after running go formatter

This fixes issue of unwanted files/directories added to the commit.

feat: add template subcommand

- created template subcommand for use with git hook templates (reusable
  git hooks)
- created subcommands for template to create, copy, edit, and remove
  templates.

feat: add config subcommand

- created HkUp configuration settings
- created subcommands for config to get and set configuration settings

NOTE: this feature is hidden and will be available when configuration
settings are finalized.

refactor(cmd): simplify flag handling & init logic

- Rename flags for consistency: `Lang` to `LangFlg`, `GitDir` to `GitDirFlg`, and `WorkTree` to `WorkTreeFlg`.
- Consolidate command registration in `root.go` by removing redundant `rootCmd.AddCommand` calls from individual command files (add.go, remove.go, list.go, doc.go).
- Simplify `init()` functions in command files to centralize logic.
- Update root command version handling to dynamically use `version` variable.
- Clarify documentation comment in `main.go`.

refactor(logic): update flags and simplify hook commands

- Rename flags: `Lang` to `LangFlg`, `GitDir` to `GitDirFlg`, `WorkTree` to `WorkTreeFlg` for consistency.
- Simplify the Add, Remove, and Init logic by centralizing directory checks and reducing redundant code.
- Update file handling to improve readability and error handling.
- Adjust comments for better clarity and consistency across functions.

refactor(git): improve comments and simplify hook logic

- Updated comments for clarity and consistency in the Git package.
- Removed unnecessary constant `HookDocSite`, and clarified hook documentation URL logic.
- Simplified the `GetHook` and `GetLang` functions to improve readability and error handling.
- Updated the `supportedLangs` map to explicitly include `sh` and `bash`, ensuring clearer intent.

feat(util): add file ops, prompts, and config functions

- Added utility functions for terminal prompts, including YesNoPrompt and UserInputPrompt, to improve user interaction.
- Expanded file handling functions, including CreateDirectory and CopyFile, to support additional use cases.
- Introduced functions to handle HkUp configuration paths:
  - GetConfigDirPath
  - GetConfigFilePath
  - GetTemplateDirPath
- Added functions for TOML file manipulation:
  - GetTOMLValue (retrieve a value from a TOML file)
  - SetTOMLValue (set a value in a TOML file)
- Implemented GetEditor function to determine the default editor for HkUp from configuration, git, or environment variables.
- Refactored existing functions for clarity and consistency (e.g., CreateFile, DoesDirectoryExist).

.github/dependabot.yml

@@ -4,9 +4,6 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
-      day: "friday"
-      time: "12:00"
-      timezone: "America/New_York"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:

.github/workflows/release-please.yml

@@ -17,12 +17,11 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      # Step 2: Run your build script
-      - name: Run build script
-        run: |
-          rm -rf ./bin
-          chmod +x ./scripts/build
-          ./scripts/build
+      # Step 2: Set up Go environment
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
 
       # Step 3: Use release-please to create a release
       - name: Create release
@@ -31,12 +30,29 @@ jobs:
         with:
           release-type: go
 
-      # Step 4: Upload Release Artifacts if a release was created
+      # Step 4: Update the version in the build and perform multi-platform builds
+      - name: Build for multiple platforms
+        if: ${{ steps.release.outputs.release_created }}
+        run: |
+          VERSION="${{ steps.release.outputs.version }}"
+          echo "Updating version to ${VERSION}"
+
+          mkdir -p bin
+
+          # Build for Linux
+          GOOS=linux GOARCH=amd64 go build -o bin/hkup-linux -ldflags="-s -w -X cmd.version=${VERSION}" .
+
+          # Build for Darwin/macOS
+          GOOS=darwin GOARCH=amd64 go build -o bin/hkup-darwin -ldflags="-s -w -X cmd.version=${VERSION}" .
+
+          # Build for Windows (optional, uncomment if needed)
+          # GOOS=windows GOARCH=amd64 go build -o bin/hkup.exe -ldflags="-s -w -X cmd.version=${VERSION}" .
+
+      # Step 5: Upload Release Artifacts if a release was created
       - name: Upload Release Artifacts
         if: ${{ steps.release.outputs.release_created }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           gh release upload ${{ steps.release.outputs.tag_name }} \
-            ./bin/*
-
+            bin/*

.hkup/pre-commit

@@ -4,10 +4,7 @@
 if git diff --cached --name-only | grep -q '\.go$'; then
     echo "Formatting Go files..."
     gofmt -w .
-    echo ""
 
-    # Add formatted files to the staging area
-    git add .
 else
     echo "No Go files changed. Skipping formatting."
     echo ""

README.md

@@ -1,5 +1,5 @@
 # HkUp
-Your CLI tool with benefits built by [iton0](https://github.com/iton0) in [Go](https://go.dev/)!
+> Your CLI tool with benefits built by [iton0](https://github.com/iton0) in [Go](https://go.dev/)!
 
 [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/iton0/hkup-cli)](https://github.com/iton0/hkup-cli/releases/latest)
 [![godoc](https://godoc.org/github.com/iton0/hkup-cli?status.svg)](http://godoc.org/github.com/iton0/hkup-cli)
@@ -11,9 +11,16 @@ Your CLI tool with benefits built by [iton0](https://github.com/iton0) in [Go](h
 ## Introduction
 Git hooks automate and implement processes in your workflow, increasing code quality and consistency.
 
-However, many developers avoid git hooks due to a lack of awareness and the perceived complexity of setup, discouraging them from using this feature.
+Common use cases include:
+- Commit Message Validation
+- Environment Configuration
+- Formatting
+- Linting
+- Testing
 
-**HkUp** simplifies the management of git hooks, allowing you to focus on the logic and usage of your hooks instead.
+However, many developers avoid Git hooks due to a lack of awareness and the perceived complexity of setup, discouraging them from using this feature.
+
+**HkUp** simplifies the management of Git hooks, allowing you to focus on the logic and usage of your hooks instead.
 
 ## Installation
 External Dependencies:
@@ -27,10 +34,9 @@ Run the script below (supports Linux and macOS):
 curl -sSL https://raw.githubusercontent.com/iton0/hkup-cli/main/scripts/install | sh
 ```
 > [!Tip]
-> To update HkUp, rerun the above script.
-> It will replace the current version.
+> To update HkUp, simply rerun the script above. It will automatically replace your current version with the latest release.
 
-#### Uninstalling hkup
+### Uninstalling HkUp
 
 ```sh
 # Locates and deletes the HkUp binary
@@ -40,49 +46,63 @@ sh -c 'rm "$(command -v 'hkup')"'
 </details>
 
 ## Usage Quickstart
-This section provides basic information about core usage. For detailed options run `hkup --help`.
+This section provides basic information about core usage. For detailed usage information run `hkup --help`.
 
-#### Initializing hkup
+### Initializing hkup
 Run the following command in your git repository to initialize HkUp:
 ```sh
 hkup init
 ```
 
-This command creates a **.hkup** folder and sets the local **core.hooksPath** variable. If the folder already exists, it will simply update the path variable. The path is relative, ensuring that moving your repository won’t affect hook sourcing.
+This creates a **.hkup** directory and sets the local **core.hooksPath** variable. If the directory already exists, it will simply update the path variable. The path is relative, ensuring that moving your repository won’t affect hook sourcing.
 
-#### Adding & Removing hooks
+### Adding & Removing hooks
 Add or remove hooks easily with:
 ```sh
 hkup add <hook-name>
+
 hkup remove <hook-name>
 ```
 
-#### Info & Docs
-There are two commands that will help you with both HkUp and git hooks:
-
-**`hkup list {hook|lang}`**
-Outputs list of either available hooks or supported languages.
+### Templates
+A **template** is a pre-configured, reusable Git hook that simplifies and automates the process of setting up hooks in a Git repository. With **HkUp**, you can create, copy, edit, or remove templates, allowing for consistent and easy application of hooks without needing to rewrite scripts each time.
 
-**`hkup doc <hook-name>`**
-Opens your browser with Git documentation for the specified git hook, helping you understand its usage.
+The templates are stored in the HkUp config templates directory that can either be found at **$XDG_CONFIG_HOME/hkup/templates** or **$HOME/.config/hkup/templates** depending on your system.
 
-## Future TODOs
-- [ ] make an update subcommand
-- [ ] store custom git hooks as templates for future use (via add template subcmd)
-    - Allow users to create, store, and share templates for common hooks. Users can fetch these templates over the network.
-- [ ] branch-specific hooks
-- [ ] logo maybe?
+#### Naming Convention
+Template files follow the naming convention:
+`<template-name>#<hook-name>`
+Where:
+- `<template-name>` is the name of the template.
+- `<hook-name>` is the specific Git hook (e.g., pre-commit, post-merge).
 
-## Contributing
-HkUp welcomes contributions to enhance this CLI application! Before submitting a pull request (PR) for a new feature, please follow these steps:
+**Create a template**:
+```sh
+hkup template create
+# OR
+hkup template create <hook-name>
+```
 
-1. **Create an Issue**:
-    If you have an idea for a new feature, please create a new issue in the repository using the **feature_request** template. Provide a clear description of the feature and its potential benefits. Please note that issues submitted without using the template may be closed without warning.
+**Copy a template** into current working directory:
+```sh
+hkup template copy <template-name>
+```
 
-2. **Wait for Approval**:
-    Once you submit your issue, I’ll review it and provide feedback. If I approve the feature request, I will let you know that you're free to proceed with your PR.
+**Edit a template**:
+```sh
+hkup template edit <template-name>
+```
+>[!CAUTION]
+> Editing a template will not update its copies.
 
-3. **Submit Your PR**:
-    After receiving approval, you can create your PR. Be sure to reference the issue in your PR description.
+**Remove a template**:
+```sh
+hkup template remove <template-name>
+```
 
-Please note that PRs submitted without prior approval through an issue may be closed without merging. This process helps us manage feature requests effectively and ensures that contributions align with the project’s goals.
+## Roadmap to v1.0.0
+1.  windows support
+2.  wrapper for git init & clone and gh repo create & clone
+3.  HkUp logo (may or may not keep this one)
+4.  better test coverage
+5.  Allow users to create, store, and share templates. Users can fetch these templates over internet (may need to make another repo for this).

cmd/add.go

@@ -18,6 +18,5 @@ var (
 )
 
 func init() {
-	addCmd.Flags().StringVar(&logic.Lang, "lang", "", "supported languages for git hooks")
-	rootCmd.AddCommand(addCmd)
+	addCmd.Flags().StringVar(&logic.LangFlg, "lang", "", "supported languages for git hooks")
 }

cmd/config/get.go

@@ -0,0 +1,17 @@
+package config
+
+import (
+	"github.com/iton0/hkup-cli/internal/logic/config"
+	"github.com/spf13/cobra"
+)
+
+var (
+	getCmd = &cobra.Command{
+		Use:   "get <config-setting>",
+		Short: "Get a HkUp config setting",
+		Args:  cobra.ExactArgs(1),
+		RunE:  config.Get,
+	}
+)
+
+func init() {}

cmd/config/main.go

@@ -0,0 +1,9 @@
+/*
+Package template initializes the config subcommand and its subcommands.
+
+This package is utilized in the root command of [github.com/iton0/hkup-cli/cmd]
+package.
+*/
+package config
+
+// NOTE: This file is for documentation purposes and should be kept empty.

cmd/config/root.go

@@ -0,0 +1,19 @@
+package config
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var (
+	// RootCmd is the config command that will be added to the root HkUp command.
+	RootCmd = &cobra.Command{
+		Use:    "config",
+		Short:  "HkUp configuration settings",
+		Hidden: true, // TODO: remove after finalizing configuration settings
+	}
+)
+
+func init() {
+	RootCmd.AddCommand(getCmd)
+	RootCmd.AddCommand(setCmd)
+}

cmd/config/set.go

@@ -0,0 +1,17 @@
+package config
+
+import (
+	"github.com/iton0/hkup-cli/internal/logic/config"
+	"github.com/spf13/cobra"
+)
+
+var (
+	setCmd = &cobra.Command{
+		Use:   "set <config-setting> <value>",
+		Short: "Set a HkUp config setting",
+		Args:  cobra.ExactArgs(2),
+		RunE:  config.Set,
+	}
+)
+
+func init() {}

cmd/doc.go

@@ -18,6 +18,4 @@ var (
 	}
 )
 
-func init() {
-	rootCmd.AddCommand(docCmd)
-}
+func init() {}

cmd/init.go

@@ -9,15 +9,14 @@ var (
 	initCmd = &cobra.Command{
 		Use:   "init",
 		Short: "Initialize hkup",
-		Long:  "Create an empty hkup folder or reinitialize an existing one",
+		Long:  "Create an empty hkup directory or reinitialize an existing one",
 		Args:  cobra.NoArgs,
 		RunE:  logic.Init,
 	}
 )
 
 func init() {
-	initCmd.Flags().StringVar(&logic.GitDir, "gitdir", "", "specified path to git directory")
-	initCmd.Flags().StringVar(&logic.WorkTree, "worktree", "", "specified path to working tree")
+	initCmd.Flags().StringVar(&logic.GitDirFlg, "gitdir", "", "specified path to git directory")
+	initCmd.Flags().StringVar(&logic.WorkTreeFlg, "worktree", "", "specified path to working tree")
 	initCmd.MarkFlagsRequiredTogether("gitdir", "worktree")
-	rootCmd.AddCommand(initCmd)
 }

cmd/list.go

@@ -16,6 +16,4 @@ var (
 	}
 )
 
-func init() {
-	rootCmd.AddCommand(listCmd)
-}
+func init() {}

cmd/main.go

@@ -1,8 +1,6 @@
 /*
 Package cmd initializes all commands (including root command) for the HkUp CLI.
-
-Additionally, the package holds all tests for commands.
 */
 package cmd
 
-// Note: This file should be kept empty.
+// NOTE: This file is for documentation purposes and should be kept empty.

cmd/remove.go

@@ -18,6 +18,4 @@ var (
 	}
 )
 
-func init() {
-	rootCmd.AddCommand(removeCmd)
-}
+func init() {}

cmd/root.go

@@ -1,23 +1,39 @@
 package cmd
 
 import (
+	"github.com/iton0/hkup-cli/cmd/config"
+	"github.com/iton0/hkup-cli/cmd/template"
 	"github.com/spf13/cobra"
 )
 
 var (
+	// version holds the centralized version of HkUp.
+	// It is updated to the latest release version at build time of the binaries.
+	//
+	// INFO: look at the .github/workflows/release-please.yml to view how version
+	//       is updated.
+	version = "dev"
+
 	rootCmd = &cobra.Command{
 		Use:     "hkup",
 		Short:   "hkup CLI",
 		Long:    `hkup is a management tool for git hooks`,
-		Args:    cobra.MinimumNArgs(1),
-		Version: "0.2.1",
+		Version: version,
 	}
 )
 
-func init() {}
+func init() {
+	rootCmd.AddCommand(initCmd)
+	rootCmd.AddCommand(addCmd)
+	rootCmd.AddCommand(removeCmd)
+	rootCmd.AddCommand(template.RootCmd)
+	rootCmd.AddCommand(config.RootCmd)
+	rootCmd.AddCommand(docCmd)
+	rootCmd.AddCommand(listCmd)
+}
 
 // Execute serves as a wrapper for the Cobra API's Execute function,
-// allowing it to be called from the main package.
+// allowing it to be called from the [github.com/iton0/hkup-cli] package.
 func Execute() {
 	rootCmd.Execute()
 }

cmd/template/copy.go

@@ -0,0 +1,17 @@
+package template
+
+import (
+	"github.com/iton0/hkup-cli/internal/logic/template"
+	"github.com/spf13/cobra"
+)
+
+var (
+	copyCmd = &cobra.Command{
+		Use:   "copy <template-name>",
+		Short: "Copy a git hook template",
+		Args:  cobra.ExactArgs(1),
+		RunE:  template.Copy,
+	}
+)
+
+func init() {}