main.go

// SPDX-License-Identifier: MIT

package main

import (
	"os"
	"path/filepath"
	"runtime"

	"github.com/boyter/hashit/processor"
	"github.com/spf13/cobra"
)

func main() {
	//f, _ := os.Create("hashit.pprof")
	//_ = pprof.StartCPUProfile(f)
	//defer pprof.StopCPUProfile()

	rootCmd := &cobra.Command{
		Use:     "hashit",
		Short:   "hashit [FILE or DIRECTORY]",
		Long:    "Hash It!\nVersion " + processor.Version + "\nBen Boyter <ben@boyter.org>",
		Version: processor.Version,
		Run: func(cmd *cobra.Command, args []string) {
			var filePaths []string
			for _, arg := range args {
				matches, err := filepath.Glob(arg)
				if err != nil || len(matches) == 0 {
					// If there's an error or no matches, treat the argument as a literal path
					filePaths = append(filePaths, arg)
				} else {
					filePaths = append(filePaths, matches...)
				}
			}

			processor.DirFilePaths = filePaths
			processor.Process()
		},
	}

	flags := rootCmd.PersistentFlags()

	flags.StringSliceVarP(
		&processor.Hash,
		"hash",
		"c",
		[]string{"md5", "sha1", "sha256", "sha512"},
		"hashes to be run for each file (set to 'all' for all possible hashes)",
	)
	flags.StringVarP(
		&processor.Format,
		"format",
		"f",
		"text",
		"set output format [text, json, sum, hashdeep, hashonly, sqlite]",
	)
	flags.StringVarP(
		&processor.AuditFile,
		"audit",
		"a",
		"",
		"audit against supplied file; audit file must be in hashdeep output format",
	)
	flags.BoolVarP(
		&processor.Recursive,
		"recursive",
		"r",
		false,
		"recursive subdirectories are traversed",
	)
	flags.BoolVar(
		&processor.Hashes,
		"hashes",
		false,
		"list all supported hashes",
	)
	flags.StringVarP(
		&processor.FileOutput,
		"output",
		"o",
		"",
		"output filename (default stdout)",
	)
	flags.BoolVar(
		&processor.NoStream,
		"no-stream",
		false,
		"do not stream out results as processed",
	)
	flags.Int64Var(
		&processor.StreamSize,
		"stream-size",
		1_000_000,
		"min size of file in bytes where stream processing starts",
	)
	flags.BoolVarP(
		&processor.Verbose,
		"verbose",
		"v",
		false,
		"verbose output",
	)
	flags.BoolVar(
		&processor.VeryVerbose,
		"vv",
		false,
		"very verbose output",
	)
	flags.BoolVarP(
		&processor.Progress,
		"progress",
		"p",
		false,
		"display progress of files as they are processed",
	)
	flags.BoolVar(
		&processor.Debug,
		"debug",
		false,
		"enable debug output",
	)
	flags.BoolVar(
		&processor.Trace,
		"trace",
		false,
		"enable trace output",
	)
	flags.IntVar(
		&processor.NoThreads,
		"threads",
		runtime.NumCPU(),
		"number of threads processing files, by default the number of CPU cores",
	)
	flags.BoolVar(
		&processor.MTime,
		"mtime",
		false,
		"enable mtime output",
	)
	flags.StringVarP(
		&processor.FileInput,
		"input",
		"i",
		"",
		"input file of newline seperated file locations to process",
	)

	flags.BoolVar(
		&processor.GitIgnore,
		"gitignore",
		false,
		"enable .gitignore file logic",
	)
	flags.BoolVar(
		&processor.GitModuleIgnore,
		"gitmodule",
		false,
		"enable .gitmodules file logic",
	)

	flags.BoolVar(
		&processor.SkipHidden,
		"skip-hidden",
		false, // Default to false, meaning hidden files are PROCESSED by default
		"skip hidden files and directories",
	)
	flags.StringSliceVar(
		&processor.PathDenyList,
		"exclude-dir",
		[]string{},
		"directories to exclude",
	)
	flags.BoolVar(
		&processor.Ignore,
		"ignore",
		false,
		"enable .ignore file logic",
	)
	flags.BoolVar(
		&processor.HashIgnore,
		"hashignore",
		false,
		"enable .hashignore file logic",
	)
	flags.StringArrayVarP(
		&processor.Exclude,
		"not-match",
		`M`,
		[]string{},
		"ignore files and directories matching regular expression",
	)

	if err := rootCmd.Execute(); err != nil {
		os.Exit(1)
	}
}