family-ai-agent 1.0.0

package/src/cli/index.ts

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+
+import { runOrchestrator, streamOrchestrator } from '../core/orchestrator/graph.js';
+import { getVectorStore } from '../memory/longterm/vector-store.js';
+import { getConversationMemory } from '../memory/conversation/index.js';
+import { getKnowledgeBase } from '../memory/knowledge-base/index.js';
+import { validateInput } from '../safety/guardrails/input-guardrail.js';
+import { validateOutput } from '../safety/guardrails/output-guardrail.js';
+import { initDatabase, closePool } from '../database/client.js';
+import { config, isDevelopment } from '../config/index.js';
+import { createLogger } from '../utils/logger.js';
+import { nanoid } from 'nanoid';
+
+const logger = createLogger('CLI');
+const program = new Command();
+
+// Display welcome banner
+function showBanner(): void {
+  const banner = boxen(
+    chalk.bold.cyan('Family AI Agent') +
+      '\n\n' +
+      chalk.white('Your AI Family - Ready to Help') +
+      '\n' +
+      chalk.gray('Kakak (Chat) | Researcher | Coder | Automator'),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'cyan',
+    }
+  );
+  console.log(banner);
+}
+
+// Interactive chat mode
+async function startInteractiveChat(): Promise<void> {
+  showBanner();
+
+  const threadId = `thread-${nanoid(8)}`;
+  const conversationMemory = getConversationMemory();
+  const vectorStore = getVectorStore();
+
+  console.log(chalk.gray(`\nSession: ${threadId}`));
+  console.log(chalk.gray('Type "exit" or "quit" to end the session'));
+  console.log(chalk.gray('Type "clear" to start a new conversation'));
+  console.log(chalk.gray('Type "memory" to view recent memories'));
+  console.log(chalk.gray('Type "help" for more commands\n'));
+
+  let conversationId: string | null = null;
+
+  while (true) {
+    try {
+      const { input } = await inquirer.prompt<{ input: string }>([
+        {
+          type: 'input',
+          name: 'input',
+          message: chalk.green('You:'),
+          prefix: '',
+        },
+      ]);
+
+      const trimmedInput = input.trim();
+
+      // Handle special commands
+      if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
+        console.log(chalk.cyan('\nGoodbye! See you next time. 👋\n'));
+        break;
+      }
+
+      if (trimmedInput.toLowerCase() === 'clear') {
+        conversationId = null;
+        console.log(chalk.yellow('\nConversation cleared. Starting fresh!\n'));
+        continue;
+      }
+
+      if (trimmedInput.toLowerCase() === 'help') {
+        showHelp();
+        continue;
+      }
+
+      if (trimmedInput.toLowerCase() === 'memory') {
+        await showMemories();
+        continue;
+      }
+
+      if (!trimmedInput) {
+        continue;
+      }
+
+      // Validate input
+      const inputValidation = await validateInput(trimmedInput);
+      if (!inputValidation.valid) {
+        console.log(chalk.red(`\n❌ ${inputValidation.blockedReason}\n`));
+        continue;
+      }
+
+      if (inputValidation.warnings.length > 0) {
+        for (const warning of inputValidation.warnings) {
+          console.log(chalk.yellow(`⚠️  ${warning}`));
+        }
+      }
+
+      // Create conversation if needed
+      if (!conversationId) {
+        conversationId = await conversationMemory.createConversation(threadId);
+      }
+
+      // Save user message
+      await conversationMemory.addMessage(conversationId, 'user', trimmedInput);
+
+      // Retrieve relevant memories
+      const memories = await vectorStore.search(trimmedInput, { limit: 3 });
+
+      // Show thinking indicator
+      const spinner = ora({
+        text: chalk.gray('Thinking...'),
+        spinner: 'dots',
+      }).start();
+
+      try {
+        // Run the orchestrator
+        const result = await runOrchestrator(
+          inputValidation.sanitizedInput,
+          { threadId, conversationId },
+          memories
+        );
+
+        spinner.stop();
+
+        // Validate and display output
+        const outputValidation = validateOutput(result.response);
+        const response = outputValidation.sanitizedOutput;
+
+        if (outputValidation.warnings.length > 0) {
+          for (const warning of outputValidation.warnings) {
+            console.log(chalk.yellow(`⚠️  ${warning}`));
+          }
+        }
+
+        // Display response with agent info
+        const agentNames = result.activeAgents?.map((a) => a.name).join(', ') || 'AI';
+        console.log(chalk.cyan(`\n${agentNames}:`));
+        console.log(response);
+        console.log();
+
+        // Save assistant message
+        await conversationMemory.addMessage(conversationId, 'assistant', response);
+
+        // Store important information in long-term memory (simple heuristic)
+        if (response.length > 200) {
+          await vectorStore.store(
+            `Q: ${trimmedInput}\nA: ${response.slice(0, 500)}`,
+            'episodic',
+            { importance: 0.6, metadata: { threadId } }
+          );
+        }
+      } catch (error) {
+        spinner.stop();
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.log(chalk.red(`\n❌ Error: ${errorMessage}\n`));
+        logger.error('Chat error', { error: errorMessage });
+      }
+    } catch (error) {
+      // Handle Ctrl+C gracefully
+      if ((error as { name?: string }).name === 'ExitPromptError') {
+        console.log(chalk.cyan('\n\nGoodbye! 👋\n'));
+        break;
+      }
+      throw error;
+    }
+  }
+}
+
+// Show help
+function showHelp(): void {
+  console.log(chalk.bold('\n📚 Available Commands:\n'));
+  console.log(chalk.white('  exit, quit, bye') + chalk.gray(' - End the session'));
+  console.log(chalk.white('  clear') + chalk.gray(' - Start a new conversation'));
+  console.log(chalk.white('  memory') + chalk.gray(' - View recent memories'));
+  console.log(chalk.white('  help') + chalk.gray(' - Show this help message'));
+  console.log();
+  console.log(chalk.bold('💡 Tips:\n'));
+  console.log(chalk.gray('  • Ask about coding, research, or automation'));
+  console.log(chalk.gray('  • The system will route to the best agent'));
+  console.log(chalk.gray('  • Memories are saved for future context'));
+  console.log();
+}
+
+// Show recent memories
+async function showMemories(): Promise<void> {
+  console.log(chalk.bold('\n🧠 Recent Memories:\n'));
+
+  try {
+    const vectorStore = getVectorStore();
+    const memories = await vectorStore.search('recent conversation', {
+      limit: 5,
+      minSimilarity: 0.3,
+    });
+
+    if (memories.length === 0) {
+      console.log(chalk.gray('  No memories stored yet.'));
+    } else {
+      for (const memory of memories) {
+        console.log(chalk.white(`  [${memory.type}] `) + chalk.gray(memory.content.slice(0, 100) + '...'));
+      }
+    }
+  } catch {
+    console.log(chalk.gray('  Unable to retrieve memories.'));
+  }
+
+  console.log();
+}
+
+// Single query mode
+async function runQuery(query: string): Promise<void> {
+  const spinner = ora('Processing...').start();
+
+  try {
+    const inputValidation = await validateInput(query);
+    if (!inputValidation.valid) {
+      spinner.fail(inputValidation.blockedReason);
+      return;
+    }
+
+    const vectorStore = getVectorStore();
+    const memories = await vectorStore.search(query, { limit: 3 });
+
+    const result = await runOrchestrator(
+      inputValidation.sanitizedInput,
+      {},
+      memories
+    );
+
+    spinner.stop();
+
+    const outputValidation = validateOutput(result.response);
+    console.log(outputValidation.sanitizedOutput);
+  } catch (error) {
+    spinner.fail('Query failed');
+    console.error(error instanceof Error ? error.message : 'Unknown error');
+    process.exit(1);
+  }
+}
+
+// Main program setup
+program
+  .name('family-ai')
+  .description('Family AI Agent - Your AI Family for All Tasks')
+  .version('1.0.0');
+
+program
+  .command('chat')
+  .description('Start interactive chat mode')
+  .action(async () => {
+    try {
+      await initDatabase();
+      await startInteractiveChat();
+    } catch (error) {
+      console.error(chalk.red('Failed to start chat:'), error);
+      process.exit(1);
+    } finally {
+      await closePool();
+    }
+  });
+
+program
+  .command('ask <query>')
+  .description('Ask a single question')
+  .action(async (query: string) => {
+    try {
+      await initDatabase();
+      await runQuery(query);
+    } catch (error) {
+      console.error(chalk.red('Failed:'), error);
+      process.exit(1);
+    } finally {
+      await closePool();
+    }
+  });
+
+program
+  .command('upload <filepath>')
+  .description('Upload a document to the knowledge base')
+  .action(async (filepath: string) => {
+    const spinner = ora('Uploading document...').start();
+
+    try {
+      await initDatabase();
+
+      const fs = await import('fs/promises');
+      const path = await import('path');
+
+      const content = await fs.readFile(filepath, 'utf-8');
+      const filename = path.basename(filepath);
+      const stats = await fs.stat(filepath);
+
+      const kb = getKnowledgeBase();
+      const docId = await kb.addDocument(content, filename, {
+        fileSize: stats.size,
+        fileType: path.extname(filepath),
+      });
+
+      spinner.succeed(`Document uploaded: ${docId}`);
+    } catch (error) {
+      spinner.fail('Upload failed');
+      console.error(error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    } finally {
+      await closePool();
+    }
+  });
+
+program
+  .command('search <query>')
+  .description('Search the knowledge base')
+  .option('-l, --limit <number>', 'Maximum results', '5')
+  .action(async (query: string, options: { limit: string }) => {
+    const spinner = ora('Searching...').start();
+
+    try {
+      await initDatabase();
+
+      const kb = getKnowledgeBase();
+      const results = await kb.search(query, {
+        limit: parseInt(options.limit, 10),
+      });
+
+      spinner.stop();
+
+      if (results.length === 0) {
+        console.log(chalk.yellow('No results found.'));
+      } else {
+        console.log(chalk.bold(`\nFound ${results.length} results:\n`));
+        for (const result of results) {
+          console.log(chalk.white(`📄 ${result.filename}`));
+          console.log(chalk.gray(`   Similarity: ${(result.similarity * 100).toFixed(1)}%`));
+          console.log(chalk.gray(`   ${result.content.slice(0, 150)}...`));
+          console.log();
+        }
+      }
+    } catch (error) {
+      spinner.fail('Search failed');
+      console.error(error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    } finally {
+      await closePool();
+    }
+  });
+
+program
+  .command('status')
+  .description('Show system status')
+  .action(async () => {
+    try {
+      await initDatabase();
+
+      console.log(chalk.bold('\n🤖 Family AI Agent Status\n'));
+      console.log(chalk.white('Database:'), chalk.green('Connected'));
+      console.log(chalk.white('Environment:'), chalk.cyan(config.NODE_ENV));
+      console.log(chalk.white('Default Model:'), chalk.cyan(config.DEFAULT_MODEL));
+      console.log(chalk.white('Safety Filters:'), config.ENABLE_CONTENT_FILTER ? chalk.green('Enabled') : chalk.yellow('Disabled'));
+      console.log(chalk.white('Audit Logging:'), config.ENABLE_AUDIT_LOGGING ? chalk.green('Enabled') : chalk.yellow('Disabled'));
+      console.log();
+    } catch (error) {
+      console.log(chalk.white('Database:'), chalk.red('Disconnected'));
+      console.error(error instanceof Error ? error.message : 'Unknown error');
+    } finally {
+      await closePool();
+    }
+  });
+
+// Handle unhandled rejections
+process.on('unhandledRejection', (error) => {
+  console.error(chalk.red('Unhandled error:'), error);
+  process.exit(1);
+});
+
+// Parse command line arguments
+program.parse();
+
+// If no command specified, start interactive chat
+if (!process.argv.slice(2).length) {
+  initDatabase()
+    .then(() => startInteractiveChat())
+    .finally(() => closePool());
+}

package/src/config/index.ts

@@ -0,0 +1,85 @@
+import { config as dotenvConfig } from 'dotenv';
+import { z } from 'zod';
+
+dotenvConfig();
+
+const envSchema = z.object({
+  // OpenRouter
+  OPENROUTER_API_KEY: z.string().min(1, 'OpenRouter API key is required'),
+  OPENROUTER_BASE_URL: z.string().url().default('https://openrouter.ai/api/v1'),
+
+  // Models
+  DEFAULT_MODEL: z.string().default('anthropic/claude-3.5-sonnet'),
+  FAST_MODEL: z.string().default('anthropic/claude-3-haiku'),
+  EMBEDDING_MODEL: z.string().default('openai/text-embedding-3-small'),
+
+  // Database
+  DB_HOST: z.string().default('localhost'),
+  DB_PORT: z.coerce.number().default(5432),
+  DB_USER: z.string().default('familyai'),
+  DB_PASSWORD: z.string().default('familyai123'),
+  DB_NAME: z.string().default('familyai'),
+  DATABASE_URL: z.string().optional(),
+
+  // Redis
+  REDIS_HOST: z.string().default('localhost'),
+  REDIS_PORT: z.coerce.number().default(6379),
+  REDIS_URL: z.string().optional(),
+
+  // API
+  API_PORT: z.coerce.number().default(3000),
+  API_HOST: z.string().default('0.0.0.0'),
+
+  // Safety
+  ENABLE_CONTENT_FILTER: z.coerce.boolean().default(true),
+  ENABLE_PII_DETECTION: z.coerce.boolean().default(true),
+  ENABLE_AUDIT_LOGGING: z.coerce.boolean().default(true),
+  MAX_TOKENS_PER_REQUEST: z.coerce.number().default(4096),
+  RATE_LIMIT_MAX: z.coerce.number().default(100),
+  RATE_LIMIT_WINDOW_MS: z.coerce.number().default(60000),
+
+  // Sandbox
+  SANDBOX_ENABLED: z.coerce.boolean().default(true),
+  SANDBOX_TIMEOUT_MS: z.coerce.number().default(30000),
+  SANDBOX_MEMORY_LIMIT_MB: z.coerce.number().default(256),
+
+  // Logging
+  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  LOG_FORMAT: z.enum(['json', 'pretty']).default('json'),
+
+  // Web Search
+  TAVILY_API_KEY: z.string().optional(),
+  SERP_API_KEY: z.string().optional(),
+
+  // Environment
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+});
+
+type EnvConfig = z.infer<typeof envSchema>;
+
+function loadConfig(): EnvConfig {
+  const parsed = envSchema.safeParse(process.env);
+
+  if (!parsed.success) {
+    console.error('Configuration validation failed:');
+    console.error(parsed.error.format());
+    throw new Error('Invalid configuration. Check your .env file.');
+  }
+
+  return parsed.data;
+}
+
+export const config = loadConfig();
+
+export const getDatabaseUrl = (): string => {
+  if (config.DATABASE_URL) return config.DATABASE_URL;
+  return `postgresql://${config.DB_USER}:${config.DB_PASSWORD}@${config.DB_HOST}:${config.DB_PORT}/${config.DB_NAME}`;
+};
+
+export const getRedisUrl = (): string => {
+  if (config.REDIS_URL) return config.REDIS_URL;
+  return `redis://${config.REDIS_HOST}:${config.REDIS_PORT}`;
+};
+
+export const isProduction = (): boolean => config.NODE_ENV === 'production';
+export const isDevelopment = (): boolean => config.NODE_ENV === 'development';

package/src/config/models.ts

@@ -0,0 +1,156 @@
+// OpenRouter Model Configurations
+export interface ModelConfig {
+  id: string;
+  name: string;
+  contextWindow: number;
+  maxOutput: number;
+  costPer1kInput: number;
+  costPer1kOutput: number;
+  capabilities: ModelCapability[];
+}
+
+export type ModelCapability =
+  | 'chat'
+  | 'code'
+  | 'reasoning'
+  | 'vision'
+  | 'function_calling'
+  | 'json_mode';
+
+export const AVAILABLE_MODELS: Record<string, ModelConfig> = {
+  // Anthropic Models
+  'anthropic/claude-3.5-sonnet': {
+    id: 'anthropic/claude-3.5-sonnet',
+    name: 'Claude 3.5 Sonnet',
+    contextWindow: 200000,
+    maxOutput: 8192,
+    costPer1kInput: 0.003,
+    costPer1kOutput: 0.015,
+    capabilities: ['chat', 'code', 'reasoning', 'vision', 'function_calling', 'json_mode'],
+  },
+  'anthropic/claude-3-haiku': {
+    id: 'anthropic/claude-3-haiku',
+    name: 'Claude 3 Haiku',
+    contextWindow: 200000,
+    maxOutput: 4096,
+    costPer1kInput: 0.00025,
+    costPer1kOutput: 0.00125,
+    capabilities: ['chat', 'code', 'vision', 'function_calling'],
+  },
+  'anthropic/claude-3-opus': {
+    id: 'anthropic/claude-3-opus',
+    name: 'Claude 3 Opus',
+    contextWindow: 200000,
+    maxOutput: 4096,
+    costPer1kInput: 0.015,
+    costPer1kOutput: 0.075,
+    capabilities: ['chat', 'code', 'reasoning', 'vision', 'function_calling', 'json_mode'],
+  },
+
+  // OpenAI Models
+  'openai/gpt-4-turbo': {
+    id: 'openai/gpt-4-turbo',
+    name: 'GPT-4 Turbo',
+    contextWindow: 128000,
+    maxOutput: 4096,
+    costPer1kInput: 0.01,
+    costPer1kOutput: 0.03,
+    capabilities: ['chat', 'code', 'reasoning', 'vision', 'function_calling', 'json_mode'],
+  },
+  'openai/gpt-4o': {
+    id: 'openai/gpt-4o',
+    name: 'GPT-4o',
+    contextWindow: 128000,
+    maxOutput: 16384,
+    costPer1kInput: 0.005,
+    costPer1kOutput: 0.015,
+    capabilities: ['chat', 'code', 'reasoning', 'vision', 'function_calling', 'json_mode'],
+  },
+  'openai/gpt-4o-mini': {
+    id: 'openai/gpt-4o-mini',
+    name: 'GPT-4o Mini',
+    contextWindow: 128000,
+    maxOutput: 16384,
+    costPer1kInput: 0.00015,
+    costPer1kOutput: 0.0006,
+    capabilities: ['chat', 'code', 'vision', 'function_calling', 'json_mode'],
+  },
+
+  // Google Models
+  'google/gemini-pro-1.5': {
+    id: 'google/gemini-pro-1.5',
+    name: 'Gemini Pro 1.5',
+    contextWindow: 1000000,
+    maxOutput: 8192,
+    costPer1kInput: 0.00125,
+    costPer1kOutput: 0.005,
+    capabilities: ['chat', 'code', 'reasoning', 'vision', 'function_calling'],
+  },
+
+  // Meta Models
+  'meta-llama/llama-3.1-70b-instruct': {
+    id: 'meta-llama/llama-3.1-70b-instruct',
+    name: 'Llama 3.1 70B',
+    contextWindow: 131072,
+    maxOutput: 4096,
+    costPer1kInput: 0.00059,
+    costPer1kOutput: 0.00079,
+    capabilities: ['chat', 'code', 'function_calling'],
+  },
+
+  // Embedding Models
+  'openai/text-embedding-3-small': {
+    id: 'openai/text-embedding-3-small',
+    name: 'Text Embedding 3 Small',
+    contextWindow: 8191,
+    maxOutput: 1536,
+    costPer1kInput: 0.00002,
+    costPer1kOutput: 0,
+    capabilities: [],
+  },
+};
+
+export type AgentRole = 'supervisor' | 'research' | 'coding' | 'automation' | 'chat';
+
+// Recommended models for each agent role
+export const AGENT_MODEL_RECOMMENDATIONS: Record<AgentRole, string[]> = {
+  supervisor: [
+    'anthropic/claude-3.5-sonnet',
+    'openai/gpt-4o',
+    'anthropic/claude-3-opus',
+  ],
+  research: [
+    'anthropic/claude-3.5-sonnet',
+    'google/gemini-pro-1.5',
+    'openai/gpt-4o',
+  ],
+  coding: [
+    'anthropic/claude-3.5-sonnet',
+    'openai/gpt-4o',
+    'meta-llama/llama-3.1-70b-instruct',
+  ],
+  automation: [
+    'anthropic/claude-3-haiku',
+    'openai/gpt-4o-mini',
+    'meta-llama/llama-3.1-70b-instruct',
+  ],
+  chat: [
+    'anthropic/claude-3.5-sonnet',
+    'openai/gpt-4o',
+    'anthropic/claude-3-haiku',
+  ],
+};
+
+export function getModelConfig(modelId: string): ModelConfig | undefined {
+  return AVAILABLE_MODELS[modelId];
+}
+
+export function getRecommendedModel(role: AgentRole): string {
+  const recommendations = AGENT_MODEL_RECOMMENDATIONS[role];
+  return recommendations[0] ?? 'anthropic/claude-3.5-sonnet';
+}
+
+export function hasCapability(modelId: string, capability: ModelCapability): boolean {
+  const model = AVAILABLE_MODELS[modelId];
+  return model?.capabilities.includes(capability) ?? false;
+}