mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
Replace list.DefaultDelegate + configureDelegate() with a new prefixItemDelegate that renders the "▌" prefix bar consistently across all 11 TUI list views (log, trash, search, install prompt, checklist, restore, audit rules, diff). - Add prefixItemDelegate (1-line) and renderPrefixRowWithDesc (2-line) - Remove configureDelegate(), NormalTitle/Desc, SelectedTitle/Desc styles - Remove hardcoded " " indent from restore item Title() methods - Fix AuditPage overflow handling with overflow prop and !overflow-clip
878 lines
21 KiB
Go
878 lines
21 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/charmbracelet/bubbles/list"
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
)
|
|
|
|
// diffExpandMsg is sent when async diff computation completes.
|
|
type diffExpandMsg struct {
|
|
skill string
|
|
diff string
|
|
files []fileDiffEntry
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Diff TUI — interactive diff browser: left panel target list, right panel
|
|
// detail showing sync/local differences. Browse-only (no mutating actions).
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// diffMinSplitWidth is the minimum terminal width for horizontal split.
|
|
const diffMinSplitWidth = tuiMinSplitWidth
|
|
|
|
// --- List items ---
|
|
|
|
type diffTargetItem struct {
|
|
result targetDiffResult
|
|
}
|
|
|
|
// diffExtraItem wraps an extraDiffResult for the bubbletea list.
|
|
type diffExtraItem struct {
|
|
result extraDiffResult
|
|
}
|
|
|
|
func (i diffExtraItem) Title() string {
|
|
icon := "✓"
|
|
if i.result.errMsg != "" {
|
|
icon = "✗"
|
|
} else if !i.result.synced {
|
|
icon = "~"
|
|
}
|
|
return fmt.Sprintf("%s %s → %s", icon, i.result.extraName, shortenPath(i.result.targetPath))
|
|
}
|
|
|
|
func (i diffExtraItem) Description() string {
|
|
if i.result.errMsg != "" {
|
|
return i.result.errMsg
|
|
}
|
|
if i.result.synced {
|
|
return fmt.Sprintf("synced (%s)", i.result.mode)
|
|
}
|
|
return fmt.Sprintf("%d difference(s) (%s)", len(i.result.items), i.result.mode)
|
|
}
|
|
|
|
func (i diffExtraItem) FilterValue() string { return i.result.extraName }
|
|
|
|
// diffSeparatorItem is a non-selectable visual separator between skills and extras.
|
|
type diffSeparatorItem struct {
|
|
label string
|
|
}
|
|
|
|
func (s diffSeparatorItem) Title() string { return s.label }
|
|
func (s diffSeparatorItem) Description() string { return "" }
|
|
func (s diffSeparatorItem) FilterValue() string { return "" }
|
|
|
|
// diffItemDelegate wraps prefixItemDelegate to render separators as group headers.
|
|
type diffItemDelegate struct {
|
|
inner prefixItemDelegate
|
|
}
|
|
|
|
func (d diffItemDelegate) Height() int { return d.inner.Height() }
|
|
func (d diffItemDelegate) Spacing() int { return d.inner.Spacing() }
|
|
func (d diffItemDelegate) Update(msg tea.Msg, m *list.Model) tea.Cmd {
|
|
return d.inner.Update(msg, m)
|
|
}
|
|
|
|
func (d diffItemDelegate) Render(w io.Writer, m list.Model, index int, item list.Item) {
|
|
if sep, ok := item.(diffSeparatorItem); ok {
|
|
width := m.Width()
|
|
if width <= 0 {
|
|
width = 40
|
|
}
|
|
renderDiffSeparatorRow(w, sep, width)
|
|
return
|
|
}
|
|
d.inner.Render(w, m, index, item)
|
|
}
|
|
|
|
func renderDiffSeparatorRow(w io.Writer, sep diffSeparatorItem, width int) {
|
|
label := tc.Dim.Render(sep.label)
|
|
lineWidth := width - lipgloss.Width(label) - 3
|
|
if lineWidth < 2 {
|
|
lineWidth = 2
|
|
}
|
|
line := strings.Repeat("─", lineWidth)
|
|
fmt.Fprint(w, tc.Dim.Render("─ ")+label+" "+tc.Dim.Render(line))
|
|
}
|
|
|
|
// skipDiffSeparator advances the list selection past diffSeparatorItem entries.
|
|
func skipDiffSeparator(l *list.Model, direction int) {
|
|
items := l.Items()
|
|
idx := l.Index()
|
|
n := len(items)
|
|
for idx >= 0 && idx < n {
|
|
if _, isSep := items[idx].(diffSeparatorItem); !isSep {
|
|
break
|
|
}
|
|
idx += direction
|
|
}
|
|
if idx >= 0 && idx < n {
|
|
l.Select(idx)
|
|
}
|
|
}
|
|
|
|
func (i diffTargetItem) Title() string {
|
|
r := i.result
|
|
if r.errMsg != "" {
|
|
return fmt.Sprintf("%s %s", tc.Red.Render("✗"), r.name)
|
|
}
|
|
if r.synced {
|
|
return fmt.Sprintf("%s %s", tc.Green.Render("✓"), r.name)
|
|
}
|
|
return fmt.Sprintf("%s %s", tc.Yellow.Render("!"), r.name)
|
|
}
|
|
|
|
func (i diffTargetItem) Description() string {
|
|
r := i.result
|
|
if r.errMsg != "" {
|
|
return "error"
|
|
}
|
|
if r.synced {
|
|
return "synced"
|
|
}
|
|
var parts []string
|
|
if r.syncCount > 0 {
|
|
parts = append(parts, fmt.Sprintf("%d sync", r.syncCount))
|
|
}
|
|
if r.localCount > 0 {
|
|
parts = append(parts, fmt.Sprintf("%d local", r.localCount))
|
|
}
|
|
if len(parts) == 0 {
|
|
return "0 diff(s)"
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
}
|
|
|
|
func (i diffTargetItem) FilterValue() string { return i.result.name }
|
|
|
|
// --- Model ---
|
|
|
|
type diffTUIModel struct {
|
|
quitting bool
|
|
termWidth int
|
|
termHeight int
|
|
|
|
// Data — sorted: error → diff → synced
|
|
allItems []targetDiffResult
|
|
allExtras []extraDiffResult
|
|
|
|
// Target list
|
|
targetList list.Model
|
|
|
|
// Filter
|
|
filterText string
|
|
filterInput textinput.Model
|
|
filtering bool
|
|
matchCount int
|
|
|
|
// Detail scroll (right panel)
|
|
detailScroll int
|
|
|
|
// Expand state — file-level diff for a specific skill
|
|
expandedSkill string // skill name currently expanded
|
|
expandedDiff string // cached unified diff text
|
|
expandedFiles []fileDiffEntry
|
|
|
|
// Async loading — spinner shown while computing file diffs
|
|
loading bool
|
|
loadSpinner spinner.Model
|
|
|
|
// Cached detail data — recomputed only on selection change
|
|
cachedIdx int
|
|
cachedItems []copyDiffEntry
|
|
cachedCats []actionCategory
|
|
}
|
|
|
|
func newDiffTUIModel(results []targetDiffResult, extrasSlice ...[]extraDiffResult) diffTUIModel {
|
|
// Sort: error first, then diffs, then synced
|
|
sorted := make([]targetDiffResult, len(results))
|
|
copy(sorted, results)
|
|
sort.Slice(sorted, func(i, j int) bool {
|
|
ri, rj := sorted[i], sorted[j]
|
|
oi, oj := diffSortOrder(ri), diffSortOrder(rj)
|
|
if oi != oj {
|
|
return oi < oj
|
|
}
|
|
return ri.name < rj.name
|
|
})
|
|
|
|
var extras []extraDiffResult
|
|
if len(extrasSlice) > 0 {
|
|
extras = extrasSlice[0]
|
|
}
|
|
|
|
listItems := make([]list.Item, len(sorted))
|
|
for i, r := range sorted {
|
|
listItems[i] = diffTargetItem{result: r}
|
|
}
|
|
// Append extras with a separator
|
|
if len(extras) > 0 {
|
|
listItems = append(listItems, diffSeparatorItem{label: "Extras"})
|
|
for _, r := range extras {
|
|
listItems = append(listItems, diffExtraItem{result: r})
|
|
}
|
|
}
|
|
|
|
delegate := diffItemDelegate{inner: newPrefixDelegate(true)}
|
|
|
|
tl := list.New(listItems, delegate, 0, 0)
|
|
var errN, diffN, syncN int
|
|
for _, r := range sorted {
|
|
switch {
|
|
case r.errMsg != "":
|
|
errN++
|
|
case !r.synced:
|
|
diffN++
|
|
default:
|
|
syncN++
|
|
}
|
|
}
|
|
var titleParts []string
|
|
if errN > 0 {
|
|
titleParts = append(titleParts, fmt.Sprintf("%d err", errN))
|
|
}
|
|
if diffN > 0 {
|
|
titleParts = append(titleParts, fmt.Sprintf("%d diff", diffN))
|
|
}
|
|
if syncN > 0 {
|
|
titleParts = append(titleParts, fmt.Sprintf("%d ok", syncN))
|
|
}
|
|
tl.Title = fmt.Sprintf("Diff — %s", strings.Join(titleParts, ", "))
|
|
tl.Styles.Title = tc.ListTitle
|
|
tl.SetShowStatusBar(false)
|
|
tl.SetFilteringEnabled(false)
|
|
tl.SetShowHelp(false)
|
|
tl.SetShowPagination(false)
|
|
|
|
fi := textinput.New()
|
|
fi.Prompt = "/ "
|
|
fi.PromptStyle = tc.Filter
|
|
fi.Cursor.Style = tc.Filter
|
|
|
|
sp := spinner.New()
|
|
sp.Spinner = spinner.Dot
|
|
sp.Style = tc.SpinnerStyle
|
|
|
|
return diffTUIModel{
|
|
allItems: sorted,
|
|
allExtras: extras,
|
|
targetList: tl,
|
|
matchCount: len(listItems),
|
|
filterInput: fi,
|
|
loadSpinner: sp,
|
|
}
|
|
}
|
|
|
|
// diffSortOrder returns 0 for error, 1 for diffs, 2 for synced.
|
|
func diffSortOrder(r targetDiffResult) int {
|
|
if r.errMsg != "" {
|
|
return 0
|
|
}
|
|
if !r.synced {
|
|
return 1
|
|
}
|
|
return 2
|
|
}
|
|
|
|
// refreshDetailCache recomputes sorted items and categories for the selected target.
|
|
func (m *diffTUIModel) refreshDetailCache() {
|
|
idx := m.targetList.Index()
|
|
if idx == m.cachedIdx && m.cachedItems != nil {
|
|
return
|
|
}
|
|
m.cachedIdx = idx
|
|
item, ok := m.targetList.SelectedItem().(diffTargetItem)
|
|
if !ok || item.result.synced || item.result.errMsg != "" {
|
|
m.cachedItems = nil
|
|
m.cachedCats = nil
|
|
return
|
|
}
|
|
items := make([]copyDiffEntry, len(item.result.items))
|
|
copy(items, item.result.items)
|
|
sort.Slice(items, func(i, j int) bool {
|
|
return items[i].name < items[j].name
|
|
})
|
|
m.cachedItems = items
|
|
m.cachedCats = categorizeItems(items)
|
|
}
|
|
|
|
func (m diffTUIModel) Init() tea.Cmd { return nil }
|
|
|
|
func (m diffTUIModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.termWidth = msg.Width
|
|
m.termHeight = msg.Height
|
|
lw := diffListWidth(m.termWidth)
|
|
h := m.diffPanelHeight()
|
|
m.targetList.SetSize(lw, h)
|
|
m.refreshDetailCache()
|
|
return m, nil
|
|
|
|
case tea.KeyMsg:
|
|
return m.handleDiffKey(msg)
|
|
|
|
case spinner.TickMsg:
|
|
if m.loading {
|
|
var cmd tea.Cmd
|
|
m.loadSpinner, cmd = m.loadSpinner.Update(msg)
|
|
return m, cmd
|
|
}
|
|
return m, nil
|
|
|
|
case diffExpandMsg:
|
|
// Discard stale result if user navigated away (loading reset on nav)
|
|
if !m.loading {
|
|
return m, nil
|
|
}
|
|
m.loading = false
|
|
m.expandedSkill = msg.skill
|
|
m.expandedDiff = msg.diff
|
|
m.expandedFiles = msg.files
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.targetList, cmd = m.targetList.Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m diffTUIModel) handleDiffKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
key := msg.String()
|
|
|
|
// Filter mode
|
|
if m.filtering {
|
|
switch key {
|
|
case "esc":
|
|
m.filtering = false
|
|
m.filterText = ""
|
|
m.filterInput.SetValue("")
|
|
m.applyDiffFilter()
|
|
return m, nil
|
|
case "enter":
|
|
m.filtering = false
|
|
return m, nil
|
|
}
|
|
var cmd tea.Cmd
|
|
m.filterInput, cmd = m.filterInput.Update(msg)
|
|
newVal := m.filterInput.Value()
|
|
if newVal != m.filterText {
|
|
m.filterText = newVal
|
|
m.applyDiffFilter()
|
|
}
|
|
return m, cmd
|
|
}
|
|
|
|
// Normal keys
|
|
switch key {
|
|
case "q", "esc", "ctrl+c":
|
|
m.quitting = true
|
|
return m, tea.Quit
|
|
|
|
case "/":
|
|
m.filtering = true
|
|
m.filterInput.Focus()
|
|
return m, textinput.Blink
|
|
|
|
case "enter":
|
|
if m.loading {
|
|
return m, nil // ignore while loading
|
|
}
|
|
item, ok := m.targetList.SelectedItem().(diffTargetItem)
|
|
if !ok {
|
|
return m, nil
|
|
}
|
|
r := item.result
|
|
if r.synced || r.errMsg != "" {
|
|
return m, nil
|
|
}
|
|
// Toggle expand
|
|
if m.expandedSkill != "" {
|
|
m.expandedSkill = ""
|
|
m.expandedDiff = ""
|
|
m.expandedFiles = nil
|
|
m.detailScroll = 0
|
|
return m, nil
|
|
}
|
|
// Find first expandable skill (any with srcDir or dstDir)
|
|
for i := range r.items {
|
|
entry := r.items[i]
|
|
if entry.srcDir != "" || entry.dstDir != "" {
|
|
m.loading = true
|
|
m.expandedSkill = ""
|
|
m.expandedDiff = ""
|
|
m.expandedFiles = nil
|
|
m.detailScroll = 0
|
|
return m, tea.Batch(m.loadSpinner.Tick, expandDiffCmd(&entry))
|
|
}
|
|
}
|
|
return m, nil
|
|
|
|
// Detail scroll
|
|
case "ctrl+d":
|
|
m.detailScroll += 5
|
|
return m, nil
|
|
case "ctrl+u":
|
|
m.detailScroll -= 5
|
|
if m.detailScroll < 0 {
|
|
m.detailScroll = 0
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// Reset detail scroll on list navigation
|
|
prevIdx := m.targetList.Index()
|
|
|
|
var cmd tea.Cmd
|
|
m.targetList, cmd = m.targetList.Update(msg)
|
|
|
|
// Skip separator items
|
|
if m.targetList.Index() != prevIdx {
|
|
direction := 1
|
|
if m.targetList.Index() < prevIdx {
|
|
direction = -1
|
|
}
|
|
skipDiffSeparator(&m.targetList, direction)
|
|
|
|
m.detailScroll = 0
|
|
m.expandedSkill = ""
|
|
m.expandedDiff = ""
|
|
m.expandedFiles = nil
|
|
m.loading = false // cancel in-flight diff if navigating away
|
|
m.refreshDetailCache()
|
|
}
|
|
|
|
return m, cmd
|
|
}
|
|
|
|
// --- Filter ---
|
|
|
|
func (m *diffTUIModel) applyDiffFilter() {
|
|
needle := strings.ToLower(m.filterText)
|
|
if needle == "" {
|
|
items := make([]list.Item, len(m.allItems))
|
|
for i, r := range m.allItems {
|
|
items[i] = diffTargetItem{result: r}
|
|
}
|
|
if len(m.allExtras) > 0 {
|
|
items = append(items, diffSeparatorItem{label: "Extras"})
|
|
for _, r := range m.allExtras {
|
|
items = append(items, diffExtraItem{result: r})
|
|
}
|
|
}
|
|
m.matchCount = len(items)
|
|
m.targetList.SetItems(items)
|
|
m.targetList.ResetSelected()
|
|
m.cachedItems = nil // invalidate cache
|
|
return
|
|
}
|
|
var matched []list.Item
|
|
for _, r := range m.allItems {
|
|
if strings.Contains(strings.ToLower(r.name), needle) {
|
|
matched = append(matched, diffTargetItem{result: r})
|
|
}
|
|
}
|
|
for _, r := range m.allExtras {
|
|
if strings.Contains(strings.ToLower(r.extraName), needle) {
|
|
matched = append(matched, diffExtraItem{result: r})
|
|
}
|
|
}
|
|
m.matchCount = len(matched)
|
|
m.targetList.SetItems(matched)
|
|
m.targetList.ResetSelected()
|
|
m.cachedItems = nil // invalidate cache
|
|
}
|
|
|
|
// --- Layout helpers ---
|
|
|
|
func diffListWidth(_ int) int { return 40 }
|
|
|
|
func diffDetailWidth(termWidth int) int {
|
|
return max(termWidth-diffListWidth(termWidth)-3, 30)
|
|
}
|
|
|
|
func (m diffTUIModel) diffPanelHeight() int {
|
|
return max(m.termHeight-4, 10)
|
|
}
|
|
|
|
// --- Views ---
|
|
|
|
func (m diffTUIModel) View() string {
|
|
if m.quitting {
|
|
return ""
|
|
}
|
|
|
|
if m.termWidth >= diffMinSplitWidth {
|
|
return m.viewDiffHorizontal()
|
|
}
|
|
return m.viewDiffVertical()
|
|
}
|
|
|
|
func (m diffTUIModel) viewDiffHorizontal() string {
|
|
var b strings.Builder
|
|
|
|
panelHeight := m.diffPanelHeight()
|
|
leftWidth := diffListWidth(m.termWidth)
|
|
rightWidth := diffDetailWidth(m.termWidth)
|
|
|
|
// Detail
|
|
detailStr, scrollInfo := wrapAndScroll(m.buildDiffDetail(), rightWidth-1, m.detailScroll, panelHeight)
|
|
|
|
body := renderHorizontalSplit(m.targetList.View(), detailStr, leftWidth, rightWidth, panelHeight)
|
|
b.WriteString(body)
|
|
b.WriteString("\n")
|
|
|
|
// Filter bar
|
|
b.WriteString(m.renderDiffFilterBar())
|
|
|
|
// Help
|
|
b.WriteString(tc.Help.Render(appendScrollInfo("↑↓ navigate / filter Enter expand Ctrl+d/u scroll q quit", scrollInfo)))
|
|
b.WriteString("\n")
|
|
|
|
return b.String()
|
|
}
|
|
|
|
func (m diffTUIModel) viewDiffVertical() string {
|
|
var b strings.Builder
|
|
|
|
b.WriteString(m.targetList.View())
|
|
b.WriteString("\n")
|
|
|
|
b.WriteString(m.renderDiffFilterBar())
|
|
|
|
// Detail below list
|
|
detailHeight := max(m.termHeight/3, 6)
|
|
detailStr, scrollInfo := wrapAndScroll(m.buildDiffDetail(), m.termWidth, m.detailScroll, detailHeight)
|
|
b.WriteString(detailStr)
|
|
b.WriteString("\n")
|
|
|
|
b.WriteString(tc.Help.Render(appendScrollInfo("↑↓ navigate / filter Enter expand Ctrl+d/u scroll q quit", scrollInfo)))
|
|
b.WriteString("\n")
|
|
|
|
return b.String()
|
|
}
|
|
|
|
func (m diffTUIModel) renderDiffFilterBar() string {
|
|
pag := renderPageInfoFromPaginator(m.targetList.Paginator)
|
|
return renderTUIFilterBar(
|
|
m.filterInput.View(), m.filtering, m.filterText,
|
|
m.matchCount, len(m.allItems), 0, "targets", pag,
|
|
)
|
|
}
|
|
|
|
// --- Detail renderer ---
|
|
|
|
func (m diffTUIModel) buildExtraDetail(selected diffExtraItem) string {
|
|
r := selected.result
|
|
var b strings.Builder
|
|
|
|
row := func(label, value string) {
|
|
b.WriteString(tc.Label.Render(label))
|
|
b.WriteString(tc.Value.Render(value))
|
|
b.WriteString("\n")
|
|
}
|
|
|
|
row("Extra: ", r.extraName)
|
|
row("Target: ", shortenPath(r.targetPath))
|
|
row("Mode: ", r.mode)
|
|
b.WriteString("\n")
|
|
|
|
if r.errMsg != "" {
|
|
b.WriteString(tc.Red.Render(" " + r.errMsg))
|
|
b.WriteString("\n")
|
|
return b.String()
|
|
}
|
|
if r.synced {
|
|
b.WriteString(tc.Green.Render(" ✓ Fully synced"))
|
|
b.WriteString("\n")
|
|
return b.String()
|
|
}
|
|
|
|
b.WriteString(tc.Yellow.Render(fmt.Sprintf(" %d difference(s):", len(r.items))))
|
|
b.WriteString("\n")
|
|
hasLocal := false
|
|
for _, item := range r.items {
|
|
var prefix string
|
|
var style lipgloss.Style
|
|
switch item.action {
|
|
case "add":
|
|
prefix, style = "+ ", tc.Green
|
|
case "remove":
|
|
prefix, style = "- ", tc.Red
|
|
case "modify":
|
|
prefix, style = "~ ", tc.Cyan
|
|
if item.reason == "not a symlink (local file)" {
|
|
hasLocal = true
|
|
}
|
|
default:
|
|
prefix, style = " ", tc.Dim
|
|
}
|
|
b.WriteString(style.Render(fmt.Sprintf(" %s%s %s", prefix, item.file, item.reason)))
|
|
b.WriteString("\n")
|
|
}
|
|
|
|
// Next Steps
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Title.Render("── Next Steps ──"))
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Cyan.Render(" → skillshare sync extras"))
|
|
b.WriteString("\n")
|
|
if hasLocal {
|
|
b.WriteString(tc.Cyan.Render(" → skillshare extras collect " + r.extraName))
|
|
b.WriteString("\n")
|
|
}
|
|
|
|
return b.String()
|
|
}
|
|
|
|
func (m diffTUIModel) buildDiffDetail() string {
|
|
selectedItem := m.targetList.SelectedItem()
|
|
switch selected := selectedItem.(type) {
|
|
case diffExtraItem:
|
|
return m.buildExtraDetail(selected)
|
|
case diffSeparatorItem:
|
|
return ""
|
|
case diffTargetItem:
|
|
// handled below
|
|
default:
|
|
return ""
|
|
}
|
|
item := selectedItem.(diffTargetItem)
|
|
r := item.result
|
|
|
|
var b strings.Builder
|
|
|
|
row := func(label, value string) {
|
|
b.WriteString(tc.Label.Render(label))
|
|
b.WriteString(tc.Value.Render(value))
|
|
b.WriteString("\n")
|
|
}
|
|
|
|
row("Target: ", r.name)
|
|
row("Mode: ", r.mode)
|
|
if len(r.include) > 0 {
|
|
row("Include: ", strings.Join(r.include, ", "))
|
|
}
|
|
if len(r.exclude) > 0 {
|
|
row("Exclude: ", strings.Join(r.exclude, ", "))
|
|
}
|
|
if !r.srcMtime.IsZero() {
|
|
row("Source: ", r.srcMtime.Format("2006-01-02 15:04"))
|
|
}
|
|
if !r.dstMtime.IsZero() {
|
|
row("Target: ", r.dstMtime.Format("2006-01-02 15:04"))
|
|
}
|
|
|
|
b.WriteString("\n")
|
|
|
|
// Error
|
|
if r.errMsg != "" {
|
|
b.WriteString(tc.Red.Render(" " + r.errMsg))
|
|
b.WriteString("\n")
|
|
return b.String()
|
|
}
|
|
|
|
// Fully synced
|
|
if r.synced {
|
|
b.WriteString(tc.Green.Render(" ✓ Fully synced"))
|
|
b.WriteString("\n")
|
|
return b.String()
|
|
}
|
|
|
|
// Loading spinner
|
|
if m.loading {
|
|
b.WriteString(fmt.Sprintf(" %s Loading diff...\n", m.loadSpinner.View()))
|
|
return b.String()
|
|
}
|
|
|
|
// Use cached sorted categories (refreshed on selection change)
|
|
cats := m.cachedCats
|
|
for _, cat := range cats {
|
|
n := len(cat.names)
|
|
skillWord := "skills"
|
|
if n == 1 {
|
|
skillWord = "skill"
|
|
}
|
|
|
|
var kindStyle lipgloss.Style
|
|
switch cat.kind {
|
|
case "new", "restore":
|
|
kindStyle = tc.Green
|
|
case "modified":
|
|
kindStyle = tc.Cyan
|
|
case "override":
|
|
kindStyle = tc.Yellow
|
|
case "orphan":
|
|
kindStyle = tc.Red
|
|
case "local":
|
|
kindStyle = tc.Dim
|
|
case "warn":
|
|
kindStyle = tc.Red
|
|
default:
|
|
kindStyle = tc.Dim
|
|
}
|
|
|
|
header := fmt.Sprintf(" %s %d %s:", cat.label, n, skillWord)
|
|
b.WriteString(kindStyle.Render(header))
|
|
b.WriteString("\n")
|
|
|
|
if cat.expand {
|
|
for _, name := range cat.names {
|
|
b.WriteString(tc.Dim.Render(" " + name))
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
}
|
|
|
|
// File list + diff content (only shown after Enter toggle)
|
|
if m.expandedSkill != "" {
|
|
if len(m.expandedFiles) > 0 {
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Separator.Render(fmt.Sprintf("── %s files ──", m.expandedSkill)))
|
|
b.WriteString("\n")
|
|
for _, f := range m.expandedFiles {
|
|
var icon string
|
|
var style lipgloss.Style
|
|
switch f.Action {
|
|
case "add":
|
|
icon, style = "+", tc.Green
|
|
case "delete":
|
|
icon, style = "-", tc.Red
|
|
case "modify":
|
|
icon, style = "~", tc.Cyan
|
|
default:
|
|
icon, style = "?", tc.Dim
|
|
}
|
|
b.WriteString(style.Render(fmt.Sprintf(" %s %s", icon, f.RelPath)))
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
|
|
// Unified diff content
|
|
if m.expandedDiff != "" {
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Separator.Render(fmt.Sprintf("── %s diff ──", m.expandedSkill)))
|
|
b.WriteString("\n")
|
|
for _, line := range strings.Split(strings.TrimRight(m.expandedDiff, "\n"), "\n") {
|
|
switch {
|
|
case strings.HasPrefix(line, "+ "):
|
|
b.WriteString(tc.Green.Render(line))
|
|
case strings.HasPrefix(line, "- "):
|
|
b.WriteString(tc.Red.Render(line))
|
|
case strings.HasPrefix(line, "--- "):
|
|
b.WriteString(tc.Cyan.Render(line))
|
|
default:
|
|
b.WriteString(tc.Dim.Render(line))
|
|
}
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
if len(m.expandedFiles) == 0 && m.expandedDiff == "" {
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Dim.Render(" (No file-level diff available)"))
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
|
|
// Next Steps
|
|
var hints []string
|
|
for _, cat := range cats {
|
|
switch cat.kind {
|
|
case "new", "modified", "restore", "orphan":
|
|
hints = append(hints, "sync")
|
|
case "override":
|
|
hints = append(hints, "sync --force")
|
|
case "local":
|
|
hints = append(hints, "collect")
|
|
}
|
|
}
|
|
if len(hints) > 0 {
|
|
b.WriteString("\n")
|
|
b.WriteString(tc.Title.Render("── Next Steps ──"))
|
|
b.WriteString("\n")
|
|
seen := map[string]bool{}
|
|
for _, h := range hints {
|
|
if seen[h] {
|
|
continue
|
|
}
|
|
seen[h] = true
|
|
b.WriteString(tc.Cyan.Render(fmt.Sprintf(" → skillshare %s", h)))
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
|
|
return b.String()
|
|
}
|
|
|
|
// --- Async diff ---
|
|
|
|
// expandDiffCmd returns a tea.Cmd that computes file diffs in a goroutine.
|
|
// For items with srcDir, also generates parallel unified diffs for modified files.
|
|
// For items with only dstDir (local only), populates file list without diff.
|
|
func expandDiffCmd(entry *copyDiffEntry) tea.Cmd {
|
|
return func() tea.Msg {
|
|
entry.ensureFiles()
|
|
|
|
// For remove/local-only items without srcDir, just return file list (no diff)
|
|
if entry.srcDir == "" {
|
|
return diffExpandMsg{skill: entry.name, files: entry.files}
|
|
}
|
|
|
|
// Collect modified files for diff
|
|
var modFiles []fileDiffEntry
|
|
for _, f := range entry.files {
|
|
if f.Action == "modify" {
|
|
modFiles = append(modFiles, f)
|
|
}
|
|
}
|
|
|
|
// Parallel diff computation
|
|
results := make([]string, len(modFiles))
|
|
var wg sync.WaitGroup
|
|
for i, f := range modFiles {
|
|
wg.Add(1)
|
|
go func(idx int, fe fileDiffEntry) {
|
|
defer wg.Done()
|
|
src := filepath.Join(entry.srcDir, fe.RelPath)
|
|
dst := filepath.Join(entry.dstDir, fe.RelPath)
|
|
results[idx] = generateUnifiedDiff(src, dst)
|
|
}(i, f)
|
|
}
|
|
wg.Wait()
|
|
|
|
// Combine results preserving order
|
|
var buf strings.Builder
|
|
for i, f := range modFiles {
|
|
if results[i] != "" {
|
|
buf.WriteString(fmt.Sprintf("--- %s\n", f.RelPath))
|
|
buf.WriteString(results[i])
|
|
}
|
|
}
|
|
|
|
return diffExpandMsg{
|
|
skill: entry.name,
|
|
diff: buf.String(),
|
|
files: entry.files,
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Entry point ---
|
|
|
|
func runDiffTUI(results []targetDiffResult, extrasResults ...[]extraDiffResult) error {
|
|
model := newDiffTUIModel(results, extrasResults...)
|
|
p := tea.NewProgram(model, tea.WithAltScreen())
|
|
_, err := p.Run()
|
|
return err
|
|
}
|