149 lines
3.5 KiB
Go
149 lines
3.5 KiB
Go
package agents
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"codex-agent-manager/internal/codexhome"
|
|
)
|
|
|
|
type Store struct {
|
|
CodexHome string
|
|
}
|
|
|
|
func (s Store) List() ([]AgentDefinition, error) {
|
|
agentsDir, err := codexhome.ResolveInside(s.CodexHome, "agents")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
entries, err := os.ReadDir(agentsDir)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return []AgentDefinition{}, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
sort.Slice(entries, func(i, j int) bool {
|
|
return entries[i].Name() < entries[j].Name()
|
|
})
|
|
|
|
result := make([]AgentDefinition, 0, len(entries))
|
|
for _, entry := range entries {
|
|
if entry.IsDir() || !strings.HasSuffix(strings.ToLower(entry.Name()), ".toml") {
|
|
continue
|
|
}
|
|
result = append(result, s.readOne(entry.Name()))
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (s Store) readOne(fileName string) AgentDefinition {
|
|
path := filepath.Join(s.CodexHome, "agents", fileName)
|
|
def := AgentDefinition{
|
|
ID: strings.TrimSuffix(fileName, filepath.Ext(fileName)),
|
|
FilePath: path,
|
|
FileName: fileName,
|
|
ParseStatus: "valid",
|
|
DraftStatus: "clean",
|
|
ExtraFields: map[string]string{},
|
|
}
|
|
|
|
safePath, err := codexhome.ResolveAgentTOML(s.CodexHome, fileName)
|
|
if err != nil {
|
|
def.ParseStatus = "invalid"
|
|
def.ParseError = err.Error()
|
|
return def
|
|
}
|
|
info, statErr := os.Stat(safePath)
|
|
if statErr == nil {
|
|
def.ModifiedAt = info.ModTime()
|
|
}
|
|
data, err := os.ReadFile(safePath)
|
|
if err != nil {
|
|
def.ParseStatus = "invalid"
|
|
def.ParseError = err.Error()
|
|
return def
|
|
}
|
|
values, err := parseSimpleTOML(string(data))
|
|
if err != nil {
|
|
def.ParseStatus = "invalid"
|
|
def.ParseError = err.Error()
|
|
return def
|
|
}
|
|
|
|
def.Name = values["name"]
|
|
def.Description = values["description"]
|
|
def.DeveloperInstructions = values["developer_instructions"]
|
|
for key, value := range values {
|
|
if key == "name" || key == "description" || key == "developer_instructions" {
|
|
continue
|
|
}
|
|
def.ExtraFields[key] = value
|
|
}
|
|
return def
|
|
}
|
|
|
|
func parseSimpleTOML(input string) (map[string]string, error) {
|
|
values := map[string]string{}
|
|
scanner := bufio.NewScanner(strings.NewReader(input))
|
|
lineNumber := 0
|
|
for scanner.Scan() {
|
|
lineNumber++
|
|
line := strings.TrimSpace(scanner.Text())
|
|
if line == "" || strings.HasPrefix(line, "#") {
|
|
continue
|
|
}
|
|
parts := strings.SplitN(line, "=", 2)
|
|
if len(parts) != 2 {
|
|
return values, fmt.Errorf("第 %d 行不是有效的键值字段", lineNumber)
|
|
}
|
|
key := strings.TrimSpace(parts[0])
|
|
raw := strings.TrimSpace(parts[1])
|
|
if key == "" {
|
|
return values, fmt.Errorf("第 %d 行缺少字段名", lineNumber)
|
|
}
|
|
|
|
value, err := parseTOMLString(raw, scanner)
|
|
if err != nil {
|
|
return values, err
|
|
}
|
|
values[key] = value
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
return values, err
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func parseTOMLString(raw string, scanner *bufio.Scanner) (string, error) {
|
|
if strings.HasPrefix(raw, `"""`) {
|
|
block := strings.TrimPrefix(raw, `"""`)
|
|
for !strings.Contains(block, `"""`) && scanner.Scan() {
|
|
block += "\n" + scanner.Text()
|
|
}
|
|
if !strings.Contains(block, `"""`) {
|
|
return "", errors.New("未闭合的多行字符串")
|
|
}
|
|
value, trailing, _ := strings.Cut(block, `"""`)
|
|
if strings.TrimSpace(trailing) != "" {
|
|
return "", errors.New("多行字符串后存在不支持的内容")
|
|
}
|
|
return value, nil
|
|
}
|
|
if !strings.HasPrefix(raw, `"`) {
|
|
return "", errors.New("仅支持字符串字段")
|
|
}
|
|
value, err := strconv.Unquote(raw)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return value, nil
|
|
}
|