feat(unreleased): commit selector for unreleased section of CHANGELOG

cmd/generate.go

···
 	sinceTag    string
 )
 
+// TODO(determinism): Add deduplication logic using diff-based identity
+//
+// Currently generates duplicate .changes/*.md files when:
+// 1. Running generate multiple times on the same range
+// 2. History is rewritten (rebase/amend) but commit content unchanged
+//
+// Implementation:
+//
+//  1. Before processing commits, load existing entries:
+//     existingEntries := changeset.LoadExisting(".changes/data")
+//     // Returns map[diffHash]Metadata for O(1) lookups
+//
+//  2. For each selected commit:
+//     a. Compute diff hash: diffHash := changeset.ComputeDiffHash(repo, commit)
+//     b. Check if exists: if meta, exists := existingEntries[diffHash]; exists {
+//     - Same commit hash → true duplicate, skip
+//     - Different commit hash → rebased/cherry-picked
+//     * If --update-rebased: update metadata.CommitHash in JSON
+//     * If --skip-rebased: skip (default)
+//     * If --warn-rebased: print warning and skip
+//     }
+//     c. If not exists: create new entry with diff hash as filename
+//
+// 3. Report statistics:
+//   - N new entries created
+//   - M duplicates skipped (same commit)
+//   - K rebased commits detected (same diff, different commit)
+//
+// Flags to add:
+// --update-rebased    Update commit hash for rebased entries
+// --skip-rebased      Skip rebased commits (default)
+// --warn-rebased      Print warnings for rebased commits
+// --force             Regenerate all entries (ignore existing)
+//
+// Related: See internal/changeset/changeset.go TODO for implementation details
 func generateCmd() *cobra.Command {
 	c := &cobra.Command{
 		Use:   "generate [from] [to]",
···
 			}
 
 			if len(commits) == 0 {
-				style.Headline(fmt.Sprintf("No commits found between %s and %s", from, to))
+				style.Headlinef("No commits found between %s and %s", from, to)
 				return nil
 			}
 
···
 					return nil
 				}
 
-				style.Headline(fmt.Sprintf("Generating entries for %d selected commits", len(selectedItems)))
+				style.Headlinef("Generating entries for %d selected commits", len(selectedItems))
 			} else {
-				style.Headline(fmt.Sprintf("Found %d commits between %s and %s", len(commits), from, to))
+				style.Headlinef("Found %d commits between %s and %s", len(commits), from, to)
 
 				for _, commit := range commits {
 					subject := commit.Message
···
 
 					meta, err := parser.Parse(commit.Hash.String(), subject, body, commit.Author.When)
 					if err != nil {
-						fmt.Printf("Warning: failed to parse commit %s: %v\n", commit.Hash.String()[:7], err)
+						style.Println("Warning: failed to parse commit %s: %v", commit.Hash.String()[:gitlog.ShaLen], err)
 						continue
 					}
 
···
 				created++
 			}
 
-			fmt.Println()
-			style.Headline(fmt.Sprintf("Generated %d changelog entries", created))
+			style.Newline()
+			style.Headlinef("Generated %d changelog entries", created)
 			if skipped > 0 {
 				style.Println("Skipped %d commits (reverts or non-matching types)", skipped)
 			}

cmd/main.go

···
 	"github.com/charmbracelet/fang"
 	"github.com/charmbracelet/log"
 	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/git-storm/internal/style"
 )
 
 var (
···
 	return c
 }
 
