family-ai-agent 1.0.0

package/src/core/agents/personalities/automation.ts

@@ -0,0 +1,202 @@
+import { nanoid } from 'nanoid';
+import { BaseAgent } from '../base-agent.js';
+import type {
+  AgentConfig,
+  AgentState,
+  TaskResult,
+  RetrievedMemory,
+  HandoffDecision,
+} from '../types.js';
+import { getRecommendedModel } from '../../../config/models.js';
+
+const AUTOMATION_SYSTEM_PROMPT = `You are an expert Automation Agent in the Family AI Agent system, specializing in task automation and workflow management.
+
+Your identity: Automation Specialist
+Your personality:
+- Systematic and organized
+- Efficient and reliable
+- Detail-oriented for error prevention
+- Proactive in identifying automation opportunities
+
+Your capabilities:
+- Creating automated workflows
+- Scheduling recurring tasks
+- Managing task queues
+- Batch processing operations
+- Setting up notifications and alerts
+- Integrating different tools and systems
+- Monitoring task execution
+
+Automation principles:
+1. Reliability over speed
+2. Clear error handling and recovery
+3. Proper logging and monitoring
+4. Minimal human intervention needed
+5. Graceful degradation on failures
+6. Clear status reporting
+
+When designing automation:
+- Understand the full workflow requirements
+- Identify potential failure points
+- Plan error handling strategies
+- Consider resource constraints
+- Design for maintainability
+
+Task categories you handle:
+- Scheduled jobs (cron-like)
+- Event-triggered workflows
+- Batch processing
+- Data pipelines
+- File operations
+- System maintenance
+
+Output format for automation tasks:
+1. Task definition (what to automate)
+2. Schedule/trigger conditions
+3. Required resources
+4. Error handling plan
+5. Success criteria
+6. Monitoring/alerting setup`;
+
+export class AutomationAgent extends BaseAgent {
+  constructor(tools: AgentConfig['tools'] = []) {
+    super({
+      identity: {
+        id: `automation-${nanoid(8)}`,
+        name: 'Automator',
+        role: 'automation',
+        description: 'Task automation and workflow management agent',
+        capabilities: [
+          'task_scheduling',
+          'workflow_creation',
+          'batch_processing',
+          'monitoring',
+          'alerting',
+          'file_operations',
+          'system_integration',
+        ],
+      },
+      model: getRecommendedModel('automation'),
+      temperature: 0.3, // Low temperature for reliable automation
+      systemPrompt: AUTOMATION_SYSTEM_PROMPT,
+      tools,
+      maxIterations: 8,
+    });
+  }
+
+  protected buildSystemPrompt(
+    context: Record<string, unknown>,
+    memories: RetrievedMemory[]
+  ): string {
+    let prompt = this.systemPrompt;
+
+    // Add workflow memories
+    const workflowMemories = memories.filter(
+      (m) => m.type === 'procedural' || m.metadata?.category === 'workflow'
+    );
+
+    if (workflowMemories.length > 0) {
+      prompt += '\n\n## Known Workflows/Automations\n';
+      for (const memory of workflowMemories) {
+        prompt += `- ${memory.content}\n`;
+      }
+    }
+
+    // Add active tasks context
+    if (context.activeTasks) {
+      prompt += '\n\n## Currently Active Tasks\n';
+      prompt += JSON.stringify(context.activeTasks, null, 2);
+    }
+
+    // Add schedule context
+    if (context.schedule) {
+      prompt += '\n\n## Existing Schedules\n';
+      prompt += JSON.stringify(context.schedule, null, 2);
+    }
+
+    return prompt;
+  }
+
+  protected async shouldHandoff(
+    state: AgentState,
+    result: TaskResult
+  ): Promise<HandoffDecision> {
+    const output = String(result.output).toLowerCase();
+
+    // Check if coding is needed
+    if (
+      output.includes('write a script') ||
+      output.includes('create a program') ||
+      output.includes('implement code')
+    ) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'coding',
+        reason: 'Need code implementation for automation',
+        context: {
+          automationSpec: result.output,
+        },
+      };
+    }
+
+    // Check if research is needed
+    if (
+      output.includes('need to investigate') ||
+      output.includes('research required')
+    ) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'research',
+        reason: 'Need research before automation setup',
+      };
+    }
+
+    return {
+      shouldHandoff: false,
+      reason: 'Automation task complete',
+    };
+  }
+
+  // Additional automation-specific methods
+  async scheduleTask(
+    taskDescription: string,
+    schedule: string
+  ): Promise<TaskResult> {
+    return this.execute(
+      `Create a scheduled task:\n\nTask: ${taskDescription}\nSchedule: ${schedule}`,
+      { task: 'scheduling' }
+    );
+  }
+
+  async createWorkflow(steps: string[]): Promise<TaskResult> {
+    return this.execute(
+      `Create an automated workflow with these steps:\n\n${steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`,
+      { task: 'workflow_creation' }
+    );
+  }
+
+  async batchProcess(
+    items: string[],
+    operation: string
+  ): Promise<TaskResult> {
+    return this.execute(
+      `Set up batch processing:\n\nOperation: ${operation}\nItems: ${items.length} items to process`,
+      { task: 'batch_processing', itemCount: items.length }
+    );
+  }
+
+  async setupMonitoring(target: string, conditions: string): Promise<TaskResult> {
+    return this.execute(
+      `Set up monitoring:\n\nTarget: ${target}\nAlert conditions: ${conditions}`,
+      { task: 'monitoring' }
+    );
+  }
+}
+
+export function createAutomationAgent(
+  tools: AgentConfig['tools'] = []
+): AutomationAgent {
+  return new AutomationAgent(tools);
+}
+
+export default AutomationAgent;

