hyperguild/cmd/supervisor/main.go

package main

import (
	"context"
	"log/slog"
	"net/http"
	"os"

	"github.com/mathiasbq/supervisor/internal/config"
	iexec "github.com/mathiasbq/supervisor/internal/exec"
	"github.com/mathiasbq/supervisor/internal/mcp"
	"github.com/mathiasbq/supervisor/internal/registry"
	"github.com/mathiasbq/supervisor/internal/skills/brain"
	"github.com/mathiasbq/supervisor/internal/skills/org"
	"github.com/mathiasbq/supervisor/internal/skills/retrospective"
	skilldebug "github.com/mathiasbq/supervisor/internal/skills/debug"
	"github.com/mathiasbq/supervisor/internal/skills/review"
	"github.com/mathiasbq/supervisor/internal/skills/spec"
	"github.com/mathiasbq/supervisor/internal/skills/trainer"
	"github.com/mathiasbq/supervisor/internal/skills/sessionlog"
	"github.com/mathiasbq/supervisor/internal/skills/tdd"
	"github.com/mathiasbq/supervisor/internal/tier"
)

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

	cfg, err := config.Load()
	if err != nil {
		logger.Error("load config", "err", err)
		os.Exit(1)
	}

	models, err := config.LoadModels(cfg.ModelsFile)
	if err != nil {
		logger.Error("load models", "err", err)
		os.Exit(1)
	}

	systemPrompt, err := os.ReadFile(cfg.ConfigDir + "/CLAUDE.md")
	if err != nil {
		logger.Error("read supervisor CLAUDE.md", "path", cfg.ConfigDir+"/CLAUDE.md", "err", err)
		os.Exit(1)
	}

	protocolsPrompt, err := os.ReadFile(cfg.ConfigDir + "/protocols.md")
	if err != nil {
		logger.Error("read protocols.md", "path", cfg.ConfigDir+"/protocols.md", "err", err)
		os.Exit(1)
	}

	// prependProtocols prepends the shared protocols to a skill discipline file.
	prependProtocols := func(skillPrompt []byte) string {
		return string(protocolsPrompt) + "\n---\n\n" + string(skillPrompt)
	}

	tddPrompt, err := os.ReadFile(cfg.ConfigDir + "/tdd.md")
	if err != nil {
		logger.Error("read tdd.md", "path", cfg.ConfigDir+"/tdd.md", "err", err)
		os.Exit(1)
	}

	retroPrompt, err := os.ReadFile(cfg.ConfigDir + "/retrospective.md")
	if err != nil {
		logger.Error("read retrospective.md", "path", cfg.ConfigDir+"/retrospective.md", "err", err)
		os.Exit(1)
	}

	reviewPrompt, err := os.ReadFile(cfg.ConfigDir + "/review.md")
	if err != nil {
		logger.Error("read review.md", "path", cfg.ConfigDir+"/review.md", "err", err)
		os.Exit(1)
	}

	debugPrompt, err := os.ReadFile(cfg.ConfigDir + "/debug.md")
	if err != nil {
		logger.Error("read debug.md", "path", cfg.ConfigDir+"/debug.md", "err", err)
		os.Exit(1)
	}

	specPrompt, err := os.ReadFile(cfg.ConfigDir + "/spec.md")
	if err != nil {
		logger.Error("read spec.md", "path", cfg.ConfigDir+"/spec.md", "err", err)
		os.Exit(1)
	}

	trainerReaderPrompt, err := os.ReadFile(cfg.ConfigDir + "/trainer-reader.md")
	if err != nil {
		logger.Error("read trainer-reader.md", "path", cfg.ConfigDir+"/trainer-reader.md", "err", err)
		os.Exit(1)
	}
	trainerWriterPrompt, err := os.ReadFile(cfg.ConfigDir + "/trainer-writer.md")
	if err != nil {
		logger.Error("read trainer-writer.md", "path", cfg.ConfigDir+"/trainer-writer.md", "err", err)
		os.Exit(1)
	}

	claudeExec := iexec.New(iexec.Config{
		SystemPrompt:   string(systemPrompt),
		LiteLLMBaseURL: cfg.LiteLLMBaseURL,
		LiteLLMAPIKey:  cfg.LiteLLMAPIKey,
	})
	litellmExec := iexec.NewLiteLLM(cfg.LiteLLMBaseURL, cfg.LiteLLMAPIKey, 0)
	verifier := iexec.NewVerifier("", models.Verifier(), 0)

	buildOrch := func(skill string) func(ctx context.Context, req iexec.Request) (iexec.Result, error) {
		return func(ctx context.Context, req iexec.Request) (iexec.Result, error) {
			rawChain := models.ChainFor(skill, req.Model)
			chain := make([]iexec.ChainEntry, len(rawChain))
			for i, m := range rawChain {
				chain[i] = iexec.EntryFor(m)
			}
			attempts := make([]iexec.AttemptRecord, 0, len(chain))
			orch := iexec.NewOrchestrator(chain, litellmExec.Run, claudeExec.Run, verifier, models.LlamaSwapURL(), &attempts)
			result, err := orch.Run(ctx, req)
			result.Attempts = attempts // attach orchestration metadata before returning
			// Log per-attempt verdicts so pass rates are visible in pod logs.
			for i, a := range attempts {
				logger.Info("chain attempt",
					"skill", skill,
					"attempt", i+1,
					"model", a.Model,
					"tier", a.Tier,
					"verdict", a.Verdict,
					"duration_ms", a.DurationMs,
					"warm", a.WarmStart,
				)
			}
			return result, err
		}
	}

	tierFn := func(ctx context.Context) tier.Info {
		return tier.Detect(ctx, "https://api.anthropic.com", cfg.LiteLLMBaseURL)
	}

	reg := registry.New()
	reg.Register(tdd.New(tdd.Config{
		SystemPrompt:  string(systemPrompt),
		SkillPrompt:   prependProtocols(tddPrompt),
		DefaultModel:  models.ChainFor("tdd", "")[0],
		ExecutorFn:    buildOrch("tdd"),
		SessionsDir:   cfg.SessionsDir,
		IngestBaseURL: cfg.IngestBaseURL,
	}))
	reg.Register(brain.New(brain.Config{
		IngestBaseURL: cfg.IngestBaseURL,
	}))
	reg.Register(org.New(org.Config{
		TierFn: tierFn,
	}))
	reg.Register(sessionlog.New(sessionlog.Config{
		SessionsDir: cfg.SessionsDir,
	}))
	reg.Register(retrospective.New(retrospective.Config{
		SkillPrompt:  prependProtocols(retroPrompt),
		DefaultModel: models.ChainFor("retrospective", "")[0],
		SessionsDir:  cfg.SessionsDir,
		ExecutorFn:   buildOrch("retrospective"),
	}))
	reg.Register(review.New(review.Config{
		SkillPrompt:   prependProtocols(reviewPrompt),
		DefaultModel:  models.ChainFor("review", "")[0],
		ExecutorFn:    buildOrch("review"),
		SessionsDir:   cfg.SessionsDir,
		IngestBaseURL: cfg.IngestBaseURL,
	}))
	reg.Register(skilldebug.New(skilldebug.Config{
		SkillPrompt:   prependProtocols(debugPrompt),
		DefaultModel:  models.ChainFor("debug", "")[0],
		ExecutorFn:    buildOrch("debug"),
		SessionsDir:   cfg.SessionsDir,
		IngestBaseURL: cfg.IngestBaseURL,
	}))
	reg.Register(spec.New(spec.Config{
		SkillPrompt:   prependProtocols(specPrompt),
		DefaultModel:  models.ChainFor("spec", "")[0],
		ExecutorFn:    buildOrch("spec"),
		SessionsDir:   cfg.SessionsDir,
		IngestBaseURL: cfg.IngestBaseURL,
	}))
	reg.Register(trainer.New(trainer.Config{
		ReaderPrompt: prependProtocols(trainerReaderPrompt),
		WriterPrompt: prependProtocols(trainerWriterPrompt),
		DefaultModel: models.ChainFor("trainer", "")[0],
		ExecutorFn:   buildOrch("trainer"),
		SessionsDir:  cfg.SessionsDir,
		BrainDir:     cfg.BrainDir,
	}))

	srv := mcp.NewServer(reg)
	mux := http.NewServeMux()
	mux.Handle("/mcp", srv)

	addr := ":" + cfg.Port
	logger.Info("supervisor starting", "addr", addr, "version", "v0.4.0")
	if err := http.ListenAndServe(addr, mux); err != nil {
		logger.Error("server stopped", "err", err)
		os.Exit(1)
	}
}