go/cmd/docs/sync.go

package docs

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/spf13/cobra"
)

// Flag variables for sync command
var (
	docsSyncRegistryPath string
	docsSyncDryRun       bool
	docsSyncOutputDir    string
)

var docsSyncCmd = &cobra.Command{
	Use:   "sync",
	Short: "Sync documentation to core-php/docs/packages/",
	RunE: func(cmd *cobra.Command, args []string) error {
		return runDocsSync(docsSyncRegistryPath, docsSyncOutputDir, docsSyncDryRun)
	},
}

func init() {
	docsSyncCmd.Flags().StringVar(&docsSyncRegistryPath, "registry", "", "Path to repos.yaml")
	docsSyncCmd.Flags().BoolVar(&docsSyncDryRun, "dry-run", false, "Show what would be synced without copying")
	docsSyncCmd.Flags().StringVar(&docsSyncOutputDir, "output", "", "Output directory (default: core-php/docs/packages)")
}

// packageOutputName maps repo name to output folder name
func packageOutputName(repoName string) string {
	// core -> go (the Go framework)
	if repoName == "core" {
		return "go"
	}
	// core-admin -> admin, core-api -> api, etc.
	if strings.HasPrefix(repoName, "core-") {
		return strings.TrimPrefix(repoName, "core-")
	}
	return repoName
}

// shouldSyncRepo returns true if this repo should be synced
func shouldSyncRepo(repoName string) bool {
	// Skip core-php (it's the destination)
	if repoName == "core-php" {
		return false
	}
	// Skip template
	if repoName == "core-template" {
		return false
	}
	return true
}

func runDocsSync(registryPath string, outputDir string, dryRun bool) error {
	// Find or use provided registry
	reg, basePath, err := loadRegistry(registryPath)
	if err != nil {
		return err
	}

	// Default output to core-php/docs/packages relative to registry
	if outputDir == "" {
		outputDir = filepath.Join(basePath, "core-php", "docs", "packages")
	}

	// Scan all repos for docs
	var docsInfo []RepoDocInfo
	for _, repo := range reg.List() {
		if !shouldSyncRepo(repo.Name) {
			continue
		}
		info := scanRepoDocs(repo)
		if info.HasDocs && len(info.DocsFiles) > 0 {
			docsInfo = append(docsInfo, info)
		}
	}

	if len(docsInfo) == 0 {
		fmt.Println("No documentation found in any repos.")
		return nil
	}

	fmt.Printf("\n%s %d repo(s) with docs/ directories\n\n", dimStyle.Render("Found"), len(docsInfo))

	// Show what will be synced
	var totalFiles int
	for _, info := range docsInfo {
		totalFiles += len(info.DocsFiles)
		outName := packageOutputName(info.Name)
		fmt.Printf("  %s → %s %s\n",
			repoNameStyle.Render(info.Name),
			docsFileStyle.Render("packages/"+outName+"/"),
			dimStyle.Render(fmt.Sprintf("(%d files)", len(info.DocsFiles))))

		for _, f := range info.DocsFiles {
			fmt.Printf("    %s\n", dimStyle.Render(f))
		}
	}

	fmt.Printf("\n%s %d files from %d repos → %s\n",
		dimStyle.Render("Total:"), totalFiles, len(docsInfo), outputDir)

	if dryRun {
		fmt.Printf("\n%s\n", dimStyle.Render("Dry run - no files copied"))
		return nil
	}

	// Confirm
	fmt.Println()
	if !confirm("Sync?") {
		fmt.Println("Aborted.")
		return nil
	}

	// Sync docs
	fmt.Println()
	var synced int
	for _, info := range docsInfo {
		outName := packageOutputName(info.Name)
		repoOutDir := filepath.Join(outputDir, outName)

		// Clear existing directory
		os.RemoveAll(repoOutDir)

		if err := os.MkdirAll(repoOutDir, 0755); err != nil {
			fmt.Printf("  %s %s: %s\n", errorStyle.Render("✗"), info.Name, err)
			continue
		}

		// Copy all docs files
		docsDir := filepath.Join(info.Path, "docs")
		for _, f := range info.DocsFiles {
			src := filepath.Join(docsDir, f)
			dst := filepath.Join(repoOutDir, f)
			os.MkdirAll(filepath.Dir(dst), 0755)
			if err := copyFile(src, dst); err != nil {
				fmt.Printf("  %s %s: %s\n", errorStyle.Render("✗"), f, err)
			}
		}

		fmt.Printf("  %s %s → packages/%s/\n", successStyle.Render("✓"), info.Name, outName)
		synced++
	}

	fmt.Printf("\n%s Synced %d packages\n", successStyle.Render("Done:"), synced)

	return nil
}