package/src/core/agents/personalities/chat.ts

@@ -0,0 +1,159 @@
+import { nanoid } from 'nanoid';
+import { BaseAgent } from '../base-agent.js';
+import type {
+  AgentConfig,
+  AgentState,
+  TaskResult,
+  RetrievedMemory,
+  HandoffDecision,
+} from '../types.js';
+import { getRecommendedModel } from '../../../config/models.js';
+
+const CHAT_SYSTEM_PROMPT = `You are a friendly and helpful AI assistant named "Kakak" (Elder Sibling) from the Family AI Agent system.
+
+Your personality:
+- Warm, supportive, and patient
+- Clear and concise in explanations
+- Proactive in offering help
+- Respectful and professional
+
+Your capabilities:
+- General conversation and Q&A
+- Explaining concepts in simple terms
+- Providing thoughtful advice
+- Creative writing and brainstorming
+- Summarizing information
+
+Guidelines:
+1. Be helpful and accurate in your responses
+2. If you don't know something, say so honestly
+3. For complex technical tasks (coding, research), suggest delegating to specialized agents
+4. Remember context from the conversation
+5. Use the user's language preference when possible
+
+When you encounter tasks better suited for other agents:
+- Research/information gathering → Research Agent
+- Code writing/debugging → Coding Agent
+- Task automation/scheduling → Automation Agent`;
+
+export class ChatAgent extends BaseAgent {
+  constructor(tools: AgentConfig['tools'] = []) {
+    super({
+      identity: {
+        id: `chat-${nanoid(8)}`,
+        name: 'Kakak',
+        role: 'chat',
+        description: 'Friendly general-purpose chat assistant',
+        capabilities: [
+          'conversation',
+          'explanation',
+          'advice',
+          'creative_writing',
+          'summarization',
+          'translation',
+        ],
+      },
+      model: getRecommendedModel('chat'),
+      temperature: 0.7,
+      systemPrompt: CHAT_SYSTEM_PROMPT,
+      tools,
+      maxIterations: 5,
+    });
+  }
+
+  protected buildSystemPrompt(
+    context: Record<string, unknown>,
+    memories: RetrievedMemory[]
+  ): string {
+    let prompt = this.systemPrompt;
+
+    // Add relevant memories
+    if (memories.length > 0) {
+      prompt += '\n\n## Relevant Memories\n';
+      for (const memory of memories) {
+        prompt += `- [${memory.type}] ${memory.content}\n`;
+      }
+    }
+
+    // Add context
+    if (Object.keys(context).length > 0) {
+      prompt += '\n\n## Current Context\n';
+      prompt += JSON.stringify(context, null, 2);
+    }
+
+    // Add user preferences if available
+    if (context.userPreferences) {
+      prompt += '\n\n## User Preferences\n';
+      prompt += JSON.stringify(context.userPreferences, null, 2);
+    }
+
+    return prompt;
+  }
+
+  protected async shouldHandoff(
+    state: AgentState,
+    result: TaskResult
+  ): Promise<HandoffDecision> {
+    // Check if the task requires specialized handling
+    const output = String(result.output).toLowerCase();
+
+    // Patterns that suggest handoff to other agents
+    const codingPatterns = [
+      'write code',
+      'debug',
+      'fix bug',
+      'implement',
+      'refactor',
+      'programming',
+    ];
+    const researchPatterns = [
+      'search for',
+      'find information',
+      'research',
+      'look up',
+      'investigate',
+    ];
+    const automationPatterns = [
+      'schedule',
+      'automate',
+      'repeat task',
+      'run every',
+      'batch process',
+    ];
+
+    if (codingPatterns.some((p) => output.includes(p))) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'coding',
+        reason: 'Task requires code-related capabilities',
+      };
+    }
+
+    if (researchPatterns.some((p) => output.includes(p))) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'research',
+        reason: 'Task requires web research capabilities',
+      };
+    }
+
+    if (automationPatterns.some((p) => output.includes(p))) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'automation',
+        reason: 'Task requires automation capabilities',
+      };
+    }
+
+    return {
+      shouldHandoff: false,
+      reason: 'Task can be handled by chat agent',
+    };
+  }
+}
+
+export function createChatAgent(tools: AgentConfig['tools'] = []): ChatAgent {
+  return new ChatAgent(tools);
+}
+
+export default ChatAgent;

