commands

type BtwCommand ¶

type BtwCommand struct {
	// contains filtered or unexported fields
}

BtwCommand drives /btw — an ephemeral side-chain Q&A that consults the current conversation context but never mutates history or invokes tools. It is exported so the host can route the async tui.BtwResultMsg back to the active overlay via SetResult.

func Btw(session *agent.Session, overlay OverlayController) *BtwCommand

func (c *BtwCommand) Active() bool

func (c *BtwCommand) Dismiss()

func (c *BtwCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *BtwCommand) IsModal() bool

func (c *BtwCommand) Run(inv Invocation) tea.Cmd

func (c *BtwCommand) SetResult(msg tui.BtwResultMsg)

func (c *BtwCommand) Spec() Spec

func (c *BtwCommand) View(width, _ int) string

type Command ¶

type Command interface {
	Spec() Spec
	Run(inv Invocation) tea.Cmd
}

Command is the unified abstraction for all slash commands.

func Clear(session *agent.Session, resetPlanState func()) Command

func Compact(session *agent.Session) Command

func Copy(session *agent.Session) Command

func Dream(d *dream.Dreamer) Command

func Exit() Command

func Loop(store *cron.Store) Command

func MCP(manager *mcpclient.Manager) Command

func Memory(cwd string, reloadSession func()) Command

func New(session *agent.Session, resetPlanState func()) Command

func NewSimple(spec Spec, run func(inv Invocation) tea.Cmd) Command

func Reload(reload func() (ReloadResult, error)) Command

type ContextCommand ¶

type ContextCommand struct {
	// contains filtered or unexported fields
}

ContextCommand drives /context — a tabbed modal overlay reporting current context window usage, message composition, and runtime suggestions.

func Context(session *agent.Session, overlay OverlayController) *ContextCommand

func (c *ContextCommand) Active() bool

func (c *ContextCommand) Dismiss()

func (c *ContextCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *ContextCommand) IsModal() bool

func (c *ContextCommand) Run(_ Invocation) tea.Cmd

func (c *ContextCommand) Spec() Spec

func (c *ContextCommand) View(width, height int) string

type DebugHarnessCommand ¶

type DebugHarnessCommand struct {
	// contains filtered or unexported fields
}

DebugHarnessCommand drives /debug-harness — a tabbed modal overlay surfacing harness runtime diagnostics (last turn, recent activity, metrics, context).

func DebugHarness(session *agent.Session, overlay OverlayController) *DebugHarnessCommand

func (c *DebugHarnessCommand) Active() bool

func (c *DebugHarnessCommand) Dismiss()

func (c *DebugHarnessCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *DebugHarnessCommand) IsModal() bool

func (c *DebugHarnessCommand) Run(_ Invocation) tea.Cmd

func (c *DebugHarnessCommand) Spec() Spec

func (c *DebugHarnessCommand) View(width, height int) string

type DiffCommand ¶ added in v0.2.0

type DiffCommand struct {
	// contains filtered or unexported fields
}

DiffCommand drives /diff — an interactive overlay listing the files the last turn changed (what /undo would roll back), with per-file added/removed counts.

func Diff(session *agent.Session, overlay OverlayController) *DiffCommand

func (c *DiffCommand) Active() bool

func (c *DiffCommand) Dismiss()

func (c *DiffCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *DiffCommand) IsModal() bool

func (c *DiffCommand) Run(_ Invocation) tea.Cmd

func (c *DiffCommand) Spec() Spec

func (c *DiffCommand) View(width, height int) string

type GoalCommand ¶ added in v0.2.2

type GoalCommand struct {
	Create func(objective string, tokenBudget int) tea.Cmd
	Status func() tea.Cmd
	Pause  func() tea.Cmd
	Resume func(tokenBudget int) tea.Cmd
	Clear  func() tea.Cmd
}

func (c *GoalCommand) Run(inv Invocation) tea.Cmd

func (c *GoalCommand) Spec() Spec

type HelpCommand ¶

type HelpCommand struct {
	// contains filtered or unexported fields
}

HelpCommand drives /help — a tabbed modal overlay listing general intro, built-in commands, custom (file/plugin) commands, and skills.

func Help(registry Registry) *HelpCommand

func (c *HelpCommand) Active() bool

func (c *HelpCommand) Dismiss()

func (c *HelpCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *HelpCommand) IsModal() bool

func (c *HelpCommand) Run(_ Invocation) tea.Cmd

func (c *HelpCommand) Spec() Spec

func (c *HelpCommand) View(width, height int) string

type InteractiveCommand ¶

type InteractiveCommand interface {
	Command
	Active() bool
	HandleKey(msg tea.KeyMsg) (handled bool, cmd tea.Cmd)
	View(width, height int) string
	Dismiss()
}

