update git mono add command

Author: qdriven

CLAUDE.md

@@ -46,7 +46,8 @@ Spark is a Go CLI tool (`module spark`, binary `spark`) for managing multiple Gi
 
 ```
 spark
-├── git [update|create|sync|gitcode|config|url|batch-clone|update-org-status]
+├── git [update|mono|gitcode|config|url|batch-clone|update-org-status]
+│   └── mono [add|sync]
 ├── agent [list|view|edit|reset] + agent profile [list|add|edit]
 ├── task [list|init|dispatch|sync|create|delete|impl]
 ├── script [list|run]

cmd/git/create.go

@@ -11,8 +11,7 @@ var GitCmd = &cobra.Command{
 
 This includes:
 - update: Update multiple git repositories
-- create: Create a mono repo with submodules
-- sync: Sync submodules in a mono repo
+- mono: Mono repo management (add/sync submodules)
 - gitcode: Add Gitcode as remote
 - config: Configure git user for repository
 - url: Get repository remote URL

cmd/git/git.go

@@ -0,0 +1,19 @@
+package git
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var MonoCmd = &cobra.Command{
+	Use:   "mono",
+	Short: "Mono repo management commands",
+	Long: `Commands for managing mono repositories with git submodules.
+
+This includes:
+- add: Add existing git repos in current folder as submodules
+- sync: Sync all submodules to latest versions`,
+}
+
+func init() {
+	GitCmd.AddCommand(MonoCmd)
+}

cmd/git/mono.go

@@ -0,0 +1,54 @@
+package git
+
+import (
+	"fmt"
+	"spark/internal/mono"
+
+	"github.com/spf13/cobra"
+)
+
+var monoAddPath string
+
+var monoAddCmd = &cobra.Command{
+	Use:   "add [flags]",
+	Short: "Add existing git repos in current folder as submodules",
+	Long: `Add existing git repositories in the current folder as git submodules
+without re-cloning them. This converts the current folder into a mono repo.
+
+The command scans for git repositories in the specified directory and adds
+each one as a submodule, preserving the existing folder structure and content.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		targetDir := monoAddPath
+		if targetDir == "" {
+			targetDir = "."
+		}
+
+		repos, err := mono.FindSubRepos(targetDir)
+		if err != nil {
+			return fmt.Errorf("failed to scan for repos: %w", err)
+		}
+
+		if len(repos) == 0 {
+			fmt.Println("No git repositories found in the specified directory.")
+			return nil
+		}
+
+		fmt.Printf("Found %d git repository(s)\n", len(repos))
+		fmt.Println("Adding as submodules...")
+
+		if err := mono.AddExistingReposAsSubmodules(targetDir, repos); err != nil {
+			return fmt.Errorf("failed to add submodules: %w", err)
+		}
+
+		fmt.Println("\nSubmodules added successfully!")
+		fmt.Println("To commit: git commit -m \"Add submodules\"")
+		fmt.Println("To sync later: spark git mono sync .")
+
+		return nil
+	},
+}
+
+func init() {
+	MonoCmd.AddCommand(monoAddCmd)
+	monoAddCmd.Flags().StringVarP(&monoAddPath, "path", "p", "", "Directory containing git repos to add as submodules (default: current directory)")
+}

cmd/git/mono_add.go

@@ -27,5 +27,5 @@ var syncCmd = &cobra.Command{
 }
 
 func init() {
-	GitCmd.AddCommand(syncCmd)
+	MonoCmd.AddCommand(syncCmd)
 }

cmd/git/sync.go

