cmd_init.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"


	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

const repoURL = "https://github.com/lorehq/lore-template.git"

var validPlatforms = []string{"claude", "copilot", "cursor", "gemini", "windsurf", "opencode", "cline"}

// alwaysKeep are entries kept from the template. Platform files are generated by projection.
var alwaysKeep = []string{".lore", ".gitignore", ".gitattributes"}


var namePattern = regexp.MustCompile(`^[a-zA-Z0-9._-]+$`)

func cmdInit(args []string) {
	var name string
	var platforms string

	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--help", "-h":
			fmt.Print(initHelpText)
			return
		case "--platforms", "-p":
			if i+1 >= len(args) {
				fatal("--platforms requires a value")
			}
			i++
			platforms = args[i]
		default:
			if name == "" {
				name = args[i]
			}
		}
	}

	// Determine mode: current dir (no name) or new dir (name given)
	cwd, _ := os.Getwd()
	var targetDir string
	var projectName string
	inPlace := name == ""

	if inPlace {
		// Init in current directory
		targetDir = cwd
		projectName = filepath.Base(cwd)
		if !isProjectSafeDir(targetDir) {
			fatal("Cannot initialize here — your home directory is not a project.\nUse: lore init <project-name>")
		}
	} else {
		// Validate project name
		projectName = filepath.Base(name)
		if !namePattern.MatchString(projectName) {
			fatal("Invalid project name '%s'. Names may contain letters, numbers, dots, hyphens, and underscores.", projectName)
		}

		// Resolve target directory
		isPath := strings.Contains(name, "/") || strings.Contains(name, string(filepath.Separator))
		if isPath {
			targetDir, _ = filepath.Abs(name)
		} else {
			targetDir = filepath.Join(cwd, name)
		}

		// Guard: already exists
		if _, err := os.Stat(targetDir); err == nil {
			fatal("%s already exists", targetDir)
		}
	}

	// Guard: already a Lore project
	if _, err := os.Stat(filepath.Join(targetDir, ".lore")); err == nil {
		fatal("Already a Lore project (.lore/ exists in %s)", targetDir)
	}

	// Parse or pick platforms
	var platformList []string
	if platforms != "" {
		platformList = parsePlatforms(platforms)
	} else {
		platformList = pickPlatforms()
	}

	if len(platformList) == 0 {
		fatal("No platforms selected.")
	}

	// Clone template
	fmt.Println("Cloning Lore template...")
	tmpDir, err := os.MkdirTemp("", "lore-init-*")
	if err != nil {
		fatal("Failed to create temp directory: %v", err)
	}
	defer os.RemoveAll(tmpDir)

	templateDir := os.Getenv("LORE_TEMPLATE")
	if templateDir != "" {
		if err := copyDir(templateDir, tmpDir); err != nil {
			fatal("Failed to copy template: %v", err)
		}
	} else {
		tag := "v" + version
		if version == "dev" {
			tag = "main"
		}
		cmd := exec.Command("git", "clone", "--depth", "1", "--branch", tag, repoURL, tmpDir)
		cmd.Stderr = os.Stderr
		if err := cmd.Run(); err != nil {
			fatal("Failed to clone template (tag %s): %v", tag, err)
		}
	}

	// Strip .git from template
	os.RemoveAll(filepath.Join(tmpDir, ".git"))

	// Filter: only keep alwaysKeep entries (platform files are generated by projection)
	keep := make(map[string]bool)
	for _, e := range alwaysKeep {
		keep[e] = true
	}

	entries, _ := os.ReadDir(tmpDir)
	for _, e := range entries {
		if !keep[e.Name()] {
			os.RemoveAll(filepath.Join(tmpDir, e.Name()))
		}
	}

	// For in-place init: don't overwrite .gitignore from template.
	// ensureGitignore will merge Lore entries into whatever exists.
	if inPlace {
		os.Remove(filepath.Join(tmpDir, ".gitignore"))
	}

	// Copy filtered template to target
	if err := copyDir(tmpDir, targetDir); err != nil {
		fatal("Failed to create project: %v", err)
	}

	// Ensure Lore entries in .gitignore (appends to existing, creates if missing)
	ensureGitignore(targetDir)

	// Write config.json
	writeConfig(targetDir, projectName, platformList)

	// Create inherit.json with empty defaults
	writeInheritConfig(targetDir, map[string]map[string]string{
		"rules":  {},
		"skills": {},
		"agents": {},
	})

	// Create .lore/MCP/ and .lore/HOOKS/ directories
	os.MkdirAll(filepath.Join(targetDir, ".lore", "MCP"), 0755)
	os.MkdirAll(filepath.Join(targetDir, ".lore", "HOOKS"), 0755)

	// Create MEMORY.md and LORE.md
	createLocalFiles(targetDir)

	// Git init (only for new directories — existing dirs may already have git)
	if !inPlace {
		gitInit := exec.Command("git", "init", "-b", "main")
		gitInit.Dir = targetDir
		gitInit.Stdout = os.Stdout
		gitInit.Stderr = os.Stderr
		_ = gitInit.Run()
	}

	if inPlace {
		// In-place: back up existing platform files, don't generate yet
		backedUp := backupPlatformFiles(targetDir, platformList)

		fmt.Printf("\nInitialized Lore in %s\n", targetDir)

		if len(backedUp) > 0 {
			fmt.Println("\nBacked up existing files (migrate content to .lore/LORE.md):")
			for _, f := range backedUp {
				clean := strings.TrimSuffix(f, "/")
				fmt.Printf("  %s → %s.pre-lore\n", f, clean)
			}
		}

		fmt.Println("\nNext steps:")
		fmt.Println("  Edit .lore/LORE.md with your project instructions")
		if len(backedUp) > 0 {
			fmt.Println("  Review .pre-lore backups and migrate content into .lore/LORE.md")
		}
		fmt.Println("  lore generate --platforms " + strings.Join(platformList, ","))
		fmt.Println("  git add -A && git commit -m \"Init Lore\"")
	} else {
		// New project: auto-generate platform files
		fmt.Println("Generating platform files...")
		runProjection(targetDir, platformList)

		fmt.Printf("\nInitialized Lore in %s\n", targetDir)
		fmt.Println("\nNext steps:")
		fmt.Printf("  cd %s\n", name)
		fmt.Println("  git add -A && git commit -m \"Init Lore\"")
	}
}

