initial build

Signed-off-by: Fletcher Aksel <[email protected]>

Author: Fletcher Aksel

.gitignore

@@ -0,0 +1 @@
+/gettrackers

cmd/block.go

@@ -0,0 +1,34 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"gettrackers/internal/filter"
+
+	"github.com/spf13/cobra"
+)
+
+var blockCmd = &cobra.Command{
+	Use:   "block <pattern>",
+	Short: "Add a pattern to the blocklist",
+	Long:  `Adds a pattern to the blocklist. If the pattern already exists, it is skipped.`,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runBlock,
+}
+
+func init() {
+	rootCmd.AddCommand(blockCmd)
+}
+
+func runBlock(cmd *cobra.Command, args []string) error {
+	pattern := args[0]
+
+	if err := filter.AddToBlocklist(pattern); err != nil {
+		return fmt.Errorf("failed to add to blocklist: %w", err)
+	}
+
+	fmt.Fprintf(os.Stderr, "Added pattern to blocklist: %s\n", pattern)
+	return nil
+}
+

cmd/config.go

@@ -0,0 +1,109 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"gettrackers/internal/config"
+
+	"github.com/spf13/cobra"
+)
+
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "Manage configuration",
+	Long:  `Get or set configuration values.`,
+}
+
+var configGetCmd = &cobra.Command{
+	Use:   "get [key]",
+	Short: "Show config values",
+	Long:  `Show all config values if no key is specified, or a specific value if key is given.`,
+	Args:  cobra.MaximumNArgs(1),
+	RunE:  runConfigGet,
+}
+
+var configSetCmd = &cobra.Command{
+	Use:   "set <key> <value>",
+	Short: "Set a config value",
+	Long:  `Set a configuration value. For source_urls, provide comma-separated URLs.`,
+	Args:  cobra.ExactArgs(2),
+	RunE:  runConfigSet,
+}
+
+func init() {
+	rootCmd.AddCommand(configCmd)
+	configCmd.AddCommand(configGetCmd)
+	configCmd.AddCommand(configSetCmd)
+}
+
+func runConfigGet(cmd *cobra.Command, args []string) error {
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	if len(args) == 0 {
+		// Show all config
+		fmt.Printf("source_urls:\n")
+		for _, url := range cfg.SourceURLs {
+			fmt.Printf("  - %s\n", url)
+		}
+		return nil
+	}
+
+	// Show specific key
+	key := args[0]
+	value, err := cfg.Get(key)
+	if err != nil {
+		return err
+	}
+
+	switch v := value.(type) {
+	case []string:
+		for _, item := range v {
+			fmt.Println(item)
+		}
+	default:
+		fmt.Println(value)
+	}
+
+	return nil
+}
+
+func runConfigSet(cmd *cobra.Command, args []string) error {
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	key := args[0]
+	valueStr := args[1]
+
+	var value interface{}
+	switch key {
+	case "source_urls":
+		// Split by comma and trim spaces
+		urls := strings.Split(valueStr, ",")
+		trimmed := make([]string, 0, len(urls))
+		for _, url := range urls {
+			trimmed = append(trimmed, strings.TrimSpace(url))
+		}
+		value = trimmed
+	default:
+		value = valueStr
+	}
+
+	if err := cfg.Set(key, value); err != nil {
+		return err
+	}
+
+	if err := cfg.Save(); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+
+	fmt.Fprintf(os.Stderr, "Set %s = %v\n", key, value)
+	return nil
+}
+

cmd/fetch.go

@@ -0,0 +1,39 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"gettrackers/internal/config"
+	"gettrackers/internal/fetch"
+
+	"github.com/spf13/cobra"
+)
+
+var fetchCmd = &cobra.Command{
+	Use:   "fetch",
+	Short: "Force download/update the cached sources file",
+	Long:  `Downloads tracker URLs from configured sources and updates the cache file.`,
+	RunE:  runFetch,
+}
+
+func init() {
+	rootCmd.AddCommand(fetchCmd)
+}
+
+func runFetch(cmd *cobra.Command, args []string) error {
+	// Load config
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	// Force fetch
+	if err := fetch.Fetch(cfg.SourceURLs); err != nil {
+		return fmt.Errorf("failed to fetch: %w", err)
+	}
+
+	fmt.Fprintf(os.Stderr, "Successfully updated cache\n")
+	return nil
+}
+

cmd/groups.go