-func unreleasedCmd() *cobra.Command {
-	add := &cobra.Command{
-		Use:   "add",
-		Short: "Add a new unreleased change entry",
-		Long: `Creates a new .changes/<date>-<summary>.md file with the specified type,
-scope, and summary.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("unreleased add not implemented")
-			fmt.Printf("type=%q scope=%q summary=%q\n", changeType, scope, summary)
-			return nil
-		},
-	}
-	add.Flags().StringVar(&changeType, "type", "", "Type of change (added, changed, fixed, removed, security)")
-	add.Flags().StringVar(&scope, "scope", "", "Optional scope or subsystem name")
-	add.Flags().StringVar(&summary, "summary", "", "Short summary of the change")
-	add.MarkFlagRequired("type")
-	add.MarkFlagRequired("summary")
-
-	list := &cobra.Command{
-		Use:   "list",
-		Short: "List all unreleased changes",
-		Long:  "Prints all pending .changes entries to stdout. Supports JSON output.",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("unreleased list not implemented")
-			fmt.Printf("outputJSON=%v\n", outputJSON)
-			return nil
-		},
-	}
-	list.Flags().BoolVar(&outputJSON, "json", false, "Output results as JSON")
-
-	review := &cobra.Command{
-		Use:   "review",
-		Short: "Review unreleased changes interactively",
-		Long: `Launches an interactive Bubble Tea TUI to review, edit, or categorize
-unreleased entries before final release.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("unreleased review not implemented (TUI)")
-			return nil
-		},
-	}
-
-	root := &cobra.Command{
-		Use:   "unreleased",
-		Short: "Manage unreleased changes (.changes directory)",
-		Long: `Work with unreleased change notes. Supports adding, listing,
-and reviewing pending entries before release.`,
-	}
-	root.AddCommand(add, list, review)
-
-	return root
-}
-
 func main() {
 	ctx := context.Background()
 	root := &cobra.Command{
···
 	root.PersistentFlags().StringVarP(&output, "output", "o", "CHANGELOG.md", "Output changelog file path")
 	root.AddCommand(generateCmd(), unreleasedCmd(), releaseCmd(), diffCmd(), versionCmd())
 
-	if err := fang.Execute(ctx, root); err != nil {
+	if err := fang.Execute(ctx, root, fang.WithColorSchemeFunc(style.NewColorScheme)); err != nil {
 		log.Fatalf("Execution failed: %v", err)
 	}
 }

cmd/unreleased.go

···
 	--output <file>     Optional file to export reviewed notes
 */
 package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/git-storm/internal/changeset"
+	"github.com/stormlightlabs/git-storm/internal/style"
+)
+
+func unreleasedCmd() *cobra.Command {
+	add := &cobra.Command{
+		Use:   "add",
+		Short: "Add a new unreleased change entry",
+		Long: `Creates a new .changes/<date>-<summary>.md file with the specified type,
+scope, and summary.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			validTypes := []string{"added", "changed", "fixed", "removed", "security"}
+			if !slices.Contains(validTypes, changeType) {
+				return fmt.Errorf("invalid type %q: must be one of %s", changeType, strings.Join(validTypes, ", "))
+			}
+
+			entry := changeset.Entry{
+				Type:    changeType,
+				Scope:   scope,
+				Summary: summary,
+			}
+
+			changesDir := ".changes"
+			filePath, err := changeset.Write(changesDir, entry)
+			if err != nil {
+				return fmt.Errorf("failed to create changelog entry: %w", err)
+			}
+
+			style.Addedf("Created %s", filePath)
+			return nil
+		},
+	}
+	add.Flags().StringVar(&changeType, "type", "", "Type of change (added, changed, fixed, removed, security)")
+	add.Flags().StringVar(&scope, "scope", "", "Optional scope or subsystem name")
+	add.Flags().StringVar(&summary, "summary", "", "Short summary of the change")
+	add.MarkFlagRequired("type")
+	add.MarkFlagRequired("summary")
+
+	list := &cobra.Command{
+		Use:   "list",
+		Short: "List all unreleased changes",
+		Long:  "Prints all pending .changes entries to stdout. Supports JSON output.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			changesDir := ".changes"
+			entries, err := changeset.List(changesDir)
+			if err != nil {
+				return fmt.Errorf("failed to list changelog entries: %w", err)
+			}
+
+			if len(entries) == 0 {
+				style.Println("No unreleased changes found")
+				return nil
+			}
+
+			if outputJSON {
+				jsonBytes, err := json.MarshalIndent(entries, "", "  ")
+				if err != nil {
+					return fmt.Errorf("failed to marshal entries to JSON: %w", err)
+				}
+				fmt.Println(string(jsonBytes))
+				return nil
+			}
+
+			style.Headlinef("Found %d unreleased change(s):", len(entries))
+			style.Newline()
+
+			for _, e := range entries {
+				displayEntry(e)
+			}
+
+			return nil
+		},
+	}
+	list.Flags().BoolVar(&outputJSON, "json", false, "Output results as JSON")
+
+	review := &cobra.Command{
+		Use:   "review",
+		Short: "Review unreleased changes interactively",
+		Long: `Launches an interactive Bubble Tea TUI to review, edit, or categorize
+unreleased entries before final release.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("unreleased review not implemented (TUI)")
+			return nil
+		},
+	}
+
+	root := &cobra.Command{
+		Use:   "unreleased",
+		Short: "Manage unreleased changes (.changes directory)",
+		Long: `Work with unreleased change notes. Supports adding, listing,
+and reviewing pending entries before release.`,
+	}
+	root.AddCommand(add, list, review)
+
+	return root
+}
+
+// displayEntry formats and prints a single changelog entry with color-coded type.
+func displayEntry(e changeset.EntryWithFile) {
+	var typeLabel string
+	switch e.Entry.Type {
+	case "added":
+		typeLabel = style.StyleAdded.Render(fmt.Sprintf("[%s]", e.Entry.Type))
+	case "changed":
+		typeLabel = style.StyleChanged.Render(fmt.Sprintf("[%s]", e.Entry.Type))
+	case "fixed":
+		typeLabel = style.StyleFixed.Render(fmt.Sprintf("[%s]", e.Entry.Type))
+	case "removed":
+		typeLabel = style.StyleRemoved.Render(fmt.Sprintf("[%s]", e.Entry.Type))
+	case "security":
+		typeLabel = style.StyleSecurity.Render(fmt.Sprintf("[%s]", e.Entry.Type))
+	default:
+		typeLabel = fmt.Sprintf("[%s]", e.Entry.Type)
+	}
+
+	var scopePart string
+	if e.Entry.Scope != "" {
+		scopePart = fmt.Sprintf("(%s) ", e.Entry.Scope)
+	}
+
+	style.Println("%s %s%s", typeLabel, scopePart, e.Entry.Summary)
+	style.Println("  File: %s", e.Filename)
+	if e.Entry.Breaking {
+		style.Println("  Breaking: %s\n", style.StyleRemoved.Render("YES"))
+	}
+	style.Newline()
+}

