Store the subagents and read them with zoom

[onechat] / subagent.go

package main

import (
        "context"
        "errors"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"
        "strconv"
        "strings"
        "sync"
        "time"
)

const (
        // subagentDirName is the directory of the subagents in the directory of
        // an agent.
        subagentDirName = "subagents"

        // subagentNameDraws is the most names that Create draws before it
        // fails.
        subagentNameDraws = 1000
)

// newSubagents returns the subagents in dir, one directory for each name. The
// clock gives the dates of their messages, and draw gives the names of new
// subagents.
func newSubagents(dir string, clock func() time.Time, draw func() string) *Subagents {
        return &Subagents{
                dir:   dir,
                clock: clock,
                draw:  draw,
                open:  make(map[string]*Subagent),
        }
}

// Subagents holds the subagents of one agent. Each subagent has a directory
// named for it, which holds its log. A log takes an exclusive lock, so
// Subagents opens the log of a name once and keeps it open until Close. Its
// mutex protects the open logs.
type Subagents struct {
        dir   string
        clock func() time.Time
        draw  func() string

        mutex sync.Mutex
        open  map[string]*Subagent
}

// Create makes the directory and the log of a new subagent. It draws a name
// again when the directory of the name exists.
func (s *Subagents) Create(ctx context.Context) (*Subagent, error) {
        err := os.MkdirAll(s.dir, 0o700)
        if err != nil {
                return nil, fmt.Errorf("create subagent directory: %w", err)
        }

        for range subagentNameDraws {
                name := s.draw()
                err = os.Mkdir(filepath.Join(s.dir, name), 0o700)
                if errors.Is(err, fs.ErrExist) {
                        continue
                }

                if err != nil {
                        return nil, fmt.Errorf("create subagent directory: %w", err)
                }

                return s.Get(ctx, name)
        }

        return nil, fmt.Errorf("no free subagent name after %d draws", subagentNameDraws)
}

// Get returns the subagent name with its log open. A name that is not valid or
// that has no directory is an unknown agent.
func (s *Subagents) Get(ctx context.Context, name string) (*Subagent, error) {
        s.mutex.Lock()
        defer s.mutex.Unlock()

        subagent, found := s.open[name]
        if found {
                return subagent, nil
        }

        unknown := fmt.Errorf("no agent %s", name)
        if !subagentNameValid(name) {
                return nil, unknown
        }

        root := filepath.Join(s.dir, name)
        info, err := os.Stat(root)
        if errors.Is(err, fs.ErrNotExist) {
                return nil, unknown
        }

        if err != nil {
                return nil, fmt.Errorf("read subagent directory: %w", err)
        }

        if !info.IsDir() {
                return nil, unknown
        }

        log, err := openLog(ctx, root, s.clock)
        if err != nil {
                return nil, fmt.Errorf("open log of %s: %w", name, err)
        }

        syncer, err := openSyncer(root)
        if err != nil {
                return nil, errors.Join(fmt.Errorf("open log of %s: %w", name, err), log.Close())
        }

        subagent = &Subagent{
                name:   name,
                log:    log,
                syncer: syncer,
        }
        s.open[name] = subagent

        return subagent, nil
}

// Close makes the writes of each open log durable and closes it.
func (s *Subagents) Close() error {
        s.mutex.Lock()
        defer s.mutex.Unlock()

        var err error
        for name, subagent := range s.open {
                err = errors.Join(err, subagent.close())
                delete(s.open, name)
        }

        return err
}

// Subagent is one subagent and its log. Its mutex protects the log, because
// the run of the subagent writes it while the agent reads it with zoom.
type Subagent struct {
        name   string
        mutex  sync.Mutex
        log    *Log
        syncer *Syncer
}

// Append logs a message of the subagent.
func (a *Subagent) Append(kind, text string) (Message, error) {
        a.mutex.Lock()
        defer a.mutex.Unlock()

        message, err := a.log.Append(kind, text)
        if err != nil {
                return Message{}, err
        }

        a.syncer.Written()

        return message, nil
}

// Flush returns when every write before the call is durable.
func (a *Subagent) Flush(ctx context.Context) error {
        return a.syncer.Flush(ctx)
}

// Show returns the whole log, each message as "i|kind: text", with a blank line
// between messages.
func (a *Subagent) Show() (string, error) {
        a.mutex.Lock()
        defer a.mutex.Unlock()

        lines := make([]string, 0, a.log.Len())
        for id := range a.log.Len() {
                message, err := a.log.Message(id)
                if err != nil {
                        return "", err
                }

                lines = append(lines, strconv.Itoa(id)+"|"+leafSource(message))
        }

        return strings.Join(lines, "\n\n"), nil
}

// close makes the writes durable and closes the log.
func (a *Subagent) close() error {
        a.mutex.Lock()
        defer a.mutex.Unlock()

        return errors.Join(a.syncer.Close(), a.log.Close())
}