milestone 2 complete

internal/commands/save.go

@@ -0,0 +1,230 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"git.dws.rip/DWS/onyx/internal/core"
+	"git.dws.rip/DWS/onyx/internal/git"
+	"git.dws.rip/DWS/onyx/internal/models"
+	"github.com/spf13/cobra"
+)
+
+const (
+	// OnyxWorkspaceRef is the ref where ephemeral commits are stored
+	OnyxWorkspaceRef = "refs/onyx/workspaces/current"
+
+	// MaxCommitTitleLength is the maximum length for a commit title
+	MaxCommitTitleLength = 72
+)
+
+// NewSaveCmd creates the save command
+func NewSaveCmd() *cobra.Command {
+	var message string
+
+	cmd := &cobra.Command{
+		Use:   "save",
+		Short: "Save the current work as a permanent commit",
+		Long: `Converts the current ephemeral snapshot into a permanent commit
+in the active workstream. This is similar to 'git commit' but works
+with Onyx's workstream model.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runSave(message)
+		},
+	}
+
+	cmd.Flags().StringVarP(&message, "message", "m", "", "Commit message (required)")
+	cmd.MarkFlagRequired("message")
+
+	return cmd
+}
+
+// runSave executes the save command
+func runSave(message string) error {
+	// Validate the commit message
+	if err := validateCommitMessage(message); err != nil {
+		return err
+	}
+
+	// Get current directory
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get current directory: %w", err)
+	}
+
+	// Check if this is an Onyx repository
+	if !core.IsOnyxRepo(cwd) {
+		return fmt.Errorf("not an Onyx repository")
+	}
+
+	// Open the repository
+	repo, err := core.Open(cwd)
+	if err != nil {
+		return fmt.Errorf("failed to open repository: %w", err)
+	}
+	defer repo.Close()
+
+	// Use ExecuteWithTransaction to capture state_before and state_after
+	err = core.ExecuteWithTransaction(repo, "save", message, func() error {
+		return executeSave(repo, message)
+	})
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Successfully saved commit: %s\n", message)
+	return nil
+}
+
+// executeSave performs the actual save operation
+func executeSave(repo *core.OnyxRepository, message string) error {
+	gitBackend := git.NewGitBackend(repo.GetGitRepo())
+
+	// 1. Read current ephemeral commit from workspace ref
+	ephemeralCommitSHA, err := getEphemeralCommit(gitBackend)
+	if err != nil {
+		return fmt.Errorf("failed to get ephemeral commit: %w", err)
+	}
+
+	// 2. Get the commit object to extract the tree
+	ephemeralCommit, err := gitBackend.GetCommit(ephemeralCommitSHA)
+	if err != nil {
+		return fmt.Errorf("failed to get ephemeral commit object: %w", err)
+	}
+
+	// 3. Load workstream collection
+	workstreams, err := loadWorkstreams(repo)
+	if err != nil {
+		return fmt.Errorf("failed to load workstreams: %w", err)
+	}
+
+	// 4. Get the current workstream
+	currentWorkstream, err := workstreams.GetCurrentWorkstream()
+	if err != nil {
+		return fmt.Errorf("no active workstream. Use 'onx new' to create one: %w", err)
+	}
+
+	// 5. Determine the parent commit
+	var parentSHA string
+	if !currentWorkstream.IsEmpty() {
+		latestCommit, err := currentWorkstream.GetLatestCommit()
+		if err != nil {
+			return err
+		}
+		parentSHA = latestCommit.SHA
+	} else {
+		// For the first commit in the workstream, use the base branch HEAD
+		baseBranch := currentWorkstream.BaseBranch
+		if baseBranch == "" {
+			baseBranch = "main"
+		}
+		// Try to get the base branch reference
+		branchRef := fmt.Sprintf("refs/heads/%s", baseBranch)
+		sha, err := gitBackend.GetRef(branchRef)
+		if err == nil {
+			parentSHA = sha
+		}
+	}
+
+	// 6. Create new commit with the user's message
+	treeHash := ephemeralCommit.TreeHash.String()
+	commitSHA, err := gitBackend.CreateCommit(treeHash, parentSHA, message, "User")
+	if err != nil {
+		return fmt.Errorf("failed to create commit: %w", err)
+	}
+
+	// 7. Determine next branch number
+	nextNumber := currentWorkstream.GetCommitCount() + 1
+
+	// 8. Create branch ref (e.g., refs/onyx/workstreams/feature-name/commit-1)
+	branchRef := fmt.Sprintf("refs/onyx/workstreams/%s/commit-%d", currentWorkstream.Name, nextNumber)
+	if err := gitBackend.UpdateRef(branchRef, commitSHA); err != nil {
+		return fmt.Errorf("failed to create branch ref: %w", err)
+	}
+
+	// 9. Add commit to workstream
+	workstreamCommit := models.NewWorkstreamCommit(
+		commitSHA,
+		message,
+		"User",
+		parentSHA,
+		currentWorkstream.BaseBranch,
+		branchRef,
+	)
+	currentWorkstream.AddCommit(workstreamCommit)
+
+	// 10. Save updated workstreams
+	if err := saveWorkstreams(repo, workstreams); err != nil {
+		return fmt.Errorf("failed to save workstreams: %w", err)
+	}
+
+	return nil
+}
+
+// getEphemeralCommit retrieves the current ephemeral commit SHA
+func getEphemeralCommit(gitBackend *git.GitBackend) (string, error) {
+	sha, err := gitBackend.GetRef(OnyxWorkspaceRef)
+	if err != nil {
+		return "", fmt.Errorf("no ephemeral commit found. The daemon may not be running")
+	}
+	return sha, nil
+}
+
+// loadWorkstreams loads the workstream collection from .onx/workstreams.json
+func loadWorkstreams(repo *core.OnyxRepository) (*models.WorkstreamCollection, error) {
+	workstreamsPath := filepath.Join(repo.GetOnyxPath(), "workstreams.json")
+
+	data, err := os.ReadFile(workstreamsPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read workstreams file: %w", err)
+	}
+
+	workstreams, err := models.DeserializeWorkstreamCollection(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to deserialize workstreams: %w", err)
+	}
+
+	return workstreams, nil
+}
+
+// saveWorkstreams saves the workstream collection to .onx/workstreams.json
+func saveWorkstreams(repo *core.OnyxRepository, workstreams *models.WorkstreamCollection) error {
+	workstreamsPath := filepath.Join(repo.GetOnyxPath(), "workstreams.json")
+
+	data, err := workstreams.Serialize()
+	if err != nil {
+		return fmt.Errorf("failed to serialize workstreams: %w", err)
+	}
+
+	if err := os.WriteFile(workstreamsPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write workstreams file: %w", err)
+	}
+
+	return nil
+}
+
+// validateCommitMessage validates the commit message
+func validateCommitMessage(message string) error {
+	// Check if message is empty
+	if strings.TrimSpace(message) == "" {
+		return fmt.Errorf("commit message cannot be empty")
+	}
+
+	// Split into lines
+	lines := strings.Split(message, "\n")
+
+	// Validate title (first line)
+	title := strings.TrimSpace(lines[0])
+	if title == "" {
+		return fmt.Errorf("commit message title cannot be empty")
+	}
+
+	if len(title) > MaxCommitTitleLength {
+		return fmt.Errorf("commit message title is too long (%d characters). Maximum is %d characters", len(title), MaxCommitTitleLength)
+	}
+
+	return nil
+}