Week 3 Day 15：状态机（FSM）驱动 Agent Workflow#

// internal/workflow/fsm.go
package workflow

import (
	"context"
	"errors"
	"fmt"
	"sync"
)

type State string

const (
	StatePending   State = "pending"
	StateRunning   State = "running"
	StateCompleted State = "completed"
	StateFailed    State = "failed"
	StateCancelled State = "cancelled"
)

type Event string

const (
	EventStart    Event = "start"
	EventStepDone Event = "step_done"
	EventFail     Event = "fail"
	EventCancel   Event = "cancel"
)

// transitions: (currentState, event) -> nextState
var transitions = map[State]map[Event]State{
	StatePending: {
		EventStart:  StateRunning,
		EventCancel: StateCancelled,
	},
	StateRunning: {
		EventStepDone: StateCompleted,
		EventFail:     StateFailed,
		EventCancel:   StateCancelled,
	},
}

type FSM struct {
	mu      sync.Mutex
	state   State
	history []transition
}

type transition struct {
	From  State
	To    State
	Event Event
}

func New() *FSM {
	return &FSM{state: StatePending}
}

func (f *FSM) Current() State {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.state
}

func (f *FSM) Fire(ctx context.Context, e Event) error {
	f.mu.Lock()
	defer f.mu.Unlock()

	next, ok := transitions[f.state][e]
	if !ok {
		return fmt.Errorf("illegal transition: %s --%s--> ?", f.state, e)
	}
	f.history = append(f.history, transition{From: f.state, To: next, Event: e})
	f.state = next
	return nil
}

// internal/workflow/step.go
package workflow

import "context"

// Step 是 workflow 的最小执行单元
type Step interface {
	Name() string
	Run(ctx context.Context, input map[string]any) (output map[string]any, err error)
}

// Workflow 串联多个 Step
type Workflow struct {
	ID    string
	Steps []Step
	fsm   *FSM
	// 每步的输出汇总，给下一步用
	ctx map[string]any
}

func NewWorkflow(id string, steps []Step) *Workflow {
	return &Workflow{
		ID:    id,
		Steps: steps,
		fsm:   New(),
		ctx:   map[string]any{},
	}
}

func (w *Workflow) Run(ctx context.Context, input map[string]any) error {
	if err := w.fsm.Fire(ctx, EventStart); err != nil {
		return err
	}
	for k, v := range input {
		w.ctx[k] = v
	}
	for _, step := range w.Steps {
		out, err := step.Run(ctx, w.ctx)
		if err != nil {
			_ = w.fsm.Fire(ctx, EventFail)
			return fmt.Errorf("step %s failed: %w", step.Name(), err)
		}
		for k, v := range out {
			w.ctx[k] = v
		}
	}
	return w.fsm.Fire(ctx, EventStepDone)
}

type ValidateStep struct{}
func (ValidateStep) Name() string { return "validate" }
func (ValidateStep) Run(ctx context.Context, in map[string]any) (map[string]any, error) {
	title, _ := in["title"].(string)
	if len(title) < 5 {
		return nil, errors.New("title too short")
	}
	return map[string]any{"validated": true}, nil
}

type DraftStep struct{ llm LLMClient }
func (d DraftStep) Name() string { return "draft" }
func (d DraftStep) Run(ctx context.Context, in map[string]any) (map[string]any, error) {
	draft, err := d.llm.Generate(ctx, fmt.Sprintf("Draft ticket for: %v", in["title"]))
	return map[string]any{"draft": draft}, err
}

type CreateStep struct{ jira JiraClient }
func (c CreateStep) Name() string { return "create" }
func (c CreateStep) Run(ctx context.Context, in map[string]any) (map[string]any, error) {
	id, err := c.jira.Create(ctx, in["draft"].(string))
	return map[string]any{"ticket_id": id}, err
}

// internal/workflow/engine.go
package workflow

type Engine struct {
	store  Store          // 持久化（Day 16 详细讲）
	events chan EventMsg
}

type EventMsg struct {
	WorkflowID string
	Event      Event
	Payload    map[string]any
}

func (e *Engine) Handle(ctx context.Context) {
	for msg := range e.events {
		wf, err := e.store.Load(ctx, msg.WorkflowID)
		if err != nil {
			continue
		}
		if err := wf.fsm.Fire(ctx, msg.Event); err != nil {
			// 非法转移，记日志即可
			continue
		}
		// 到达某个状态触发动作
		switch wf.fsm.Current() {
		case StateRunning:
			go e.runNextStep(ctx, wf) // 异步执行
		case StateCompleted, StateFailed, StateCancelled:
			_ = e.store.Save(ctx, wf)
		}
	}
}

func minWindow(s, t string) string {
	need := map[byte]int{}
	for i := 0; i < len(t); i++ {
		need[t[i]]++
	}
	have := map[byte]int{}
	left, count := 0, 0
	resStart, resLen := 0, -1

	for right := 0; right < len(s); right++ {
		c := s[right]
		have[c]++
		// 该字符数量刚好满足需求时，满足字符种数+1
		if need[c] > 0 && have[c] == need[c] {
			count++
		}
		// 窗口满足所有字符需求，尝试收缩左边
		for count == len(need) {
			if resLen == -1 || right-left+1 < resLen {
				resStart, resLen = left, right-left+1
			}
			lc := s[left]
			have[lc]--
			if need[lc] > 0 && have[lc] < need[lc] {
				count--
			}
			left++
		}
	}
	if resLen == -1 {
		return ""
	}
	return s[resStart : resStart+resLen]
}

func nextPermutation(nums []int) {
	n := len(nums)
	// 步骤1：从右往左找第一个下降点 i（nums[i] < nums[i+1]）
	i := n - 2
	for i >= 0 && nums[i] >= nums[i+1] {
		i--
	}
	if i >= 0 {
		// 步骤2：从右往左找第一个大于 nums[i] 的位置 j
		j := n - 1
		for j > i && nums[j] <= nums[i] {
			j--
		}
		// 步骤3：交换
		nums[i], nums[j] = nums[j], nums[i]
	}
	// 步骤4：反转 i+1 到末尾（使后缀变最小）
	left, right := i+1, n-1
	for left < right {
		nums[left], nums[right] = nums[right], nums[left]
		left++
		right--
	}
}

func characterReplacement(s string, k int) int {
	count := [26]int{}
	maxFreq := 0
	left, result := 0, 0

	for right := 0; right < len(s); right++ {
		count[s[right]-'A']++
		if count[s[right]-'A'] > maxFreq {
			maxFreq = count[s[right]-'A']
		}
		// 窗口内需要替换的字符数 = 窗口长度 - 最高频字符数
		for right-left+1-maxFreq > k {
			count[s[left]-'A']--
			left++
		}
		if right-left+1 > result {
			result = right - left + 1
		}
	}
	return result
}