family-ai-agent 1.0.0 → 1.0.3

package/src/cli/setup-wizard.ts

@@ -0,0 +1,343 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+
+import {
+  saveUserConfig,
+  getAllModels,
+  getConfigPath,
+  type PartialUserConfig,
+} from '../config/user-config.js';
+
+/**
+ * Display welcome banner for setup
+ */
+function showSetupBanner(): void {
+  const banner = boxen(
+    chalk.bold.cyan('Family AI Agent Setup') +
+      '\n\n' +
+      chalk.white('Configure your AI agent in a few simple steps') +
+      '\n' +
+      chalk.gray('Your settings will be saved locally'),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'cyan',
+    }
+  );
+  console.log(banner);
+}
+
+/**
+ * Test API connection
+ */
+async function testConnection(
+  apiKey: string,
+  baseUrl: string
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const response = await fetch(`${baseUrl}/models`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'HTTP-Referer': 'https://family-ai-agent.local',
+        'X-Title': 'Family AI Agent Setup',
+      },
+    });
+
+    if (response.ok) {
+      return { success: true };
+    }
+
+    const errorData = await response.json().catch(() => ({}));
+    return {
+      success: false,
+      error: (errorData as Record<string, unknown>)?.error?.toString() || `HTTP ${response.status}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Connection failed',
+    };
+  }
+}
+
+/**
+ * Run the interactive setup wizard
+ */
+export async function runSetupWizard(): Promise<boolean> {
+  showSetupBanner();
+
+  try {
+    // Step 1: API Key
+    console.log(chalk.bold('\n📝 Step 1: API Configuration\n'));
+
+    const { apiKey } = await inquirer.prompt<{ apiKey: string }>([
+      {
+        type: 'password',
+        name: 'apiKey',
+        message: 'Enter your OpenRouter API Key:',
+        mask: '*',
+        validate: (input: string) => {
+          if (!input || input.trim().length === 0) {
+            return 'API key is required';
+          }
+          if (input.length < 10) {
+            return 'API key seems too short';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    // Step 2: Base URL
+    const { baseUrl } = await inquirer.prompt<{ baseUrl: string }>([
+      {
+        type: 'input',
+        name: 'baseUrl',
+        message: 'API Base URL:',
+        default: 'https://openrouter.ai/api/v1',
+        validate: (input: string) => {
+          try {
+            new URL(input);
+            return true;
+          } catch {
+            return 'Please enter a valid URL';
+          }
+        },
+      },
+    ]);
+
+    // Test connection
+    const spinner = ora('Testing API connection...').start();
+    const testResult = await testConnection(apiKey, baseUrl);
+
+    if (!testResult.success) {
+      spinner.fail(`Connection failed: ${testResult.error}`);
+
+      const { continueAnyway } = await inquirer.prompt<{ continueAnyway: boolean }>([
+        {
+          type: 'confirm',
+          name: 'continueAnyway',
+          message: 'Continue with setup anyway?',
+          default: false,
+        },
+      ]);
+
+      if (!continueAnyway) {
+        console.log(chalk.yellow('\nSetup cancelled. Please check your API key and try again.\n'));
+        return false;
+      }
+    } else {
+      spinner.succeed('API connection successful!');
+    }
+
+    // Step 3: Model Selection
+    console.log(chalk.bold('\n🤖 Step 2: Model Configuration\n'));
+
+    const models = getAllModels();
+    const modelChoices = [
+      ...models.map((m) => ({
+        name: `${m.name} (${m.id})`,
+        value: m.id,
+      })),
+      { name: chalk.gray('Enter custom model ID...'), value: '__custom__' },
+    ];
+
+    const { defaultModel } = await inquirer.prompt<{ defaultModel: string }>([
+      {
+        type: 'list',
+        name: 'defaultModel',
+        message: 'Select your default model:',
+        choices: modelChoices,
+        default: 'anthropic/claude-3.5-sonnet',
+      },
+    ]);
+
+    let finalDefaultModel = defaultModel;
+
+    if (defaultModel === '__custom__') {
+      const { customModel } = await inquirer.prompt<{ customModel: string }>([
+        {
+          type: 'input',
+          name: 'customModel',
+          message: 'Enter custom model ID (e.g., provider/model-name):',
+          validate: (input: string) => {
+            if (!input || input.trim().length === 0) {
+              return 'Model ID is required';
+            }
+            return true;
+          },
+        },
+      ]);
+      finalDefaultModel = customModel;
+    }
+
+    // Step 4: Fast Model (optional)
+    const { configureFastModel } = await inquirer.prompt<{ configureFastModel: boolean }>([
+      {
+        type: 'confirm',
+        name: 'configureFastModel',
+        message: 'Configure a separate fast model for quick tasks?',
+        default: true,
+      },
+    ]);
+
+    let fastModel = 'anthropic/claude-3-haiku';
+
+    if (configureFastModel) {
+      const { selectedFastModel } = await inquirer.prompt<{ selectedFastModel: string }>([
+        {
+          type: 'list',
+          name: 'selectedFastModel',
+          message: 'Select fast model:',
+          choices: modelChoices,
+          default: 'anthropic/claude-3-haiku',
+        },
+      ]);
+
+      if (selectedFastModel === '__custom__') {
+        const { customFastModel } = await inquirer.prompt<{ customFastModel: string }>([
+          {
+            type: 'input',
+            name: 'customFastModel',
+            message: 'Enter custom fast model ID:',
+          },
+        ]);
+        fastModel = customFastModel;
+      } else {
+        fastModel = selectedFastModel;
+      }
+    }
+
+    // Step 5: Safety Settings
+    console.log(chalk.bold('\n🛡️ Step 3: Safety Settings\n'));
+
+    const { enableSafetyFilters, enableAuditLogging } = await inquirer.prompt<{
+      enableSafetyFilters: boolean;
+      enableAuditLogging: boolean;
+    }>([
+      {
+        type: 'confirm',
+        name: 'enableSafetyFilters',
+        message: 'Enable content safety filters?',
+        default: true,
+      },
+      {
+        type: 'confirm',
+        name: 'enableAuditLogging',
+        message: 'Enable audit logging?',
+        default: true,
+      },
+    ]);
+
+    // Save configuration
+    console.log();
+    const saveSpinner = ora('Saving configuration...').start();
+
+    try {
+      const config: PartialUserConfig = {
+        apiKey,
+        baseUrl,
+        defaultModel: finalDefaultModel,
+        fastModel,
+        embeddingModel: 'openai/text-embedding-3-small',
+        enableSafetyFilters,
+        enableAuditLogging,
+        customModels: [],
+      };
+
+      saveUserConfig(config);
+      saveSpinner.succeed('Configuration saved!');
+
+      // Show summary
+      console.log(
+        boxen(
+          chalk.bold.green('Setup Complete!') +
+            '\n\n' +
+            chalk.white('Configuration saved to:') +
+            '\n' +
+            chalk.gray(getConfigPath()) +
+            '\n\n' +
+            chalk.white('Default Model: ') +
+            chalk.cyan(finalDefaultModel) +
+            '\n' +
+            chalk.white('Fast Model: ') +
+            chalk.cyan(fastModel) +
+            '\n\n' +
+            chalk.gray('Run `family-ai-agent` to start chatting!'),
+          {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+          }
+        )
+      );
+
+      return true;
+    } catch (error) {
+      saveSpinner.fail('Failed to save configuration');
+      console.error(
+        chalk.red(error instanceof Error ? error.message : 'Unknown error')
+      );
+      return false;
+    }
+  } catch (error) {
+    // Handle Ctrl+C gracefully
+    if ((error as { name?: string }).name === 'ExitPromptError') {
+      console.log(chalk.yellow('\n\nSetup cancelled.\n'));
+      return false;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Quick setup with minimal prompts
+ */
+export async function runQuickSetup(apiKey: string): Promise<boolean> {
+  const spinner = ora('Configuring with defaults...').start();
+
+  try {
+    const config: PartialUserConfig = {
+      apiKey,
+      baseUrl: 'https://openrouter.ai/api/v1',
+      defaultModel: 'anthropic/claude-3.5-sonnet',
+      fastModel: 'anthropic/claude-3-haiku',
+      embeddingModel: 'openai/text-embedding-3-small',
+      enableSafetyFilters: true,
+      enableAuditLogging: true,
+      customModels: [],
+    };
+
+    saveUserConfig(config);
+    spinner.succeed('Configuration saved with defaults!');
+    return true;
+  } catch (error) {
+    spinner.fail('Failed to save configuration');
+    console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+    return false;
+  }
+}
+
+/**
+ * Check if setup is needed and run wizard if so
+ */
+export async function checkAndRunSetup(): Promise<boolean> {
+  const { configExists } = await import('../config/user-config.js');
+
+  if (configExists()) {
+    return true; // Already configured
+  }
+
+  console.log(chalk.yellow('\n⚠️  No configuration found. Starting setup wizard...\n'));
+  return runSetupWizard();
+}
+
+export default {
+  runSetupWizard,
+  runQuickSetup,
+  checkAndRunSetup,
+};

package/src/config/index.ts

@@ -1,11 +1,119 @@
 import { config as dotenvConfig } from 'dotenv';
 import { z } from 'zod';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 
 dotenvConfig();
 
+// User config path
+const USER_CONFIG_PATH = join(homedir(), '.family-ai-agent', 'config.json');
+
+// Try to load user config
+function loadUserConfigFile(): Record<string, unknown> | null {
+  if (!existsSync(USER_CONFIG_PATH)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(USER_CONFIG_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// Get config value with priority: user config > env > default
+function getConfigValue<T>(
+  userConfig: Record<string, unknown> | null,
+  userKey: string,
+  envKey: string,
+  envValue: string | undefined
+): string | undefined {
+  // Priority 1: User config
+  if (userConfig && userKey in userConfig) {
+    const value = userConfig[userKey];
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'boolean') return String(value);
+  }
+
+  // Priority 2: Environment variable
+  return envValue;
+}
+
+// Load user config if available
+const userConfig = loadUserConfigFile();
+
+// Build merged environment for Zod schema
+const mergedEnv = {
+  ...process.env,
+
+  // Override with user config if available
+  OPENROUTER_API_KEY: getConfigValue(
+    userConfig,
+    'apiKey',
+    'OPENROUTER_API_KEY',
+    process.env.OPENROUTER_API_KEY
+  ),
+  OPENROUTER_BASE_URL: getConfigValue(
+    userConfig,
+    'baseUrl',
+    'OPENROUTER_BASE_URL',
+    process.env.OPENROUTER_BASE_URL
+  ),
+  DEFAULT_MODEL: getConfigValue(
+    userConfig,
+    'defaultModel',
+    'DEFAULT_MODEL',
+    process.env.DEFAULT_MODEL
+  ),
+  FAST_MODEL: getConfigValue(
+    userConfig,
+    'fastModel',
+    'FAST_MODEL',
+    process.env.FAST_MODEL
+  ),
+  EMBEDDING_MODEL: getConfigValue(
+    userConfig,
+    'embeddingModel',
+    'EMBEDDING_MODEL',
+    process.env.EMBEDDING_MODEL
+  ),
+  ENABLE_CONTENT_FILTER: getConfigValue(
+    userConfig,
+    'enableSafetyFilters',
+    'ENABLE_CONTENT_FILTER',
+    process.env.ENABLE_CONTENT_FILTER
+  ),
+  ENABLE_AUDIT_LOGGING: getConfigValue(
+    userConfig,
+    'enableAuditLogging',
+    'ENABLE_AUDIT_LOGGING',
+    process.env.ENABLE_AUDIT_LOGGING
+  ),
+
+  // Database from user config
+  DB_HOST: userConfig?.database && typeof userConfig.database === 'object'
+    ? (userConfig.database as Record<string, unknown>).host as string
+    : process.env.DB_HOST,
+  DB_PORT: userConfig?.database && typeof userConfig.database === 'object'
+    ? String((userConfig.database as Record<string, unknown>).port)
+    : process.env.DB_PORT,
+  DB_USER: userConfig?.database && typeof userConfig.database === 'object'
+    ? (userConfig.database as Record<string, unknown>).user as string
+    : process.env.DB_USER,
+  DB_PASSWORD: userConfig?.database && typeof userConfig.database === 'object'
+    ? (userConfig.database as Record<string, unknown>).password as string
+    : process.env.DB_PASSWORD,
+  DB_NAME: userConfig?.database && typeof userConfig.database === 'object'
+    ? (userConfig.database as Record<string, unknown>).name as string
+    : process.env.DB_NAME,
+};
+
 const envSchema = z.object({
-  // OpenRouter
-  OPENROUTER_API_KEY: z.string().min(1, 'OpenRouter API key is required'),
+  // OpenRouter - now optional (can be set via user config)
+  OPENROUTER_API_KEY: z.string().min(1).optional(),
   OPENROUTER_BASE_URL: z.string().url().default('https://openrouter.ai/api/v1'),
 
   // Models
@@ -58,12 +166,48 @@ const envSchema = z.object({
 type EnvConfig = z.infer<typeof envSchema>;
 
 function loadConfig(): EnvConfig {
-  const parsed = envSchema.safeParse(process.env);
+  const parsed = envSchema.safeParse(mergedEnv);
 
   if (!parsed.success) {
+    // More helpful error message
+    const errors = parsed.error.format();
     console.error('Configuration validation failed:');
-    console.error(parsed.error.format());
-    throw new Error('Invalid configuration. Check your .env file.');
+    console.error(errors);
+
+    // Check if it's just missing API key
+    if (!mergedEnv.OPENROUTER_API_KEY) {
+      // Don't throw - let CLI handle setup
+      return {
+        OPENROUTER_API_KEY: undefined,
+        OPENROUTER_BASE_URL: 'https://openrouter.ai/api/v1',
+        DEFAULT_MODEL: 'anthropic/claude-3.5-sonnet',
+        FAST_MODEL: 'anthropic/claude-3-haiku',
+        EMBEDDING_MODEL: 'openai/text-embedding-3-small',
+        DB_HOST: 'localhost',
+        DB_PORT: 5432,
+        DB_USER: 'familyai',
+        DB_PASSWORD: 'familyai123',
+        DB_NAME: 'familyai',
+        REDIS_HOST: 'localhost',
+        REDIS_PORT: 6379,
+        API_PORT: 3000,
+        API_HOST: '0.0.0.0',
+        ENABLE_CONTENT_FILTER: true,
+        ENABLE_PII_DETECTION: true,
+        ENABLE_AUDIT_LOGGING: true,
+        MAX_TOKENS_PER_REQUEST: 4096,
+        RATE_LIMIT_MAX: 100,
+        RATE_LIMIT_WINDOW_MS: 60000,
+        SANDBOX_ENABLED: true,
+        SANDBOX_TIMEOUT_MS: 30000,
+        SANDBOX_MEMORY_LIMIT_MB: 256,
+        LOG_LEVEL: 'info',
+        LOG_FORMAT: 'json',
+        NODE_ENV: 'development',
+      };
+    }
+
+    throw new Error('Invalid configuration. Check your settings.');
   }
 
   return parsed.data;
@@ -71,6 +215,21 @@ function loadConfig(): EnvConfig {
 
 export const config = loadConfig();
 
+// Check if config is complete (has API key)
+export const isConfigured = (): boolean => {
+  return Boolean(config.OPENROUTER_API_KEY);
+};
+
+// Check if using user config file
+export const hasUserConfig = (): boolean => {
+  return userConfig !== null;
+};
+
+// Get user config path
+export const getUserConfigPath = (): string => {
+  return USER_CONFIG_PATH;
+};
+
 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}`;