Queue external data for the next root turn

[onechat] / memory.go

diff --git a/memory.go b/memory.go
index 49215ac54405edb82e3957609713022aaeecf14c..97be6a1b6547bab878d8fa01d3de91b89793d25a 100644 (file)
--- a/memory.go
+++ b/memory.go
@@ -86,7 +86,7 @@ type MemoryViewFile struct {
 func openMemory(ctx context.Context, root string, clock func() time.Time, summarizer Summarizer, logger *slog.Logger) (*Memory, error) {
        log, err := openLog(ctx, root, clock)
        if err != nil {
-               return nil, err
+               return nil, fmt.Errorf("open memory log: %w", err)
        }
 
        m := &Memory{
@@ -207,7 +207,7 @@ func (m *Memory) restoreQueue() error {
        for id := range m.chat.end {
                built, err := m.tree.Built(0, id)
                if err != nil {
-                       return err
+                       return fmt.Errorf("check restored leaf: %w", err)
                }
 
                if built {
@@ -216,7 +216,7 @@ func (m *Memory) restoreQueue() error {
 
                message, err := m.log.Message(id)
                if err != nil {
-                       return err
+                       return fmt.Errorf("read restored message: %w", err)
                }
 
                leaf, free := freeLeaf(message)
@@ -228,13 +228,13 @@ func (m *Memory) restoreQueue() error {
 
                err = m.build(leaf)
                if err != nil {
-                       return err
+                       return fmt.Errorf("build restored leaf: %w", err)
                }
        }
 
        keys, err := m.tree.Keys()
        if err != nil {
-               return err
+               return fmt.Errorf("read built nodes: %w", err)
        }
 
        for _, key := range keys {
@@ -244,7 +244,7 @@ func (m *Memory) restoreQueue() error {
 
                err = m.settle(key)
                if err != nil {
-                       return err
+                       return fmt.Errorf("settle restored node: %w", err)
                }
        }
 
@@ -261,16 +261,21 @@ func (m *Memory) catchUp() error {
        for m.chat.end < m.log.Len() {
                message, err := m.log.Message(m.chat.end)
                if err != nil {
-                       return err
+                       return fmt.Errorf("read pending message: %w", err)
                }
 
                err = m.addMessage(message)
                if err != nil {
-                       return err
+                       return fmt.Errorf("add pending message: %w", err)
                }
        }
 
-       return m.save()
+       err := m.save()
+       if err != nil {
+               return fmt.Errorf("save caught-up memory: %w", err)
+       }
+
+       return nil
 }
 
 // dispatch starts the builds that are ready, up to the limit. A build whose
@@ -305,13 +310,18 @@ func (m *Memory) viewPath() string {
 func (m *Memory) build(node Node) error {
        err := m.tree.Add(node)
        if err != nil {
-               return err
+               return fmt.Errorf("add built node: %w", err)
        }
 
        m.chat.Refresh(node)
        m.cview.Refresh(node)
 
-       return m.settle(NodeKey{node.Level, node.Index})
+       err = m.settle(NodeKey{node.Level, node.Index})
+       if err != nil {
+               return fmt.Errorf("settle built node: %w", err)
+       }
+
+       return nil
 }
 
 // settle looks at the parent of the built node key when both children are
@@ -322,12 +332,16 @@ func (m *Memory) settle(key NodeKey) error {
                parent := NodeKey{key.level + 1, key.index / 2}
                ready, err := m.ready(parent)
                if err != nil || !ready {
-                       return err
+                       if err != nil {
+                               return fmt.Errorf("check parent readiness: %w", err)
+                       }
+
+                       return nil
                }
 
                left, right, err := m.children(parent)
                if err != nil {
-                       return err
+                       return fmt.Errorf("read parent children: %w", err)
                }
 
                node, free := freeMerge(left, right)
@@ -339,7 +353,7 @@ func (m *Memory) settle(key NodeKey) error {
 
                err = m.tree.Add(node)
                if err != nil {
-                       return err
+                       return fmt.Errorf("add merged node: %w", err)
                }
 
                key = parent
@@ -353,7 +367,7 @@ func (m *Memory) settle(key NodeKey) error {
 func (m *Memory) addMessage(message Message) error {
        built, err := m.tree.Built(0, message.ID)
        if err != nil {
-               return err
+               return fmt.Errorf("check message leaf: %w", err)
        }
 
        leaf, free := freeLeaf(message)
@@ -362,7 +376,7 @@ func (m *Memory) addMessage(message Message) error {
        case free:
                err = m.build(leaf)
                if err != nil {
-                       return err
+                       return fmt.Errorf("build message leaf: %w", err)
                }
        default:
                m.queue.AddLeaf(message.ID)
@@ -415,7 +429,7 @@ func (m *Memory) task(key NodeKey) (Task, error) {
        if key.level == 0 {
                message, err := m.log.Message(key.index)
                if err != nil {
-                       return Task{}, err
+                       return Task{}, fmt.Errorf("read leaf message: %w", err)
                }
 
                task.Input = []string{leafSource(message)}
@@ -426,7 +440,7 @@ func (m *Memory) task(key NodeKey) (Task, error) {
 
        left, right, err := m.children(key)
        if err != nil {
-               return Task{}, err
+               return Task{}, fmt.Errorf("read task children: %w", err)
        }
 
        for _, child := range []Node{left, right} {
@@ -483,13 +497,20 @@ func (m *Memory) ready(key NodeKey) (bool, error) {
        for _, index := range []int{2 * key.index, 2*key.index + 1} {
                built, err := m.tree.Built(key.level-1, index)
                if err != nil || !built {
-                       return false, err
+                       if err != nil {
+                               return false, fmt.Errorf("check child readiness: %w", err)
+                       }
+
+                       return false, nil
                }
        }
 
        built, err := m.tree.Built(key.level, key.index)
+       if err != nil {
+               return !built, fmt.Errorf("check parent readiness: %w", err)
+       }
 
-       return !built, err
+       return !built, nil
 }
 
 // children reads the two children of the node key.
@@ -499,7 +520,7 @@ func (m *Memory) children(key NodeKey) (Node, Node, error) {
        for n := range children {
                child, built, err := m.tree.Node(key.level-1, 2*key.index+n)
                if err != nil {
-                       return Node{}, Node{}, err
+                       return Node{}, Node{}, fmt.Errorf("read child node: %w", err)
                }
 
                if !built {