go.mod

···
 	github.com/aymanbagabas/go-udiff v0.3.1 // indirect
 	github.com/charmbracelet/bubbletea v1.3.10
 	github.com/charmbracelet/colorprofile v0.3.3 // indirect
-	github.com/charmbracelet/lipgloss/v2 v2.0.0-beta.3.0.20250917201909-41ff0bf215ea // indirect
+	github.com/charmbracelet/lipgloss/v2 v2.0.0-beta.3.0.20250917201909-41ff0bf215ea
 	github.com/charmbracelet/ultraviolet v0.0.0-20250915111650-81d4262876ef // indirect
 	github.com/charmbracelet/x/ansi v0.10.3 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect

internal/changeset/changeset.go

···
+// TODO(determinism): Make changeset file generation deterministic using diff-based identity
+//
+// Current implementation uses [time.Now] for filenames, causing duplicate entries
+// when generate is run multiple times on the same commit range.
+//
+// Store commit metadata in .changes/data/<diff-hash>.json:
+// - Compute hash of git diff content (not commit message)
+// - Use diff hash as stable identifier across rebases
+// - Store JSON metadata: {commit_hash, diff_hash, type, scope, summary, breaking, author, date}
+// - Generate .changes/<diff-hash-7>-<slug>.md from metadata
+//
+// Implementation:
+// 1. Add DiffHash field to Entry struct
+// 2. Add CommitHash field for tracking source (optional, for reference)
+// 3. Create ComputeDiffHash(commit) function:
+//   - Get commit.Tree() and parent.Tree()
+//   - Compute diff between trees
+//   - Hash the diff content (files changed + line changes)
+//   - Return hex string
+//
+// 4. Update Write() to:
+//   - Accept diff hash as parameter
+//   - Use format: .changes/<diff-hash-7>-<slug>.md
+//   - Write JSON to .changes/data/<diff-hash>.json
+//   - Check if diff hash exists before writing (deduplication)
+//
+// 5. Add Read() function to parse existing entries by diff hash
+//
+// Directory structure:
+//
+//	.changes/
+//	  a1b2c3d-add-authentication.md      # Human-readable entry
+//	  e5f6a7b-fix-memory-leak.md
+//	  data/
+//	    a1b2c3d4e5f6...json              # Full metadata
+//	    e5f6a7b8c9d0...json
+//
+// Related: See cmd/generate.go TODO for deduplication logic
 package changeset
 
 import (
+	"bytes"
 	"fmt"
 	"os"
 	"path/filepath"
···
 		if _, err := os.Stat(filePath); os.IsNotExist(err) {
 			break
 		}
-		// File exists, add counter
 		filename = fmt.Sprintf("%s-%s-%d.md", timestamp, slug, counter)
 		filePath = filepath.Join(dir, filename)
 		counter++
···
 	return filePath, nil
 }
 
