corago/codex-keep/intent.go

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"io"
	"os"
	"strings"
)

type intentLog struct {
	Path    string `json:"path"`
	Pos     int64  `json:"pos"`
	Fence   int64  `json:"fence"`
	Partial bool   `json:"partial,omitempty"`
	Sealed  bool   `json:"sealed,omitempty"`
}

func openIntent(path string) (*intentLog, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer func() { _ = f.Close() }()
	info, err := f.Stat()
	if err != nil {
		return nil, err
	}
	log := &intentLog{Path: path, Pos: info.Size(), Fence: info.Size()}
	if info.Size() != 0 {
		var last [1]byte
		if _, err := f.ReadAt(last[:], info.Size()-1); err != nil {
			return nil, err
		}
		log.Partial = last[0] != '\n'
	}
	return log, nil
}

func (l *intentLog) end() (int64, error) {
	info, err := os.Stat(l.Path)
	if err != nil {
		return 0, err
	}
	return info.Size(), nil
}

func (l *intentLog) seal() error {
	l.Sealed = true
	info, err := os.Stat(l.Path)
	if err != nil {
		return err
	}
	l.Fence = info.Size()
	l.Sealed = false
	return nil
}

func (l *intentLog) read(end int64) (goalStatus, error) {
	if l.Sealed {
		if err := l.seal(); err != nil {
			return "", err
		}
	}
	f, err := os.Open(l.Path)
	if err != nil {
		return "", err
	}
	defer func() { _ = f.Close() }()
	reader := bufio.NewReader(io.NewSectionReader(f, l.Pos, end-l.Pos))
	var latest goalStatus
	for {
		line, err := reader.ReadBytes('\n')
		if errors.Is(err, io.EOF) {
			return latest, nil
		}
		if err != nil {
			return "", err
		}
		next := l.Pos + int64(len(line))
		if l.Partial {
			l.Partial = false
			l.Pos = next
			continue
		}
		if l.Pos < l.Fence {
			l.Pos = next
			continue
		}
		status, match, err := parseIntent(line)
		if err != nil {
			return "", err
		}
		l.Pos = next
		if match {
			latest = status
		}
	}
}

func parseIntent(line []byte) (goalStatus, bool, error) {
	var record struct {
		Type    string `json:"type"`
		Payload struct {
			Type    string `json:"type"`
			Role    string `json:"role"`
			Content []struct {
				Type string `json:"type"`
				Text string `json:"text"`
			} `json:"content"`
			Meta struct {
				Kinds []string `json:"content_item_kinds"`
			} `json:"internal_chat_message_metadata_passthrough"`
		} `json:"payload"`
	}
	if err := json.Unmarshal(line, &record); err != nil {
		return "", false, err
	}
	p := record.Payload
	if record.Type != "response_item" || p.Type != "message" || p.Role != "user" || len(p.Content) != 1 ||
		p.Content[0].Type != "input_text" || len(p.Meta.Kinds) != 1 ||
		p.Meta.Kinds[0] != "user.goal" && p.Meta.Kinds[0] != "user.goal.omitted" {
		return "", false, nil
	}
	for _, line := range strings.Split(p.Content[0].Text, "\n") {
		if line == "User cleared the goal." {
			return "cleared", true, nil
		}
		if value, ok := strings.CutPrefix(line, "User set goal status: "); ok {
			var status goalStatus
			if err := json.Unmarshal([]byte(strings.TrimSuffix(value, ".")), &status); err != nil {
				return "", false, err
			}
			switch status {
			case active, paused, blocked, "complete", "budgetLimited", "usageLimited":
				return status, true, nil
			}
		}
	}
	return "", true, nil
}