chatops

type Deliverable ¶

type Deliverable struct {
	URL     string // a deploy/PR/preview URL surfaced from the run's output
	Summary string // a workflow-provided delivery summary (ctx["delivery"])
}

Deliverable describes what a successful run produced, for presentation.

type Gate ¶

type Gate struct {
	ID      string
	Kind    GateKind
	Prompt  string
	Choices []string // GateChoice / GateYesNo: selectable labels
	Default string   // preferred label, if any
}

Gate describes a human decision the pipeline is blocked on, for presentation in a conversation thread. One ThreadInterviewer serves one thread, so a Gate carries no thread id — the ThreadUI it is posted through is already bound to its thread. ID correlates the eventual answer back to the blocked call. Interview gates are decomposed into a sequence of these by the interviewer.

type GateAnswer ¶

type GateAnswer struct {
	Choice   string // GateChoice / GateYesNo / labeled freeform
	Freeform string // GateFreeform / labeled freeform "other"
	Canceled bool
}

GateAnswer carries a human's response back to the blocked pipeline. Exactly one field is meaningful per gate kind; Canceled short-circuits both.

type GateKind ¶

type GateKind string

GateKind classifies how a human gate is presented in a thread.

const (
	GateChoice   GateKind = "choice"   // pick one of N labels (buttons)
	GateYesNo    GateKind = "yes_no"   // a fixed Yes/No decision
	GateFreeform GateKind = "freeform" // open-ended text reply
)

type GrammarResolver ¶

type GrammarResolver struct{}

GrammarResolver understands the explicit form "[run] <workflow> [k=v ...]".

func (GrammarResolver) Resolve(_ context.Context, text string) (Intent, error)

type Intent ¶

type Intent struct {
	Workflow string
	Params   map[string]string
}

Intent is a parsed request: which workflow to run and any param overrides.

type IntentResolver ¶

type IntentResolver interface {
	Resolve(ctx context.Context, text string) (Intent, error)
}

IntentResolver turns the free text of an @mention into an Intent.

type PendingClearer ¶

type PendingClearer interface {
	ClearPending(gateID string)
}

PendingClearer is an optional ThreadUI capability: clear a thread's pending freeform gate when it stops waiting (resolved or abandoned), so a later unrelated reply isn't consumed by a stale gate.

type RunRecord ¶

type RunRecord struct {
	ThreadTS string            `json:"thread_ts"`
	Channel  string            `json:"channel"`
	Workflow string            `json:"workflow"`
	Params   map[string]string `json:"params,omitempty"`
}

RunRecord is what's needed to resume a run after a restart: which thread and channel it belongs to, and which workflow (+ params) it ran. The workdir and checkpoint path are derived deterministically from the thread_ts.

type RunView ¶

type RunView struct {
	Key   string // external id — a Slack thread_ts
	State string // "starting" | "running" | terminal status
}

RunView is a read-only snapshot of an active run, for a transport that renders a standing dashboard (Slack App Home, a web status page). It is decoupled from the engine's *ManagedRun so the transport layer needs no pipeline types.

type Runner ¶

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

Runner maps Slack threads to tracker runs. It owns a RunManager and, per active thread, the ThreadInterviewer that inbound interactions resolve against.

func NewRunner(rm *tracker.RunManager, deps RunnerDeps) *Runner

func (r *Runner) ActiveRuns() []RunView

func (r *Runner) OnInteraction(threadTS, gateID string, answer GateAnswer) bool

func (r *Runner) OnMention(ctx context.Context, channel, threadTS, text string)

func (r *Runner) Resume(ctx context.Context, rec RunRecord)

func (r *Runner) SweepOrphans(keep []RunRecord)

type RunnerDeps ¶