func parsePlatforms(input string) []string {
	if strings.TrimSpace(strings.ToLower(input)) == "all" {
		return append([]string{}, validPlatforms...)
	}
	parts := strings.Split(input, ",")
	var result []string
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		if !isValidPlatform(p) {
			fatal("Unknown platform: %s\nValid: %s, all", p, strings.Join(validPlatforms, ", "))
		}
		result = append(result, p)
	}
	return result
}

func isValidPlatform(p string) bool {
	for _, v := range validPlatforms {
		if v == p {
			return true
		}
	}
	return false
}

// pickPlatforms runs an interactive platform picker using bubbletea.
func pickPlatforms() []string {
	m := &pickerModel{
		platforms: validPlatforms,
		selected:  make(map[int]bool),
	}
	p := tea.NewProgram(m)
	final, err := p.Run()
	if err != nil {
		fatal("Platform picker error: %v", err)
	}
	fm := final.(*pickerModel)
	if fm.cancelled {
		fmt.Println("Cancelled.")
		os.Exit(0)
	}
	var result []string
	for i, p := range fm.platforms {
		if fm.selected[i] {
			result = append(result, p)
		}
	}
	return result
}

// --- Interactive platform picker ---

type pickerModel struct {
	platforms []string
	cursor    int
	selected  map[int]bool
	done      bool
	cancelled bool
}

func (m *pickerModel) Init() tea.Cmd { return nil }

func (m *pickerModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "q", "ctrl+c":
			m.cancelled = true
			return m, tea.Quit
		case "up", "k":
			if m.cursor > 0 {
				m.cursor--
			}
		case "down", "j":
			if m.cursor < len(m.platforms)-1 {
				m.cursor++
			}
		case " ", "x":
			m.selected[m.cursor] = !m.selected[m.cursor]
		case "enter":
			m.done = true
			return m, tea.Quit
		}
	}
	return m, nil
}

func (m *pickerModel) View() string {
	s := lipgloss.NewStyle().Bold(true).Render("Select platforms") + " (space to toggle, enter to confirm)\n\n"
	for i, p := range m.platforms {
		cursor := "  "
		if m.cursor == i {
			cursor = "> "
		}
		check := "[ ]"
		if m.selected[i] {
			check = "[x]"
		}
		s += fmt.Sprintf("%s%s %s\n", cursor, check, p)
	}
	s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render("q: cancel • space: toggle • enter: confirm")
	return s
}

// --- Backup ---

