2035 lines
58 KiB
Go
2035 lines
58 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/textarea"
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"golang.org/x/text/cases"
|
|
)
|
|
|
|
const (
|
|
formAuthorName = iota
|
|
formAuthorEmail
|
|
formAuthorDate
|
|
formCommitterName
|
|
formCommitterEmail
|
|
formCommitterDate
|
|
formMessage
|
|
formFieldCount
|
|
)
|
|
|
|
const (
|
|
bulkAuthorSearch = iota
|
|
bulkAuthorName
|
|
bulkAuthorEmail
|
|
bulkAuthorFieldCount
|
|
)
|
|
|
|
const (
|
|
dateSpreadStartDay = iota
|
|
dateSpreadEndDay
|
|
dateSpreadFromTime
|
|
dateSpreadToTime
|
|
dateSpreadFieldCount
|
|
)
|
|
|
|
type uiFocus int
|
|
|
|
const (
|
|
focusList uiFocus = iota
|
|
focusForm
|
|
)
|
|
|
|
type uiOverlay int
|
|
|
|
const (
|
|
overlayNone uiOverlay = iota
|
|
overlaySearch
|
|
overlayPath
|
|
overlayBulkAuthor
|
|
overlayConfirmApply
|
|
overlayConfirmForce
|
|
overlayHelp
|
|
overlayDatePicker
|
|
overlayDateSpread
|
|
)
|
|
|
|
type statusKind string
|
|
|
|
const (
|
|
statusInfo statusKind = "info"
|
|
statusSuccess statusKind = "success"
|
|
statusError statusKind = "error"
|
|
)
|
|
|
|
var (
|
|
colorInk = lipgloss.Color("#DCE7F7")
|
|
colorMuted = lipgloss.Color("#7E8DA3")
|
|
colorDim = lipgloss.Color("#506075")
|
|
colorPanel = lipgloss.Color("#111B27")
|
|
colorPanelLift = lipgloss.Color("#172536")
|
|
colorSelected = lipgloss.Color("#20364B")
|
|
colorCyan = lipgloss.Color("#55D6FF")
|
|
colorGreen = lipgloss.Color("#78F0B4")
|
|
colorMagenta = lipgloss.Color("#D68DFF")
|
|
colorAmber = lipgloss.Color("#FFD166")
|
|
colorRed = lipgloss.Color("#FF6B7A")
|
|
colorBorder = lipgloss.Color("#2B435A")
|
|
|
|
appBaseStyle = lipgloss.NewStyle().
|
|
Foreground(colorInk).
|
|
Background(lipgloss.Color("#08111B"))
|
|
panelStyle = lipgloss.NewStyle().
|
|
Background(colorPanel).
|
|
Border(lipgloss.RoundedBorder()).
|
|
BorderForeground(colorBorder)
|
|
activePanelStyle = panelStyle.Copy().
|
|
BorderForeground(colorCyan)
|
|
headerStyle = lipgloss.NewStyle().
|
|
Bold(true).
|
|
Foreground(colorCyan)
|
|
mutedStyle = lipgloss.NewStyle().
|
|
Foreground(colorMuted)
|
|
dimStyle = lipgloss.NewStyle().
|
|
Foreground(colorDim)
|
|
selectedItemStyle = lipgloss.NewStyle().
|
|
Background(colorSelected).
|
|
Foreground(colorInk).
|
|
Bold(true).
|
|
Padding(0, 1)
|
|
itemStyle = lipgloss.NewStyle().
|
|
Foreground(colorInk).
|
|
Padding(0, 1)
|
|
fieldLabelStyle = lipgloss.NewStyle().
|
|
Foreground(colorMuted).
|
|
Bold(true)
|
|
focusedFieldStyle = lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
BorderForeground(colorCyan).
|
|
Background(colorPanelLift).
|
|
Padding(0, 1)
|
|
blurredFieldStyle = lipgloss.NewStyle().
|
|
Border(lipgloss.NormalBorder()).
|
|
BorderForeground(colorBorder).
|
|
Background(colorPanel).
|
|
Padding(0, 1)
|
|
)
|
|
|
|
type repoLoadedMsg struct {
|
|
repo RepositoryState
|
|
commits []CommitRecord
|
|
path string
|
|
err error
|
|
}
|
|
|
|
type applyFinishedMsg struct {
|
|
result ApplyResult
|
|
repo RepositoryState
|
|
commits []CommitRecord
|
|
err error
|
|
}
|
|
|
|
type tuiModel struct {
|
|
app *App
|
|
initialPath string
|
|
|
|
repository RepositoryState
|
|
repoLoaded bool
|
|
commits []CommitRecord
|
|
|
|
originalByHash map[string]CommitRecord
|
|
draftByHash map[string]CommitRecord
|
|
|
|
selectedHash string
|
|
selectedIndex int
|
|
listOffset int
|
|
|
|
width int
|
|
height int
|
|
|
|
focus uiFocus
|
|
overlay uiOverlay
|
|
|
|
formFocus int
|
|
inputs []textinput.Model
|
|
message textarea.Model
|
|
|
|
searchInput textinput.Model
|
|
pathInput textinput.Model
|
|
confirmInput textinput.Model
|
|
datePickerTime time.Time
|
|
datePickerTarget int
|
|
bulkAuthorFocus int
|
|
bulkAuthorInputs []textinput.Model
|
|
bulkAuthorExact bool
|
|
dateSpreadFocus int
|
|
dateSpreadInputs []textinput.Model
|
|
|
|
forcePush bool
|
|
pushTags bool
|
|
removeCoAuthors bool
|
|
aiOnly bool
|
|
aiHashes map[string]bool
|
|
busy bool
|
|
|
|
status string
|
|
statusKind statusKind
|
|
}
|
|
|
|
func initialRepositoryPath(args []string, getwd func() (string, error)) (string, error) {
|
|
if len(args) > 1 {
|
|
return "", errors.New("usage: nexus [repo-path]")
|
|
}
|
|
if len(args) == 1 {
|
|
return normalizePath(args[0])
|
|
}
|
|
wd, err := getwd()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return normalizePath(wd)
|
|
}
|
|
|
|
func newTUIModel(app *App, initialPath string) tuiModel {
|
|
inputs := make([]textinput.Model, formFieldCount-1)
|
|
for i := range inputs {
|
|
inputs[i] = newTextInput()
|
|
}
|
|
|
|
message := textarea.New()
|
|
message.Prompt = ""
|
|
message.Placeholder = "Commit message"
|
|
message.ShowLineNumbers = false
|
|
message.CharLimit = 0
|
|
message.Blur()
|
|
|
|
searchInput := newTextInput()
|
|
searchInput.Placeholder = "Search hash, author, email, or message"
|
|
|
|
pathInput := newTextInput()
|
|
pathInput.Placeholder = "/path/to/repository"
|
|
pathInput.SetValue(initialPath)
|
|
|
|
confirmInput := newTextInput()
|
|
confirmInput.Placeholder = "FORCE"
|
|
|
|
bulkAuthorInputs := make([]textinput.Model, bulkAuthorFieldCount)
|
|
for i := range bulkAuthorInputs {
|
|
bulkAuthorInputs[i] = newTextInput()
|
|
}
|
|
bulkAuthorInputs[bulkAuthorSearch].Placeholder = "Existing author name or email"
|
|
bulkAuthorInputs[bulkAuthorName].Placeholder = "Replacement author name"
|
|
bulkAuthorInputs[bulkAuthorEmail].Placeholder = "Replacement author email"
|
|
|
|
dateSpreadInputs := make([]textinput.Model, dateSpreadFieldCount)
|
|
for i := range dateSpreadInputs {
|
|
dateSpreadInputs[i] = newTextInput()
|
|
}
|
|
dateSpreadInputs[dateSpreadStartDay].Placeholder = "YYYY-MM-DD"
|
|
dateSpreadInputs[dateSpreadEndDay].Placeholder = "YYYY-MM-DD"
|
|
dateSpreadInputs[dateSpreadFromTime].Placeholder = "08:00"
|
|
dateSpreadInputs[dateSpreadToTime].Placeholder = "12:00"
|
|
|
|
return tuiModel{
|
|
dateSpreadInputs: dateSpreadInputs,
|
|
app: app,
|
|
initialPath: initialPath,
|
|
originalByHash: map[string]CommitRecord{},
|
|
draftByHash: map[string]CommitRecord{},
|
|
inputs: inputs,
|
|
message: message,
|
|
searchInput: searchInput,
|
|
pathInput: pathInput,
|
|
confirmInput: confirmInput,
|
|
bulkAuthorInputs: bulkAuthorInputs,
|
|
pushTags: true,
|
|
status: "Loading repository...",
|
|
statusKind: statusInfo,
|
|
}
|
|
}
|
|
|
|
func newTextInput() textinput.Model {
|
|
input := textinput.New()
|
|
input.Prompt = ""
|
|
input.PlaceholderStyle = lipgloss.NewStyle().Foreground(colorDim)
|
|
input.TextStyle = lipgloss.NewStyle().Foreground(colorInk)
|
|
input.Cursor.Style = lipgloss.NewStyle().Foreground(colorCyan)
|
|
return input
|
|
}
|
|
|
|
func (m tuiModel) Init() tea.Cmd {
|
|
return loadRepositoryCmd(m.app, m.initialPath)
|
|
}
|
|
|
|
func (m tuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.width = msg.Width
|
|
m.height = msg.Height
|
|
m.updateComponentSizes()
|
|
return m, nil
|
|
case repoLoadedMsg:
|
|
m.busy = false
|
|
m.handleRepoLoaded(msg)
|
|
return m, nil
|
|
case applyFinishedMsg:
|
|
m.busy = false
|
|
m.handleApplyFinished(msg)
|
|
return m, nil
|
|
case tea.KeyMsg:
|
|
return m.handleKey(msg)
|
|
default:
|
|
return m, nil
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) handleRepoLoaded(msg repoLoadedMsg) {
|
|
if msg.err != nil {
|
|
m.repoLoaded = false
|
|
m.repository = RepositoryState{}
|
|
m.commits = nil
|
|
m.originalByHash = map[string]CommitRecord{}
|
|
m.draftByHash = map[string]CommitRecord{}
|
|
m.selectedHash = ""
|
|
m.selectedIndex = 0
|
|
m.listOffset = 0
|
|
m.overlay = overlayPath
|
|
m.focus = focusList
|
|
m.pathInput.SetValue(msg.path)
|
|
m.focusPathInput()
|
|
m.setStatus(fmt.Sprintf("Repository unavailable: %v", msg.err), statusError)
|
|
return
|
|
}
|
|
|
|
m.repoLoaded = true
|
|
m.repository = msg.repo
|
|
m.commits = newestFirst(msg.commits)
|
|
m.originalByHash = mapByHash(m.commits)
|
|
m.draftByHash = cloneMapByHash(m.commits)
|
|
m.aiHashes = aiCommitHashes(m.commits)
|
|
m.pathInput.SetValue(msg.repo.Path)
|
|
m.reconcileSelection()
|
|
m.loadSelectedCommitIntoForm()
|
|
m.overlay = overlayNone
|
|
m.setStatus(fmt.Sprintf("Loaded %d commits from %s", len(m.commits), filepath.Base(msg.repo.Path)), statusSuccess)
|
|
}
|
|
|
|
func (m *tuiModel) handleApplyFinished(msg applyFinishedMsg) {
|
|
if msg.err != nil {
|
|
m.setStatus(msg.err.Error(), statusError)
|
|
return
|
|
}
|
|
|
|
if msg.repo.Path != "" {
|
|
m.repository = msg.repo
|
|
m.repoLoaded = true
|
|
}
|
|
if msg.commits != nil {
|
|
m.removeCoAuthors = false
|
|
m.commits = newestFirst(msg.commits)
|
|
m.originalByHash = mapByHash(m.commits)
|
|
m.draftByHash = cloneMapByHash(m.commits)
|
|
m.reconcileSelection()
|
|
m.loadSelectedCommitIntoForm()
|
|
}
|
|
|
|
m.setStatus(applyResultSummary(msg.result), statusSuccess)
|
|
}
|
|
|
|
func (m tuiModel) handleKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
key := msg.String()
|
|
if key == "ctrl+c" {
|
|
return m, tea.Quit
|
|
}
|
|
|
|
if m.busy {
|
|
return m, nil
|
|
}
|
|
|
|
switch m.overlay {
|
|
case overlayHelp:
|
|
if key == "esc" || key == "?" || key == "q" {
|
|
m.overlay = overlayNone
|
|
}
|
|
return m, nil
|
|
case overlaySearch:
|
|
return m.updateSearch(msg)
|
|
case overlayPath:
|
|
return m.updatePathEntry(msg)
|
|
case overlayBulkAuthor:
|
|
return m.updateBulkAuthor(msg)
|
|
case overlayDateSpread:
|
|
return m.updateDateSpread(msg)
|
|
case overlayConfirmApply, overlayConfirmForce:
|
|
return m.updateConfirmation(msg)
|
|
case overlayDatePicker:
|
|
return m.updateDatePicker(msg)
|
|
}
|
|
|
|
if m.focus == focusForm {
|
|
return m.updateForm(msg)
|
|
}
|
|
|
|
switch key {
|
|
case "q":
|
|
return m, tea.Quit
|
|
case "?":
|
|
m.overlay = overlayHelp
|
|
case "/":
|
|
m.overlay = overlaySearch
|
|
m.searchInput.Focus()
|
|
m.searchInput.CursorEnd()
|
|
case "p", "o":
|
|
m.overlay = overlayPath
|
|
m.focusPathInput()
|
|
case "b":
|
|
if m.repoLoaded {
|
|
m.openBulkAuthor()
|
|
} else {
|
|
m.setStatus("Load a repository before replacing authors.", statusError)
|
|
}
|
|
case "d":
|
|
if m.repoLoaded {
|
|
m.openDateSpread()
|
|
} else {
|
|
m.setStatus("Load a repository before rewriting dates.", statusError)
|
|
}
|
|
case "r":
|
|
if m.repository.Path != "" {
|
|
m.busy = true
|
|
m.setStatus("Reloading history...", statusInfo)
|
|
return m, loadRepositoryCmd(m.app, m.repository.Path)
|
|
}
|
|
m.overlay = overlayPath
|
|
m.focusPathInput()
|
|
case "f":
|
|
m.forcePush = !m.forcePush
|
|
m.setStatus(fmt.Sprintf("Force push %s", onOff(m.forcePush)), statusInfo)
|
|
case "t":
|
|
m.pushTags = !m.pushTags
|
|
m.setStatus(fmt.Sprintf("Push tags %s", onOff(m.pushTags)), statusInfo)
|
|
case "c":
|
|
m.removeCoAuthors = !m.removeCoAuthors
|
|
count, lines := coAuthorCleanupImpact(m.commits, m.draftByHash)
|
|
m.setStatus(fmt.Sprintf("Co-author cleanup %s: %d line%s across %d commit%s", onOff(m.removeCoAuthors), lines, plural(lines), count, plural(count)), statusInfo)
|
|
case "i":
|
|
m.aiOnly = !m.aiOnly
|
|
m.reconcileSelection()
|
|
m.loadSelectedCommitIntoForm()
|
|
m.setStatus(fmt.Sprintf("Claude/Codex filter %s: %d commit%s", onOff(m.aiOnly), len(m.aiHashes), plural(len(m.aiHashes))), statusInfo)
|
|
case "a":
|
|
return m.beginApply()
|
|
case "x":
|
|
m.resetSelectedCommit()
|
|
case "tab":
|
|
if m.selectedHash != "" {
|
|
m.focus = focusForm
|
|
m.focusFormField(0)
|
|
}
|
|
case "up", "k":
|
|
m.moveSelection(-1)
|
|
case "down", "j":
|
|
m.moveSelection(1)
|
|
case "pgup":
|
|
m.moveSelection(-5)
|
|
case "pgdown":
|
|
m.moveSelection(5)
|
|
case "home":
|
|
m.moveSelectionTo(0)
|
|
case "end":
|
|
filtered, _, _ := selectionAfterFilter(m.listCommits(), m.draftByHash, m.selectedHash, m.searchInput.Value())
|
|
m.moveSelectionTo(len(filtered) - 1)
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m tuiModel) updateSearch(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
switch msg.String() {
|
|
case "esc", "enter":
|
|
m.overlay = overlayNone
|
|
m.searchInput.Blur()
|
|
m.reconcileSelection()
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.searchInput, cmd = m.searchInput.Update(msg)
|
|
m.reconcileSelection()
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updatePathEntry(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
switch msg.String() {
|
|
case "esc":
|
|
if m.repoLoaded {
|
|
m.overlay = overlayNone
|
|
m.pathInput.Blur()
|
|
}
|
|
return m, nil
|
|
case "enter":
|
|
path := strings.TrimSpace(m.pathInput.Value())
|
|
if path == "" {
|
|
m.setStatus("Repository path is required.", statusError)
|
|
return m, nil
|
|
}
|
|
normalized, err := normalizePath(path)
|
|
if err != nil {
|
|
m.setStatus(err.Error(), statusError)
|
|
return m, nil
|
|
}
|
|
m.busy = true
|
|
m.pathInput.Blur()
|
|
m.setStatus("Loading repository...", statusInfo)
|
|
return m, loadRepositoryCmd(m.app, normalized)
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.pathInput, cmd = m.pathInput.Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updateBulkAuthor(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
switch msg.String() {
|
|
case "esc":
|
|
m.overlay = overlayNone
|
|
m.blurBulkAuthorInputs()
|
|
m.setStatus("Bulk author replacement cancelled.", statusInfo)
|
|
return m, nil
|
|
case "tab", "shift+tab":
|
|
delta := 1
|
|
if msg.String() == "shift+tab" {
|
|
delta = -1
|
|
}
|
|
next := (m.bulkAuthorFocus + delta + bulkAuthorFieldCount) % bulkAuthorFieldCount
|
|
m.focusBulkAuthorField(next)
|
|
return m, nil
|
|
case "ctrl+t":
|
|
m.bulkAuthorExact = !m.bulkAuthorExact
|
|
m.setStatus(fmt.Sprintf("Author match mode: %s.", authorMatchMode(m.bulkAuthorExact)), statusInfo)
|
|
return m, nil
|
|
case "enter":
|
|
m.syncFormToDraft()
|
|
matched, err := stageAuthorReplacement(
|
|
m.commits,
|
|
m.draftByHash,
|
|
m.bulkAuthorInputs[bulkAuthorSearch].Value(),
|
|
m.bulkAuthorInputs[bulkAuthorName].Value(),
|
|
m.bulkAuthorInputs[bulkAuthorEmail].Value(),
|
|
m.bulkAuthorExact,
|
|
)
|
|
if err != nil {
|
|
m.setStatus(err.Error(), statusError)
|
|
return m, nil
|
|
}
|
|
if matched == 0 {
|
|
m.setStatus("No author names or emails matched the search.", statusInfo)
|
|
return m, nil
|
|
}
|
|
m.overlay = overlayNone
|
|
m.blurBulkAuthorInputs()
|
|
m.reconcileSelection()
|
|
m.loadSelectedCommitIntoForm()
|
|
m.setStatus(fmt.Sprintf("Staged author replacement for %d commit%s.", matched, plural(matched)), statusSuccess)
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.bulkAuthorInputs[m.bulkAuthorFocus], cmd = m.bulkAuthorInputs[m.bulkAuthorFocus].Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updateDateSpread(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
switch msg.String() {
|
|
case "esc":
|
|
m.overlay = overlayNone
|
|
m.blurInputs(m.dateSpreadInputs)
|
|
m.setStatus("Date rewrite cancelled.", statusInfo)
|
|
return m, nil
|
|
case "tab", "shift+tab":
|
|
delta := 1
|
|
if msg.String() == "shift+tab" {
|
|
delta = -1
|
|
}
|
|
m.focusDateSpreadField((m.dateSpreadFocus + delta + dateSpreadFieldCount) % dateSpreadFieldCount)
|
|
return m, nil
|
|
case "enter":
|
|
m.syncFormToDraft()
|
|
v := func(i int) string { return m.dateSpreadInputs[i].Value() }
|
|
count, err := stageDateSpread(m.commits, m.draftByHash, v(dateSpreadStartDay), v(dateSpreadEndDay), v(dateSpreadFromTime), v(dateSpreadToTime), rand.Int63n)
|
|
if err != nil {
|
|
m.setStatus(err.Error(), statusError)
|
|
return m, nil
|
|
}
|
|
m.overlay = overlayNone
|
|
m.blurInputs(m.dateSpreadInputs)
|
|
m.loadSelectedCommitIntoForm()
|
|
m.setStatus(fmt.Sprintf("Staged new timestamps for %d commit%s.", count, plural(count)), statusSuccess)
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.dateSpreadInputs[m.dateSpreadFocus], cmd = m.dateSpreadInputs[m.dateSpreadFocus].Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updateConfirmation(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
key := msg.String()
|
|
if key == "esc" || key == "n" {
|
|
m.overlay = overlayNone
|
|
m.confirmInput.Blur()
|
|
m.setStatus("Apply cancelled.", statusInfo)
|
|
return m, nil
|
|
}
|
|
|
|
if m.overlay == overlayConfirmApply {
|
|
if key == "y" {
|
|
return m.applyNow()
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
if key == "enter" {
|
|
if m.confirmInput.Value() != "FORCE" {
|
|
m.setStatus("Type FORCE to confirm rewriting and force pushing.", statusError)
|
|
return m, nil
|
|
}
|
|
return m.applyNow()
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.confirmInput, cmd = m.confirmInput.Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updateForm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
key := msg.String()
|
|
switch key {
|
|
case "enter":
|
|
if m.formFocus == formAuthorDate || m.formFocus == formCommitterDate {
|
|
selected, err := parseGitDate(m.inputs[m.formFocus].Value())
|
|
if err != nil {
|
|
m.setStatus(fmt.Sprintf("Cannot open date picker: %v", err), statusError)
|
|
return m, nil
|
|
}
|
|
m.datePickerTime = selected
|
|
m.datePickerTarget = m.formFocus
|
|
m.overlay = overlayDatePicker
|
|
m.blurForm()
|
|
m.setStatus("Date/time picker opened.", statusInfo)
|
|
return m, nil
|
|
}
|
|
case "ctrl+t":
|
|
if m.formFocus == formAuthorDate || m.formFocus == formCommitterDate {
|
|
m.inputs[m.formFocus].SetValue(time.Now().Format("2006-01-02T15:04:05-07:00"))
|
|
m.syncFormToDraft()
|
|
m.setStatus("Updated the focused date/time to now.", statusInfo)
|
|
}
|
|
return m, nil
|
|
case "esc":
|
|
m.normalizeFocusedDateInput()
|
|
m.syncFormToDraft()
|
|
m.focus = focusList
|
|
m.blurForm()
|
|
return m, nil
|
|
case "tab", "shift+tab":
|
|
m.normalizeFocusedDateInput()
|
|
m.syncFormToDraft()
|
|
next, returnToList := nextFormFocus(m.formFocus, key == "shift+tab")
|
|
if returnToList {
|
|
m.focus = focusList
|
|
m.blurForm()
|
|
return m, nil
|
|
}
|
|
m.focusFormField(next)
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
if m.formFocus == formMessage {
|
|
m.message, cmd = m.message.Update(msg)
|
|
} else if m.formFocus >= 0 && m.formFocus < len(m.inputs) {
|
|
m.inputs[m.formFocus], cmd = m.inputs[m.formFocus].Update(msg)
|
|
}
|
|
m.syncFormToDraft()
|
|
return m, cmd
|
|
}
|
|
|
|
func (m tuiModel) updateDatePicker(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
switch msg.String() {
|
|
case "esc":
|
|
m.overlay = overlayNone
|
|
m.focusFormField(m.datePickerTarget)
|
|
m.setStatus("Date/time change cancelled.", statusInfo)
|
|
case "enter":
|
|
m.inputs[m.datePickerTarget].SetValue(formatGitDate(m.datePickerTime))
|
|
m.overlay = overlayNone
|
|
m.focusFormField(m.datePickerTarget)
|
|
m.syncFormToDraft()
|
|
m.setStatus("Date/time updated.", statusInfo)
|
|
case "left", "h":
|
|
m.datePickerTime = m.datePickerTime.AddDate(0, 0, -1)
|
|
case "right", "l":
|
|
m.datePickerTime = m.datePickerTime.AddDate(0, 0, 1)
|
|
case "up", "k":
|
|
m.datePickerTime = m.datePickerTime.Add(time.Hour)
|
|
case "down", "j":
|
|
m.datePickerTime = m.datePickerTime.Add(-time.Hour)
|
|
case "pgup", "[":
|
|
m.datePickerTime = shiftCalendarMonth(m.datePickerTime, -1)
|
|
case "pgdown", "]":
|
|
m.datePickerTime = shiftCalendarMonth(m.datePickerTime, 1)
|
|
case "shift+left", "H":
|
|
m.datePickerTime = shiftCalendarYear(m.datePickerTime, -1)
|
|
case "shift+right", "L":
|
|
m.datePickerTime = shiftCalendarYear(m.datePickerTime, 1)
|
|
case "-", "_":
|
|
m.datePickerTime = m.datePickerTime.Add(-5 * time.Minute)
|
|
case "+", "=":
|
|
m.datePickerTime = m.datePickerTime.Add(5 * time.Minute)
|
|
case "t":
|
|
m.datePickerTime = time.Now()
|
|
case "u":
|
|
m.datePickerTime = sameWallClockIn(m.datePickerTime, time.UTC)
|
|
case "z":
|
|
m.datePickerTime = sameWallClockIn(m.datePickerTime, time.Local)
|
|
case "0":
|
|
m.datePickerTime = m.datePickerTime.Add(-time.Duration(m.datePickerTime.Second()) * time.Second)
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (m tuiModel) beginApply() (tea.Model, tea.Cmd) {
|
|
if !m.repoLoaded {
|
|
m.setStatus("Load a repository before applying changes.", statusError)
|
|
return m, nil
|
|
}
|
|
|
|
m.syncFormToDraft()
|
|
if err := validateDraftDates(m.commits, m.draftByHash); err != nil {
|
|
m.setStatus(err.Error(), statusError)
|
|
return m, nil
|
|
}
|
|
count := plannedRewriteCount(m.commits, m.originalByHash, m.draftByHash, m.removeCoAuthors)
|
|
if count == 0 && !m.forcePush {
|
|
m.setStatus("No history edits or co-author lines to apply.", statusInfo)
|
|
return m, nil
|
|
}
|
|
|
|
if m.forcePush {
|
|
m.overlay = overlayConfirmForce
|
|
m.confirmInput.SetValue("")
|
|
m.confirmInput.Focus()
|
|
m.setStatus("Force push confirmation required.", statusInfo)
|
|
return m, nil
|
|
}
|
|
|
|
m.overlay = overlayConfirmApply
|
|
m.setStatus(fmt.Sprintf("Confirm rewriting %d edited commit%s.", count, plural(count)), statusInfo)
|
|
return m, nil
|
|
}
|
|
|
|
func (m tuiModel) applyNow() (tea.Model, tea.Cmd) {
|
|
m.syncFormToDraft()
|
|
m.overlay = overlayNone
|
|
m.confirmInput.Blur()
|
|
m.busy = true
|
|
m.setStatus("Applying commit metadata changes...", statusInfo)
|
|
return m, applyChangesCmd(m.app, m.applyRequest())
|
|
}
|
|
|
|
func (m tuiModel) View() string {
|
|
m.updateComponentSizes()
|
|
width := m.width
|
|
height := m.height
|
|
if width <= 0 {
|
|
width = 120
|
|
}
|
|
if height <= 0 {
|
|
height = 36
|
|
}
|
|
width = maxInt(1, width-1)
|
|
|
|
top := m.renderTopBar(width)
|
|
bottom := m.renderBottomBar(width)
|
|
bodyHeight := maxInt(1, height-lipgloss.Height(top)-lipgloss.Height(bottom))
|
|
leftWidth, rightWidth, separator := tuiColumnWidths(width)
|
|
|
|
left := m.renderCommitPane(leftWidth, bodyHeight)
|
|
right := m.renderDetailPane(rightWidth, bodyHeight)
|
|
body := lipgloss.JoinHorizontal(lipgloss.Top, left, strings.Repeat(" ", separator), right)
|
|
|
|
return appBaseStyle.Width(width).Render(strings.Join([]string{top, body, bottom}, "\n"))
|
|
}
|
|
|
|
func (m tuiModel) renderTopBar(width int) string {
|
|
barStyle := lipgloss.NewStyle().
|
|
Width(contentWidthFor(lipgloss.NewStyle().Padding(0, 1), width)).
|
|
Background(lipgloss.Color("#0C1824")).
|
|
Padding(0, 1)
|
|
contentWidth := contentWidthFor(barStyle, width)
|
|
title := lipgloss.NewStyle().
|
|
Bold(true).
|
|
Foreground(colorCyan).
|
|
Render("NEXUS")
|
|
|
|
repoText := "No repository loaded"
|
|
if m.repoLoaded {
|
|
clean := "clean"
|
|
if !m.repository.Clean {
|
|
clean = "dirty"
|
|
}
|
|
branch := "detached HEAD"
|
|
if !m.repository.DetachedHead && m.repository.CurrentBranch != "" {
|
|
branch = m.repository.CurrentBranch
|
|
}
|
|
repoText = fmt.Sprintf("%s %s %s", filepath.Base(m.repository.Path), branch, clean)
|
|
}
|
|
|
|
flags := fmt.Sprintf("force:%s tags:%s coauthors:%s edits:%d", onOff(m.forcePush), onOff(m.pushTags), onOff(m.removeCoAuthors), plannedRewriteCount(m.commits, m.originalByHash, m.draftByHash, m.removeCoAuthors))
|
|
if m.busy {
|
|
flags = "working..."
|
|
}
|
|
|
|
repoWidth := maxInt(4, contentWidth-lipgloss.Width(title)-lipgloss.Width(flags)-6)
|
|
line := lipgloss.JoinHorizontal(
|
|
lipgloss.Center,
|
|
title,
|
|
" ",
|
|
mutedStyle.Render(truncateText(repoText, repoWidth)),
|
|
)
|
|
line = line + strings.Repeat(" ", maxInt(1, contentWidth-lipgloss.Width(line)-lipgloss.Width(flags))) + dimStyle.Render(flags)
|
|
line = truncateText(line, contentWidth)
|
|
|
|
if m.overlay == overlaySearch {
|
|
search := renderBox(focusedFieldStyle, width, 0, fieldLabelStyle.Render("Search")+"\n"+m.searchInput.View())
|
|
return lipgloss.NewStyle().Width(width).Render(line + "\n" + search)
|
|
}
|
|
|
|
return barStyle.Render(line)
|
|
}
|
|
|
|
func (m tuiModel) renderBottomBar(width int) string {
|
|
barStyle := lipgloss.NewStyle().
|
|
Width(contentWidthFor(lipgloss.NewStyle().Padding(0, 1), width)).
|
|
Background(lipgloss.Color("#0C1824")).
|
|
Padding(0, 1)
|
|
contentWidth := contentWidthFor(barStyle, width)
|
|
statusColor := colorCyan
|
|
switch m.statusKind {
|
|
case statusSuccess:
|
|
statusColor = colorGreen
|
|
case statusError:
|
|
statusColor = colorRed
|
|
}
|
|
|
|
status := lipgloss.NewStyle().Foreground(statusColor).Render(truncateText(m.status, contentWidth))
|
|
help := "Tab form/list / search b bulk author d dates p path r reload x reset a apply c co-authors i claude/codex f force t tags ? help q quit"
|
|
if m.focus == focusForm {
|
|
help = "Tab next field Shift+Tab previous Ctrl+T set focused date to now Esc list Ctrl+C quit"
|
|
}
|
|
if m.overlay == overlayPath {
|
|
help = "Enter load repository Esc close"
|
|
}
|
|
if m.overlay == overlayBulkAuthor {
|
|
help = "Tab next field Shift+Tab previous Ctrl+T partial/exact Enter stage Esc cancel"
|
|
}
|
|
if m.overlay == overlayDateSpread {
|
|
help = "Tab next field Shift+Tab previous Enter stage Esc cancel"
|
|
}
|
|
if m.overlay == overlayConfirmApply {
|
|
help = "Press y to rewrite history, n/Esc to cancel"
|
|
}
|
|
if m.overlay == overlayConfirmForce {
|
|
help = "Type FORCE then Enter to rewrite and force push, Esc to cancel"
|
|
}
|
|
if m.overlay == overlayDatePicker {
|
|
help = "←/→ day ↑/↓ hour PgUp/PgDn month +/- 5 min H/L year t now z local u UTC Enter save Esc cancel"
|
|
}
|
|
|
|
return barStyle.Render(status + "\n" + dimStyle.Render(truncateText(help, contentWidth)))
|
|
}
|
|
|
|
func (m tuiModel) renderCommitPane(width int, height int) string {
|
|
style := panelStyle
|
|
if m.focus == focusList && m.overlay == overlayNone {
|
|
style = activePanelStyle
|
|
}
|
|
innerWidth := maxInt(1, contentWidthFor(style, width))
|
|
innerHeight := maxInt(1, contentHeightFor(style, height))
|
|
|
|
filtered, selectedIndex, _ := selectionAfterFilter(m.listCommits(), m.draftByHash, m.selectedHash, m.searchInput.Value())
|
|
header := headerStyle.Render(fmt.Sprintf("Commits %d/%d", len(filtered), len(m.commits)))
|
|
if m.aiOnly {
|
|
header += " " + dimStyle.Render("[AI]")
|
|
}
|
|
if m.searchInput.Value() != "" {
|
|
header += " " + dimStyle.Render("/"+truncateText(m.searchInput.Value(), innerWidth-12))
|
|
}
|
|
|
|
lines := []string{truncateText(header, innerWidth)}
|
|
if len(filtered) == 0 {
|
|
lines = append(lines, "", mutedStyle.Render("No commits match this filter."))
|
|
return renderBox(style, width, height, fitLines(lines, innerHeight, innerWidth))
|
|
}
|
|
|
|
visibleSlots := maxInt(1, (innerHeight-2)/5)
|
|
offset := clamp(m.listOffset, 0, maxInt(0, len(filtered)-visibleSlots))
|
|
if selectedIndex < offset {
|
|
offset = selectedIndex
|
|
}
|
|
if selectedIndex >= offset+visibleSlots {
|
|
offset = selectedIndex - visibleSlots + 1
|
|
}
|
|
|
|
for i := offset; i < len(filtered) && len(lines) < innerHeight-1; i++ {
|
|
item := m.renderCommitItem(filtered[i], i == selectedIndex, innerWidth)
|
|
lines = append(lines, strings.Split(item, "\n")...)
|
|
if len(lines) < innerHeight {
|
|
lines = append(lines, "")
|
|
}
|
|
}
|
|
|
|
return renderBox(style, width, height, fitLines(lines, innerHeight, innerWidth))
|
|
}
|
|
|
|
func (m tuiModel) renderCommitItem(commit CommitRecord, selected bool, width int) string {
|
|
draft := m.draftByHash[commit.Hash]
|
|
if draft.Hash == "" {
|
|
draft = commit
|
|
}
|
|
|
|
marker := " "
|
|
if commitDirty(commit.Hash, m.originalByHash, m.draftByHash) {
|
|
marker = "*"
|
|
}
|
|
|
|
top := fmt.Sprintf("%s %s %s", marker, draft.ShortHash, formatCommitTime(draft.AuthorDate))
|
|
author := draft.AuthorName
|
|
if author == "" {
|
|
author = "(no author)"
|
|
}
|
|
preview := commitPreviewLines(draft.Message, maxInt(8, width-2), 2)
|
|
for len(preview) < 2 {
|
|
preview = append(preview, "")
|
|
}
|
|
|
|
block := strings.Join([]string{
|
|
truncateText(top, width-2),
|
|
truncateText(author, width-2),
|
|
truncateText(preview[0], width-2),
|
|
truncateText(preview[1], width-2),
|
|
}, "\n")
|
|
|
|
if selected {
|
|
return renderBox(selectedItemStyle, width, 0, block)
|
|
}
|
|
return renderBox(itemStyle, width, 0, block)
|
|
}
|
|
|
|
func (m tuiModel) renderDetailPane(width int, height int) string {
|
|
style := panelStyle
|
|
if m.focus == focusForm && m.overlay == overlayNone {
|
|
style = activePanelStyle
|
|
}
|
|
innerWidth := maxInt(1, contentWidthFor(style, width))
|
|
innerHeight := maxInt(1, contentHeightFor(style, height))
|
|
|
|
var content string
|
|
switch m.overlay {
|
|
case overlayPath:
|
|
content = m.renderPathPane(innerWidth, innerHeight)
|
|
case overlayBulkAuthor:
|
|
content = m.renderBulkAuthorPane(innerWidth, innerHeight)
|
|
case overlayDateSpread:
|
|
content = m.renderDateSpreadPane(innerWidth, innerHeight)
|
|
case overlayConfirmApply, overlayConfirmForce:
|
|
content = m.renderConfirmPane(innerWidth, innerHeight)
|
|
case overlayHelp:
|
|
content = m.renderHelpPane(innerWidth, innerHeight)
|
|
case overlayDatePicker:
|
|
content = m.renderDatePickerPane(innerWidth, innerHeight)
|
|
default:
|
|
content = m.renderFormPane(innerWidth, innerHeight)
|
|
}
|
|
|
|
return renderBox(style, width, height, content)
|
|
}
|
|
|
|
func (m tuiModel) renderDatePickerPane(width int, height int) string {
|
|
target := "Author date"
|
|
if m.datePickerTarget == formCommitterDate {
|
|
target = "Committer date"
|
|
}
|
|
zoneName, offset := m.datePickerTime.Zone()
|
|
if zoneName == "" {
|
|
zoneName = formatZoneOffset(offset)
|
|
} else {
|
|
zoneName = fmt.Sprintf("%s (%s)", zoneName, formatZoneOffset(offset))
|
|
}
|
|
|
|
lines := []string{
|
|
headerStyle.Render("Date & Time Picker"),
|
|
mutedStyle.Render(target),
|
|
"",
|
|
lipgloss.NewStyle().Bold(true).Foreground(colorGreen).Render(m.datePickerTime.Format("Monday, 02 January 2006")),
|
|
lipgloss.NewStyle().Bold(true).Foreground(colorCyan).Render(m.datePickerTime.Format("15:04:05") + " " + zoneName),
|
|
"",
|
|
}
|
|
lines = append(lines, renderMonthCalendar(m.datePickerTime)...)
|
|
lines = append(lines,
|
|
"",
|
|
"←/→ or h/l day ↑/↓ or k/j hour",
|
|
"PgUp/PgDn or [/] month H/L year +/- five minutes",
|
|
"t now z local timezone u UTC 0 clear seconds",
|
|
"",
|
|
dimStyle.Render("Enter saves the selection. Esc keeps the original timestamp."),
|
|
)
|
|
return fitLines(lines, height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderBulkAuthorPane(width int, height int) string {
|
|
lines := []string{
|
|
headerStyle.Render("Bulk replace author"),
|
|
"Search current draft author names and emails, then stage a new author identity on every matching commit.",
|
|
"",
|
|
m.renderBulkAuthorField(bulkAuthorSearch, "Search", width),
|
|
m.renderBulkAuthorField(bulkAuthorName, "Replacement author name", width),
|
|
m.renderBulkAuthorField(bulkAuthorEmail, "Replacement author email", width),
|
|
"",
|
|
fmt.Sprintf("Match mode: %s %s", authorMatchMode(m.bulkAuthorExact), dimStyle.Render("(Ctrl+T to toggle)")),
|
|
dimStyle.Render("Press Enter to stage these changes. Use a to apply the history rewrite."),
|
|
}
|
|
return fitLines(wrapBlockLines(lines, width), height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderDateSpreadPane(width int, height int) string {
|
|
field := func(index int, label string) string {
|
|
style := blurredFieldStyle
|
|
if m.dateSpreadFocus == index {
|
|
style = focusedFieldStyle
|
|
}
|
|
return renderBox(style, width, 0, fieldLabelStyle.Render(label)+"\n"+m.dateSpreadInputs[index].View())
|
|
}
|
|
lines := []string{
|
|
headerStyle.Render("Rewrite all timestamps"),
|
|
"Give every commit, oldest first, a random author and committer timestamp between the start and end dates, within the daily time window. Each timestamp is never earlier than the one before it.",
|
|
"",
|
|
field(dateSpreadStartDay, "Start date"),
|
|
field(dateSpreadEndDay, "End date"),
|
|
field(dateSpreadFromTime, "Daily window from (HH:MM)"),
|
|
field(dateSpreadToTime, "Daily window to (HH:MM)"),
|
|
"",
|
|
dimStyle.Render("Press Enter to stage these changes. Use a to apply the history rewrite."),
|
|
}
|
|
return fitLines(wrapBlockLines(lines, width), height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderBulkAuthorField(index int, label string, width int) string {
|
|
style := blurredFieldStyle
|
|
if m.overlay == overlayBulkAuthor && m.bulkAuthorFocus == index {
|
|
style = focusedFieldStyle
|
|
}
|
|
return renderBox(style, width, 0, fieldLabelStyle.Render(label)+"\n"+m.bulkAuthorInputs[index].View())
|
|
}
|
|
|
|
func (m tuiModel) renderPathPane(width int, height int) string {
|
|
lines := []string{
|
|
headerStyle.Render("Open Repository"),
|
|
"",
|
|
"Enter a Git worktree path. Nexus starts with the current directory, but you can switch repositories here at any time.",
|
|
"",
|
|
renderBox(focusedFieldStyle, width, 0, fieldLabelStyle.Render("Path")+"\n"+m.pathInput.View()),
|
|
"",
|
|
dimStyle.Render("Press Enter to load. Press Esc to return to the current repository."),
|
|
}
|
|
return fitLines(wrapBlockLines(lines, width), height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderConfirmPane(width int, height int) string {
|
|
count := plannedRewriteCount(m.commits, m.originalByHash, m.draftByHash, m.removeCoAuthors)
|
|
coAuthorCommits, coAuthorLines := coAuthorCleanupImpact(m.commits, m.draftByHash)
|
|
lines := []string{
|
|
headerStyle.Render("Confirm Rewrite"),
|
|
"",
|
|
fmt.Sprintf("This will rewrite Git history for %d edited commit%s. A backup tag will be created first.", count, plural(count)),
|
|
}
|
|
if m.removeCoAuthors {
|
|
lines = append(lines, "", fmt.Sprintf("Co-author cleanup will remove %d matching line%s from %d commit%s.", coAuthorLines, plural(coAuthorLines), coAuthorCommits, plural(coAuthorCommits)))
|
|
}
|
|
|
|
if m.forcePush {
|
|
lines = append(lines,
|
|
"",
|
|
lipgloss.NewStyle().Foreground(colorRed).Bold(true).Render("Force push is enabled."),
|
|
"Type FORCE to confirm rewriting history and pushing with --force-with-lease.",
|
|
"",
|
|
renderBox(focusedFieldStyle, minInt(width, 24), 0, fieldLabelStyle.Render("Confirmation")+"\n"+m.confirmInput.View()),
|
|
)
|
|
} else {
|
|
lines = append(lines, "", "Press y to continue, or n/Esc to cancel.")
|
|
}
|
|
|
|
return fitLines(wrapBlockLines(lines, width), height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderHelpPane(width int, height int) string {
|
|
lines := []string{
|
|
headerStyle.Render("Keyboard"),
|
|
"",
|
|
"List: Up/Down, PgUp/PgDn, Home/End select commits.",
|
|
"Tab moves from the list into the commit form.",
|
|
"Form: Tab and Shift+Tab move through every editable value. Esc returns to the list.",
|
|
"/ searches commits. b bulk-replaces author identities. d spreads all timestamps across a date range. p opens a repository path prompt. r reloads history.",
|
|
"x resets the selected commit. a applies edits. c toggles bulk Co-authored-by cleanup. i shows only Claude/Codex commits and merges that brought them in.",
|
|
"f toggles force push. t toggles tag push. Ctrl+T stamps the focused date field with the current local time.",
|
|
"",
|
|
headerStyle.Render("Safety"),
|
|
"",
|
|
"Apply creates a backup tag before rewriting history. Force push uses --force-with-lease.",
|
|
"",
|
|
dimStyle.Render("Press ? or Esc to close help."),
|
|
}
|
|
return fitLines(wrapBlockLines(lines, width), height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderFormPane(width int, height int) string {
|
|
if !m.repoLoaded {
|
|
return fitLines([]string{
|
|
headerStyle.Render("No Repository"),
|
|
"",
|
|
"Enter a repository path to begin.",
|
|
"",
|
|
dimStyle.Render("Press p to open the path prompt."),
|
|
}, height, width)
|
|
}
|
|
if m.selectedHash == "" {
|
|
return fitLines([]string{
|
|
headerStyle.Render("No Commits"),
|
|
"",
|
|
"This repository has no commits to edit.",
|
|
}, height, width)
|
|
}
|
|
|
|
draft := m.draftByHash[m.selectedHash]
|
|
title := fmt.Sprintf("%s %s", draft.ShortHash, firstLine(draft.Message))
|
|
lines := []string{headerStyle.Render(truncateText(title, width)), ""}
|
|
|
|
cellGap := 2
|
|
cellWidth := maxInt(1, (width-cellGap)/2)
|
|
rows := [][2]int{
|
|
{formAuthorName, formAuthorEmail},
|
|
{formAuthorDate, formCommitterName},
|
|
{formCommitterEmail, formCommitterDate},
|
|
}
|
|
labels := []string{
|
|
"Author name",
|
|
"Author email",
|
|
"Author date",
|
|
"Committer name",
|
|
"Committer email",
|
|
"Committer date",
|
|
}
|
|
|
|
if width >= 44 {
|
|
for _, row := range rows {
|
|
left := m.renderTextField(row[0], labels[row[0]], cellWidth)
|
|
right := m.renderTextField(row[1], labels[row[1]], cellWidth)
|
|
lines = append(lines, lipgloss.JoinHorizontal(lipgloss.Top, left, strings.Repeat(" ", cellGap), right))
|
|
}
|
|
} else {
|
|
for _, row := range rows {
|
|
lines = append(lines, m.renderTextField(row[0], labels[row[0]], width))
|
|
lines = append(lines, m.renderTextField(row[1], labels[row[1]], width))
|
|
}
|
|
}
|
|
|
|
messageHeight := clamp(height-lipgloss.Height(strings.Join(lines, "\n"))-8, 5, 10)
|
|
lines = append(lines, m.renderMessageField(width, messageHeight))
|
|
|
|
meta := []string{
|
|
fmt.Sprintf("Hash: %s", draft.Hash),
|
|
fmt.Sprintf("Parents: %s", strings.Join(draft.Parents, ", ")),
|
|
fmt.Sprintf("Tree: %s", draft.Tree),
|
|
fmt.Sprintf("Refs: %s", strings.Join(draft.Refs, ", ")),
|
|
}
|
|
if len(draft.Parents) == 0 {
|
|
meta[1] = "Parents: (root commit)"
|
|
}
|
|
if len(draft.Refs) == 0 {
|
|
meta[3] = "Refs: (none)"
|
|
}
|
|
lines = append(lines, dimStyle.Render(truncateText(strings.Join(meta, " "), width)))
|
|
|
|
return fitLines(lines, height, width)
|
|
}
|
|
|
|
func (m tuiModel) renderTextField(index int, label string, width int) string {
|
|
style := blurredFieldStyle
|
|
if m.focus == focusForm && m.overlay == overlayNone && m.formFocus == index {
|
|
style = focusedFieldStyle
|
|
}
|
|
return renderBox(style, width, 0, fieldLabelStyle.Render(label)+"\n"+m.inputs[index].View())
|
|
}
|
|
|
|
func (m tuiModel) renderMessageField(width int, height int) string {
|
|
style := blurredFieldStyle
|
|
if m.focus == focusForm && m.overlay == overlayNone && m.formFocus == formMessage {
|
|
style = focusedFieldStyle
|
|
}
|
|
return renderBox(style, width, height, fieldLabelStyle.Render("Commit message")+"\n"+m.message.View())
|
|
}
|
|
|
|
func (m *tuiModel) updateComponentSizes() {
|
|
width := m.width
|
|
height := m.height
|
|
if width <= 0 {
|
|
width = 120
|
|
}
|
|
if height <= 0 {
|
|
height = 36
|
|
}
|
|
_, rightWidth, _ := tuiColumnWidths(width)
|
|
innerRight := maxInt(1, contentWidthFor(panelStyle, rightWidth))
|
|
cellWidth := maxInt(18, (innerRight-2)/2)
|
|
|
|
for i := range m.inputs {
|
|
m.inputs[i].Width = maxInt(4, contentWidthFor(blurredFieldStyle, cellWidth))
|
|
}
|
|
m.message.SetWidth(maxInt(4, contentWidthFor(blurredFieldStyle, innerRight)))
|
|
m.message.SetHeight(clamp(height/4, 5, 10))
|
|
m.searchInput.Width = maxInt(16, width-10)
|
|
m.pathInput.Width = maxInt(4, contentWidthFor(focusedFieldStyle, innerRight))
|
|
m.confirmInput.Width = 12
|
|
for i := range m.bulkAuthorInputs {
|
|
m.bulkAuthorInputs[i].Width = maxInt(4, contentWidthFor(blurredFieldStyle, innerRight))
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) openBulkAuthor() {
|
|
m.blurForm()
|
|
m.searchInput.Blur()
|
|
m.pathInput.Blur()
|
|
m.confirmInput.Blur()
|
|
for i := range m.bulkAuthorInputs {
|
|
m.bulkAuthorInputs[i].SetValue("")
|
|
}
|
|
m.bulkAuthorExact = false
|
|
m.overlay = overlayBulkAuthor
|
|
m.focusBulkAuthorField(bulkAuthorSearch)
|
|
m.setStatus("Enter an author search and replacement identity.", statusInfo)
|
|
}
|
|
|
|
func (m *tuiModel) openDateSpread() {
|
|
m.blurForm()
|
|
m.searchInput.Blur()
|
|
m.pathInput.Blur()
|
|
m.confirmInput.Blur()
|
|
m.overlay = overlayDateSpread
|
|
m.focusDateSpreadField(dateSpreadStartDay)
|
|
m.setStatus("Enter a date range and daily time window.", statusInfo)
|
|
}
|
|
|
|
func (m *tuiModel) focusDateSpreadField(index int) {
|
|
m.blurInputs(m.dateSpreadInputs)
|
|
m.dateSpreadFocus = clamp(index, 0, dateSpreadFieldCount-1)
|
|
m.dateSpreadInputs[m.dateSpreadFocus].Focus()
|
|
m.dateSpreadInputs[m.dateSpreadFocus].CursorEnd()
|
|
}
|
|
|
|
func (m *tuiModel) blurInputs(inputs []textinput.Model) {
|
|
for i := range inputs {
|
|
inputs[i].Blur()
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) focusBulkAuthorField(index int) {
|
|
m.blurBulkAuthorInputs()
|
|
m.bulkAuthorFocus = clamp(index, 0, bulkAuthorFieldCount-1)
|
|
m.bulkAuthorInputs[m.bulkAuthorFocus].Focus()
|
|
m.bulkAuthorInputs[m.bulkAuthorFocus].CursorEnd()
|
|
}
|
|
|
|
func (m *tuiModel) blurBulkAuthorInputs() {
|
|
for i := range m.bulkAuthorInputs {
|
|
m.bulkAuthorInputs[i].Blur()
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) focusPathInput() {
|
|
m.blurForm()
|
|
m.searchInput.Blur()
|
|
m.confirmInput.Blur()
|
|
m.pathInput.Focus()
|
|
m.pathInput.CursorEnd()
|
|
}
|
|
|
|
func (m *tuiModel) focusFormField(index int) {
|
|
m.blurForm()
|
|
m.formFocus = clamp(index, 0, formFieldCount-1)
|
|
if m.formFocus == formMessage {
|
|
m.message.Focus()
|
|
return
|
|
}
|
|
m.inputs[m.formFocus].Focus()
|
|
m.inputs[m.formFocus].CursorEnd()
|
|
}
|
|
|
|
func (m *tuiModel) blurForm() {
|
|
for i := range m.inputs {
|
|
m.inputs[i].Blur()
|
|
}
|
|
m.message.Blur()
|
|
}
|
|
|
|
func (m *tuiModel) reconcileSelection() {
|
|
previousHash := m.selectedHash
|
|
filtered, index, hash := selectionAfterFilter(m.listCommits(), m.draftByHash, m.selectedHash, m.searchInput.Value())
|
|
if len(filtered) == 0 {
|
|
m.selectedHash = ""
|
|
m.selectedIndex = 0
|
|
m.listOffset = 0
|
|
m.blurForm()
|
|
m.focus = focusList
|
|
return
|
|
}
|
|
m.selectedHash = hash
|
|
m.selectedIndex = index
|
|
m.ensureSelectionVisible(len(filtered))
|
|
if previousHash != m.selectedHash {
|
|
m.loadSelectedCommitIntoForm()
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) ensureSelectionVisible(total int) {
|
|
visibleSlots := 5
|
|
if m.height > 0 {
|
|
visibleSlots = maxInt(1, (m.height-8)/5)
|
|
}
|
|
if m.selectedIndex < m.listOffset {
|
|
m.listOffset = m.selectedIndex
|
|
}
|
|
if m.selectedIndex >= m.listOffset+visibleSlots {
|
|
m.listOffset = m.selectedIndex - visibleSlots + 1
|
|
}
|
|
m.listOffset = clamp(m.listOffset, 0, maxInt(0, total-visibleSlots))
|
|
}
|
|
|
|
func (m *tuiModel) moveSelection(delta int) {
|
|
filtered, selectedIndex, _ := selectionAfterFilter(m.listCommits(), m.draftByHash, m.selectedHash, m.searchInput.Value())
|
|
if len(filtered) == 0 {
|
|
return
|
|
}
|
|
m.syncFormToDraft()
|
|
next := clamp(selectedIndex+delta, 0, len(filtered)-1)
|
|
m.selectedHash = filtered[next].Hash
|
|
m.selectedIndex = next
|
|
m.ensureSelectionVisible(len(filtered))
|
|
m.loadSelectedCommitIntoForm()
|
|
}
|
|
|
|
func (m *tuiModel) moveSelectionTo(index int) {
|
|
filtered, _, _ := selectionAfterFilter(m.listCommits(), m.draftByHash, m.selectedHash, m.searchInput.Value())
|
|
if len(filtered) == 0 {
|
|
return
|
|
}
|
|
m.syncFormToDraft()
|
|
next := clamp(index, 0, len(filtered)-1)
|
|
m.selectedHash = filtered[next].Hash
|
|
m.selectedIndex = next
|
|
m.ensureSelectionVisible(len(filtered))
|
|
m.loadSelectedCommitIntoForm()
|
|
}
|
|
|
|
func (m *tuiModel) loadSelectedCommitIntoForm() {
|
|
if m.selectedHash == "" {
|
|
return
|
|
}
|
|
draft, ok := m.draftByHash[m.selectedHash]
|
|
if !ok {
|
|
return
|
|
}
|
|
values := []string{
|
|
draft.AuthorName,
|
|
draft.AuthorEmail,
|
|
draft.AuthorDate,
|
|
draft.CommitterName,
|
|
draft.CommitterEmail,
|
|
draft.CommitterDate,
|
|
}
|
|
for i, value := range values {
|
|
m.inputs[i].SetValue(value)
|
|
}
|
|
m.message.SetValue(draft.Message)
|
|
}
|
|
|
|
func (m *tuiModel) syncFormToDraft() {
|
|
if m.selectedHash == "" {
|
|
return
|
|
}
|
|
draft, ok := m.draftByHash[m.selectedHash]
|
|
if !ok {
|
|
return
|
|
}
|
|
draft.AuthorName = m.inputs[formAuthorName].Value()
|
|
draft.AuthorEmail = m.inputs[formAuthorEmail].Value()
|
|
draft.AuthorDate = m.inputs[formAuthorDate].Value()
|
|
draft.CommitterName = m.inputs[formCommitterName].Value()
|
|
draft.CommitterEmail = m.inputs[formCommitterEmail].Value()
|
|
draft.CommitterDate = m.inputs[formCommitterDate].Value()
|
|
draft.Message = m.message.Value()
|
|
draft.Subject = firstLine(draft.Message)
|
|
m.draftByHash[m.selectedHash] = draft
|
|
}
|
|
|
|
func (m *tuiModel) normalizeFocusedDateInput() {
|
|
if m.formFocus != formAuthorDate && m.formFocus != formCommitterDate {
|
|
return
|
|
}
|
|
if normalized, err := normalizeGitDate(m.inputs[m.formFocus].Value()); err == nil {
|
|
m.inputs[m.formFocus].SetValue(normalized)
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) resetSelectedCommit() {
|
|
if m.selectedHash == "" {
|
|
return
|
|
}
|
|
original, ok := m.originalByHash[m.selectedHash]
|
|
if !ok {
|
|
return
|
|
}
|
|
m.draftByHash[m.selectedHash] = cloneCommitRecord(original)
|
|
m.loadSelectedCommitIntoForm()
|
|
m.setStatus(fmt.Sprintf("Reset %s", original.ShortHash), statusInfo)
|
|
}
|
|
|
|
func (m tuiModel) applyRequest() ApplyRequest {
|
|
commits := make([]CommitRecord, 0, len(m.commits))
|
|
for _, commit := range m.commits {
|
|
draft, ok := m.draftByHash[commit.Hash]
|
|
if !ok {
|
|
draft = commit
|
|
}
|
|
commits = append(commits, cloneCommitRecord(draft))
|
|
}
|
|
return ApplyRequest{
|
|
Commits: commits,
|
|
ForcePush: m.forcePush,
|
|
PushTags: m.pushTags,
|
|
RemoveCoAuthors: m.removeCoAuthors,
|
|
}
|
|
}
|
|
|
|
func (m *tuiModel) setStatus(message string, kind statusKind) {
|
|
m.status = message
|
|
m.statusKind = kind
|
|
}
|
|
|
|
func loadRepositoryCmd(app *App, path string) tea.Cmd {
|
|
return func() tea.Msg {
|
|
repo, err := app.SetRepository(path)
|
|
if err != nil {
|
|
return repoLoadedMsg{path: path, err: err}
|
|
}
|
|
commits, err := app.LoadHistory()
|
|
if err != nil {
|
|
return repoLoadedMsg{path: path, err: err}
|
|
}
|
|
return repoLoadedMsg{repo: repo, commits: commits, path: path}
|
|
}
|
|
}
|
|
|
|
func applyChangesCmd(app *App, req ApplyRequest) tea.Cmd {
|
|
return func() tea.Msg {
|
|
result, err := app.ApplyChanges(req)
|
|
if err != nil {
|
|
return applyFinishedMsg{err: err}
|
|
}
|
|
repo, repoErr := app.GetRepositoryState()
|
|
if repoErr != nil {
|
|
return applyFinishedMsg{result: result, err: repoErr}
|
|
}
|
|
commits, historyErr := app.LoadHistory()
|
|
if historyErr != nil {
|
|
return applyFinishedMsg{result: result, repo: repo, err: historyErr}
|
|
}
|
|
return applyFinishedMsg{result: result, repo: repo, commits: commits}
|
|
}
|
|
}
|
|
|
|
func newestFirst(commits []CommitRecord) []CommitRecord {
|
|
out := make([]CommitRecord, 0, len(commits))
|
|
for i := len(commits) - 1; i >= 0; i-- {
|
|
out = append(out, cloneCommitRecord(commits[i]))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func mapByHash(commits []CommitRecord) map[string]CommitRecord {
|
|
result := make(map[string]CommitRecord, len(commits))
|
|
for _, commit := range commits {
|
|
result[commit.Hash] = cloneCommitRecord(commit)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func cloneMapByHash(commits []CommitRecord) map[string]CommitRecord {
|
|
return mapByHash(commits)
|
|
}
|
|
|
|
func cloneCommitRecord(commit CommitRecord) CommitRecord {
|
|
clone := commit
|
|
clone.Refs = append([]string(nil), commit.Refs...)
|
|
clone.Parents = append([]string(nil), commit.Parents...)
|
|
return clone
|
|
}
|
|
|
|
func stageAuthorReplacement(commits []CommitRecord, draftByHash map[string]CommitRecord, query string, replacementName string, replacementEmail string, exact bool) (int, error) {
|
|
query = strings.TrimSpace(query)
|
|
replacementName = strings.TrimSpace(replacementName)
|
|
replacementEmail = strings.TrimSpace(replacementEmail)
|
|
if query == "" {
|
|
return 0, errors.New("author search is required")
|
|
}
|
|
if replacementName == "" {
|
|
return 0, errors.New("replacement author name is required")
|
|
}
|
|
if replacementEmail == "" {
|
|
return 0, errors.New("replacement author email is required")
|
|
}
|
|
fold := cases.Fold()
|
|
foldedQuery := fold.String(query)
|
|
matched := 0
|
|
for _, commit := range commits {
|
|
draft, ok := draftByHash[commit.Hash]
|
|
if !ok {
|
|
draft = cloneCommitRecord(commit)
|
|
}
|
|
nameMatches := strings.EqualFold(draft.AuthorName, query)
|
|
emailMatches := strings.EqualFold(draft.AuthorEmail, query)
|
|
if !exact {
|
|
nameMatches = strings.Contains(fold.String(draft.AuthorName), foldedQuery)
|
|
emailMatches = strings.Contains(fold.String(draft.AuthorEmail), foldedQuery)
|
|
}
|
|
if !nameMatches && !emailMatches {
|
|
continue
|
|
}
|
|
draft.AuthorName = replacementName
|
|
draft.AuthorEmail = replacementEmail
|
|
draftByHash[commit.Hash] = draft
|
|
matched++
|
|
}
|
|
return matched, nil
|
|
}
|
|
|
|
// stageDateSpread gives every commit (oldest first) the same author and
|
|
// committer timestamp: a random day in [startDay, endDay] at a random time in
|
|
// [fromTime, toTime), in local time. Sorting the random instants keeps them
|
|
// non-decreasing. randN returns a value in [0, n).
|
|
func stageDateSpread(commits []CommitRecord, draftByHash map[string]CommitRecord, startDay, endDay, fromTime, toTime string, randN func(int64) int64) (int, error) {
|
|
start, err := time.ParseInLocation("2006-01-02", strings.TrimSpace(startDay), time.Local)
|
|
if err != nil {
|
|
return 0, errors.New("start date must be YYYY-MM-DD")
|
|
}
|
|
end, err := time.ParseInLocation("2006-01-02", strings.TrimSpace(endDay), time.Local)
|
|
if err != nil {
|
|
return 0, errors.New("end date must be YYYY-MM-DD")
|
|
}
|
|
if end.Before(start) {
|
|
return 0, errors.New("end date must not be before start date")
|
|
}
|
|
from, err := time.Parse("15:04", strings.TrimSpace(fromTime))
|
|
if err != nil {
|
|
return 0, errors.New("window start must be HH:MM")
|
|
}
|
|
to, err := time.Parse("15:04", strings.TrimSpace(toTime))
|
|
if err != nil {
|
|
return 0, errors.New("window end must be HH:MM")
|
|
}
|
|
window := int64(to.Sub(from) / time.Second)
|
|
if window <= 0 {
|
|
return 0, errors.New("window end must be after window start")
|
|
}
|
|
|
|
days := int64(0)
|
|
for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
|
|
days++
|
|
}
|
|
stamps := make([]time.Time, len(commits))
|
|
for i := range stamps {
|
|
day := start.AddDate(0, 0, int(randN(days)))
|
|
base := time.Date(day.Year(), day.Month(), day.Day(), from.Hour(), from.Minute(), 0, 0, time.Local)
|
|
stamps[i] = base.Add(time.Duration(randN(window)) * time.Second)
|
|
}
|
|
sort.Slice(stamps, func(i, j int) bool { return stamps[i].Before(stamps[j]) })
|
|
|
|
// commits is newest first; walk it oldest first.
|
|
for i := range commits {
|
|
commit := commits[len(commits)-1-i]
|
|
draft, ok := draftByHash[commit.Hash]
|
|
if !ok {
|
|
draft = cloneCommitRecord(commit)
|
|
}
|
|
draft.AuthorDate = formatGitDate(stamps[i])
|
|
draft.CommitterDate = draft.AuthorDate
|
|
draftByHash[commit.Hash] = draft
|
|
}
|
|
return len(commits), nil
|
|
}
|
|
|
|
func authorMatchMode(exact bool) string {
|
|
if exact {
|
|
return "Exact"
|
|
}
|
|
return "Partial"
|
|
}
|
|
|
|
func selectionAfterFilter(commits []CommitRecord, draftByHash map[string]CommitRecord, selectedHash string, query string) ([]CommitRecord, int, string) {
|
|
filtered := filterCommits(commits, draftByHash, query)
|
|
if len(filtered) == 0 {
|
|
return filtered, 0, ""
|
|
}
|
|
for index, commit := range filtered {
|
|
if commit.Hash == selectedHash {
|
|
return filtered, index, selectedHash
|
|
}
|
|
}
|
|
return filtered, 0, filtered[0].Hash
|
|
}
|
|
|
|
func (m tuiModel) listCommits() []CommitRecord {
|
|
if !m.aiOnly {
|
|
return m.commits
|
|
}
|
|
filtered := make([]CommitRecord, 0, len(m.aiHashes))
|
|
for _, commit := range m.commits {
|
|
if m.aiHashes[commit.Hash] {
|
|
filtered = append(filtered, commit)
|
|
}
|
|
}
|
|
return filtered
|
|
}
|
|
|
|
var aiIdentityPattern = regexp.MustCompile(`(?i)\b(claude|codex|anthropic)\b`)
|
|
|
|
// aiCommitHashes marks commits whose author, committer, or message mentions
|
|
// Claude/Codex, plus merge commits whose merged-in side contains such a commit.
|
|
func aiCommitHashes(commits []CommitRecord) map[string]bool {
|
|
byHash := mapByHash(commits)
|
|
ai := map[string]bool{}
|
|
for _, c := range commits {
|
|
if aiIdentityPattern.MatchString(strings.Join([]string{c.AuthorName, c.AuthorEmail, c.CommitterName, c.CommitterEmail, c.Message}, "\n")) {
|
|
ai[c.Hash] = true
|
|
}
|
|
}
|
|
// ponytail: full ancestor walk per merge, O(commits x merges); memoise if huge repos crawl.
|
|
walk := func(start []string, skip map[string]bool, visit func(string) bool) map[string]bool {
|
|
seen := map[string]bool{}
|
|
stack := append([]string(nil), start...)
|
|
for len(stack) > 0 {
|
|
h := stack[len(stack)-1]
|
|
stack = stack[:len(stack)-1]
|
|
if seen[h] || skip[h] {
|
|
continue
|
|
}
|
|
seen[h] = true
|
|
if visit(h) {
|
|
return seen
|
|
}
|
|
stack = append(stack, byHash[h].Parents...)
|
|
}
|
|
return seen
|
|
}
|
|
for _, c := range commits {
|
|
if len(c.Parents) < 2 || ai[c.Hash] {
|
|
continue
|
|
}
|
|
base := walk(c.Parents[:1], nil, func(string) bool { return false })
|
|
walk(c.Parents[1:], base, func(h string) bool {
|
|
if ai[h] {
|
|
ai[c.Hash] = true
|
|
}
|
|
return ai[c.Hash]
|
|
})
|
|
}
|
|
return ai
|
|
}
|
|
|
|
func filterCommits(commits []CommitRecord, draftByHash map[string]CommitRecord, query string) []CommitRecord {
|
|
query = strings.ToLower(strings.TrimSpace(query))
|
|
if query == "" {
|
|
return append([]CommitRecord(nil), commits...)
|
|
}
|
|
filtered := make([]CommitRecord, 0, len(commits))
|
|
for _, commit := range commits {
|
|
draft := commit
|
|
if item, ok := draftByHash[commit.Hash]; ok {
|
|
draft = item
|
|
}
|
|
haystack := strings.ToLower(strings.Join([]string{
|
|
commit.Hash,
|
|
commit.ShortHash,
|
|
draft.AuthorName,
|
|
draft.AuthorEmail,
|
|
draft.Subject,
|
|
draft.Message,
|
|
}, "\n"))
|
|
if strings.Contains(haystack, query) {
|
|
filtered = append(filtered, commit)
|
|
}
|
|
}
|
|
return filtered
|
|
}
|
|
|
|
func dirtyCommitCount(commits []CommitRecord, originalByHash map[string]CommitRecord, draftByHash map[string]CommitRecord) int {
|
|
count := 0
|
|
for _, commit := range commits {
|
|
if commitDirty(commit.Hash, originalByHash, draftByHash) {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func plannedRewriteCount(commits []CommitRecord, originalByHash map[string]CommitRecord, draftByHash map[string]CommitRecord, removeCoAuthors bool) int {
|
|
count := 0
|
|
for _, commit := range commits {
|
|
dirty := commitDirty(commit.Hash, originalByHash, draftByHash)
|
|
draft := draftByHash[commit.Hash]
|
|
_, coAuthorLines := removeCoAuthorLines(draft.Message)
|
|
if dirty || (removeCoAuthors && coAuthorLines > 0) {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func coAuthorCleanupImpact(commits []CommitRecord, draftByHash map[string]CommitRecord) (int, int) {
|
|
commitCount := 0
|
|
lineCount := 0
|
|
for _, commit := range commits {
|
|
draft := draftByHash[commit.Hash]
|
|
_, removed := removeCoAuthorLines(draft.Message)
|
|
if removed > 0 {
|
|
commitCount++
|
|
lineCount += removed
|
|
}
|
|
}
|
|
return commitCount, lineCount
|
|
}
|
|
|
|
func validateDraftDates(commits []CommitRecord, draftByHash map[string]CommitRecord) error {
|
|
for _, commit := range commits {
|
|
draft := draftByHash[commit.Hash]
|
|
if _, err := normalizeGitDate(draft.AuthorDate); err != nil {
|
|
return fmt.Errorf("commit %s has an invalid author date: %v", draft.ShortHash, err)
|
|
}
|
|
if _, err := normalizeGitDate(draft.CommitterDate); err != nil {
|
|
return fmt.Errorf("commit %s has an invalid committer date: %v", draft.ShortHash, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func commitDirty(hash string, originalByHash map[string]CommitRecord, draftByHash map[string]CommitRecord) bool {
|
|
original, hasOriginal := originalByHash[hash]
|
|
draft, hasDraft := draftByHash[hash]
|
|
if !hasOriginal || !hasDraft {
|
|
return false
|
|
}
|
|
return editableFieldsChanged(original, draft)
|
|
}
|
|
|
|
func nextFormFocus(current int, backwards bool) (int, bool) {
|
|
if backwards {
|
|
if current <= 0 {
|
|
return 0, true
|
|
}
|
|
return current - 1, false
|
|
}
|
|
if current >= formFieldCount-1 {
|
|
return current, true
|
|
}
|
|
return current + 1, false
|
|
}
|
|
|
|
func commitPreviewLines(message string, width int, maxLines int) []string {
|
|
summary := strings.Join(strings.Fields(normalizeMessage(message)), " ")
|
|
if summary == "" {
|
|
summary = "(no message)"
|
|
}
|
|
return wrapText(summary, maxInt(4, width), maxInt(1, maxLines))
|
|
}
|
|
|
|
func wrapText(value string, width int, maxLines int) []string {
|
|
words := strings.Fields(value)
|
|
if len(words) == 0 {
|
|
return []string{""}
|
|
}
|
|
lines := make([]string, 0, maxLines)
|
|
current := ""
|
|
for _, word := range words {
|
|
if current == "" {
|
|
current = word
|
|
continue
|
|
}
|
|
if lipgloss.Width(current)+1+lipgloss.Width(word) <= width {
|
|
current += " " + word
|
|
continue
|
|
}
|
|
lines = append(lines, truncateText(current, width))
|
|
current = word
|
|
if len(lines) == maxLines {
|
|
break
|
|
}
|
|
}
|
|
if len(lines) < maxLines && current != "" {
|
|
lines = append(lines, truncateText(current, width))
|
|
}
|
|
if len(lines) == maxLines && len(words) > 0 {
|
|
last := strings.Join(lines, " ")
|
|
if lipgloss.Width(last) < lipgloss.Width(value) {
|
|
lines[len(lines)-1] = truncateText(lines[len(lines)-1], width)
|
|
}
|
|
}
|
|
return lines
|
|
}
|
|
|
|
func wrapBlockLines(lines []string, width int) []string {
|
|
var out []string
|
|
for _, line := range lines {
|
|
if strings.TrimSpace(line) == "" || strings.Contains(line, "\x1b[") {
|
|
out = append(out, line)
|
|
continue
|
|
}
|
|
wrapped := wrapText(line, width, 99)
|
|
out = append(out, wrapped...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func fitLines(lines []string, height int, width int) string {
|
|
out := make([]string, 0, height)
|
|
for _, block := range lines {
|
|
for _, line := range strings.Split(block, "\n") {
|
|
if len(out) >= height {
|
|
break
|
|
}
|
|
out = append(out, truncateText(line, width))
|
|
}
|
|
if len(out) >= height {
|
|
break
|
|
}
|
|
}
|
|
for len(out) < height {
|
|
out = append(out, "")
|
|
}
|
|
return strings.Join(out, "\n")
|
|
}
|
|
|
|
func truncateText(value string, width int) string {
|
|
if width <= 0 {
|
|
return ""
|
|
}
|
|
if lipgloss.Width(value) <= width {
|
|
return value
|
|
}
|
|
if width <= 3 {
|
|
return strings.Repeat(".", width)
|
|
}
|
|
var builder strings.Builder
|
|
for _, r := range value {
|
|
if lipgloss.Width(builder.String()+string(r)+"...") > width {
|
|
break
|
|
}
|
|
builder.WriteRune(r)
|
|
}
|
|
return builder.String() + "..."
|
|
}
|
|
|
|
func formatCommitTime(value string) string {
|
|
parsed, err := time.Parse(time.RFC3339, value)
|
|
if err != nil {
|
|
parsed, err = time.Parse(time.RFC3339Nano, value)
|
|
}
|
|
if err != nil {
|
|
return value
|
|
}
|
|
return parsed.Local().Format("2006-01-02 15:04")
|
|
}
|
|
|
|
func sameWallClockIn(value time.Time, location *time.Location) time.Time {
|
|
return time.Date(value.Year(), value.Month(), value.Day(), value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), location)
|
|
}
|
|
|
|
func shiftCalendarMonth(value time.Time, months int) time.Time {
|
|
targetMonth := time.Date(value.Year(), value.Month()+time.Month(months), 1, value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), value.Location())
|
|
day := minInt(value.Day(), targetMonth.AddDate(0, 1, -1).Day())
|
|
return time.Date(targetMonth.Year(), targetMonth.Month(), day, value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), value.Location())
|
|
}
|
|
|
|
func shiftCalendarYear(value time.Time, years int) time.Time {
|
|
targetYear := value.Year() + years
|
|
lastDay := time.Date(targetYear, value.Month()+1, 0, value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), value.Location()).Day()
|
|
return time.Date(targetYear, value.Month(), minInt(value.Day(), lastDay), value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), value.Location())
|
|
}
|
|
|
|
func formatZoneOffset(offsetSeconds int) string {
|
|
sign := "+"
|
|
if offsetSeconds < 0 {
|
|
sign = "-"
|
|
offsetSeconds = -offsetSeconds
|
|
}
|
|
return fmt.Sprintf("%s%02d:%02d", sign, offsetSeconds/3600, (offsetSeconds%3600)/60)
|
|
}
|
|
|
|
func renderMonthCalendar(selected time.Time) []string {
|
|
first := time.Date(selected.Year(), selected.Month(), 1, 0, 0, 0, 0, selected.Location())
|
|
leading := (int(first.Weekday()) + 6) % 7
|
|
daysInMonth := first.AddDate(0, 1, -1).Day()
|
|
|
|
lines := []string{
|
|
lipgloss.NewStyle().Bold(true).Foreground(colorMagenta).Render(selected.Format("January 2006")),
|
|
dimStyle.Render("Mo Tu We Th Fr Sa Su"),
|
|
}
|
|
week := make([]string, 7)
|
|
for day := 1; day <= daysInMonth; day++ {
|
|
position := leading + day - 1
|
|
cell := fmt.Sprintf("%2d", day)
|
|
if day == selected.Day() {
|
|
cell = lipgloss.NewStyle().Bold(true).Foreground(colorPanel).Background(colorCyan).Render(cell)
|
|
}
|
|
week[position%7] = cell
|
|
if position%7 == 6 || day == daysInMonth {
|
|
for index := range week {
|
|
if week[index] == "" {
|
|
week[index] = " "
|
|
}
|
|
}
|
|
lines = append(lines, strings.Join(week, " "))
|
|
week = make([]string, 7)
|
|
}
|
|
}
|
|
return lines
|
|
}
|
|
|
|
func applyResultSummary(result ApplyResult) string {
|
|
parts := []string{}
|
|
if result.RewrittenCommits == 0 {
|
|
parts = append(parts, "No commits required rewriting.")
|
|
} else {
|
|
parts = append(parts, fmt.Sprintf("Rewrote %d commit%s.", result.RewrittenCommits, plural(result.RewrittenCommits)))
|
|
}
|
|
if result.BackupReference != "" {
|
|
parts = append(parts, "Backup "+result.BackupReference+".")
|
|
}
|
|
if result.RemovedCoAuthors > 0 {
|
|
parts = append(parts, fmt.Sprintf("Removed %d co-author line%s.", result.RemovedCoAuthors, plural(result.RemovedCoAuthors)))
|
|
}
|
|
if result.ForcePushed {
|
|
parts = append(parts, "Force push completed.")
|
|
}
|
|
if len(result.Warnings) > 0 {
|
|
parts = append(parts, "Warning: "+strings.Join(result.Warnings, " "))
|
|
}
|
|
return strings.Join(parts, " ")
|
|
}
|
|
|
|
func onOff(value bool) string {
|
|
if value {
|
|
return "on"
|
|
}
|
|
return "off"
|
|
}
|
|
|
|
func plural(count int) string {
|
|
if count == 1 {
|
|
return ""
|
|
}
|
|
return "s"
|
|
}
|
|
|
|
func clamp(value int, low int, high int) int {
|
|
if high < low {
|
|
return low
|
|
}
|
|
if value < low {
|
|
return low
|
|
}
|
|
if value > high {
|
|
return high
|
|
}
|
|
return value
|
|
}
|
|
|
|
func minInt(a int, b int) int {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func maxInt(a int, b int) int {
|
|
if a > b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func contentWidthFor(style lipgloss.Style, outerWidth int) int {
|
|
return maxInt(1, outerWidth-style.GetHorizontalFrameSize())
|
|
}
|
|
|
|
func contentHeightFor(style lipgloss.Style, outerHeight int) int {
|
|
return maxInt(1, outerHeight-style.GetVerticalFrameSize())
|
|
}
|
|
|
|
func renderBox(style lipgloss.Style, outerWidth int, outerHeight int, content string) string {
|
|
if outerWidth > 0 {
|
|
style = style.Width(contentWidthFor(style, outerWidth))
|
|
}
|
|
if outerHeight > 0 {
|
|
style = style.Height(contentHeightFor(style, outerHeight))
|
|
}
|
|
return style.Render(content)
|
|
}
|
|
|
|
func tuiColumnWidths(totalWidth int) (int, int, int) {
|
|
if totalWidth <= 2 {
|
|
return maxInt(1, totalWidth), 1, 0
|
|
}
|
|
|
|
separator := 1
|
|
if totalWidth < 50 {
|
|
separator = 0
|
|
}
|
|
|
|
left := clamp(totalWidth*38/100, 24, 54)
|
|
minRight := 24
|
|
if totalWidth < 70 {
|
|
minRight = maxInt(10, totalWidth/2)
|
|
}
|
|
maxLeft := totalWidth - separator - minRight
|
|
if maxLeft < 10 {
|
|
maxLeft = maxInt(1, totalWidth-separator-1)
|
|
}
|
|
left = clamp(left, 1, maxLeft)
|
|
right := totalWidth - separator - left
|
|
if right < 1 {
|
|
right = 1
|
|
left = maxInt(1, totalWidth-separator-right)
|
|
}
|
|
return left, right, separator
|
|
}
|