commands: Make the hugo command non-global

See #4598

23 files changed, 292 insertions, 329 deletions

diff --git a/commands/benchmark.go b/commands/benchmark.go
index ae5d436e8..b1291cc45 100644
--- a/commands/benchmark.go
+++ b/commands/benchmark.go
@@ -23,22 +23,12 @@ import (
 	jww "github.com/spf13/jwalterweatherman"
 )
 
-var _ cmder = (*benchmarkCmd)(nil)
-
 type benchmarkCmd struct {
 	benchmarkTimes int
 	cpuProfileFile string
 	memProfileFile string
 
-	cmd *cobra.Command
-}
-
-type cmder interface {
-	getCommand() *cobra.Command
-}
-
-func (c *benchmarkCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseBuilderCmd
 }
 
 func newBenchmarkCmd() *benchmarkCmd {
@@ -49,15 +39,14 @@ func newBenchmarkCmd() *benchmarkCmd {
 creating a benchmark.`,
 	}
 
-	initHugoBuilderFlags(cmd)
-	initBenchmarkBuildingFlags(cmd)
-
-	c := &benchmarkCmd{cmd: cmd}
+	c := &benchmarkCmd{baseBuilderCmd: newBuilderCmd(cmd)}
 
 	cmd.Flags().StringVar(&c.cpuProfileFile, "cpuprofile", "", "path/filename for the CPU profile file")
 	cmd.Flags().StringVar(&c.memProfileFile, "memprofile", "", "path/filename for the memory profile file")
 	cmd.Flags().IntVarP(&c.benchmarkTimes, "count", "n", 13, "number of times to build the site")
 
+	cmd.Flags().Bool("renderToMemory", false, "render to memory (only useful for benchmark testing)")
+
 	cmd.RunE = c.benchmark
 
 	return c
@@ -67,7 +56,7 @@ func (c *benchmarkCmd) benchmark(cmd *cobra.Command, args []string) error {
 	cfgInit := func(c *commandeer) error {
 		return nil
 	}
-	comm, err := InitializeConfig(false, cfgInit, c.cmd)
+	comm, err := initializeConfig(false, &c.hugoBuilderCommon, c, cfgInit)
 	if err != nil {
 		return err
 	}
diff --git a/commands/check.go b/commands/check.go
index 5812bb6aa..f20a18b02 100644
--- a/commands/check.go
+++ b/commands/check.go
@@ -20,17 +20,13 @@ import (
 var _ cmder = (*checkCmd)(nil)
 
 type checkCmd struct {
-	cmd *cobra.Command
+	*baseCmd
 }
 
 func newCheckCmd() *checkCmd {
-	return &checkCmd{cmd: &cobra.Command{
+	return &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
 		Use:   "check",
 		Short: "Contains some verification checks",
 	},
-	}
-}
-
-func (c *checkCmd) getCommand() *cobra.Command {
-	return c.cmd
+	}}
 }
diff --git a/commands/commandeer.go b/commands/commandeer.go
index 7d053f249..4c8abd7d8 100644
--- a/commands/commandeer.go
+++ b/commands/commandeer.go
@@ -40,7 +40,8 @@ import (
 type commandeer struct {
 	*deps.DepsCfg
 
-	subCmdVs []*cobra.Command
+	h             *hugoBuilderCommon
+	ftch flagsToConfigHandler
 
 	pathSpec    *helpers.PathSpec
 	visitedURLs *types.EvictingStringQueue
@@ -96,7 +97,7 @@ func (c *commandeer) initFs(fs *hugofs.Fs) error {
 	return nil
 }
 
-func newCommandeer(running bool, doWithCommandeer func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
+func newCommandeer(running bool, h *hugoBuilderCommon, f flagsToConfigHandler, doWithCommandeer func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
 
 	var rebuildDebouncer func(f func())
 	if running {
@@ -107,8 +108,9 @@ func newCommandeer(running bool, doWithCommandeer func(c *commandeer) error, sub
 	}
 
 	c := &commandeer{
+		h:                h,
+		ftch:    f,
 		doWithCommandeer: doWithCommandeer,
-		subCmdVs:         append([]*cobra.Command{hugoCmdV}, subCmdVs...),
 		visitedURLs:      types.NewEvictingStringQueue(10),
 		debounce:         rebuildDebouncer,
 	}
@@ -127,8 +129,8 @@ func (c *commandeer) loadConfig(running bool) error {
 	cfg.Running = running
 
 	var dir string
-	if source != "" {
-		dir, _ = filepath.Abs(source)
+	if c.h.source != "" {
+		dir, _ = filepath.Abs(c.h.source)
 	} else {
 		dir, _ = os.Getwd()
 	}
@@ -139,8 +141,9 @@ func (c *commandeer) loadConfig(running bool) error {
 	}
 
 	doWithConfig := func(cfg config.Provider) error {
-		for _, cmdV := range c.subCmdVs {
-			initializeFlags(cmdV, cfg)
+
+		if c.ftch != nil {
+			c.ftch.flagsToConfig(cfg)
 		}
 
 		cfg.Set("workingDir", dir)
@@ -158,7 +161,7 @@ func (c *commandeer) loadConfig(running bool) error {
 	}
 
 	config, configFiles, err := hugolib.LoadConfig(
-		hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: source, WorkingDir: dir, Filename: cfgFile},
+		hugolib.ConfigSourceDescriptor{Fs: sourceFs, Path: c.h.source, WorkingDir: dir, Filename: c.h.cfgFile},
 		doWithCommandeer,
 		doWithConfig)
 
@@ -181,7 +184,7 @@ func (c *commandeer) loadConfig(running bool) error {
 		}
 	}
 
-	logger, err := createLogger(config)
+	logger, err := c.createLogger(config)
 	if err != nil {
 		return err
 	}
diff --git a/commands/convert.go b/commands/convert.go
index cc07fe087..9e0a66026 100644
--- a/commands/convert.go
+++ b/commands/convert.go
@@ -32,31 +32,34 @@ var (
 	_ cmder = (*convertCmd)(nil)
 )
 
+// TODO(bep) cli refactor
 var outputDir string
 var unsafe bool
 
 type convertCmd struct {
-	cmd *cobra.Command
+	*baseBuilderCmd
 }
 
 func newConvertCmd() *convertCmd {
-	cmd := &cobra.Command{
+	cc := &convertCmd{}
+
+	cc.baseBuilderCmd = newBuilderCmd(&cobra.Command{
 		Use:   "convert",
 		Short: "Convert your content to different formats",
 		Long: `Convert your content (e.g. front matter) to different formats.
 
 See convert's subcommands toJSON, toTOML and toYAML for more information.`,
 		RunE: nil,
-	}
+	})
 
