diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index e3dde936e..f868dff9a 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -55,6 +55,7 @@ import ( "github.com/samcharles93/archie-core/internal/infrastructure/skillcurator" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" "github.com/samcharles93/archie-core/internal/infrastructure/taskactions" + "github.com/samcharles93/archie-core/internal/infrastructure/toolbuilder" "github.com/samcharles93/archie-core/internal/logging" "github.com/samcharles93/archie-core/internal/plugin" "github.com/samcharles93/archie-core/internal/plugin/pluginextract" @@ -1024,6 +1025,10 @@ func (b *boot) setupCurators(ctx context.Context) { b.curatorRegistry = curator.NewRegistry(curator.Registrar{ Log: log.With("component", "curator"), Events: curatorEventSink{b.bus}, + // Tools resolves declared curator tool names from the same + // process-wide registry a chat turn is given (b.toolReg): one + // catalogue, resolved down to the declared set by the builder. + Tools: toolbuilder.New(b.toolReg), // b.memEngines (*domainmemory.Registry) satisfies // curator.MemoryEngineSource's Get(name) signature directly, no // adapter needed. Set by setupMemoryEngine, which Run() calls before @@ -1053,6 +1058,33 @@ func (b *boot) setupCurators(ctx context.Context) { if err := b.curatorRegistry.Register(sessioncurator.New(sessioncurator.DefaultInterval, infraMemory.EngineName)); err != nil { log.Error("session-memory curator registration failed", "err", err) } + // Config definitions are seed data: each enabled [[curators]] entry is + // registered through the one generic definition-driven engine. Code + // registrations above win for their own name (a duplicate is refused + // and logged, not silently replaced). + for _, def := range b.cfg.Curators { + if !def.Enabled { + continue + } + engine := curator.NewDefinitionEngine(curator.Definition{ + Name: def.Name, + Enabled: def.Enabled, + Instructions: def.Instructions, + Manifest: curator.Manifest{ + Interval: def.Interval.Std(), + Cooldown: def.Cooldown.Std(), + OnInput: def.OnInput, + Tools: def.Tools, + Skills: def.Skills, + MemoryEngine: def.MemoryEngine, + Conversations: def.Conversations, + Model: def.Model, + }, + }) + if err := b.curatorRegistry.Register(engine); err != nil { + log.Error("config curator registration failed", "curator", def.Name, "err", err) + } + } // The runtime owns the per-curator loops (archie-core-89x): one // goroutine per curator, wake nudges, per-pass budgets, panic // recovery, bounded shutdown. Stop order at shutdown: runtime first diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index d5910d42a..9a54b5d25 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -498,8 +498,10 @@ func (s curatorEventSink) Emit(kind, detail string, data map[string]any) { // curatorLLMRunner adapts the shared ai-sdk runtime to the curator // family's narrow LLMRunner contract: one model reference, plain -// messages, no tools, no streaming -- curators that need more than a -// single completion are a bigger decision than this adapter makes. +// messages, and the declared tool set -- no streaming. Tools are built +// through the same agentexec path a chat turn uses, so a curator's +// declared set is converted to a runnable core.ToolSet rather than a +// parallel catalogue. type curatorLLMRunner struct { rt *runtime.Runtime // outcomes records this call for /status alongside sendChatTurn's. A @@ -523,12 +525,26 @@ func (r curatorLLMRunner) Chat(ctx context.Context, req curator.ChatRequest) (cu for _, m := range req.Messages { msgs = append(msgs, chat.Message{Role: chat.Role(m.Role), Content: m.Content}) } - res, err := r.rt.Chat(ctx, req.Model, core.GenerateOptions{Messages: msgs, MaxSteps: max(req.MaxSteps, 1)}) + toolSet, err := agentexec.BuildToolSetFrom(req.Tools, agentexec.ToolSetOptions{}) + if err != nil { + r.outcomes.record(req.Model, err) + return curator.ChatResult{}, err + } + res, err := r.rt.Chat(ctx, req.Model, core.GenerateOptions{ + Messages: msgs, + Tools: toolSet, + MaxSteps: max(req.MaxSteps, 1), + }) r.outcomes.record(req.Model, err) if err != nil { return curator.ChatResult{}, err } - return curator.ChatResult{Text: res.Text}, nil + + calls := make([]curator.ToolCall, 0, len(res.ToolCalls)) + for _, call := range res.ToolCalls { + calls = append(calls, curator.ToolCall{Name: call.ToolName, Input: call.Input}) + } + return curator.ChatResult{Text: res.Text, ToolCalls: calls}, nil } type chatTaskWriterAdapter struct { diff --git a/internal/config/config.go b/internal/config/config.go index 0ae523684..ff0af1788 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -546,6 +546,13 @@ type Config struct { Repos []Repo `toml:"repos" yaml:"repos"` ModelLimits map[string]ModelLimits `toml:"-" yaml:"-" json:"-"` + // Curators holds curator definitions as seed data ([[curators]]). + // Each entry is a curator.Manifest plus name/enabled/instructions. + // Seed data only: the app layer registers each enabled definition + // through the one generic definition-driven engine, and (once + // persistence lands) a stored definition of the same name wins. + Curators []CuratorDefinition `toml:"curators" yaml:"curators" json:"curators,omitempty"` + // Extra holds additional feature configuration from conf.d/ files that // don't match a known feature name. Keys are the filename stem (e.g. // "custom-tool" for conf.d/custom-tool.yaml). diff --git a/internal/config/curator.go b/internal/config/curator.go new file mode 100644 index 000000000..b64485653 --- /dev/null +++ b/internal/config/curator.go @@ -0,0 +1,21 @@ +package config + +// CuratorDefinition is one [[curators]] entry: a curator definition as +// seed data. It carries the curator.Manifest shape verbatim plus the +// identity, lifecycle flag, and free-form instructions the manifest cannot +// express. A definition missing interval is refused by configuration +// validation, never defaulted. +type CuratorDefinition struct { + Name string `toml:"name" yaml:"name" json:"name"` + Enabled bool `toml:"enabled" yaml:"enabled" json:"enabled"` + Instructions string `toml:"instructions" yaml:"instructions" json:"instructions"` + + Interval Duration `toml:"interval" yaml:"interval" json:"interval"` + Cooldown Duration `toml:"cooldown" yaml:"cooldown" json:"cooldown"` + OnInput bool `toml:"on_input" yaml:"on_input" json:"on_input"` + Tools []string `toml:"tools" yaml:"tools" json:"tools"` + Skills bool `toml:"skills" yaml:"skills" json:"skills"` + MemoryEngine string `toml:"memory_engine" yaml:"memory_engine" json:"memory_engine"` + Conversations bool `toml:"conversations" yaml:"conversations" json:"conversations"` + Model string `toml:"model" yaml:"model" json:"model"` +} diff --git a/internal/domain/curator/definition.go b/internal/domain/curator/definition.go new file mode 100644 index 000000000..1ed78e4a9 --- /dev/null +++ b/internal/domain/curator/definition.go @@ -0,0 +1,18 @@ +package curator + +// Definition is a curator definition as data: the declared Manifest plus +// the identity, lifecycle flag, and free-form instructions the manifest +// cannot express. One generic engine (DefinitionEngine) interprets any +// definition -- there is deliberately no catalogue of curator "types" and +// no second authority beside the existing registry. +type Definition struct { + // Name is the registry key. + Name string + // Enabled gates registration: a disabled definition is seed data that + // the app layer does not register. + Enabled bool + // Instructions is the free-form system prompt for the generic engine. + Instructions string + // Manifest is the declared shape, verbatim. + Manifest Manifest +} diff --git a/internal/domain/curator/definition_engine.go b/internal/domain/curator/definition_engine.go new file mode 100644 index 000000000..3aeda3fa0 --- /dev/null +++ b/internal/domain/curator/definition_engine.go @@ -0,0 +1,130 @@ +package curator + +import ( + "context" + "fmt" + "strings" + + "github.com/samcharles93/archie-core/internal/tools" +) + +// ActionToolCalled is the Action.Type recorded for each tool the model +// loop invoked, so a definition-driven pass stays attributable through the +// registry's activity surface and events. +const ActionToolCalled = "tool.called" + +// defaultDefinitionMaxSteps bounds the model/tool loop of one definition +// pass. It is not a definition value and is deliberately not configurable +// yet: the PRD's no-live-path-constants rule covers interval, cooldown, +// tools, model, and memory engine, not loop length. +const defaultDefinitionMaxSteps = 10 + +// DefinitionEngine interprets a Definition: one generic engine serving +// every data-defined curator. Its pass composes the definition's +// instructions with the built declared tool set, calls the model, and +// records an Action per tool invocation. +type DefinitionEngine struct { + def Definition + host Registrar +} + +// NewDefinitionEngine builds the generic engine for one definition. +func NewDefinitionEngine(def Definition) *DefinitionEngine { + return &DefinitionEngine{def: def} +} + +func (e *DefinitionEngine) Name() string { return e.def.Name } +func (e *DefinitionEngine) Version() string { return "1" } +func (e *DefinitionEngine) Manifest() Manifest { return e.def.Manifest } + +func (e *DefinitionEngine) Bind(host Registrar) { e.host = host } + +func (e *DefinitionEngine) Start(context.Context) error { return nil } + +func (e *DefinitionEngine) Health(context.Context) Health { + return Health{Status: HealthHealthy} +} + +func (e *DefinitionEngine) Stop(context.Context) error { return nil } + +// Check reports a definition is eligible whenever the runtime schedules it: +// a definition has no input state of its own to read, so eligibility is the +// manifest interval (and optional OnInput nudge) the runtime already owns. +func (e *DefinitionEngine) Check(context.Context) (bool, error) { return true, nil } + +// Pass resolves the declared tools, composes the instructions with the +// built set, runs the model loop, and records an Action per tool call. A +// declared name with no implementation fails the pass (fail closed); the +// model receives exactly the declared set, never a broader registry. +func (e *DefinitionEngine) Pass(ctx context.Context, in PassInput) (PassResult, error) { + declared := e.def.Manifest.Tools + var built []tools.ToolEntry + if len(declared) > 0 { + if e.host.Tools == nil { + return PassResult{}, fmt.Errorf("curator %s: declares tools but no ToolBuilder is bound", e.def.Name) + } + var err error + built, err = e.host.Tools.Build(ctx, declared) + if err != nil { + return PassResult{}, fmt.Errorf("curator %s: build tools: %w", e.def.Name, err) + } + } + if e.host.LLM == nil { + return PassResult{}, fmt.Errorf("curator %s: no model runner is bound", e.def.Name) + } + + model := e.def.Manifest.Model + if model == "" { + model = e.host.Model + } + res, err := e.host.LLM.Chat(ctx, ChatRequest{ + Model: model, + Messages: definitionMessages(e.def.Instructions, built, in.Reason), + Tools: built, + MaxSteps: defaultDefinitionMaxSteps, + }) + if err != nil { + return PassResult{}, err + } + + actions := make([]Action, 0, len(res.ToolCalls)) + for _, call := range res.ToolCalls { + actions = append(actions, Action{ + At: e.host.Clock.Now(), + Type: ActionToolCalled, + Detail: call.Name, + Reason: in.Reason, + }) + } + return PassResult{Actions: actions}, nil +} + +// definitionMessages builds the prompt for one pass: the definition's +// instructions plus a summary of the built tool set as the system prompt, +// and the pass reason as the user turn. The tool summaries come from the +// same set that was built, never from a wider list. +func definitionMessages(instructions string, built []tools.ToolEntry, reason string) []Message { + system := instructions + if len(built) > 0 { + var b strings.Builder + b.WriteString(instructions) + b.WriteString("\n\nAvailable tools:\n") + for _, t := range built { + desc := strings.TrimSpace(t.Description) + if desc == "" { + desc = "(no description)" + } + fmt.Fprintf(&b, "- %s: %s\n", t.Name, desc) + } + system = b.String() + } + + user := strings.TrimSpace(reason) + if user == "" { + user = "Run your scheduled pass now." + } + return []Message{ + {Role: "system", Content: system}, + {Role: "user", Content: user}, + } +} diff --git a/internal/domain/curator/definition_engine_test.go b/internal/domain/curator/definition_engine_test.go new file mode 100644 index 000000000..401480503 --- /dev/null +++ b/internal/domain/curator/definition_engine_test.go @@ -0,0 +1,183 @@ +package curator + +import ( + "context" + "fmt" + "strings" + "testing" + "time" + + "github.com/samcharles93/archie-core/internal/tools" +) + +// recordingLLM captures the ChatRequest a definition pass builds and returns +// a fixed result, so tests assert exactly what reached the model. +type recordingLLM struct { + req ChatRequest + result ChatResult + err error +} + +func (l *recordingLLM) Chat(_ context.Context, req ChatRequest) (ChatResult, error) { + l.req = req + return l.result, l.err +} + +// mapBuilder resolves declared names from a fixed map: the same resolution +// contract as the infrastructure ToolBuilder, without domain tests importing +// infrastructure. +type mapBuilder struct { + entries map[string]tools.ToolEntry +} + +func (b mapBuilder) Build(_ context.Context, declared []string) ([]tools.ToolEntry, error) { + out := make([]tools.ToolEntry, 0, len(declared)) + for _, name := range declared { + entry, ok := b.entries[name] + if !ok { + return nil, fmt.Errorf("declared tool %q has no implementation", name) + } + out = append(out, entry) + } + return out, nil +} + +func definitionTool(name string) tools.ToolEntry { + return tools.ToolEntry{ + Name: name, + Description: name + " tool", + Handler: func(context.Context, map[string]any) (any, error) { return nil, nil }, + } +} + +func TestDefinitionEnginePassReachesExactlyDeclaredTools(t *testing.T) { + t.Parallel() + + def := Definition{ + Name: "project-curator", + Enabled: true, + Instructions: "Review the repository and report what you changed.", + Manifest: Manifest{ + Interval: time.Hour, + Model: "provider/config-model", + Tools: []string{"read"}, + }, + } + llm := &recordingLLM{result: ChatResult{ + Text: "done", + ToolCalls: []ToolCall{{Name: "read", Input: "{}"}}, + }} + engine := NewDefinitionEngine(def) + engine.Bind(Registrar{ + LLM: llm, + Model: "provider/default-model", + Tools: mapBuilder{entries: map[string]tools.ToolEntry{ + "read": definitionTool("read"), + "write": definitionTool("write"), + }}, + Clock: testClock{now: time.Unix(0, 0)}, + }) + + res, err := engine.Pass(context.Background(), PassInput{Reason: "check-in"}) + if err != nil { + t.Fatalf("Pass() error = %v, want nil", err) + } + + if got := len(llm.req.Tools); got != 1 { + t.Fatalf("model received %d tools, want exactly the declared 1 (never a broader registry)", got) + } + if llm.req.Tools[0].Name != "read" { + t.Fatalf("model received tool %q, want the declared %q", llm.req.Tools[0].Name, "read") + } + if llm.req.Model != "provider/config-model" { + t.Fatalf("model reference = %q, want the definition's %q (no fallback to the default)", llm.req.Model, "provider/config-model") + } + if llm.req.MaxSteps <= 1 { + t.Fatalf("MaxSteps = %d, want more than one so the tool loop can run", llm.req.MaxSteps) + } + if len(llm.req.Messages) == 0 || llm.req.Messages[0].Role != "system" { + t.Fatalf("messages = %+v, want a leading system prompt", llm.req.Messages) + } + if sys := llm.req.Messages[0].Content; !strings.Contains(sys, def.Instructions) || !strings.Contains(sys, "read") { + t.Fatalf("system prompt = %q, want the definition instructions plus the declared tool summary", sys) + } + + if len(res.Actions) != 1 { + t.Fatalf("Pass() actions = %d, want one per tool call", len(res.Actions)) + } + a := res.Actions[0] + if a.Type != ActionToolCalled || a.Detail != "read" || a.Reason != "check-in" { + t.Fatalf("action = %+v, want the invoked tool attributed with the pass reason", a) + } +} + +func TestDefinitionEnginePassFailsOnUnknownDeclaredTool(t *testing.T) { + t.Parallel() + + def := Definition{ + Name: "project-curator", + Manifest: Manifest{ + Interval: time.Hour, + Tools: []string{"gh.issue.create"}, + }, + } + llm := &recordingLLM{} + engine := NewDefinitionEngine(def) + engine.Bind(Registrar{ + LLM: llm, + Tools: mapBuilder{entries: map[string]tools.ToolEntry{}}, + Clock: testClock{now: time.Unix(0, 0)}, + }) + + if _, err := engine.Pass(context.Background(), PassInput{Reason: "check-in"}); err == nil { + t.Fatal("Pass() with an unknown declared tool = nil error, want the build failure to fail the pass") + } + if llm.req.Messages != nil { + t.Fatalf("model was called despite the failed build: %+v", llm.req) + } +} + +func TestDefinitionEngineManifestIsTheDefinitionNoCodeFallback(t *testing.T) { + t.Parallel() + + def := Definition{ + Name: "config-defined", + Enabled: true, + Instructions: "do the thing", + Manifest: Manifest{ + Interval: 17 * time.Minute, + Cooldown: 3 * time.Minute, + OnInput: true, + Tools: []string{"read", "shell"}, + Model: "provider/config-model", + }, + } + engine := NewDefinitionEngine(def) + + got := engine.Manifest() + if got.Interval != 17*time.Minute { + t.Fatalf("Manifest().Interval = %v, want the definition's %v (no code constant)", got.Interval, 17*time.Minute) + } + if got.Cooldown != 3*time.Minute || !got.OnInput { + t.Fatalf("Manifest() = %+v, want the definition's cooldown/on_input", got) + } + if len(got.Tools) != 2 || got.Tools[0] != "read" || got.Tools[1] != "shell" { + t.Fatalf("Manifest().Tools = %v, want the definition's declared set", got.Tools) + } + if got.Model != "provider/config-model" { + t.Fatalf("Manifest().Model = %q, want the definition's model", got.Model) + } +} + +func TestDefinitionEngineRegistrationRequiresToolBuilder(t *testing.T) { + t.Parallel() + + reg := NewRegistry(Registrar{}) + err := reg.Register(NewDefinitionEngine(Definition{ + Name: "project-curator", + Manifest: Manifest{Interval: time.Hour, Tools: []string{"read"}}, + })) + if err == nil { + t.Fatal("Register(tools-declaring definition) = nil, want the existing no-ToolBuilder refusal") + } +} diff --git a/internal/domain/curator/registrar.go b/internal/domain/curator/registrar.go index f3535a6eb..14e09ccaf 100644 --- a/internal/domain/curator/registrar.go +++ b/internal/domain/curator/registrar.go @@ -74,9 +74,20 @@ type Message struct { Content string } -// ChatResult is the model's final answer. +// ChatResult is the model's final answer plus the tool invocations the +// model loop executed, so a pass can attribute its actions to the tools +// that ran. type ChatResult struct { Text string + // ToolCalls is every tool invocation across the loop, in execution + // order. Empty for a single completion with no tools. + ToolCalls []ToolCall +} + +// ToolCall is one tool invocation the model loop executed. +type ToolCall struct { + Name string + Input string // JSON-encoded arguments, verbatim from the model } // ToolBuilder resolves declared tool names into a runnable tool set. A diff --git a/internal/domain/curator/runtime.go b/internal/domain/curator/runtime.go index 13940afdf..e50e1da44 100644 --- a/internal/domain/curator/runtime.go +++ b/internal/domain/curator/runtime.go @@ -207,6 +207,9 @@ func (rt *Runtime) runLoop(ctx context.Context, name string, c CuratorEngine) { } if !due { next = clock.Now().Add(m.Interval) + if log := rt.registry.Host().Log; log != nil { + log.Debug("curator not due", "curator", name, "next", next) + } continue } diff --git a/internal/domain/curator/runtime_test.go b/internal/domain/curator/runtime_test.go index 79b09b88d..2bbce9d5b 100644 --- a/internal/domain/curator/runtime_test.go +++ b/internal/domain/curator/runtime_test.go @@ -3,6 +3,7 @@ package curator import ( "context" "errors" + "log/slog" "slices" "sync" "testing" @@ -454,6 +455,60 @@ func TestRuntimePassInputRecordsReasonAndLastPass(t *testing.T) { } } +// debugCaptureHandler records debug-level messages so a test can observe an +// idle curator that the runtime would otherwise be silent about. +type debugCaptureHandler struct { + mu sync.Mutex + msgs []string +} + +func (h *debugCaptureHandler) Enabled(context.Context, slog.Level) bool { return true } +func (h *debugCaptureHandler) Handle(_ context.Context, r slog.Record) error { + if r.Level == slog.LevelDebug { + h.mu.Lock() + h.msgs = append(h.msgs, r.Message) + h.mu.Unlock() + } + return nil +} +func (h *debugCaptureHandler) WithAttrs([]slog.Attr) slog.Handler { return h } +func (h *debugCaptureHandler) WithGroup(string) slog.Handler { return h } + +func (h *debugCaptureHandler) count(msg string) int { + h.mu.Lock() + defer h.mu.Unlock() + n := 0 + for _, m := range h.msgs { + if m == msg { + n++ + } + } + return n +} + +func TestRuntimeLogsWhenCheckReportsNotDue(t *testing.T) { + t.Parallel() + + clock := newFakeClock(time.Unix(0, 0)) + handler := &debugCaptureHandler{} + c := newFake("idle", Manifest{Interval: testInterval}) + c.checkResult = false + + reg := NewRegistry(Registrar{Clock: clock, Events: &testSink{}, Log: slog.New(handler)}) + if err := reg.Register(c); err != nil { + t.Fatalf("Register(idle) = %v, want nil", err) + } + rt := NewRuntime(reg, RuntimeConfig{}) + if err := rt.Start(context.Background()); err != nil { + t.Fatalf("Start() = %v, want nil", err) + } + t.Cleanup(func() { _ = rt.Stop(context.Background()) }) + + waitFor(t, 2*time.Second, "idle check-in logged", func() bool { + return handler.count("curator not due") > 0 + }) +} + func TestRuntimePassInputSetsSinceToPriorPass(t *testing.T) { t.Parallel() diff --git a/internal/infrastructure/configuration/curator_validate_test.go b/internal/infrastructure/configuration/curator_validate_test.go new file mode 100644 index 000000000..5c73c36e8 --- /dev/null +++ b/internal/infrastructure/configuration/curator_validate_test.go @@ -0,0 +1,69 @@ +package configuration + +import ( + "testing" + "time" + + "github.com/samcharles93/archie-core/internal/config" +) + +func TestValidateCurators(t *testing.T) { + tests := []struct { + name string + mutate func(cfg *config.Config) + wantErr bool + }{ + { + name: "no curators", + mutate: func(cfg *config.Config) {}, + }, + { + name: "valid curator", + mutate: func(cfg *config.Config) { + cfg.Curators = []config.CuratorDefinition{{Name: "project", Enabled: true, Interval: config.Duration(time.Hour)}} + }, + }, + { + name: "missing interval", + mutate: func(cfg *config.Config) { + cfg.Curators = []config.CuratorDefinition{{Name: "project", Enabled: true}} + }, + wantErr: true, + }, + { + name: "zero interval", + mutate: func(cfg *config.Config) { + cfg.Curators = []config.CuratorDefinition{{Name: "project", Enabled: true, Interval: config.Duration(0)}} + }, + wantErr: true, + }, + { + name: "negative interval", + mutate: func(cfg *config.Config) { + cfg.Curators = []config.CuratorDefinition{{Name: "project", Enabled: true, Interval: config.Duration(-time.Minute)}} + }, + wantErr: true, + }, + { + // A definition must be valid seed data whether or not it is + // currently enabled: flipping Enabled on later must not silently + // default the interval. + name: "disabled curator still requires interval", + mutate: func(cfg *config.Config) { + cfg.Curators = []config.CuratorDefinition{{Name: "project"}} + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := minimalValidConfig() + tt.mutate(&cfg) + err := Validate(&cfg) + if (err != nil) != tt.wantErr { + t.Fatalf("Validate() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/internal/infrastructure/configuration/validate.go b/internal/infrastructure/configuration/validate.go index 9cf0f0300..df585db12 100644 --- a/internal/infrastructure/configuration/validate.go +++ b/internal/infrastructure/configuration/validate.go @@ -109,6 +109,9 @@ func validateBootstrap(cfg *config.Config) error { if err := validateImage(cfg); err != nil { return err } + if err := validateCurators(cfg); err != nil { + return err + } return validateCapture(cfg) } @@ -173,6 +176,19 @@ func validateImage(cfg *config.Config) error { return nil } +// validateCurators rejects a curator definition with no interval. The +// interval is a live-path value: a definition missing it is refused with a +// clear error rather than defaulted at registration or pass time, so a +// config-defined curator can never silently inherit a code constant. +func validateCurators(cfg *config.Config) error { + for i, def := range cfg.Curators { + if def.Interval <= 0 { + return fmt.Errorf("%w: curators[%d].interval must be positive", ErrInvalidInput, i) + } + } + return nil +} + // validateMemory rejects an engine name outside memoryEngines. Empty is // valid input to Validate (applyDefaults resolves it to memoryEngineBuiltin // before this runs on the real load path); it is not "unknown" so it does diff --git a/internal/infrastructure/toolbuilder/toolbuilder.go b/internal/infrastructure/toolbuilder/toolbuilder.go new file mode 100644 index 000000000..e09a214f8 --- /dev/null +++ b/internal/infrastructure/toolbuilder/toolbuilder.go @@ -0,0 +1,48 @@ +// Package toolbuilder resolves a curator's declared tool names from the +// daemon's process-wide tool registry (internal/tools.Registry). It is the +// implementation of curator.ToolBuilder: resolution returns exactly the +// declared set, never a broader registry, and a declared name with no +// implementation fails the build rather than silently returning fewer tools. +package toolbuilder + +import ( + "context" + "errors" + "fmt" + + "github.com/samcharles93/archie-core/internal/domain/curator" + "github.com/samcharles93/archie-core/internal/tools" +) + +var _ curator.ToolBuilder = (*Builder)(nil) + +// Builder resolves declared curator tool names against a tools.Registry. +type Builder struct { + reg *tools.Registry +} + +// New builds a ToolBuilder over reg. A nil reg is valid and reports a +// clear error from Build when a declared tool set is requested. +func New(reg *tools.Registry) *Builder { + return &Builder{reg: reg} +} + +// Build returns exactly the declared set in declared order. A declared name +// absent from the registry fails the build. +func (b *Builder) Build(_ context.Context, declared []string) ([]tools.ToolEntry, error) { + if b.reg == nil { + if len(declared) == 0 { + return nil, nil + } + return nil, errors.New("toolbuilder: no tool registry bound") + } + out := make([]tools.ToolEntry, 0, len(declared)) + for _, name := range declared { + entry, ok := b.reg.Get(name) + if !ok { + return nil, fmt.Errorf("toolbuilder: declared tool %q has no implementation", name) + } + out = append(out, entry) + } + return out, nil +} diff --git a/internal/infrastructure/toolbuilder/toolbuilder_test.go b/internal/infrastructure/toolbuilder/toolbuilder_test.go new file mode 100644 index 000000000..08abfb7bf --- /dev/null +++ b/internal/infrastructure/toolbuilder/toolbuilder_test.go @@ -0,0 +1,73 @@ +package toolbuilder + +import ( + "context" + "testing" + + "github.com/samcharles93/archie-core/internal/tools" +) + +func mustRegister(t *testing.T, reg *tools.Registry, names ...string) { + t.Helper() + for _, name := range names { + if err := reg.Register(tools.ToolEntry{ + Name: name, + Handler: func(context.Context, map[string]any) (any, error) { return nil, nil }, + }); err != nil { + t.Fatalf("register %s: %v", name, err) + } + } +} + +func namesOf(entries []tools.ToolEntry) []string { + out := make([]string, 0, len(entries)) + for _, e := range entries { + out = append(out, e.Name) + } + return out +} + +func TestBuilderResolvesExactlyDeclared(t *testing.T) { + t.Parallel() + + reg := tools.NewRegistry() + mustRegister(t, reg, "read", "write", "shell") + + got, err := New(reg).Build(context.Background(), []string{"read", "shell"}) + if err != nil { + t.Fatalf("Build() error = %v, want nil", err) + } + want := []string{"read", "shell"} + if len(got) != len(want) { + t.Fatalf("Build() returned %d tools, want exactly %d (declared set, never broader)", len(got), len(want)) + } + if gotNames := namesOf(got); gotNames[0] != want[0] || gotNames[1] != want[1] { + t.Fatalf("Build() = %v, want %v in declared order", gotNames, want) + } +} + +func TestBuilderUnknownNameFails(t *testing.T) { + t.Parallel() + + reg := tools.NewRegistry() + mustRegister(t, reg, "read") + + if _, err := New(reg).Build(context.Background(), []string{"read", "gh.issue.create"}); err == nil { + t.Fatal("Build() with an unknown declared name = nil error, want failure") + } +} + +func TestBuilderEmptyDeclaredSetIsEmptyNotWholeRegistry(t *testing.T) { + t.Parallel() + + reg := tools.NewRegistry() + mustRegister(t, reg, "read") + + got, err := New(reg).Build(context.Background(), nil) + if err != nil { + t.Fatalf("Build(nil) error = %v, want nil", err) + } + if len(got) != 0 { + t.Fatalf("Build(nil) = %v, want no tools (an empty declaration must not fall back to the whole registry)", namesOf(got)) + } +}