Personality

import { createDatabase, createPersonalityManager } from '@astreus-ai/astreus';

// Create database and personality manager
const database = await createDatabase({ type: 'sqlite', connection: './data.db' });
const personalityManager = await createPersonalityManager(database);

// Create a custom personality
const customPersonality = await personalityManager.create({
  name: 'friendly-teacher',
  description: 'A patient and encouraging teacher',
  prompt: `You are a friendly, patient teacher who loves helping students learn. 
           You explain complex concepts in simple terms, use encouraging language, 
           and always check for understanding. You celebrate small wins and 
           make learning enjoyable.`
});

import { createAgent, createProvider, createMemory } from '@astreus-ai/astreus';

// Create agent with personality
const agent = await createAgent({
  name: 'teaching-bot',
  provider: await createProvider({ type: 'openai', model: 'gpt-4o-mini' }),
  memory: await createMemory({ type: 'sqlite' }),
  personality: customPersonality  // 🎭 Personality automatically integrated!
});

// Or set personality later
agent.setPersonality(technicalExpert);

// Switch personalities based on context
const personalities = {
  creative: await personalityManager.getByName('creative-writer'),
  technical: await personalityManager.getByName('technical-expert'),
  helpful: await personalityManager.getByName('helpful-assistant')
};

// Switch based on user request
if (userRequest.includes('creative') || userRequest.includes('story')) {
  agent.setPersonality(personalities.creative);
} else if (userRequest.includes('code') || userRequest.includes('technical')) {
  agent.setPersonality(personalities.technical);
} else {
  agent.setPersonality(personalities.helpful);
}

const response = await agent.chat({ message: userRequest });

// In Agent.chat() method:
const finalSystemPrompt = this.getCombinedSystemPrompt(systemPrompt);
// Result: [Personality Prompt] + [Original System Prompt]

// Option 1: Direct task creation through agent (recommended)
const task = await agent.createTask({
  name: "explain-concept", 
  description: "Explain a complex topic to a student"
});

const result = await agent.executeTask(task.id, {
  topic: "machine learning"
});
// 🎭 Agent's personality is automatically used in task execution

// Option 2: Manual TaskManager with personality
const taskManager = await createTaskManager({
  database,
  personality: customPersonality  // All tasks will use this personality
});

interface PersonalityManagerInstance {
  // Create a new personality
  create(config: PersonalityConfig): Promise<PersonalityInstance>;
  
  // Get personality by ID
  get(id: string): Promise<PersonalityInstance | null>;
  
  // Get personality by name
  getByName(name: string): Promise<PersonalityInstance | null>;
  
  // List all personalities
  list(limit?: number): Promise<PersonalityInstance[]>;
  
  // Search personalities
  search(query: string): Promise<PersonalityInstance[]>;
  
  // Update personality
  update(id: string, updates: Partial<PersonalityConfig>): Promise<void>;
  
  // Delete personality  
  delete(id: string): Promise<void>;
}

interface AgentInstance {
  // Get current personality
  getPersonality(): PersonalityInstance | undefined;
  
  // Set personality
  setPersonality(personality: PersonalityInstance): void;
  
  // Remove personality
  removePersonality(): void;
}

const customerServicePersonality = await personalityManager.create({
  name: 'customer-service',
  description: 'Professional customer service representative',
  prompt: `You are a professional customer service representative. You are helpful, 
           patient, and solution-oriented. You always acknowledge customer concerns, 
           provide clear explanations, and offer practical solutions. You maintain 
           a positive, empathetic tone even in difficult situations.`
});

const serviceBot = await createAgent({
  name: 'service-bot',
  provider: provider,
  memory: memory,
  personality: customerServicePersonality
});

const codeReviewPersonality = await personalityManager.create({
  name: 'code-reviewer',
  description: 'Senior software engineer focused on code quality',
  prompt: `You are a senior software engineer with expertise in code review. 
           You focus on code quality, best practices, security, and maintainability. 
           You provide constructive feedback with specific suggestions and explain 
           the reasoning behind your recommendations. You are thorough but respectful.`
});

const reviewBot = await createAgent({
  name: 'code-reviewer',
  provider: provider,
  memory: memory,
  personality: codeReviewPersonality
});