package/src/core/agents/personalities/coding.ts

@@ -0,0 +1,227 @@
+import { nanoid } from 'nanoid';
+import { BaseAgent } from '../base-agent.js';
+import type {
+  AgentConfig,
+  AgentState,
+  TaskResult,
+  RetrievedMemory,
+  HandoffDecision,
+} from '../types.js';
+import { getRecommendedModel } from '../../../config/models.js';
+
+const CODING_SYSTEM_PROMPT = `You are an expert Coding Agent in the Family AI Agent system, specializing in software development.
+
+Your identity: "Adik" (Younger Sibling) - The brilliant coder
+Your personality:
+- Highly skilled and confident
+- Detail-oriented and precise
+- Creative problem solver
+- Efficient and pragmatic
+
+Your capabilities:
+- Writing clean, efficient code in multiple languages
+- Debugging and fixing errors
+- Code review and optimization
+- Explaining code and concepts
+- Refactoring and improving code quality
+- Writing tests and documentation
+- Architecture and design decisions
+
+Supported languages (proficient):
+- JavaScript/TypeScript
+- Python
+- Go, Rust
+- Java, C#
+- SQL
+- HTML/CSS
+- Shell scripting
+
+Coding principles:
+1. Write clean, readable, maintainable code
+2. Follow language-specific best practices
+3. Include error handling
+4. Consider edge cases
+5. Optimize for performance when needed
+6. Write self-documenting code
+7. Add comments only when necessary
+
+When writing code:
+- Start with understanding the requirements
+- Plan the solution before coding
+- Write modular, reusable code
+- Test the logic mentally
+- Provide clear explanations
+
+When debugging:
+- Analyze the error message carefully
+- Identify the root cause
+- Explain what went wrong
+- Provide a fix with explanation
+
+Code output format:
+\`\`\`language
+// code here
+\`\`\`
+
+Always explain your code decisions briefly.`;
+
+export class CodingAgent extends BaseAgent {
+  constructor(tools: AgentConfig['tools'] = []) {
+    super({
+      identity: {
+        id: `coding-${nanoid(8)}`,
+        name: 'Adik',
+        role: 'coding',
+        description: 'Expert software development agent',
+        capabilities: [
+          'code_generation',
+          'debugging',
+          'code_review',
+          'refactoring',
+          'testing',
+          'documentation',
+          'architecture',
+          'optimization',
+        ],
+      },
+      model: getRecommendedModel('coding'),
+      temperature: 0.2, // Low temperature for precise code
+      systemPrompt: CODING_SYSTEM_PROMPT,
+      tools,
+      maxIterations: 10,
+      timeout: 180000, // 3 minutes for complex coding tasks
+    });
+  }
+
+  protected buildSystemPrompt(
+    context: Record<string, unknown>,
+    memories: RetrievedMemory[]
+  ): string {
+    let prompt = this.systemPrompt;
+
+    // Add code-related memories (previous solutions, patterns)
+    const codeMemories = memories.filter(
+      (m) => m.type === 'procedural' || m.metadata?.category === 'code'
+    );
+
+    if (codeMemories.length > 0) {
+      prompt += '\n\n## Relevant Code Patterns/Solutions\n';
+      for (const memory of codeMemories) {
+        prompt += `- ${memory.content}\n`;
+      }
+    }
+
+    // Add project context
+    if (context.projectLanguage) {
+      prompt += `\n\n## Project Language: ${context.projectLanguage}`;
+    }
+
+    if (context.codebase) {
+      prompt += '\n\n## Codebase Context\n';
+      prompt += JSON.stringify(context.codebase, null, 2);
+    }
+
+    if (context.existingCode) {
+      prompt += `\n\n## Existing Code\n\`\`\`\n${context.existingCode}\n\`\`\``;
+    }
+
+    if (context.errorMessage) {
+      prompt += `\n\n## Error to Debug\n${context.errorMessage}`;
+    }
+
+    return prompt;
+  }
+
+  protected async shouldHandoff(
+    state: AgentState,
+    result: TaskResult
+  ): Promise<HandoffDecision> {
+    const output = String(result.output).toLowerCase();
+
+    // Check if research is needed
+    if (
+      output.includes('need to research') ||
+      output.includes('requires investigation') ||
+      output.includes('look up documentation')
+    ) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'research',
+        reason: 'Need to research before implementation',
+      };
+    }
+
+    // Check if automation is needed
+    if (
+      output.includes('deploy this') ||
+      output.includes('run regularly') ||
+      output.includes('automate deployment')
+    ) {
+      return {
+        shouldHandoff: true,
+        targetAgent: 'automation',
+        reason: 'Code ready for automation/deployment',
+        context: {
+          code: result.output,
+        },
+      };
+    }
+
+    return {
+      shouldHandoff: false,
+      reason: 'Coding task complete',
+    };
+  }
+
+  // Additional coding-specific methods
+  async generateCode(
+    description: string,
+    language: string = 'typescript'
+  ): Promise<TaskResult> {
+    return this.execute(
+      `Generate ${language} code for the following:\n\n${description}`,
+      { task: 'code_generation', language }
+    );
+  }
+
+  async debug(code: string, error: string): Promise<TaskResult> {
+    return this.execute(
+      `Debug the following code:\n\n\`\`\`\n${code}\n\`\`\`\n\nError:\n${error}`,
+      { task: 'debugging' }
+    );
+  }
+
+  async review(code: string): Promise<TaskResult> {
+    return this.execute(
+      `Review the following code for quality, bugs, and improvements:\n\n\`\`\`\n${code}\n\`\`\``,
+      { task: 'code_review' }
+    );
+  }
+
+  async refactor(code: string, goal: string): Promise<TaskResult> {
+    return this.execute(
+      `Refactor the following code with this goal: ${goal}\n\n\`\`\`\n${code}\n\`\`\``,
+      { task: 'refactoring' }
+    );
+  }
+
+  async explainCode(code: string): Promise<TaskResult> {
+    return this.execute(
+      `Explain the following code in detail:\n\n\`\`\`\n${code}\n\`\`\``,
+      { task: 'explanation' }
+    );
+  }
+
+  async writeTests(code: string, framework: string = 'vitest'): Promise<TaskResult> {
+    return this.execute(
+      `Write ${framework} tests for the following code:\n\n\`\`\`\n${code}\n\`\`\``,
+      { task: 'testing', framework }
+    );
+  }
+}
+
+export function createCodingAgent(tools: AgentConfig['tools'] = []): CodingAgent {
+  return new CodingAgent(tools);
+}
+
+export default CodingAgent;