forgechat

type AnswerPayload struct {
	QuestionID int64  `json:"question_id"`
	OptionID   string `json:"option_id,omitempty"`
}

type AnvilContext map[string]string

type AnvilLookup func(name string) (path string, ok bool)

type AnvilTarget struct {
	Name string
	Path string
}

type BdRunner func(ctx context.Context, dir string, args ...string) ([]byte, error)

type BeadProposal struct {
	ProposalID  string   `json:"id"`
	Anvil       string   `json:"anvil"`
	Title       string   `json:"title"`
	Description string   `json:"description"`
	Type        string   `json:"type"`
	Priority    int      `json:"priority"`
	Labels      []string `json:"labels,omitempty"`
	// DependsOn is a list of sibling ProposalIDs that must complete before
	// this bead. Cross-anvil deps are rejected up front because bd's
	// dep-store is anvil-local — a "depends on" link from anvil X to anvil Y
	// would never resolve, so we refuse rather than silently break.
	DependsOn []string `json:"depends_on,omitempty"`
}

type ClaudeRunner struct {
	// Provider is the AI backend used for every turn. Callers typically
	// resolve this from settings.stage_providers["forgechat"] with a fallback
	// to the global provider chain.
	Provider provider.Provider
	// MaxTurns caps the AI session length. Defaults to 10. The grilling
	// prompt asks for a single JSON envelope, so a low budget is fine.
	MaxTurns int
	// Timeout caps the wall-clock duration of a single turn. Defaults to
	// defaultTurnTimeout (5m). Override at construction from
	// settings.forgechat.turn_timeout.
	Timeout time.Duration
	// ExtraFlags are passed through to claude (e.g. --model).
	ExtraFlags []string
}

type EmissionEnvelope struct {
	Beads   []BeadProposal `json:"beads"`
	Summary string         `json:"summary,omitempty"`
}

type EmittedMessage struct {
	Kind     string
	Content  string
	Metadata string
}

type HistoryMessage struct {
	Role     string
	Kind     string
	Content  string
	Metadata string
}

type MaterializeResult struct {
	Created       []MaterializedBead
	RolledBack    bool
	RollbackError error
	Err           error
}

type MaterializedBead struct {
	ProposalID string
	BeadID     string
	Anvil      string
	AnvilPath  string
	Title      string
}

type Mode string

type QuestionOption struct {
	ID          string `json:"id"`
	Label       string `json:"label"`
	Description string `json:"description,omitempty"`
}

type QuestionPayload struct {
	Options        []QuestionOption `json:"options"`
	Recommendation string           `json:"recommendation,omitempty"`
	Rationale      string           `json:"rationale,omitempty"`
}

type Runner interface {
	Turn(ctx context.Context, req TurnRequest) (*TurnResponse, error)
}

type Stage string

type TurnRequest struct {
	Stage    Stage
	Mode     Mode
	Title    string
	Plan     string
	History  []HistoryMessage
	UserText string
	// Anvils is the set of registered anvils the AI may target when emitting
	// beads (ModeEmit). Keys are anvil names; values are short hints. Unused
	// for chat / plan / grill modes.
	Anvils AnvilContext
	// Anvil is the session-scoped target for drafting / plan / grilling turns
	// — the bead being designed already has an anvil association, so the AI
	// is told the resolved name + absolute path up-front and uses it to read
	// the codebase via Read / Grep / Glob. Nil leaves the anvil context out
	// of the prompt (the AI then has to ask, which is what we're fixing).
	Anvil *AnvilTarget
	// SessionID identifies the originating Beads-Forge session and is logged
	// when a turn fails (e.g. on timeout). Zero is acceptable for callers
	// that don't have a persistent session (tests, one-off runs).
	SessionID int64
}

type TurnResponse struct {
	Messages []EmittedMessage
	NewStage Stage
	NewPlan  string
	// CostUSD is the cumulative cost of this turn (best-effort — real
	// runners read it from the claude stream, mocks may set 0).
	CostUSD float64
	// Emission is set when Mode == ModeEmit and parsing succeeded. Callers
	// inspect this to materialise beads via bd; the returned Messages slice
	// is empty in that case (the handler decides what to persist after
	// materialisation).
	Emission *EmissionEnvelope
}