Orbofi Personality Engine Integration

# Required dependencies
- @sendaifun/solana-agent-kit
- @orbofi/personality-engine

npm install @orbofi/personality-engine

// Add to your Solana Agent Kit configuration
const config = {
  // ... other configuration options
  ORBOFI_API_KEY: "your_api_key_here"
};

// Import personality module
import { fetchPersonality } from '@orbofi/personality-engine';

// Fetch a personality by name
const personality = await agent.fetchOrbofiPersonality('satoshi nakamoto');

// Start interactive chat with the personality
const chat = await agent.startOrbofiChat(personality);

// Send a message and get a response
const response = await chat.sendMessage('Tell me about yourself');

// Start autonomous mode with specific goals
const autonomous = await agent.startOrbofiAutonomousMode(personality, {
  goal: 'Explain blockchain technology',
  steps: 5
});

// Execute autonomous actions
const result = await autonomous.execute();

import { SolanaAgentKit } from '@sendaifun/solana-agent-kit';
import readline from 'readline';

// Initialize Solana Agent Kit
const agent = new SolanaAgentKit({
  // ... configuration
});

// Create interactive CLI
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function main() {
  // Prompt for personality selection
  console.log('************');
  console.log('Personality Selection:');
  console.log('What is the name of the celebrity/person/character that you would like to create?');
  console.log('************');
  
  rl.question('', async (name) => {
    try {
      // Fetch the personality
      const personality = await agent.fetchOrbofiPersonality(name);
      console.log(`Fetched personality: ${personality.description}`);
      
      // Select mode
      console.log('\nAvailable modes:');
      console.log('1. chat\n- Interactive chat mode');
      console.log('2. auto\n- Autonomous action mode');
      
      rl.question('Choose a mode (enter number or name): ', async (mode) => {
        if (mode === '1' || mode.toLowerCase() === 'chat') {
          // Start chat mode
          startChatMode(personality);
        } else if (mode === '2' || mode.toLowerCase() === 'auto') {
          // Start autonomous mode
          startAutonomousMode(personality);
        } else {
          console.log('Invalid mode selected.');
          rl.close();
        }
      });
    } catch (error) {
      console.error('Error fetching personality:', error.message);
      rl.close();
    }
  });
}

async function startChatMode(personality) {
  console.log('Starting chat mode... Type \'exit\' to end.');
  
  const chat = await agent.startOrbofiChat(personality);
  const promptUser = () => {
    rl.question('Prompt: ', async (input) => {
      if (input.toLowerCase() === 'exit') {
        rl.close();
        return;
      }
      
      try {
        const response = await chat.sendMessage(input);
        console.log(response);
        promptUser();
      } catch (error) {
        console.error('Error in chat:', error.message);
        promptUser();
      }
    });
  };
  
  promptUser();
}

async function startAutonomousMode(personality) {
  console.log('Starting autonomous mode...');
  
  try {
    const autonomous = await agent.startOrbofiAutonomousMode(personality, {
      goal: 'Provide insights about your field of expertise',
      steps: 3
    });
    
    const result = await autonomous.execute();
    console.log('Autonomous execution complete:');
    console.log(result.join('\n'));
    rl.close();
  } catch (error) {
    console.error('Error in autonomous mode:', error.message);
    rl.close();
  }
}

main();

/**
 * Fetches personality data from the Orbofi database
 * @param name Name of the celebrity/character to fetch
 * @returns Personality object with description and properties
 */
async function fetchOrbofiPersonality(name: string): Promise<Personality>

/**
 * Starts an interactive chat session with the personality
 * @param personality Personality object returned from fetchOrbofiPersonality
 * @returns Chat object with methods for interaction
 */
async function startOrbofiChat(personality: Personality): Promise<OrbofiChat>

/**
 * Starts autonomous mode with the specified personality
 * @param personality Personality object returned from fetchOrbofiPersonality
 * @param options Configuration options for autonomous behavior
 * @returns Autonomous object with execution methods
 */
async function startOrbofiAutonomousMode(
  personality: Personality, 
  options: AutonomousOptions
): Promise<OrbofiAutonomous>

interface Personality {
  id: string;
  name: string;
  description: string;
  traits: {
    [key: string]: number;
  };
  background: string;
  capabilities: string[];
  limitations: string[];
}

interface AutonomousOptions {
  goal: string;
  steps?: number;
  constraints?: string[];
  outputFormat?: 'text' | 'json';
}