feat: import agents_and_robots platform as unibots (Matrix-out, unibus transport)

Reemplaza el scaffold del echobot por la plataforma completa de bots traida
desde ~/DataProyects/Github/agents_and_robots tras la operacion Matrix-out:
los bots ya no hablan por Matrix sino por el bus unibus (modelo todo-rooms +
E2E via shell/transportunibus sobre github.com/enmanuel/unibus/pkg/client).

- go.mod: replace de unibus -> ../unibus y de fn-registry -> ../../../.. (paths
  relativos reajustados a la nueva ubicacion dentro de fn_registry).
- app.md: bump a 0.2.0, descripcion + arquitectura + comandos + gotchas reales.
- modulo Go conservado como github.com/enmanuel/agents (sin reescribir imports).

agents_and_robots queda archivado como museo de la era Matrix.
This commit is contained in:
agent
2026-06-07 11:50:13 +02:00
parent bb5b0e09b1
commit fc644ecd6e
308 changed files with 38829 additions and 474 deletions
+47
View File
@@ -0,0 +1,47 @@
package personality
import "github.com/enmanuel/agents/internal/config"
// FromConfig convierte PersonalityCfg (config) a Personality (tipo puro).
// Esta funcion es pura: no tiene side effects.
func FromConfig(cfg config.PersonalityCfg) Personality {
return Personality{
Tone: Tone(cfg.Tone),
Verbosity: Verbosity(cfg.Verbosity),
Language: cfg.Language,
LanguagesSupported: cfg.LanguagesSupported,
EmojiStyle: EmojiStyle(cfg.EmojiStyle),
Prefix: cfg.Prefix,
ErrorStyle: ErrorStyle(cfg.ErrorStyle),
Templates: Templates{
Greeting: cfg.Templates.Greeting,
UnknownCommand: cfg.Templates.UnknownCommand,
PermissionDenied: cfg.Templates.PermissionDenied,
Error: cfg.Templates.Error,
Success: cfg.Templates.Success,
Busy: cfg.Templates.Busy,
},
Behavior: Behavior{
Proactive: cfg.Behavior.Proactive,
AskConfirmation: cfg.Behavior.AskConfirmation,
ShowReasoning: cfg.Behavior.ShowReasoning,
ThreadReplies: cfg.Behavior.ThreadReplies,
TypingIndicator: cfg.Behavior.TypingIndicator,
AcknowledgeReceipt: cfg.Behavior.AcknowledgeReceipt,
},
Role: cfg.Role,
Backstory: cfg.Backstory,
Expertise: cfg.Expertise,
Limitations: cfg.Limitations,
Communication: Communication{
Formality: Formality(cfg.Communication.Formality),
Humor: Humor(cfg.Communication.Humor),
Personality: PersonalityType(cfg.Communication.Personality),
ResponseStyle: ResponseStyle(cfg.Communication.ResponseStyle),
Quirks: cfg.Communication.Quirks,
AvoidTopics: cfg.Communication.AvoidTopics,
Catchphrases: cfg.Communication.Catchphrases,
},
CustomDirectives: cfg.CustomDirectives,
}
}
+110
View File
@@ -0,0 +1,110 @@
package personality
import (
"fmt"
"strings"
)
// BuildPersonalityPrompt genera un bloque de system prompt a partir de la personalidad.
// Esta funcion es pura: recibe datos, devuelve string, sin side effects.
func BuildPersonalityPrompt(p Personality) string {
if isEmpty(p) {
return ""
}
var sb strings.Builder
sb.WriteString("## Tu personalidad\n\n")
// Role y backstory
if p.Role != "" || p.Backstory != "" {
if p.Backstory != "" {
sb.WriteString(p.Backstory)
sb.WriteString("\n\n")
}
if p.Role != "" {
sb.WriteString(fmt.Sprintf("**Rol**: %s.\n", p.Role))
}
}
// Expertise
if len(p.Expertise) > 0 {
sb.WriteString(fmt.Sprintf("**Expertise**: %s.\n", strings.Join(p.Expertise, ", ")))
}
// Limitations
if len(p.Limitations) > 0 {
sb.WriteString(fmt.Sprintf("**Limitaciones**: %s.\n", strings.Join(p.Limitations, ", ")))
}
// Communication style
if !isEmptyCommunication(p.Communication) {
sb.WriteString("\n**Como te comunicas**:\n")
if p.Communication.Formality != "" {
sb.WriteString(fmt.Sprintf("- Formalidad: %s\n", p.Communication.Formality))
}
if p.Tone != "" {
sb.WriteString(fmt.Sprintf("- Tono: %s\n", p.Tone))
}
if p.Communication.Humor != "" {
sb.WriteString(fmt.Sprintf("- Humor: %s\n", p.Communication.Humor))
}
if p.Communication.Personality != "" {
sb.WriteString(fmt.Sprintf("- Personalidad: %s\n", p.Communication.Personality))
}
if p.Communication.ResponseStyle != "" {
sb.WriteString(fmt.Sprintf("- Estilo de respuesta: %s\n", p.Communication.ResponseStyle))
}
if p.Verbosity != "" {
sb.WriteString(fmt.Sprintf("- Verbosidad: %s\n", p.Verbosity))
}
if len(p.Communication.Quirks) > 0 {
sb.WriteString(fmt.Sprintf("- Rasgos unicos: %s\n", strings.Join(p.Communication.Quirks, "; ")))
}
if len(p.Communication.AvoidTopics) > 0 {
sb.WriteString(fmt.Sprintf("- Evitas hablar de: %s\n", strings.Join(p.Communication.AvoidTopics, ", ")))
}
if len(p.Communication.Catchphrases) > 0 {
sb.WriteString(fmt.Sprintf("- Frases tipicas: %s\n", strings.Join(p.Communication.Catchphrases, "; ")))
}
}
// Custom directives
if len(p.CustomDirectives) > 0 {
sb.WriteString("\n**Directivas especiales**:\n")
for _, directive := range p.CustomDirectives {
sb.WriteString(fmt.Sprintf("- %s\n", directive))
}
}
return sb.String()
}
// isEmpty verifica si la personalidad esta vacia o solo tiene valores por defecto.
func isEmpty(p Personality) bool {
return p.Role == "" &&
p.Backstory == "" &&
len(p.Expertise) == 0 &&
len(p.Limitations) == 0 &&
isEmptyCommunication(p.Communication) &&
len(p.CustomDirectives) == 0
}
// isEmptyCommunication verifica si la seccion de comunicacion esta vacia.
func isEmptyCommunication(c Communication) bool {
return c.Formality == "" &&
c.Humor == "" &&
c.Personality == "" &&
c.ResponseStyle == "" &&
len(c.Quirks) == 0 &&
len(c.AvoidTopics) == 0 &&
len(c.Catchphrases) == 0
}
+152
View File
@@ -0,0 +1,152 @@
// Package personality defines pure types for agent personality and behavior.
package personality
type Tone string
const (
ToneDirect Tone = "direct"
ToneFriendly Tone = "friendly"
ToneFormal Tone = "formal"
ToneCasual Tone = "casual"
ToneTechnical Tone = "technical"
)
type Verbosity string
const (
VerbosityMinimal Verbosity = "minimal"
VerbosityConcise Verbosity = "concise"
VerbosityDetailed Verbosity = "detailed"
VerbosityVerbose Verbosity = "verbose"
)
type EmojiStyle string
const (
EmojiNone EmojiStyle = "none"
EmojiMinimal EmojiStyle = "minimal"
EmojiModerate EmojiStyle = "moderate"
EmojiHeavy EmojiStyle = "heavy"
)
type ErrorStyle string
const (
ErrorTerse ErrorStyle = "terse"
ErrorHelpful ErrorStyle = "helpful"
ErrorDetailed ErrorStyle = "detailed"
)
type Formality string
const (
FormalityFormal Formality = "formal"
FormalitySemiformal Formality = "semiformal"
FormalityCasual Formality = "casual"
FormalityColoquial Formality = "coloquial"
)
type Humor string
const (
HumorNone Humor = "none"
HumorSubtle Humor = "subtle"
HumorModerate Humor = "moderate"
HumorFrequent Humor = "frequent"
)
type PersonalityType string
const (
PersonalityAnalytical PersonalityType = "analytical"
PersonalityCreative PersonalityType = "creative"
PersonalityPragmatic PersonalityType = "pragmatic"
PersonalityEmpathetic PersonalityType = "empathetic"
PersonalityAssertive PersonalityType = "assertive"
)
type ResponseStyle string
const (
ResponseStructured ResponseStyle = "structured"
ResponseConversational ResponseStyle = "conversational"
ResponseBulletPoints ResponseStyle = "bullet_points"
ResponseNarrative ResponseStyle = "narrative"
)
type Templates struct {
Greeting string
UnknownCommand string
PermissionDenied string
Error string
Success string
Busy string
}
type Behavior struct {
Proactive bool
AskConfirmation bool
ShowReasoning bool
ThreadReplies bool
TypingIndicator bool
AcknowledgeReceipt bool
}
type Communication struct {
Formality Formality
Humor Humor
Personality PersonalityType
ResponseStyle ResponseStyle
Quirks []string
AvoidTopics []string
Catchphrases []string
}
type Personality struct {
Tone Tone
Verbosity Verbosity
Language string
LanguagesSupported []string
EmojiStyle EmojiStyle
Prefix string
ErrorStyle ErrorStyle
Templates Templates
Behavior Behavior
// Identidad narrativa
Role string
Backstory string
Expertise []string
Limitations []string
// Estilo de comunicacion
Communication Communication
// Directivas personalizadas
CustomDirectives []string
}
// DefaultPersonality returns a sensible baseline.
func DefaultPersonality() Personality {
return Personality{
Tone: ToneFriendly,
Verbosity: VerbosityConcise,
Language: "en",
EmojiStyle: EmojiMinimal,
ErrorStyle: ErrorHelpful,
Templates: Templates{
Greeting: "Ready. What do you need?",
UnknownCommand: "Unknown command. Use `!help` for available commands.",
PermissionDenied: "You don't have permission for that.",
Error: "Something failed: {{.Error}}",
Success: "Done. {{.Summary}}",
Busy: "I'm busy with another task. Wait or use `!queue`.",
},
Behavior: Behavior{
AskConfirmation: true,
ThreadReplies: true,
TypingIndicator: true,
AcknowledgeReceipt: true,
},
}
}