ghostree/macos/Sources/Features/Terminal/RepoPromptSplitButton.swift at a18574ebe9536168ba4579201413bce7d3cd2a81 · sidequery/ghostree · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#if os(macOS)
import AppKit

enum RepoPromptSplitButton {
    private static let fallbackImage = NSImage(
        systemSymbolName: "arrow.trianglehead.branch",
        accessibilityDescription: "Repo action"
    ) ?? NSImage()

    static func make(target: TerminalController?) -> NSSegmentedControl {
        let segmented = NSSegmentedControl()
        segmented.segmentCount = 2
        segmented.trackingMode = .momentary
        segmented.segmentStyle = .separated

        segmented.setImage(fallbackImage, forSegment: 0)
        segmented.setImageScaling(.scaleProportionallyDown, forSegment: 0)
        segmented.setLabel("Action", forSegment: 0)
        segmented.setWidth(0, forSegment: 0)
        segmented.setWidth(22, forSegment: 1)
        segmented.setShowsMenuIndicator(true, forSegment: 1)
        segmented.target = target
        segmented.action = #selector(TerminalController.repoPromptToolbarAction(_:))

        update(segmented, resolution: target?.repoPromptResolution ?? .disabled(.noFocusedTerminal))
        return segmented
    }

    static func update(
        _ segmented: NSSegmentedControl,
        resolution: TerminalRepoPromptResolution
    ) {
        segmented.setToolTip("Type a repo workflow prompt into the current AI session", forSegment: 0)
        segmented.setToolTip("Choose a repo workflow prompt", forSegment: 1)

        switch resolution {
        case .disabled(let reason):
            segmented.isEnabled = false
            segmented.setLabel("Action", forSegment: 0)
            segmented.toolTip = reason.description
            segmented.setToolTip(reason.description, forSegment: 0)
            segmented.setToolTip(reason.description, forSegment: 1)
            segmented.setMenu(disabledMenu(reason: reason), forSegment: 1)

        case .ready(let readyState):
            segmented.isEnabled = true
            segmented.setLabel(readyState.primaryAction.title, forSegment: 0)
            let primaryDescription = readyState.state(for: readyState.primaryAction)?.description
                ?? "Type a repo workflow prompt into the current AI session."
            segmented.toolTip = primaryDescription
            segmented.setToolTip(primaryDescription, forSegment: 0)
            segmented.setToolTip("Choose a repo workflow prompt", forSegment: 1)
            segmented.setMenu(menu(for: readyState, target: segmented.target), forSegment: 1)
        }
    }

    private static func disabledMenu(reason: TerminalRepoPromptDisabledReason) -> NSMenu {
        let menu = NSMenu()
        let item = NSMenuItem(title: reason.title, action: nil, keyEquivalent: "")
        item.isEnabled = false
        item.toolTip = reason.description
        menu.addItem(item)
        return menu
    }

    private static func menu(
        for readyState: TerminalRepoPromptReadyState,
        target: AnyObject?
    ) -> NSMenu {
        let menu = NSMenu()
        if let shortcut = readyState.shortcutAction {
            menu.addItem(shortcutItem(for: shortcut, target: target))
            menu.addItem(.separator())
        }
        for state in readyState.actionStates {
            menu.addItem(item(for: state, target: target))
        }
        return menu
    }

    private static func selector(for action: TerminalRepoPromptAction) -> Selector {
        switch action {
        case .smart:
            return #selector(TerminalController.insertSmartRepoPrompt(_:))
        case .commit:
            return #selector(TerminalController.insertCommitRepoPrompt(_:))
        case .commitAndPush:
            return #selector(TerminalController.insertCommitAndPushRepoPrompt(_:))
        case .push:
            return #selector(TerminalController.insertPushRepoPrompt(_:))
        case .pushAndOpenPR:
            return #selector(TerminalController.insertPushAndOpenPRRepoPrompt(_:))
        case .openPR:
            return #selector(TerminalController.insertOpenPRRepoPrompt(_:))
        case .pushAndUpdatePR:
            return #selector(TerminalController.insertPushAndUpdatePRRepoPrompt(_:))
        case .updatePR:
            return #selector(TerminalController.insertUpdatePRRepoPrompt(_:))
        }
    }

    private static func shortcutItem(
        for shortcut: TerminalRepoPromptShortcutState,
        target: AnyObject?
    ) -> NSMenuItem {
        let item = NSMenuItem(
            title: shortcut.action.title,
            action: selector(for: shortcut.action),
            keyEquivalent: ""
        )
        item.target = target
        item.toolTip = shortcut.description
        return item
    }

    private static func item(
        for state: TerminalRepoPromptActionState,
        target: AnyObject?
    ) -> NSMenuItem {
        let item = NSMenuItem(
            title: state.action.title,
            action: state.isAvailable ? selector(for: state.action) : nil,
            keyEquivalent: ""
        )
        item.target = target
        item.isEnabled = state.isAvailable
        item.toolTip = state.description
        return item
    }
}
#endif