-// slugify converts a string into a URL-friendly slug.
-// Converts to lowercase, replaces spaces and special chars with hyphens.
+// slugify converts a string into a URL-friendly slug by converting to lowercase,
+// replaces spaces and special chars with hyphens.
 func slugify(input string) string {
 	s := strings.ToLower(input)
 	reg := regexp.MustCompile(`[^a-z0-9]+`)
···
 
 	return s
 }
+
+// EntryWithFile pairs an Entry with its source filename for display/processing.
+type EntryWithFile struct {
+	Entry    Entry
+	Filename string
+}
+
+// List reads all .changes/*.md files and returns their parsed entries.
+func List(dir string) ([]EntryWithFile, error) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []EntryWithFile{}, nil
+		}
+		return nil, fmt.Errorf("failed to read directory %s: %w", dir, err)
+	}
+
+	var results []EntryWithFile
+
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".md") {
+			continue
+		}
+
+		filePath := filepath.Join(dir, entry.Name())
+		content, err := os.ReadFile(filePath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read file %s: %w", filePath, err)
+		}
+
+		parsed, err := parseEntry(content)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s: %w", entry.Name(), err)
+		}
+
+		results = append(results, EntryWithFile{
+			Entry:    parsed,
+			Filename: entry.Name(),
+		})
+	}
+
+	return results, nil
+}
+
+// parseEntry extracts YAML frontmatter from a markdown file and unmarshals it into an Entry.
+func parseEntry(content []byte) (Entry, error) {
+	var entry Entry
+
+	parts := bytes.Split(content, []byte("---"))
+	if len(parts) < 3 {
+		return entry, fmt.Errorf("invalid frontmatter format: expected ---...--- delimiters")
+	}
+
+	yamlContent := parts[1]
+	if err := yaml.Unmarshal(yamlContent, &entry); err != nil {
+		return entry, fmt.Errorf("failed to unmarshal YAML: %w", err)
+	}
+
+	return entry, nil
+}

internal/gitlog/gitlog.go

···
 	"github.com/go-git/go-git/v6/plumbing/object"
 )
 
+const ShaLen = 7
+
 // CommitKind represents the kind of commit according to Conventional Commits.
 type CommitKind int
 
···
 type ConventionalParser struct{}
 
 // Parse parses a conventional commit message into structured metadata.
-// Format: type(scope): description or type(scope)!: description
+//
+// Format:
+//
+//	type(scope): description or type(scope)!: description
+//
 // Breaking changes can also be indicated by BREAKING CHANGE: in footer.
 func (p *ConventionalParser) Parse(hash, subject, body string, date time.Time) (CommitMeta, error) {
 	meta := CommitMeta{
···
 	case "docs", "style", "test", "build", "ci", "chore":
 		return "changed"
 	case "revert":
-		return "" // Skip reverts
+		return ""
 	default:
-		return "" // Unknown types are skipped
+		return ""
 	}
 }
 
···
 }
 
 // ParseRefArgs parses command arguments to extract from/to refs.