@@ -0,0 +1,156 @@
+package mono
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"spark/internal/git"
+	"strings"
+)
+
+func AddExistingReposAsSubmodules(parentDir string, repoPaths []string) error {
+	absParent, err := filepath.Abs(parentDir)
+	if err != nil {
+		return fmt.Errorf("failed to resolve parent dir: %w", err)
+	}
+
+	if !git.IsGitRepository(absParent) {
+		fmt.Println("Initializing git repository...")
+		cmd := exec.Command("git", "init")
+		cmd.Dir = absParent
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("failed to init git repo: %w", err)
+		}
+	}
+
+	modulesBase := filepath.Join(absParent, ".git", "modules")
+	if err := os.MkdirAll(modulesBase, 0755); err != nil {
+		return fmt.Errorf("failed to create modules dir: %w", err)
+	}
+
+	gitmodulesPath := filepath.Join(absParent, ".gitmodules")
+
+	for _, repoPath := range repoPaths {
+		absRepo, err := filepath.Abs(repoPath)
+		if err != nil {
+			fmt.Printf("Warning: Could not resolve path %s: %v\n", repoPath, err)
+			continue
+		}
+
+		repoName := filepath.Base(absRepo)
+		remoteURL, err := git.GetRemoteURL(absRepo)
+		if err != nil {
+			fmt.Printf("Warning: Could not get remote URL for %s: %v\n", repoName, err)
+			continue
+		}
+
+		// Skip if already a submodule (.git is a file pointing to modules)
+		gitEntry := filepath.Join(absRepo, ".git")
+		if info, err := os.Lstat(gitEntry); err == nil && !info.IsDir() {
+			fmt.Printf("Skipping %s: already a submodule\n", repoName)
+			continue
+		}
+
+		fmt.Printf("Adding submodule: %s (%s)\n", repoName, remoteURL)
+
+		// Move .git directory to .git/modules/<name>
+		targetModuleDir := filepath.Join(modulesBase, repoName)
+		if _, err := os.Stat(targetModuleDir); err == nil {
+			fmt.Printf("Warning: Module dir already exists for %s, skipping\n", repoName)
+			continue
+		}
+
+		if err := os.Rename(gitEntry, targetModuleDir); err != nil {
+			fmt.Printf("Warning: Failed to move .git for %s: %v\n", repoName, err)
+			continue
+		}
+
+		// Create .git file pointing to modules dir
+		relPath := filepath.Join("..", ".git", "modules", repoName)
+		if err := os.WriteFile(gitEntry, []byte("gitdir: "+relPath+"\n"), 0644); err != nil {
+			fmt.Printf("Warning: Failed to create .git file for %s: %v\n", repoName, err)
+			// Try to restore
+			os.Rename(targetModuleDir, gitEntry)
+			continue
+		}
+
+		// Update core.worktree in the module config
+		setWorktreeCmd := exec.Command("git", "config", "--file",
+			filepath.Join(targetModuleDir, "config"),
+			"core.worktree", "../../../"+repoName)
+		setWorktreeCmd.Dir = absParent
+		if err := setWorktreeCmd.Run(); err != nil {
+			fmt.Printf("Warning: Failed to set worktree for %s: %v\n", repoName, err)
+		}
+
+		// Add entry to .gitmodules
+		setPathCmd := exec.Command("git", "config", "--file", gitmodulesPath,
+			fmt.Sprintf("submodule.%s.path", repoName), repoName)
+		setPathCmd.Dir = absParent
+		setPathCmd.Stdout = os.Stdout
+		setPathCmd.Stderr = os.Stderr
+		if err := setPathCmd.Run(); err != nil {
+			fmt.Printf("Warning: Failed to set .gitmodules path for %s: %v\n", repoName, err)
+			continue
+		}
+
+		setURLCmd := exec.Command("git", "config", "--file", gitmodulesPath,
+			fmt.Sprintf("submodule.%s.url", repoName), remoteURL)
+		setURLCmd.Dir = absParent
+		setURLCmd.Stdout = os.Stdout
+		setURLCmd.Stderr = os.Stderr
+		if err := setURLCmd.Run(); err != nil {
+			fmt.Printf("Warning: Failed to set .gitmodules url for %s: %v\n", repoName, err)
+			continue
+		}
+
+		// Stage the submodule
+		addCmd := exec.Command("git", "add", repoName)
+		addCmd.Dir = absParent
+		if err := addCmd.Run(); err != nil {
+			fmt.Printf("Warning: Failed to stage submodule %s: %v\n", repoName, err)
+		}
+	}
+
+	// Stage .gitmodules if it exists
+	if _, err := os.Stat(gitmodulesPath); err == nil {
+		addModulesCmd := exec.Command("git", "add", ".gitmodules")
+		addModulesCmd.Dir = absParent
+		if err := addModulesCmd.Run(); err != nil {
+			fmt.Printf("Warning: Failed to stage .gitmodules: %v\n", err)
+		}
+	}
+
+	return nil
+}
+
+func FindSubRepos(parentDir string) ([]string, error) {
+	absParent, err := filepath.Abs(parentDir)
+	if err != nil {
+		return nil, err
+	}
+
+	entries, err := os.ReadDir(absParent)
+	if err != nil {
+		return nil, err
+	}
+
+	var repos []string
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		if strings.HasPrefix(entry.Name(), ".") {
+			continue
+		}
+		dirPath := filepath.Join(absParent, entry.Name())
+		if git.IsGitRepository(dirPath) {
+			repos = append(repos, dirPath)
+		}
+	}
+
+	return repos, nil
+}