Taken over from the join (6ada2089, f1417ab0, 6e162a60, 3a4e62b0, 73fb42d7, ee15a280, a5476f62, 94a4e62a, 33907a81, e519cc87, e8f268c1) and fitted to the final contracts: the seat's events are pull-updated, pull-merged, pull-closed, forge-delete; OwedEnded keeps only the fields §164 names; merge-pull takes no ask. A merge act is performed only as a switched act (§169); from G the gate owes none (§167). Builds: design 47 G §43, §45, §157, §161, §162, §163, §164, §167, §168, §169, §171, §250 Claude-Session: https://claude.ai/code/session_01JG73KEq4zoDfM9WtYpcQgZ
133 lines
5.5 KiB
Go
133 lines
5.5 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
stdio "git.novox.be/novox/mesh-sdk/go"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
|
|
|
"mesh-delivery-forge-bridge/internal/groups"
|
|
)
|
|
|
|
// The tools of what the bridge performs of what is owed to the forge (novox/hq design 47 *What the gate owes the forge*).
|
|
const (
|
|
OwedTool = "bridge_owed"
|
|
OwedAgainTool = "bridge_owed_again"
|
|
OwedDropTool = "bridge_owed_drop"
|
|
)
|
|
|
|
// OwedRow is one act the bridge performed, as the state performed keeps it: the outcome said as owed.ended.
|
|
type OwedRow = forgemsg.OwedEnded
|
|
|
|
// performedRows reads every act the state performed holds; a key that is not an act (a group end's bookkeeping) is left.
|
|
func performedRows(s stdio.KeptState) ([]OwedRow, error) {
|
|
keys, err := s.Keys()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("the bridge's performed state cannot be listed: %w", err)
|
|
}
|
|
var rows []OwedRow
|
|
for _, k := range keys {
|
|
e, err := s.Get(k)
|
|
if err != nil || e == nil {
|
|
continue
|
|
}
|
|
var p struct {
|
|
Ended OwedRow `json:"ended"`
|
|
}
|
|
if json.Unmarshal(e.Value, &p) == nil && p.Ended.Of != "" {
|
|
rows = append(rows, p.Ended)
|
|
}
|
|
}
|
|
sort.Slice(rows, func(i, j int) bool { return rows[i].At.After(rows[j].At) })
|
|
return rows, nil
|
|
}
|
|
|
|
// OwedTools are bridge_owed, bridge_owed_again and bridge_owed_drop: ask writes an owed-asks value and waits for the
|
|
// bridge's answer; performed reads the state performed; record writes a hand act in the seat mesh-hand-acts' log before
|
|
// a drop is asked, so a drop is never made without its record.
|
|
func OwedTools(ask func(key string, value []byte) ([]byte, error), performed func() ([]OwedRow, error), record func(what, why string) error, now func() time.Time) []stdio.Tool {
|
|
str := func(args map[string]any, k string) string { s, _ := args[k].(string); return strings.TrimSpace(s) }
|
|
act := map[string]any{
|
|
"of": map[string]any{"type": "string", "description": "the seat that said the act: mesh-delivery (the gate) or mesh-delivery-checker"},
|
|
"id": map[string]any{"type": "string", "description": "the act's id, as owed and owed.ended say it"}}
|
|
asked := func(kind string, args map[string]any) (groups.OwedAsk, error) {
|
|
key, value, err := groups.NewOwedAsk(kind, str(args, "of"), str(args, "id"), str(args, "why"), stdio.CallerOf(args), now())
|
|
if err != nil {
|
|
return groups.OwedAsk{}, err
|
|
}
|
|
v, err := ask(key, value)
|
|
if err != nil {
|
|
return groups.OwedAsk{}, err
|
|
}
|
|
return groups.DecodeOwedAsk(v)
|
|
}
|
|
withWhy := map[string]any{"why": map[string]any{"type": "string", "description": "why it is dropped, in plain words"}}
|
|
for k, v := range act {
|
|
withWhy[k] = v
|
|
}
|
|
return []stdio.Tool{
|
|
{Name: OwedTool,
|
|
Description: "What the forge bridge performed of what the gate and the checker owe the forge (design 47): each act it said as " +
|
|
"owed.ended, newest first, with its seat, id, pull request, outcome (performed, refused, could not be performed, " +
|
|
"undecodable, dropped), the forge's words and when, from its state performed (kept 7 days); and the backlog of its " +
|
|
"durable on each seat's stream owed: the last event applied, the events waiting and held, the age of the oldest. " +
|
|
"of or id narrow it. Read-only.",
|
|
Input: map[string]any{"type": "object", "properties": act},
|
|
Run: func(args map[string]any) (any, error) {
|
|
rows, err := performed()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
kept := []OwedRow{}
|
|
for _, r := range rows {
|
|
if (str(args, "of") == "" || r.Of == str(args, "of")) && (str(args, "id") == "" || r.ID == str(args, "id")) {
|
|
kept = append(kept, r)
|
|
}
|
|
}
|
|
out := map[string]any{"performed": kept}
|
|
if a, err := asked(groups.OwedBacklog, args); err != nil {
|
|
out["backlog-error"] = err.Error()
|
|
} else {
|
|
out["backlog"] = a.Backlog
|
|
}
|
|
return out, nil
|
|
}},
|
|
{Name: OwedAgainTool,
|
|
Description: "Perform one act owed to the forge again now, by hand, whatever its last outcome (a refusal the forge no longer " +
|
|
"makes, an act that could not be performed): the bridge calls the seat git's verb of the act under its id (safe to " +
|
|
"repeat) and says its outcome as owed.ended. The act is the one the bridge kept, or, for the gate's, the seat " +
|
|
"mesh-delivery's groups. Answers the outcome.",
|
|
Input: map[string]any{"type": "object", "required": []string{"of", "id"}, "properties": act},
|
|
Run: func(args map[string]any) (any, error) {
|
|
a, err := asked(groups.OwedAgain, args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return map[string]any{"of": a.Of, "id": a.ID, "outcome": a.Outcome, "answer": a.Answer}, nil
|
|
}},
|
|
{Name: OwedDropTool,
|
|
Description: "Drop one act owed to the forge, by hand, with why: written first in the hand-act log of the seat mesh-hand-acts, " +
|
|
"then said by the bridge as owed.ended with the outcome dropped, so its owner records it answered and stops saying " +
|
|
"it again. Nothing is done at the forge. Answers the outcome said.",
|
|
Input: map[string]any{"type": "object", "required": []string{"of", "id", "why"}, "properties": withWhy},
|
|
Run: func(args map[string]any) (any, error) {
|
|
if str(args, "why") == "" {
|
|
return nil, fmt.Errorf("a drop says why")
|
|
}
|
|
if err := record(fmt.Sprintf("dropped the act %s that %s owes the forge", str(args, "id"), str(args, "of")), str(args, "why")); err != nil {
|
|
return nil, err
|
|
}
|
|
a, err := asked(groups.OwedDrop, args)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return map[string]any{"of": a.Of, "id": a.ID, "outcome": a.Outcome, "answer": a.Answer}, nil
|
|
}},
|
|
}
|
|
}
|