InteractiveCommand extends Command with modal keyboard interception and custom rendering. When Active() returns true the host TUI routes all keyboard events through HandleKey and replaces the input area with View.

Implementations are modal by default — see ModalOverlay below for opting out.

View receives the available width AND height of the terminal viewport so implementations can clip or paginate their content. A height of 0 means "unconstrained" (legacy callers); implementations should treat any positive value as a hard upper bound to avoid having their headers scroll out of view.

type Invocation ¶

type Invocation struct {
	Input   string
	Name    string
	RawArgs string
	Args    []string
}

Invocation is the parsed slash-command input passed to command handlers.

func ParseInvocation(input string) (Invocation, bool)

type Kind ¶

type Kind string

Kind classifies how a command was contributed.

const (
	KindBuiltin Kind = "builtin"
	KindCustom  Kind = "custom"
	KindSkill   Kind = "skill"
)

type MCPReloadResult ¶

type MCPReloadResult struct {
	Connected int
	Failed    int
	Tools     int
	Errors    []string
}

MCPReloadResult is the subset of MCP runtime status that plugin mutations surface back to the user. The host fills it in after rebuilding the MCP pool following a plugin enable/disable/trust/install/remove.

type ModalOverlay ¶

type ModalOverlay interface {
	IsModal() bool
}

ModalOverlay is an optional interface used by overlays that want to opt out of the modal default. Overlays that intercept keyboard input (the typical case) replace the input area, so they don't need to implement this. Non-modal overlays — autocomplete-style hint panels that coexist with the input — must implement this and return false.

type ModelCommand ¶

type ModelCommand struct {
	// contains filtered or unexported fields
}

ModelCommand drives /model — an interactive selector that switches the current chat model and persists the choice to whichever settings file already owns the model setting (project if present, otherwise global).

func Model(session *agent.Session, overlay OverlayController, cwd string) *ModelCommand

func (c *ModelCommand) Active() bool

func (c *ModelCommand) Dismiss()

func (c *ModelCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *ModelCommand) IsModal() bool

func (c *ModelCommand) Run(_ Invocation) tea.Cmd

func (c *ModelCommand) Spec() Spec

func (c *ModelCommand) View(width, _ int) string

type OverlayController ¶

type OverlayController interface {
	SetOverlay(InteractiveCommand)
	ClearOverlay()
}

OverlayController is the surface needed to install or dismiss the active modal overlay. Most interactive commands (/btw, /context, /tasks, ...) take this directly because they never enumerate peers.

type PlanCommand ¶

type PlanCommand struct {
	Phase  func() plan.Phase
	Enter  func() tea.Cmd
	Show   func() tea.Cmd
	Cancel func() tea.Cmd
	Open   func() tea.Cmd
}

PlanCommand drives /plan — entering plan mode or managing the active plan. The plan state machine (review modal, key handling, agentcore event hooks) stays in the ui package because it spans multiple TUI subsystems; this command only routes the slash-command surface into it via the callbacks below.

func (c *PlanCommand) Run(inv Invocation) tea.Cmd

func (c *PlanCommand) Spec() Spec

type PluginsCommand ¶

type PluginsCommand struct {
	Catalog        *plugin.Catalog
	Session        *agent.Session
	Cwd            string
	ReloadState    func() error
	RefreshRuntime func() (MCPReloadResult, error)
}

PluginsCommand drives /plugins — a multi-subcommand entry that inspects and mutates the plugin catalog. The fields below are the host hooks the mutating paths need; construct with a struct literal at registration time.

func (p *PluginsCommand) Run(inv Invocation) tea.Cmd

func (p *PluginsCommand) Spec() Spec

type RedoCommand ¶ added in v0.2.0

type RedoCommand struct {
	// contains filtered or unexported fields
}

RedoCommand drives /redo — it re-applies the file changes undone by the last /undo, returning the workspace to the state just before that undo. A new turn (fresh edits) clears the redo branch.

func Redo(session *agent.Session) *RedoCommand

func (c *RedoCommand) Run(_ Invocation) tea.Cmd

func (c *RedoCommand) Spec() Spec

type Registry ¶

type Registry interface {
	OverlayController
	All() []Command
	EffectiveSpec(cmd Command) Spec
}

Registry extends OverlayController with peer-enumeration methods used by /help. ui.Registry is the only implementation; everywhere except /help takes OverlayController directly so its dependency surface stays narrow.

type ReloadResult ¶

type ReloadResult struct {
	Commands     int
	Skills       int
	MCPTools     int
	MCPConnected int
	MCPFailed    int
}

ReloadResult summarises the outcome of a /reload run, used to render the terminal feedback line. The host App fills in the counts after reloading plugin / skill / MCP state.