type RunnerDeps struct {
	// NewThreadUI returns a ThreadUI bound to one (channel, thread) — supplied by
	// the transport (slack.go) so the runner stays Slack-agnostic.
	NewThreadUI func(channel, threadTS string) ThreadUI
	// WorkDir is where ResolveSource looks for local .dip files (built-ins
	// resolve regardless).
	WorkDir string
	// RunsBase is the parent directory for per-thread isolated run workdirs
	// (base/<sanitized thread_ts>), each holding that run's checkpoint.
	RunsBase string
	// NewID returns a fresh unique gate id per call.
	NewID func() string
	// Intent resolves @mention text to a workflow + params. Nil falls back to the
	// deterministic grammar ("[run] <workflow> [k=v ...]").
	Intent IntentResolver
	// Store persists active runs for resume-after-restart. Nil disables it.
	Store *Store
	// KeepWorkdirs retains a run's workdir after it finishes (for later
	// inspection) instead of reclaiming the disk. Default false: reap on
	// terminal, bounding disk under sustained multi-run load.
	KeepWorkdirs bool
	// ConfirmOverUSD requires a human to confirm a run whose expected cost meets
	// or exceeds this dollar amount before it starts. 0 disables confirmation.
	ConfirmOverUSD float64
	// ConfigBase carries provider/budget/backend config; the runner overlays the
	// per-run Interviewer, EventHandler, and Params onto a copy of it.
	ConfigBase tracker.Config
}

RunnerDeps are the transport-provided hooks and per-run config a Runner needs.

type StatusCard ¶

type StatusCard struct {
	Workflow    string
	State       string // "running" | "success" | "fail" | "budget_exceeded" | "validation_overridden"
	Nodes       []StatusNode
	CurrentNode string
	DoneCount   int
	TotalCount  int
	CostUSD     float64
	BudgetUSD   float64 // 0 = no ceiling
	Tokens      int
	Elapsed     time.Duration
}

StatusCard is the transport-neutral snapshot the renderer draws. It is a plain value so a renderer can hold it without racing the tracker.

type StatusNode ¶

type StatusNode struct {
	Label string
	State string // "pending" | "active" | "done" | "failed"
}

StatusNode is one node's lamp in the card.

type StatusRenderer ¶

type StatusRenderer interface {
	UpsertStatus(card StatusCard) error
}

StatusRenderer is an optional ThreadUI capability: post-or-update a single status message for the run. A transport that implements it (Slack via chat.update; a future Discord via message edit) gets the live card; one that doesn't just falls back to the discrete notifier posts.

type Store ¶

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

store is a small JSON-file-backed set of active runs, keyed by thread_ts. A nil *Store is a valid no-op (persistence disabled).

func OpenStore(path string) *Store

func (s *Store) List() []RunRecord

type ThreadInterviewer ¶

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

ThreadInterviewer implements tracker's human-gate interviewer interfaces by presenting each gate in a Slack thread and blocking until the thread resolves it (a button click, modal submit, or reply). One instance serves one run.

It implements the full family (Interviewer, FreeformInterviewer, LabeledFreeformInterviewer, InterviewInterviewer) plus Actor()/Cancel()/ SetPipelineContext, so tracker's human handler picks the richest mode.

func NewThreadInterviewer(ui ThreadUI, newID func() string) *ThreadInterviewer

func (s *ThreadInterviewer) Actor() pipeline.Actor

func (s *ThreadInterviewer) Ask(prompt string, choices []string, def string) (string, error)

func (s *ThreadInterviewer) AskFreeform(prompt string) (string, error)

func (s *ThreadInterviewer) AskFreeformWithLabels(prompt string, labels []string, def string) (string, error)

func (s *ThreadInterviewer) AskInterview(questions []handlers.Question, _ *handlers.InterviewResult) (*handlers.InterviewResult, error)

func (s *ThreadInterviewer) Cancel()

func (s *ThreadInterviewer) Resolve(gateID string, ans GateAnswer) bool

func (s *ThreadInterviewer) SetPipelineContext(ctx context.Context)

type ThreadUI ¶

type ThreadUI interface {
	// PostGate renders a gate to the thread; gate.ID correlates the answer.
	PostGate(gate Gate) error
	// Post sends a plain notification/message to the thread.
	Post(text string) error
}

ThreadUI presents gates and messages in a single conversation thread. It is the seam between the transport-neutral gate logic (ThreadInterviewer, runner) and the Slack Block Kit layer (slack.go) — so the logic is testable without a live Slack connection. Implementations are bound to one thread.