Files
coder/scripts/aibridgepricesdiff/main.go
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

157 lines
3.8 KiB
Go
Raw Normal View History

// aibridgepricesdiff renders a human-readable Markdown summary of the
// difference between two AI Gateway price seed files (the prices.json produced
// by aibridgepricesgen).
//
// The price refresh workflow uses it to fill the pull request body, so
// a reviewer sees at a glance which models appeared, which disappeared, and
// which repriced. Exact figures are deliberately left to the pull request
// diff, which is the source of truth.
//
// Usage:
//
// aibridgepricesdiff -old <path> -new <path>
package main
import (
"flag"
"fmt"
"io"
"os"
"sort"
"strings"
"golang.org/x/xerrors"
"github.com/coder/coder/v2/coderd/aibridge/prices/pricebook"
)
func less(a, b pricebook.Key) bool {
if a.Provider != b.Provider {
return a.Provider < b.Provider
}
return a.Model < b.Model
}
// diff is the full comparison between two snapshots
type diff struct {
added []pricebook.Key
removed []pricebook.Key
changed []pricebook.Key
}
func (d diff) empty() bool {
return len(d.added) == 0 && len(d.removed) == 0 && len(d.changed) == 0
}
func main() {
oldPath := flag.String("old", "", "path to the previous prices.json (required)")
newPath := flag.String("new", "", "path to the refreshed prices.json (required)")
flag.Parse()
if err := run(*oldPath, *newPath, os.Stdout); err != nil {
_, _ = fmt.Fprintf(os.Stderr, "aibridgepricesdiff: %v\n", err)
os.Exit(1)
}
}
func run(oldPath, newPath string, w io.Writer) error {
if oldPath == "" || newPath == "" {
return xerrors.New("-old and -new are both required")
}
oldRows, err := readRows(oldPath)
if err != nil {
return xerrors.Errorf("read %s: %w", oldPath, err)
}
newRows, err := readRows(newPath)
if err != nil {
return xerrors.Errorf("read %s: %w", newPath, err)
}
_, err = io.WriteString(w, render(compare(oldRows, newRows)))
return err
}
func readRows(path string) ([]pricebook.Row, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, err
}
rows, err := pricebook.Parse(data)
if err != nil {
return nil, xerrors.Errorf("parse: %w", err)
}
return rows, nil
}
// compare classifies every model as added, removed, or changed.
func compare(oldRows, newRows []pricebook.Row) diff {
oldByKey := make(map[pricebook.Key]pricebook.Row, len(oldRows))
for _, r := range oldRows {
oldByKey[r.Key()] = r
}
var d diff
seen := make(map[pricebook.Key]struct{}, len(newRows))
for _, r := range newRows {
seen[r.Key()] = struct{}{}
prev, ok := oldByKey[r.Key()]
switch {
case !ok:
d.added = append(d.added, r.Key())
case !prev.SamePrices(r):
d.changed = append(d.changed, r.Key())
}
}
for _, r := range oldRows {
if _, ok := seen[r.Key()]; !ok {
d.removed = append(d.removed, r.Key())
}
}
for _, keys := range [][]pricebook.Key{d.added, d.removed, d.changed} {
sort.Slice(keys, func(i, j int) bool { return less(keys[i], keys[j]) })
}
return d
}
// render writes the Markdown summary: counts, then the models in each
// category. Empty categories are omitted.
func render(d diff) string {
var b strings.Builder
write := func(format string, args ...any) {
_, _ = fmt.Fprintf(&b, format, args...)
}
write("## Price book changes\n\n")
if d.empty() {
write("No price changes.\n")
return b.String()
}
write("%s added, %s removed, %s changed.\n",
plural(len(d.added), "model"),
plural(len(d.removed), "model"),
plural(len(d.changed), "model"),
)
renderList := func(heading string, keys []pricebook.Key) {
if len(keys) == 0 {
return
}
write("\n<details>\n<summary>%s</summary>\n\n", heading)
for _, k := range keys {
write("- %s\n", k)
}
write("</details>\n")
}
renderList("Added", d.added)
renderList("Removed", d.removed)
renderList("Changed", d.changed)
return b.String()
}
func plural(n int, noun string) string {
if n == 1 {
return fmt.Sprintf("%d %s", n, noun)
}
return fmt.Sprintf("%d %ss", n, noun)
}