type ResumeCommand ¶

type ResumeCommand struct {
	// contains filtered or unexported fields
}

ResumeCommand drives /resume — an interactive overlay listing recent sessions and switching to the chosen one.

func Resume(session *agent.Session, overlay OverlayController, resetPlan func(), afterSwitch func() error) *ResumeCommand

func (c *ResumeCommand) Active() bool

func (c *ResumeCommand) Dismiss()

func (c *ResumeCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *ResumeCommand) IsModal() bool

func (c *ResumeCommand) Run(_ Invocation) tea.Cmd

func (c *ResumeCommand) Spec() Spec

func (c *ResumeCommand) View(width, _ int) string

type SettingsCommand ¶

type SettingsCommand struct {
	// contains filtered or unexported fields
}

SettingsCommand drives /settings — a tabbed modal overlay reporting the current general / runtime / providers configuration.

func Settings(session *agent.Session, overlay OverlayController, approvalEngine *approval.Engine, cwd string) *SettingsCommand

func (c *SettingsCommand) Active() bool

func (c *SettingsCommand) Dismiss()

func (c *SettingsCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *SettingsCommand) IsModal() bool

func (c *SettingsCommand) Run(_ Invocation) tea.Cmd

func (c *SettingsCommand) Spec() Spec

func (c *SettingsCommand) View(width, height int) string

type Spec ¶

type Spec struct {
	Name        string
	Aliases     []string
	Usage       string
	Description string
	Category    string
	NeedsIdle   bool
	Hidden      bool
	Kind        Kind
	Source      string
}

Spec describes command metadata used by the registry, palette, and help command.

type StatusCommand ¶

type StatusCommand struct {
	Session   *agent.Session
	Overlay   OverlayController
	Approval  *approval.Engine
	Plugins   *plugin.Catalog
	MCP       *mcpclient.Manager
	Cron      *cron.Store
	PlanPhase func() plan.Phase

	Cwd       string
	GitBranch string
	Version   string

	// SkillCount / CommandCount are read on every render so /reload-driven
	// changes are reflected without re-registering the command.
	SkillCount   func() int
	CommandCount func() int
	// contains filtered or unexported fields
}

StatusCommand drives /status — a tabbed modal overlay reporting the live runtime snapshot of the current session: who you are, what you're running, what you've spent, and what's plugged in.

/status answers "what does the agent look like *right now*". /settings is the static config side of the same coin; /debug-harness is the internal observability side. The three should never duplicate each other.

func (c *StatusCommand) Active() bool

func (c *StatusCommand) Dismiss()

func (c *StatusCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *StatusCommand) IsModal() bool

func (c *StatusCommand) Run(_ Invocation) tea.Cmd

func (c *StatusCommand) Spec() Spec

func (c *StatusCommand) View(width, height int) string

type TasksCommand ¶

type TasksCommand struct {
	// contains filtered or unexported fields
}

TasksCommand drives /tasks — an interactive overlay listing background shells and forked sub-agents, with detail and stop controls.

func Tasks(runtime *task.Runtime, overlay OverlayController) *TasksCommand

func (c *TasksCommand) Active() bool

func (c *TasksCommand) Dismiss()

func (c *TasksCommand) HandleKey(msg tea.KeyMsg) (bool, tea.Cmd)

func (c *TasksCommand) IsModal() bool

func (c *TasksCommand) Run(_ Invocation) tea.Cmd

func (c *TasksCommand) Spec() Spec

func (c *TasksCommand) View(width, _ int) string

type UndoCommand ¶ added in v0.2.0

type UndoCommand struct {
	// contains filtered or unexported fields
}

UndoCommand drives /undo — it reverts workspace files to the start of the most recent turn, undoing the agent's last round of edits. Conversation history is left untouched.

func Undo(session *agent.Session) *UndoCommand

func (c *UndoCommand) Run(_ Invocation) tea.Cmd

func (c *UndoCommand) Spec() Spec

type WorktreeCommand ¶ added in v0.3.0

type WorktreeCommand struct {
	Enter  func(name string) (string, error)
	Exit   func(discard bool) (string, error)
	Active func() bool
}

WorktreeCommand drives /worktree — an isolated git-worktree sandbox the session works in, reviewed and merged or discarded on exit.

/worktree <name>   create a sandbox and move the session into it
/worktree exit     return to the main workspace, keeping changes for review
/worktree discard  return to the main workspace, discarding the sandbox

Enter/Exit are wired to the runtime and return a ready-to-display message. They are nil outside the interactive TUI, where the command is unavailable.

func (c *WorktreeCommand) Run(inv Invocation) tea.Cmd

func (c *WorktreeCommand) Spec() Spec