initial

Author: Andrei

cmd/autostart.go

@@ -0,0 +1,55 @@
+package cmd
+
+import (
+    "fmt"
+    "os"
+    "os/exec"
+    "path/filepath"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var autostartCmd = &cobra.Command{
+    Use:   "autostart",
+    Short: "Manage launch-at-login (launchd) autostart for guardian",
+}
+
+var autostartEnableCmd = &cobra.Command{
+    Use:   "enable",
+    Short: "Enable autostart (install launch agent and load it)",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        plist := supervisor.GenerateLaunchdPlist()
+        home, _ := os.UserHomeDir()
+        plistDir := filepath.Join(home, "Library", "LaunchAgents")
+        if err := os.MkdirAll(plistDir, 0755); err != nil {
+            return fmt.Errorf("failed to make launchagents dir: %w", err)
+        }
+        plistPath := filepath.Join(plistDir, "com.gitguardian.agent.plist")
+        if err := os.WriteFile(plistPath, []byte(plist), 0644); err != nil {
+            return fmt.Errorf("failed to write plist: %w", err)
+        }
+        exec.Command("launchctl", "load", plistPath).Run()
+        fmt.Println("Autostart enabled. Plist:", plistPath)
+        return nil
+    },
+}
+
+var autostartDisableCmd = &cobra.Command{
+    Use:   "disable",
+    Short: "Disable autostart (unload and remove launch agent)",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        home, _ := os.UserHomeDir()
+        plistPath := filepath.Join(home, "Library", "LaunchAgents", "com.gitguardian.agent.plist")
+        exec.Command("launchctl", "unload", plistPath).Run()
+        os.Remove(plistPath)
+        fmt.Println("Autostart disabled. Removed:", plistPath)
+        return nil
+    },
+}
+
+func init() {
+    autostartCmd.AddCommand(autostartEnableCmd)
+    autostartCmd.AddCommand(autostartDisableCmd)
+    rootCmd.AddCommand(autostartCmd)
+}

cmd/daemon.go

@@ -0,0 +1,20 @@
+package cmd
+
+import (
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var daemonCmd = &cobra.Command{
+    Use:    "daemon",
+    Hidden: true,
+    Short:  "Internal: start daemon (used by launchd)",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        supervisor.StartAllBlocking()
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(daemonCmd)
+}

cmd/init.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+    "bufio"
+    "fmt"
+    "os"
+    "os/exec"
+    "strings"
+
+    "github.com/spf13/cobra"
+)
+
+var initCmd = &cobra.Command{
+    Use:   "init",
+    Short: "Create a new GitHub repository using the GitHub CLI (`gh`) and initialize locally",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        rd := bufio.NewReader(os.Stdin)
+
+        fmt.Print("Repository name (user/repo or repo): ")
+        name, _ := rd.ReadString('\n')
+        name = strings.TrimSpace(name)
+
+        fmt.Print("Private? (y/N): ")
+        privRaw, _ := rd.ReadString('\n')
+        priv := strings.ToLower(strings.TrimSpace(privRaw)) == "y"
+
+        flag := "--public"
+        if priv {
+            flag = "--private"
+        }
+
+        create := exec.Command("gh", "repo", "create", name, flag, "--confirm")
+        create.Stdout = os.Stdout
+        create.Stderr = os.Stderr
+        if err := create.Run(); err != nil {
+            return fmt.Errorf("failed to create repo via gh: %w", err)
+        }
+
+        fmt.Println("Created GitHub repo:", name)
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(initCmd)
+}

cmd/link.go

@@ -0,0 +1,37 @@
+package cmd
+
+import (
+    "fmt"
+    "os"
+
+    "github.com/google/uuid"
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/state"
+)
+
+var linkCmd = &cobra.Command{
+    Use:   "link <folder>",
+    Args:  cobra.ExactArgs(1),
+    Short: "Link an existing folder to guardian (adds it to persistent state, initially paused)",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        folder := args[0]
+        if _, err := os.Stat(folder); os.IsNotExist(err) {
+            return fmt.Errorf("folder does not exist: %s", folder)
+        }
+
+        w := state.WatcherState{
+            ID:     uuid.NewString()[:8],
+            Folder: folder,
+            Mode:   "none",
+            Paused: true,
+        }
+        state.Append(w)
+        fmt.Println("Linked folder (paused):", folder, "id:", w.ID)
+        fmt.Println("Run `guardian start <folder> --watch` or `--interval <duration>` to enable.")
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(linkCmd)
+}