@@ -0,0 +1,103 @@
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"gettrackers/internal/config"
+	"gettrackers/internal/fetch"
+	"gettrackers/internal/filter"
+	"gettrackers/internal/group"
+
+	"github.com/spf13/cobra"
+)
+
+var groupsCmd = &cobra.Command{
+	Use:   "groups",
+	Short: "Output grouped tracker URLs (default command)",
+	Long:  `Downloads, filters, and outputs tracker URLs grouped by domain in random order.`,
+	RunE:  runGroups,
+}
+
+func init() {
+	rootCmd.AddCommand(groupsCmd)
+}
+
+func runGroups(cmd *cobra.Command, args []string) error {
+	// Load config
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	// Check if we need to fetch
+	shouldFetch, err := fetch.ShouldFetch(false)
+	if err != nil {
+		return fmt.Errorf("failed to check cache: %w", err)
+	}
+
+	if shouldFetch {
+		if err := fetch.Fetch(cfg.SourceURLs); err != nil {
+			// Try to use stale cache if available
+			fmt.Fprintf(os.Stderr, "Warning: failed to fetch new data: %v\n", err)
+			fmt.Fprintf(os.Stderr, "Attempting to use stale cache...\n")
+		}
+	}
+
+	// Load cache
+	urls, err := fetch.LoadCache()
+	if err != nil {
+		return fmt.Errorf("failed to load cache: %w", err)
+	}
+
+	// Load blocklist
+	blocklist, err := filter.LoadBlocklist()
+	if err != nil {
+		return fmt.Errorf("failed to load blocklist: %w", err)
+	}
+
+	// Filter URLs
+	filtered := filter.Filter(urls, blocklist)
+
+	if len(filtered) == 0 {
+		if len(urls) > 0 {
+			fmt.Fprintf(os.Stderr, "all urls blocked\n")
+		}
+		return nil
+	}
+
+	// Group by domain
+	groups := group.GroupByDomain(filtered)
+
+	// Get output writer
+	writer, err := getOutputWriter()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if writer != os.Stdout {
+			writer.Close()
+		}
+	}()
+
+	// Output groups
+	return outputGroups(writer, groups)
+}
+
+func outputGroups(writer io.Writer, groups []group.Group) error {
+	for i, g := range groups {
+		if i > 0 {
+			if _, err := fmt.Fprintln(writer); err != nil {
+				return err
+			}
+		}
+		for _, url := range g.URLs {
+			if _, err := fmt.Fprintln(writer, url); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+

cmd/root.go

@@ -0,0 +1,39 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "gettrackers",
+	Short: "Download, filter, and output tracker URLs grouped by domain",
+	Long:  `gettrackers is a CLI tool that downloads tracker URLs from configurable sources, filters them using a blocklist, and outputs them grouped by domain.`,
+	RunE:  runGroups,
+}
+
+var outputFile string
+
+func init() {
+	rootCmd.PersistentFlags().StringVarP(&outputFile, "output", "o", "", "Write output to file instead of stdout")
+}
+
+// Execute runs the root command
+func Execute() error {
+	return rootCmd.Execute()
+}
+
+// getOutputWriter returns the appropriate writer for output
+func getOutputWriter() (*os.File, error) {
+	if outputFile != "" {
+		file, err := os.Create(outputFile)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create output file: %w", err)
+		}
+		return file, nil
+	}
+	return os.Stdout, nil
+}
+

cmd/show.go

@@ -0,0 +1,67 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"gettrackers/internal/fetch"
+	"gettrackers/internal/filter"
+
+	"github.com/spf13/cobra"
+)
+
+var showCmd = &cobra.Command{
+	Use:   "show",
+	Short: "Show cached sources or blocklist",
+	Long:  `Display the cached source URLs or blocklist entries.`,
+}
+
+var showSourcesCmd = &cobra.Command{
+	Use:   "sources",
+	Short: "Display the cached source URLs",
+	RunE:  runShowSources,
+}
+
+var showBlocklistCmd = &cobra.Command{
+	Use:   "blocklist",
+	Short: "Display blocklist entries",
+	RunE:  runShowBlocklist,
+}
+
+func init() {
+	rootCmd.AddCommand(showCmd)
+	showCmd.AddCommand(showSourcesCmd)
+	showCmd.AddCommand(showBlocklistCmd)
+}
+
+func runShowSources(cmd *cobra.Command, args []string) error {
+	urls, err := fetch.LoadCache()
+	if err != nil {
+		return fmt.Errorf("failed to load cache: %w", err)
+	}
+
+	for _, url := range urls {
+		fmt.Println(url)
+	}
+
+	return nil
+}
+
+func runShowBlocklist(cmd *cobra.Command, args []string) error {
+	blocklist, err := filter.LoadBlocklist()
+	if err != nil {
+		return fmt.Errorf("failed to load blocklist: %w", err)
+	}
+
+	if len(blocklist) == 0 {
+		fmt.Fprintf(os.Stderr, "Blocklist is empty\n")
+		return nil
+	}
+
+	for _, pattern := range blocklist {
+		fmt.Println(pattern)
+	}
+
+	return nil
+}
+