package gateway import ( "context" "fmt" "sort" "strings" "sync" "github.com/samcharles93/archie-core/internal/domain/agent" "github.com/samcharles93/archie-core/internal/domain/messaging" ) // Persona is a named communication style that modifies the system prompt. type Persona struct { Name string Prompt string // prepended to the system prompt } // PersonaRegistry holds available personas and tracks the active one // per session. Safe for concurrent use. type PersonaRegistry struct { mu sync.RWMutex personas map[string]Persona active map[string]string // sessionKey -> persona name defaultName string } // NewPersonaRegistry creates a registry pre-populated with the given // personas. The first persona is the default for new sessions. func NewPersonaRegistry(personas []Persona) *PersonaRegistry { r := &PersonaRegistry{ personas: make(map[string]Persona, len(personas)), active: make(map[string]string), } for index, p := range personas { r.personas[p.Name] = p if index == 0 { r.defaultName = p.Name } } return r } // DefaultPersonas returns Archie as the baseline identity followed by // optional communication styles. func DefaultPersonas() []Persona { shipped := agent.ShippedPersonas() personas := make([]Persona, 0, len(shipped.Personas)) for _, persona := range shipped.Personas { personas = append(personas, Persona{Name: persona.Name, Prompt: persona.Prompt}) } return personas } // List returns all available persona names. func (r *PersonaRegistry) List() []string { r.mu.RLock() defer r.mu.RUnlock() names := make([]string, 0, len(r.personas)) for _, p := range r.personas { names = append(names, p.Name) } sort.Strings(names) return names } // Replace atomically changes the available definitions. Sessions whose // selection no longer exists use the new default. func (r *PersonaRegistry) Replace(personas []Persona, defaultName string) { r.mu.Lock() defer r.mu.Unlock() next := make(map[string]Persona, len(personas)) for _, persona := range personas { next[persona.Name] = persona } for session, name := range r.active { if _, exists := next[name]; !exists { delete(r.active, session) } } r.personas = next r.defaultName = defaultName } // SetActive sets the active persona for a session. func (r *PersonaRegistry) SetActive(sessionKey, name string) bool { r.mu.Lock() defer r.mu.Unlock() if _, ok := r.personas[name]; !ok { return false } r.active[sessionKey] = name return true } // GetActive returns the active persona's prompt for a session, or an // empty string when no persona is selected. func (r *PersonaRegistry) GetActive(sessionKey string) string { r.mu.RLock() defer r.mu.RUnlock() name, ok := r.active[sessionKey] if !ok { name = r.defaultName } p, ok := r.personas[name] if !ok { return "" } if name == r.defaultName { return p.Prompt } if baseline, ok := r.personas[r.defaultName]; ok && baseline.Prompt != "" { return baseline.Prompt + "\n\n" + p.Prompt } return p.Prompt } // ActiveName returns the selected persona name for a session, falling back to // the registry default. It is used by channel adapters that render a compact // selector summary rather than the full prompt. func (r *PersonaRegistry) ActiveName(sessionKey string) string { r.mu.RLock() defer r.mu.RUnlock() if name := r.active[sessionKey]; name != "" { return name } return r.defaultName } // Get returns a persona by name, or false when not found. func (r *PersonaRegistry) Get(name string) (Persona, bool) { r.mu.RLock() defer r.mu.RUnlock() p, ok := r.personas[name] return p, ok } func (r *Router) handlePersonality(ctx context.Context, msg messaging.Message, rest string) (string, error) { if r.Personas == nil { return "Personality switching is not configured.", nil } name := strings.ToLower(strings.TrimSpace(rest)) if name == "" { return fmt.Sprintf("Active personality: %s\nAvailable: %s", r.Personas.ActiveName(r.sessionKey(ctx, msg)), strings.Join(r.Personas.List(), ", ")), nil } if !r.Personas.SetActive(r.sessionKey(ctx, msg), name) { return fmt.Sprintf("Unknown personality %q. Available: %s", name, strings.Join(r.Personas.List(), ", ")), nil } return fmt.Sprintf("Personality set to %q.", name), nil } func (r *Router) sessionKey(ctx context.Context, msg messaging.Message) string { if r.sessionTracker == nil { return msg.ConversationID.ChannelID } key, err := r.ResolveSessionKey(ctx, Inbound{Message: msg}) if err != nil { return msg.ConversationID.ChannelID } return key } func (r *Router) helpText() string { return "Send a message to chat with Archie. Available commands:\n" + strings.Join(LocalCommands(), " ") }