cmd/listeners.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+    "fmt"
+    "strings"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var listenersCmd = &cobra.Command{
+    Use:   "listeners",
+    Short: "List all configured watchers",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        list := supervisor.List()
+        fmt.Printf("\n%-8s %-10s %-45s %-10s %-25s\n", "ID", "Mode", "Folder", "Status", "LastRun")
+        fmt.Println(strings.Repeat("-", 110))
+        for _, w := range list {
+            status := "paused"
+            if !w.Paused {
+                status = "running"
+            }
+            fmt.Printf("%-8s %-10s %-45s %-10s %-25s\n", w.ID, w.Mode, w.Folder, status, w.LastRun)
+        }
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(listenersCmd)
+}

cmd/pause.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+    "fmt"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var pauseCmd = &cobra.Command{
+    Use:   "pause <id>",
+    Args:  cobra.ExactArgs(1),
+    Short: "Pause a running watcher by id",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        id := args[0]
+        if err := supervisor.Pause(id); err != nil {
+            return fmt.Errorf("pause failed: %w", err)
+        }
+        fmt.Println("Paused:", id)
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(pauseCmd)
+}

cmd/remove.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+    "fmt"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var removeCmd = &cobra.Command{
+    Use:   "remove <id>",
+    Args:  cobra.ExactArgs(1),
+    Short: "Remove a watcher configuration and stop it",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        id := args[0]
+        if err := supervisor.Remove(id); err != nil {
+            return fmt.Errorf("remove failed: %w", err)
+        }
+        fmt.Println("Removed:", id)
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(removeCmd)
+}

cmd/resume.go

@@ -0,0 +1,26 @@
+package cmd
+
+import (
+    "fmt"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+)
+
+var resumeCmd = &cobra.Command{
+    Use:   "resume <id>",
+    Args:  cobra.ExactArgs(1),
+    Short: "Resume a paused watcher by id",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        id := args[0]
+        if err := supervisor.Resume(id); err != nil {
+            return fmt.Errorf("resume failed: %w", err)
+        }
+        fmt.Println("Resumed:", id)
+        return nil
+    },
+}
+
+func init() {
+    rootCmd.AddCommand(resumeCmd)
+}

cmd/root.go

@@ -0,0 +1,25 @@
+package cmd
+
+import (
+    "fmt"
+    "os"
+
+    "github.com/itzcodex24/git-guardian/internal/supervisor"
+    "github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+    Use:   "guardian",
+    Short: "Git Guardian — automatic git-backed folder watcher for macOS",
+    Long:  "Guardian watches folders, auto-commits and pushes changes to git/GitHub and runs as a macOS background agent.",
+}
+
+func Execute() {
+    // Load and start any configured watchers (fast startup).
+    supervisor.StartAll()
+
+    if err := rootCmd.Execute(); err != nil {
+        fmt.Println(err)
+        os.Exit(1)
+    }
+}

cmd/start.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+    "fmt"
+
+    "github.com/spf13/cobra"
+    "github.com/itzcodex24/git-guardian/internal/state"
+)
+
+var (
+    startInterval string
+    startDebounce string
+    startWatch    bool
+)
+
+var startCmd = &cobra.Command{
+    Use:   "start <folder>",
+    Args:  cobra.ExactArgs(1),
+    Short: "Start a watcher for a linked folder (watch mode or interval mode)",
+    RunE: func(cmd *cobra.Command, args []string) error {
+        folder := args[0]
+        list := state.Get()
+        for i := range list {
+            if list[i].Folder == folder {
+                if startWatch {
+                    list[i].Mode = "watch"
+                    list[i].Debounce = startDebounce
+                } else if startInterval != "" {
+                    list[i].Mode = "interval"
+                    list[i].Interval = startInterval
+                } else {
+                    return fmt.Errorf("must specify --watch or --interval <duration>")
+                }
+                list[i].Paused = false
+                state.Update(list)
+                fmt.Println("Watcher activated for:", folder)
+                return nil
+            }
+        }
+        return fmt.Errorf("folder not linked: %s. Use `guardian link` first", folder)
+    },
+}
+
+func init() {
+    startCmd.Flags().BoolVar(&startWatch, "watch", false, "Use file-change watch mode")
+    startCmd.Flags().StringVar(&startInterval, "interval", "", "Use interval mode, e.g. 5m")
+    startCmd.Flags().StringVar(&startDebounce, "debounce", "30s", "Debounce duration for watch mode")
+    rootCmd.AddCommand(startCmd)
+}