-	cmd.AddCommand(
+	cc.cmd.AddCommand(
 		&cobra.Command{
 			Use:   "toJSON",
 			Short: "Convert front matter to JSON",
 			Long: `toJSON converts all front matter in the content directory
 to use JSON for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return convertContents(rune([]byte(parser.JSONLead)[0]))
+				return cc.convertContents(rune([]byte(parser.JSONLead)[0]))
 			},
 		},
 		&cobra.Command{
@@ -65,7 +68,7 @@ to use JSON for the front matter.`,
 			Long: `toTOML converts all front matter in the content directory
 to use TOML for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return convertContents(rune([]byte(parser.TOMLLead)[0]))
+				return cc.convertContents(rune([]byte(parser.TOMLLead)[0]))
 			},
 		},
 		&cobra.Command{
@@ -74,29 +77,26 @@ to use TOML for the front matter.`,
 			Long: `toYAML converts all front matter in the content directory
 to use YAML for the front matter.`,
 			RunE: func(cmd *cobra.Command, args []string) error {
-				return convertContents(rune([]byte(parser.YAMLLead)[0]))
+				return cc.convertContents(rune([]byte(parser.YAMLLead)[0]))
 			},
 		},
 	)
 
-	cmd.PersistentFlags().StringVarP(&outputDir, "output", "o", "", "filesystem path to write files to")
-	cmd.PersistentFlags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
-	cmd.PersistentFlags().BoolVar(&unsafe, "unsafe", false, "enable less safe operations, please backup first")
-	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
-
-	return &convertCmd{cmd: cmd}
-}
+	// TODO(bep) cli refactor
+	//	cmd.PersistentFlags().StringVarP(&outputDir, "output", "o", "", "filesystem path to write files to")
+	//	cmd.PersistentFlags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
+	//	cmd.PersistentFlags().BoolVar(&unsafe, "unsafe", false, "enable less safe operations, please backup first")
+	cc.cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
 