+//
 // Supports both "from..to" and "from to" syntax.
 // If only one arg, treats it as from with to=HEAD.
 func ParseRefArgs(args []string) (from, to string) {

internal/style/style.go

···
 
 import (
 	"fmt"
+	"image/color"
 
+	"github.com/charmbracelet/fang"
 	"github.com/charmbracelet/lipgloss"
+	lg "github.com/charmbracelet/lipgloss/v2"
 )
 
 var (
···
 	fmt.Println(v)
 }
 
+func Headlinef(format string, args ...any) {
+	s := fmt.Sprintf(format, args...)
+	v := StyleHeadline.Render(s)
+	fmt.Println(v)
+}
+
 func Added(s string) {
 	v := StyleAdded.Render(s)
 	fmt.Println(v)
···
 	fmt.Println(v)
 }
 
+func Newline() { fmt.Println() }
+
 func Fixed(s string) {
 	v := StyleFixed.Render(s)
 	fmt.Println(v)
···
 	msg := fmt.Sprintf(format, args...)
 	fmt.Println(msg)
 }
+
+var darkTheme = fang.ColorScheme{
+	Base:           color.RGBA{25, 28, 35, 255},
+	Title:          color.RGBA{129, 161, 193, 255},
+	Description:    color.RGBA{180, 198, 211, 255},
+	Codeblock:      color.RGBA{46, 52, 64, 255},
+	Program:        color.RGBA{94, 129, 172, 255},
+	DimmedArgument: color.RGBA{110, 115, 125, 255},
+	Comment:        color.RGBA{76, 86, 106, 255},
+	Flag:           color.RGBA{143, 188, 187, 255},
+	FlagDefault:    color.RGBA{163, 190, 140, 255},
+	Command:        color.RGBA{208, 135, 112, 255},
+	QuotedString:   color.RGBA{136, 192, 208, 255},
+	Argument:       color.RGBA{191, 97, 106, 255},
+	Help:           color.RGBA{143, 188, 187, 255},
+	Dash:           color.RGBA{216, 222, 233, 255},
+	ErrorHeader: [2]color.Color{
+		color.RGBA{236, 239, 244, 255},
+		color.RGBA{191, 97, 106, 255},
+	},
+	ErrorDetails: color.RGBA{255, 203, 107, 255},
+}
+
+var lightTheme = fang.ColorScheme{
+	Base:           color.RGBA{245, 247, 250, 255},
+	Title:          color.RGBA{52, 73, 94, 255},
+	Description:    color.RGBA{88, 110, 117, 255},
+	Codeblock:      color.RGBA{230, 235, 240, 255},
+	Program:        color.RGBA{70, 106, 145, 255},
+	DimmedArgument: color.RGBA{140, 145, 155, 255},
+	Comment:        color.RGBA{150, 160, 170, 255},
+	Flag:           color.RGBA{0, 114, 178, 255},
+	FlagDefault:    color.RGBA{106, 153, 85, 255},
+	Command:        color.RGBA{217, 95, 2, 255},
+	QuotedString:   color.RGBA{38, 139, 210, 255},
+	Argument:       color.RGBA{203, 75, 22, 255},
+	Help:           color.RGBA{0, 114, 178, 255},
+	Dash:           color.RGBA{120, 130, 140, 255},
+	ErrorHeader: [2]color.Color{
+		color.RGBA{255, 255, 255, 255},
+		color.RGBA{203, 75, 22, 255},
+	},
+	ErrorDetails: color.RGBA{230, 150, 50, 255},
+}
+
+func NewColorScheme(c lg.LightDarkFunc) fang.ColorScheme {
+	return fang.ColorScheme{
+		Base:           c(lightTheme.Base, darkTheme.Base),
+		Title:          c(lightTheme.Title, darkTheme.Title),
+		Description:    c(lightTheme.Description, darkTheme.Description),
+		Codeblock:      c(lightTheme.Codeblock, darkTheme.Codeblock),
+		Program:        c(lightTheme.Program, darkTheme.Program),
+		DimmedArgument: c(lightTheme.DimmedArgument, darkTheme.DimmedArgument),
+		Comment:        c(lightTheme.Comment, darkTheme.Comment),
+		Flag:           c(lightTheme.Flag, darkTheme.Flag),
+		FlagDefault:    c(lightTheme.FlagDefault, darkTheme.FlagDefault),
+		Command:        c(lightTheme.Command, darkTheme.Command),
+		QuotedString:   c(lightTheme.QuotedString, darkTheme.QuotedString),
+		Argument:       c(lightTheme.Argument, darkTheme.Argument),
+		Help:           c(lightTheme.Help, darkTheme.Help),
+		Dash:           c(lightTheme.Dash, darkTheme.Dash),
+		ErrorHeader: [2]color.Color{
+			c(lightTheme.ErrorHeader[0], darkTheme.ErrorHeader[0]),
+			c(lightTheme.ErrorHeader[1], darkTheme.ErrorHeader[1]),
+		},
+		ErrorDetails: c(lightTheme.ErrorDetails, darkTheme.ErrorDetails),
+	}
+}

internal/ui/commit_selector.go

···
 		checkbox = "[✓]"
 	}
 
-	shortHash := item.Commit.Hash.String()[:7]
+	shortHash := item.Commit.Hash.String()[:gitlog.ShaLen]
 	subject := item.Meta.Description
 	if subject == "" {
 		subject = strings.Split(item.Commit.Message, "\n")[0]