Separate program entry point from commands

1 files changed, 0 insertions, 181 deletions

diff --git a/cmd/atlas.go b/cmd/atlas.go
deleted file mode 100644
index 422218b..0000000
--- a/cmd/atlas.go
+++ /dev/null
@@ -1,181 +0,0 @@
-package main
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"io/fs"
-	"log/slog"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/adrg/xdg"
-	"github.com/jpappel/atlas/pkg/data"
-	"github.com/jpappel/atlas/pkg/query"
-	"github.com/jpappel/atlas/pkg/shell"
-)
-
-const VERSION = "0.0.1"
-const ExitCommand = 2 // exit because of a command parsing error
-
-type GlobalFlags struct {
-	IndexRoot  string
-	DBPath     string
-	LogLevel   string
-	LogJson    bool
-	NumWorkers uint
-	DateFormat string
-}
-
-func addGlobalFlagUsage(fs *flag.FlagSet) func() {
-	return func() {
-		f := fs.Output()
-		fmt.Fprintln(f, "Usage of", fs.Name())
-		fs.PrintDefaults()
-		fmt.Fprintln(f, "\nGlobal Flags:")
-		flag.PrintDefaults()
-	}
-}
-
-func printHelp() {
-	fmt.Println("atlas is a note indexing and querying tool")
-	fmt.Printf("\nUsage:\n  %s [global-flags] <command>\n\n", os.Args[0])
-	fmt.Println("Commands:")
-	fmt.Println("  index  - build, update, or modify an index")
-	fmt.Println("  query  - search against an index")
-	fmt.Println("  shell  - start a debug shell")
-	fmt.Println("  server - start an http query server (EXPERIMENTAL)")
-	fmt.Println("  help   - print this help then exit")
-}
-
-func main() {
-	home, _ := os.UserHomeDir()
-	dataHome := xdg.DataHome
-	if dataHome == "" {
-		dataHome = strings.Join([]string{home, ".local", "share"}, string(os.PathSeparator))
-	}
-	dataHome += string(os.PathSeparator) + "atlas"
-	if err := os.Mkdir(dataHome, 0755); errors.Is(err, fs.ErrExist) {
-	} else if err != nil {
-		panic(err)
-	}
-
-	globalFlags := GlobalFlags{}
-	flag.StringVar(&globalFlags.IndexRoot, "root", xdg.UserDirs.Documents, "root `directory` for indexing")
-	flag.StringVar(&globalFlags.DBPath, "db", dataHome+string(os.PathSeparator)+"default.db", "`path` to document database")
-	flag.StringVar(&globalFlags.LogLevel, "logLevel", "error", "set log `level` (debug, info, warn, error)")
-	flag.BoolVar(&globalFlags.LogJson, "logJson", false, "log to json")
-	flag.UintVar(&globalFlags.NumWorkers, "numWorkers", uint(runtime.NumCPU()), "number of worker threads to use (defaults to core count)")
-	flag.StringVar(&globalFlags.DateFormat, "dateFormat", time.RFC3339, "format for dates (see https://pkg.go.dev/time#Layout for more details)")
-
-	indexFs := flag.NewFlagSet("index", flag.ExitOnError)
-	queryFs := flag.NewFlagSet("query", flag.ExitOnError)
-	shellFs := flag.NewFlagSet("debug", flag.ExitOnError)
-	serverFs := flag.NewFlagSet("server", flag.ExitOnError)
-
-	indexFs.Usage = addGlobalFlagUsage(indexFs)
-	queryFs.Usage = addGlobalFlagUsage(queryFs)
-	shellFs.Usage = addGlobalFlagUsage(shellFs)
-	serverFs.Usage = addGlobalFlagUsage(serverFs)
-
-	flag.Parse()
-	args := flag.Args()
-
-	queryFlags := QueryFlags{Outputer: query.DefaultOutput{}}
-	indexFlags := IndexFlags{}
-	serverFlags := ServerFlags{Port: 8080}
-
-	if len(args) < 1 {
-		fmt.Fprintln(os.Stderr, "No Command provided")
-		printHelp()
-		fmt.Fprintln(flag.CommandLine.Output(), "\nGlobal Flags:")
-		flag.PrintDefaults()
-		os.Exit(ExitCommand)
-	}
-	command := args[0]
-
-	switch command {
-	case "query", "q":
-		setupQueryFlags(args[1:], queryFs, &queryFlags, globalFlags.DateFormat)
-	case "index":
-		setupIndexFlags(args[1:], indexFs, &indexFlags)
-	case "server":
-		setupServerFlags(args[1:], serverFs, &serverFlags)
-	case "help":
-		printHelp()
-		flag.PrintDefaults()
-		return
-	case "shell":
-		shellFs.Parse(args[1:])
-	default:
-		fmt.Fprintln(os.Stderr, "Unrecognized command: ", command)
-		printHelp()
-		os.Exit(ExitCommand)
-	}
-
-	slogLevel := &slog.LevelVar{}
-	loggerOpts := &slog.HandlerOptions{Level: slogLevel}
-	switch globalFlags.LogLevel {
-	case "debug":
-		slogLevel.Set(slog.LevelDebug)
-		loggerOpts.AddSource = true
-	case "info":
-		slogLevel.Set(slog.LevelInfo)
-	case "warn":
-		slogLevel.Set(slog.LevelWarn)
-	case "error":
-		slogLevel.Set(slog.LevelError)
-	default:
-		fmt.Fprintln(os.Stderr, "Unrecognized log level:", globalFlags.LogLevel)
-		os.Exit(ExitCommand)
-	}
-	var logHandler slog.Handler
-	if globalFlags.LogJson {
-		logHandler = slog.NewJSONHandler(os.Stderr, loggerOpts)
-	} else {
-		// strip time
-		loggerOpts.ReplaceAttr = func(groups []string, a slog.Attr) slog.Attr {
-			if a.Key == slog.TimeKey && len(groups) == 0 {
-				return slog.Attr{}
-			}
-			return a
-		}
-		logHandler = slog.NewTextHandler(os.Stderr, loggerOpts)
-	}
-	logger := slog.New(logHandler)
-	slog.SetDefault(logger)
-
-	querier := data.NewQuery(globalFlags.DBPath)
-
-	// command specific
-	var exitCode int
-	switch command {
-	case "query", "q":
-		searchQuery := strings.Join(queryFs.Args(), " ")
-		exitCode = int(runQuery(globalFlags, queryFlags, querier, searchQuery))
-	case "index":
-		exitCode = int(runIndex(globalFlags, indexFlags, querier))
-	case "server":
-		exitCode = int(runServer(serverFlags, querier))
-	case "shell":
-		state := make(shell.State)
-		env := make(map[string]string)
-
-		env["workers"] = fmt.Sprint(globalFlags.NumWorkers)
-		env["db_path"] = globalFlags.DBPath
-		env["index_root"] = globalFlags.IndexRoot
-		env["version"] = VERSION
-
-		interpreter := shell.NewInterpreter(state, env, globalFlags.NumWorkers, querier)
-		if err := interpreter.Run(); err != nil && err != io.EOF {
-			slog.Error("Fatal error occured", slog.String("err", err.Error()))
-			exitCode = 1
-		}
-	}
-
-	querier.Close()
-	os.Exit(exitCode)
-}