-func (c *convertCmd) getCommand() *cobra.Command {
-	return c.cmd
+	return cc
 }
 
-func convertContents(mark rune) error {
+func (cc *convertCmd) convertContents(mark rune) error {
 	if outputDir == "" && !unsafe {
 		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
 	}
 
-	c, err := InitializeConfig(false, nil)
+	c, err := initializeConfig(false, &cc.hugoBuilderCommon, cc, nil)
 	if err != nil {
 		return err
 	}
diff --git a/commands/env.go b/commands/env.go
index 700cddf5a..76c16b93b 100644
--- a/commands/env.go
+++ b/commands/env.go
@@ -23,15 +23,11 @@ import (
 var _ cmder = (*envCmd)(nil)
 
 type envCmd struct {
-	cmd *cobra.Command
-}
-
-func (c *envCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func newEnvCmd() *envCmd {
-	return &envCmd{cmd: &cobra.Command{
+	return &envCmd{baseCmd: newBaseCmd(&cobra.Command{
 		Use:   "env",
 		Short: "Print Hugo version and environment info",
 		Long:  `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
@@ -43,6 +39,6 @@ func newEnvCmd() *envCmd {
 
 			return nil
 		},
-	},
+	}),
 	}
 }
diff --git a/commands/gen.go b/commands/gen.go
index c22d8f8b0..6878cfe70 100644
--- a/commands/gen.go
+++ b/commands/gen.go
@@ -20,19 +20,15 @@ import (
 var _ cmder = (*genCmd)(nil)
 
 type genCmd struct {
-	cmd *cobra.Command
-}
-
-func (c *genCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func newGenCmd() *genCmd {
 	cc := &genCmd{}
-	cc.cmd = &cobra.Command{
+	cc.baseCmd = newBaseCmd(&cobra.Command{
 		Use:   "gen",
 		Short: "A collection of several useful generators.",
-	}
+	})
 
 	cc.cmd.AddCommand(
 		newGenautocompleteCmd().getCommand(),
diff --git a/commands/genautocomplete.go b/commands/genautocomplete.go
index 245635454..b0b98abb4 100644
--- a/commands/genautocomplete.go
+++ b/commands/genautocomplete.go
@@ -26,17 +26,13 @@ type genautocompleteCmd struct {
 	// bash for now (zsh and others will come)
 	autocompleteType string
 
-	cmd *cobra.Command
-}
-
-func (c *genautocompleteCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func newGenautocompleteCmd() *genautocompleteCmd {
 	cc := &genautocompleteCmd{}
 
-	cc.cmd = &cobra.Command{
+	cc.baseCmd = newBaseCmd(&cobra.Command{
 		Use:   "autocomplete",
 		Short: "Generate shell autocompletion script for Hugo",
 		Long: `Generates a shell autocompletion script for Hugo.
@@ -72,7 +68,7 @@ or just source them in directly:
 
 			return nil
 		},
-	}
+	})
 
 	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteTarget, "completionfile", "", "/etc/bash_completion.d/hugo.sh", "autocompletion file")
 	cc.cmd.PersistentFlags().StringVarP(&cc.autocompleteType, "type", "", "bash", "autocompletion type (currently only bash supported)")
diff --git a/commands/genchromastyles.go b/commands/genchromastyles.go
index 6d7b8b5cb..a2231e56e 100644
--- a/commands/genchromastyles.go
+++ b/commands/genchromastyles.go
@@ -30,23 +30,19 @@ type genChromaStyles struct {
 	style          string
 	highlightStyle string
 	linesStyle     string
-	cmd            *cobra.Command
-}
-
-func (c *genChromaStyles) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 // TODO(bep) highlight
 func createGenChromaStyles() *genChromaStyles {
 	g := &genChromaStyles{
-		cmd: &cobra.Command{
+		baseCmd: newBaseCmd(&cobra.Command{
 			Use:   "chromastyles",
 			Short: "Generate CSS stylesheet for the Chroma code highlighter",
 			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if pygmentsUseClasses is enabled in config.
 
 See https://help.farbox.com/pygments.html for preview of available styles`,
-		},
+		}),
 	}
 
 	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
diff --git a/commands/gendoc.go b/commands/gendoc.go
index 8c46fe98c..3446c2622 100644
--- a/commands/gendoc.go
+++ b/commands/gendoc.go
@@ -31,11 +31,7 @@ var _ cmder = (*genDocCmd)(nil)
 
 type genDocCmd struct {
 	gendocdir string
-	cmd       *cobra.Command
-}
-
-func (c *genDocCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func newGenDocCmd() *genDocCmd {
@@ -49,7 +45,7 @@ url: %s
 
 	cc := &genDocCmd{}
 
-	cc.cmd = &cobra.Command{
+	cc.baseCmd = newBaseCmd(&cobra.Command{
 		Use:   "doc",
 		Short: "Generate Markdown documentation for the Hugo CLI.",
 		Long: `Generate Markdown documentation for the Hugo CLI.
@@ -89,7 +85,7 @@ for rendering in Hugo.`,
 
 			return nil
 		},
-	}
+	})
 
 	cc.cmd.PersistentFlags().StringVar(&cc.gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
 
diff --git a/commands/gendocshelper.go b/commands/gendocshelper.go
index e98bfde79..c243581f6 100644
--- a/commands/gendocshelper.go
+++ b/commands/gendocshelper.go
@@ -29,20 +29,16 @@ var (
 
 type genDocsHelper struct {
 	target string
-	cmd    *cobra.Command
-}
-
-func (c *genDocsHelper) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func createGenDocsHelper() *genDocsHelper {
 	g := &genDocsHelper{
-		cmd: &cobra.Command{
+		baseCmd: newBaseCmd(&cobra.Command{
 			Use:    "docshelper",
 			Short:  "Generate some data files for the Hugo docs.",
 			Hidden: true,
-		},
+		}),
 	}
 
 	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
diff --git a/commands/genman.go b/commands/genman.go
index fd9a49720..ac4eaf8d1 100644
--- a/commands/genman.go
+++ b/commands/genman.go
@@ -28,17 +28,13 @@ var _ cmder = (*genManCmd)(nil)
 
 type genManCmd struct {
 	genmandir string
-	cmd       *cobra.Command
-}
-
-func (c *genManCmd) getCommand() *cobra.Command {
-	return c.cmd
+	*baseCmd
 }
 
 func newGenManCmd() *genManCmd {
 	cc := &genManCmd{}
 
-	cc.cmd = &cobra.Command{
+	cc.baseCmd = newBaseCmd(&cobra.Command{
 		Use:   "man",
 		Short: "Generate man pages for the Hugo CLI",
 		Long: `This command automatically generates up-to-date man pages of Hugo's
@@ -69,7 +65,7 @@ in the "man" directory under the current directory.`,
 
 			return nil
 		},
-	}
+	})
 
 	cc.cmd.PersistentFlags().StringVar(&cc.genmandir, "dir", "man/", "the directory to write the man pages.")
 
diff --git a/commands/helpers.go b/commands/helpers.go
index 78e549d22..1386e425f 100644
--- a/commands/helpers.go
+++ b/commands/helpers.go
@@ -15,6 +15,14 @@
 // used by Hugo. Commands and flags are implemented using Cobra.
 package commands
 
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/spf13/cobra"
+)
+
 const (
 	ansiEsc    = "\u001B"
 	clearLine  = "\r\033[K"
@@ -22,6 +30,15 @@ const (
 	showCursor = ansiEsc + "[?25h"
 )
 
+type flagsToConfigHandler interface {
+	flagsToConfig(cfg config.Provider)
+}
+
+type cmder interface {
+	flagsToConfigHandler
+	getCommand() *cobra.Command
+}
+
 // commandError is an error used to signal different error situations in command handling.
 type commandError struct {
 	s         string
diff --git a/commands/hugo.go b/commands/hugo.go
index 3f468dd7d..1da764d93 100644
--- a/commands/hugo.go
+++ b/commands/hugo.go
@@ -39,8 +39,6 @@ import (
 	"github.com/gohugoio/hugo/parser"
 	flag "github.com/spf13/pflag"
 
-	"regexp"
-
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugolib"
@@ -54,137 +52,123 @@ import (
 	"github.com/spf13/nitro"
 )
 
-// Hugo represents the Hugo sites to build. This variable is exported as it
-// is used by at least one external library (the Hugo caddy plugin). We should
-// provide a cleaner external API, but until then, this is it.
-var Hugo *hugolib.HugoSites
-
-// Reset resets Hugo ready for a new full build. This is mainly only useful
-// for benchmark testing etc. via the CLI commands.
-func Reset() error {
-	Hugo = nil
-	return nil
+type baseCmd struct {
+	cmd *cobra.Command
 }
 
-// HugoCmd is Hugo's root command.
-// Every other command attached to HugoCmd is a child command to it.
-var HugoCmd = &cobra.Command{
-	Use:   "hugo",
-	Short: "hugo builds your site",
-	Long: `hugo is the main command, used to build your Hugo site.
-
-Hugo is a Fast and Flexible Static Site Generator
-built with love by spf13 and friends in Go.
-
-Complete documentation is available at http://gohugo.io/.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
-
-		cfgInit := func(c *commandeer) error {
-			if buildWatch {
-				c.Set("disableLiveReload", true)
-			}
-			return nil
-		}
+type baseBuilderCmd struct {
+	hugoBuilderCommon
+	*baseCmd
+}
 
-		c, err := InitializeConfig(buildWatch, cfgInit)
-		if err != nil {
-			return err
-		}
+func (c *baseCmd) getCommand() *cobra.Command {
+	return c.cmd
+}
 
-		return c.build()
-	},
+func newBaseCmd(cmd *cobra.Command) *baseCmd {
+	return &baseCmd{cmd: cmd}
 }
 
-var hugoCmdV *cobra.Command
+func newBuilderCmd(cmd *cobra.Command) *baseBuilderCmd {
+	bcmd := &baseBuilderCmd{baseCmd: &baseCmd{cmd: cmd}}
+	bcmd.hugoBuilderCommon.handleFlags(cmd)
+	return bcmd
+}
 
-type flagVals struct {
+// TODO(bep) cli refactor need root?
+func (c *baseCmd) flagsToConfig(cfg config.Provider) {
+	initializeFlags(c.cmd, cfg)
 }
 
-// Flags that are to be added to commands.
-var (
-	// TODO(bep) var vs string
-	buildWatch bool
-	logging    bool
-	verbose    bool
-	verboseLog bool
-	debug      bool
-	quiet      bool
-)
+type hugoCmd struct {
 
-var (
-	gc      bool
-	baseURL string
 	//cacheDir        string
 	//contentDir      string
 	//layoutDir       string
-	cfgFile string
 	//destination     string
-	logFile string
 	//theme           string
 	//themesDir       string
-	source string
 	//logI18nWarnings bool
 	//disableKinds []string
-)
 
-// Execute adds all child commands to the root command HugoCmd and sets flags appropriately.
-func Execute() {
-	HugoCmd.SetGlobalNormalizationFunc(helpers.NormalizeHugoFlags)
-
-	HugoCmd.SilenceUsage = true
+	*baseBuilderCmd
+}
 
-	AddCommands()
+func newHugoCmd() *hugoCmd {
+	cc := &hugoCmd{}
 
-	if c, err := HugoCmd.ExecuteC(); err != nil {
-		if isUserError(err) {
-			c.Println("")
-			c.Println(c.UsageString())
-		}
+	cc.baseBuilderCmd = newBuilderCmd(&cobra.Command{
+		Use:   "hugo",
+		Short: "hugo builds your site",
+		Long: `hugo is the main command, used to build your Hugo site.
 
-		os.Exit(-1)
-	}
-}
+Hugo is a Fast and Flexible Static Site Generator
+built with love by spf13 and friends in Go.
 
-// AddCommands adds child commands to the root command HugoCmd.
-func AddCommands() {
-	HugoCmd.AddCommand(newServerCmd().getCommand())
-	HugoCmd.AddCommand(newVersionCmd().getCommand())
-	HugoCmd.AddCommand(newEnvCmd().getCommand())
-	HugoCmd.AddCommand(newConfigCmd().getCommand())
-	HugoCmd.AddCommand(newCheckCmd().getCommand())
-	HugoCmd.AddCommand(newBenchmarkCmd().getCommand())
-	HugoCmd.AddCommand(newConvertCmd().getCommand())
-	HugoCmd.AddCommand(newNewCmd().getCommand())
-	HugoCmd.AddCommand(newListCmd().getCommand())
-	HugoCmd.AddCommand(newImportCmd().getCommand())
-
-	HugoCmd.AddCommand(newGenCmd().getCommand())
+Complete documentation is available at http://gohugo.io/.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfgInit := func(c *commandeer) error {
+				if cc.buildWatch {
+					c.Set("disableLiveReload", true)
+				}
+				return nil
+			}
 
-}
+			c, err := initializeConfig(cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
+			if err != nil {
+				return err
+			}
 
-// initHugoBuilderFlags initializes all common flags, typically used by the
-// core build commands, namely hugo itself, server, check and benchmark.
-func initHugoBuilderFlags(cmd *cobra.Command) {
-	initHugoBuildCommonFlags(cmd)
-}
+			return c.build()
+		},
+	})
 
-func initRootPersistentFlags() {
-	HugoCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
-	HugoCmd.PersistentFlags().BoolVar(&quiet, "quiet", false, "build in quiet mode")
+	cc.cmd.PersistentFlags().StringVar(&cc.cfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
+	cc.cmd.PersistentFlags().BoolVar(&cc.quiet, "quiet", false, "build in quiet mode")
 
 	// Set bash-completion
 	validConfigFilenames := []string{"json", "js", "yaml", "yml", "toml", "tml"}
-	_ = HugoCmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, validConfigFilenames)
+	_ = cc.cmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, validConfigFilenames)
+
+	cc.cmd.PersistentFlags().BoolVarP(&cc.verbose, "verbose", "v", false, "verbose output")
+	cc.cmd.PersistentFlags().BoolVarP(&cc.debug, "debug", "", false, "debug output")
+	cc.cmd.PersistentFlags().BoolVar(&cc.logging, "log", false, "enable Logging")
+	cc.cmd.PersistentFlags().StringVar(&cc.logFile, "logFile", "", "log File path (if set, logging enabled automatically)")
+	cc.cmd.PersistentFlags().BoolVar(&cc.verboseLog, "verboseLog", false, "verbose logging")
+
+	cc.cmd.Flags().BoolVarP(&cc.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
+
+	// Set bash-completion
+	_ = cc.cmd.PersistentFlags().SetAnnotation("logFile", cobra.BashCompFilenameExt, []string{})
+
+	return cc
+}
+
+type hugoBuilderCommon struct {
+	source  string
+	baseURL string
+
+	buildWatch bool
+
+	gc bool
+
+	// TODO(bep) var vs string
+	logging    bool
+	verbose    bool
+	verboseLog bool
+	debug      bool
+	quiet      bool
+
+	cfgFile string
+	logFile string
 }
 
-// initHugoBuildCommonFlags initialize common flags related to the Hugo build.
-// Called by initHugoBuilderFlags.
-func initHugoBuildCommonFlags(cmd *cobra.Command) {
+func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool("cleanDestinationDir", false, "remove files from destination not found in static directories")
 	cmd.Flags().BoolP("buildDrafts", "D", false, "include content marked as draft")
 	cmd.Flags().BoolP("buildFuture", "F", false, "include content with publishdate in the future")
 	cmd.Flags().BoolP("buildExpired", "E", false, "include expired content")
-	cmd.Flags().StringVarP(&source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.Flags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
 	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
 	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
 	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
@@ -194,9 +178,9 @@ func initHugoBuildCommonFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("themesDir", "", "", "filesystem path to themes directory")
 	cmd.Flags().Bool("uglyURLs", false, "(deprecated) if true, use /filename.html instead of /filename/")
 	cmd.Flags().Bool("canonifyURLs", false, "(deprecated) if true, all relative URLs will be canonicalized using baseURL")
-	cmd.Flags().StringVarP(&baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. http://spf13.com/")
+	cmd.Flags().StringVarP(&cc.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. http://spf13.com/")
 	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date and author info to the pages")
-	cmd.Flags().BoolVar(&gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
+	cmd.Flags().BoolVar(&cc.gc, "gc", false, "en