// backupPlatformFiles backs up existing platform files that would be overwritten
// by projection. Returns the list of files that were backed up.
func backupPlatformFiles(targetDir string, platforms []string) []string {
	// Files that projection overwrites per platform
	targets := map[string][]string{
		"claude":   {"CLAUDE.md", ".claude/settings.json"},
		"cursor":   {"AGENTS.md", ".cursor/hooks.json"},
		"copilot":  {"AGENTS.md", ".github/copilot-instructions.md", ".github/hooks/lore.json"},
		"gemini":   {"GEMINI.md", ".gemini/settings.json"},
		"windsurf": {"AGENTS.md", ".windsurfrules", ".windsurf/hooks.json"},
		"opencode": {"AGENTS.md", ".opencode/plugins/lore-hooks.mjs"},
		"cline":    {"AGENTS.md", ".clinerules/_lore-mandate.md"},
	}

	// Directories where projection writes rules/skills/agents.
	// Back up existing content so users don't lose hand-written agentics.
	dirTargets := map[string][]string{
		"claude":   {".claude/rules", ".claude/skills", ".claude/agents"},
		"cursor":   {".cursor/rules", ".cursor/skills", ".cursor/agents"},
		"copilot":  {".github/instructions", ".github/skills", ".github/agents"},
		"gemini":   {".gemini/skills", ".gemini/agents"},
		"windsurf": {".windsurf/rules", ".windsurf/skills"},
		"opencode": {".opencode/skills", ".opencode/agents"},
		"cline":    {".clinerules", ".cline/skills"},
	}

	seen := map[string]bool{}
	var backedUp []string

	for _, platform := range platforms {
		// Back up files
		for _, f := range targets[platform] {
			if seen[f] {
				continue
			}
			seen[f] = true
			src := filepath.Join(targetDir, f)
			if _, err := os.Stat(src); err != nil {
				continue
			}
			dst := src + ".pre-lore"
			if _, err := os.Stat(dst); err == nil {
				continue // don't overwrite existing backup
			}
			if data, err := os.ReadFile(src); err == nil {
				os.WriteFile(dst, data, 0644)
				backedUp = append(backedUp, f)
			}
		}

		// Back up directories (rename to .pre-lore)
		for _, d := range dirTargets[platform] {
			if seen[d] {
				continue
			}
			seen[d] = true
			src := filepath.Join(targetDir, d)
			if info, err := os.Stat(src); err != nil || !info.IsDir() {
				continue
			}
			// Only back up if it has content
			entries, err := os.ReadDir(src)
			if err != nil || len(entries) == 0 {
				continue
			}
			dst := src + ".pre-lore"
			if _, err := os.Stat(dst); err == nil {
				continue
			}
			if err := copyDir(src, dst); err == nil {
				backedUp = append(backedUp, d+"/")
			}
		}
	}

	return backedUp
}

// ensureGitignore creates or appends Lore entries to .gitignore.
func ensureGitignore(targetDir string) {
	entries := []string{".lore/MEMORY.md", ".lore/.session-nonce", ".lore/.last-generated", ".lore/.sessions/", "*.pre-lore"}
	gitignorePath := filepath.Join(targetDir, ".gitignore")

	existing := ""
	if data, err := os.ReadFile(gitignorePath); err == nil {
		existing = string(data)
	}

	var toAdd []string
	for _, entry := range entries {
		if !strings.Contains(existing, entry) {
			toAdd = append(toAdd, entry)
		}
	}

	if len(toAdd) == 0 {
		return
	}

	f, err := os.OpenFile(gitignorePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return
	}
	defer f.Close()

	// Add newline before Lore entries if file has content and doesn't end with newline
	if len(existing) > 0 && !strings.HasSuffix(existing, "\n") {
		f.WriteString("\n")
	}
	for _, entry := range toAdd {
		f.WriteString(entry + "\n")
	}
}

// --- File operations ---

func writeConfig(targetDir, projectName string, platforms []string) {
	platMap := platformsFromList(platforms)
	cfg := map[string]interface{}{
		"platforms": orderedPlatformJSON(platMap),
	}
	data, _ := json.MarshalIndent(cfg, "", "  ")
	_ = os.MkdirAll(filepath.Join(targetDir, ".lore"), 0755)
	_ = os.WriteFile(filepath.Join(targetDir, ".lore", "config.json"), append(data, '\n'), 0644)
}

func createLocalFiles(targetDir string) {
	memPath := filepath.Join(targetDir, ".lore", "MEMORY.md")
	if _, err := os.Stat(memPath); err != nil {
		_ = os.WriteFile(memPath, []byte("# Local Memory\n"), 0644)
	}

	// LORE.md — operator instructions, projected into each platform's mandate file
	lorePath := filepath.Join(targetDir, ".lore", "LORE.md")
	if _, err := os.Stat(lorePath); err != nil {
		stub, _ := templateFS.ReadFile("templates/project-lore.md")
		_ = os.WriteFile(lorePath, stub, 0644)
	}
}

func copyFile(src, dst string) {
	data, err := os.ReadFile(src)
	if err != nil {
		return
	}
	_ = os.WriteFile(dst, data, 0644)
}

// copyDir recursively copies src to dst.
func copyDir(src, dst string) error {
	return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		rel, _ := filepath.Rel(src, path)
		target := filepath.Join(dst, rel)

		if info.IsDir() {
			return os.MkdirAll(target, info.Mode())
		}

		data, err := os.ReadFile(path)
		if err != nil {
			return err
		}
		return os.WriteFile(target, data, info.Mode())
	})
}

func fatal(format string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, "Error: "+format+"\n", args...)
	os.Exit(1)
}

const initHelpText = `Initialize Lore in a project.

Usage: lore init [name] [--platforms <list>]

  lore init                  Initialize in current directory
  lore init <name>           Create new directory and initialize

Options:
  -p, --platforms <list>   Comma-separated platforms (interactive picker if omitted)
                           Valid: claude, copilot, cursor, gemini, windsurf, opencode, cline
  --help, -h           Print this help

Examples:
  lore init                                   # current dir, interactive picker
  lore init --platforms claude                 # current dir, specific platform
  lore init myproject --platforms claude,cursor # new dir
`