family-ai-agent 1.0.0 → 1.0.3

package/src/config/user-config.ts

@@ -0,0 +1,323 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { z } from 'zod';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('UserConfig');
+
+// Config directory and file paths
+const CONFIG_DIR_NAME = '.family-ai-agent';
+const CONFIG_FILE_NAME = 'config.json';
+
+// Custom model schema
+const CustomModelSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  contextWindow: z.number().positive().default(8192),
+  maxOutput: z.number().positive().default(4096),
+  description: z.string().optional(),
+});
+
+export type CustomModel = z.infer<typeof CustomModelSchema>;
+
+// User config schema
+const UserConfigSchema = z.object({
+  // API Configuration
+  apiKey: z.string().min(1, 'API key is required'),
+  baseUrl: z.string().url().default('https://openrouter.ai/api/v1'),
+
+  // Model Configuration
+  defaultModel: z.string().default('anthropic/claude-3.5-sonnet'),
+  fastModel: z.string().default('anthropic/claude-3-haiku'),
+  embeddingModel: z.string().default('openai/text-embedding-3-small'),
+
+  // Custom Models
+  customModels: z.array(CustomModelSchema).default([]),
+
+  // Optional Settings
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().positive().optional(),
+
+  // Feature Flags
+  enableSafetyFilters: z.boolean().default(true),
+  enableAuditLogging: z.boolean().default(true),
+
+  // Database (optional - uses defaults if not set)
+  database: z.object({
+    host: z.string().default('localhost'),
+    port: z.number().default(5432),
+    user: z.string().default('familyai'),
+    password: z.string().default('familyai123'),
+    name: z.string().default('familyai'),
+  }).optional(),
+
+  // Metadata
+  createdAt: z.string().datetime().optional(),
+  updatedAt: z.string().datetime().optional(),
+});
+
+export type UserConfig = z.infer<typeof UserConfigSchema>;
+
+// Partial config for updates
+export type PartialUserConfig = Partial<Omit<UserConfig, 'createdAt' | 'updatedAt'>>;
+
+/**
+ * Get the config directory path
+ */
+export function getConfigDir(): string {
+  return join(homedir(), CONFIG_DIR_NAME);
+}
+
+/**
+ * Get the config file path
+ */
+export function getConfigPath(): string {
+  return join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+/**
+ * Check if config file exists
+ */
+export function configExists(): boolean {
+  return existsSync(getConfigPath());
+}
+
+/**
+ * Ensure config directory exists
+ */
+export function ensureConfigDir(): void {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+    logger.debug('Config directory created', { path: configDir });
+  }
+}
+
+/**
+ * Load user config from file
+ */
+export function loadUserConfig(): UserConfig | null {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    logger.debug('Config file not found', { path: configPath });
+    return null;
+  }
+
+  try {
+    const fileContent = readFileSync(configPath, 'utf-8');
+    const rawConfig = JSON.parse(fileContent);
+    const parsed = UserConfigSchema.safeParse(rawConfig);
+
+    if (!parsed.success) {
+      logger.warn('Config file validation failed', {
+        errors: parsed.error.format(),
+      });
+      return null;
+    }
+
+    logger.debug('Config loaded successfully');
+    return parsed.data;
+  } catch (error) {
+    logger.error('Failed to load config file', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
+    return null;
+  }
+}
+
+/**
+ * Save user config to file
+ */
+export function saveUserConfig(config: PartialUserConfig): UserConfig {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+
+  // Load existing config if present
+  const existingConfig = loadUserConfig();
+
+  // Merge with existing config
+  const mergedConfig = {
+    ...existingConfig,
+    ...config,
+    updatedAt: new Date().toISOString(),
+  };
+
+  // Add createdAt if new config
+  if (!existingConfig) {
+    mergedConfig.createdAt = new Date().toISOString();
+  }
+
+  // Validate merged config
+  const parsed = UserConfigSchema.safeParse(mergedConfig);
+  if (!parsed.success) {
+    throw new Error(`Invalid config: ${JSON.stringify(parsed.error.format())}`);
+  }
+
+  // Write to file
+  writeFileSync(configPath, JSON.stringify(parsed.data, null, 2), 'utf-8');
+  logger.info('Config saved successfully', { path: configPath });
+
+  return parsed.data;
+}
+
+/**
+ * Update specific config values
+ */
+export function updateUserConfig(updates: PartialUserConfig): UserConfig {
+  const existingConfig = loadUserConfig();
+
+  if (!existingConfig) {
+    throw new Error('No config file found. Run setup first.');
+  }
+
+  return saveUserConfig({
+    ...existingConfig,
+    ...updates,
+  });
+}
+
+/**
+ * Delete config file
+ */
+export function deleteUserConfig(): boolean {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return false;
+  }
+
+  try {
+    unlinkSync(configPath);
+    logger.info('Config deleted', { path: configPath });
+    return true;
+  } catch (error) {
+    logger.error('Failed to delete config', {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
+    return false;
+  }
+}
+
+/**
+ * Get a specific config value
+ */
+export function getConfigValue<K extends keyof UserConfig>(
+  key: K
+): UserConfig[K] | undefined {
+  const config = loadUserConfig();
+  return config?.[key];
+}
+
+/**
+ * Add a custom model
+ */
+export function addCustomModel(model: CustomModel): UserConfig {
+  const config = loadUserConfig();
+
+  if (!config) {
+    throw new Error('No config file found. Run setup first.');
+  }
+
+  // Check if model already exists
+  const existingIndex = config.customModels.findIndex((m) => m.id === model.id);
+
+  if (existingIndex >= 0) {
+    // Update existing model
+    config.customModels[existingIndex] = model;
+  } else {
+    // Add new model
+    config.customModels.push(model);
+  }
+
+  return saveUserConfig(config);
+}
+
+/**
+ * Remove a custom model
+ */
+export function removeCustomModel(modelId: string): UserConfig {
+  const config = loadUserConfig();
+
+  if (!config) {
+    throw new Error('No config file found. Run setup first.');
+  }
+
+  config.customModels = config.customModels.filter((m) => m.id !== modelId);
+
+  return saveUserConfig(config);
+}
+
+/**
+ * Get all available models (built-in + custom)
+ */
+export function getAllModels(): Array<{ id: string; name: string; isCustom: boolean }> {
+  const config = loadUserConfig();
+
+  // Built-in models from OpenRouter
+  const builtInModels = [
+    { id: 'anthropic/claude-3.5-sonnet', name: 'Claude 3.5 Sonnet', isCustom: false },
+    { id: 'anthropic/claude-3-haiku', name: 'Claude 3 Haiku', isCustom: false },
+    { id: 'anthropic/claude-3-opus', name: 'Claude 3 Opus', isCustom: false },
+    { id: 'openai/gpt-4-turbo', name: 'GPT-4 Turbo', isCustom: false },
+    { id: 'openai/gpt-4o', name: 'GPT-4o', isCustom: false },
+    { id: 'openai/gpt-4o-mini', name: 'GPT-4o Mini', isCustom: false },
+    { id: 'google/gemini-pro-1.5', name: 'Gemini Pro 1.5', isCustom: false },
+    { id: 'meta-llama/llama-3.1-70b-instruct', name: 'Llama 3.1 70B', isCustom: false },
+    { id: 'meta-llama/llama-3.1-8b-instruct', name: 'Llama 3.1 8B', isCustom: false },
+    { id: 'mistralai/mistral-large', name: 'Mistral Large', isCustom: false },
+    { id: 'deepseek/deepseek-chat', name: 'DeepSeek Chat', isCustom: false },
+  ];
+
+  // Add custom models
+  const customModels = (config?.customModels || []).map((m) => ({
+    id: m.id,
+    name: m.name,
+    isCustom: true,
+  }));
+
+  return [...builtInModels, ...customModels];
+}
+
+/**
+ * Mask API key for display
+ */
+export function maskApiKey(apiKey: string): string {
+  if (apiKey.length <= 8) {
+    return '****';
+  }
+  return `${apiKey.slice(0, 4)}...${apiKey.slice(-4)}`;
+}
+
+/**
+ * Get config for display (with masked API key)
+ */
+export function getDisplayConfig(): Record<string, unknown> | null {
+  const config = loadUserConfig();
+
+  if (!config) {
+    return null;
+  }
+
+  return {
+    ...config,
+    apiKey: maskApiKey(config.apiKey),
+  };
+}
+
+export default {
+  getConfigDir,
+  getConfigPath,
+  configExists,
+  loadUserConfig,
+  saveUserConfig,
+  updateUserConfig,
+  deleteUserConfig,
+  getConfigValue,
+  addCustomModel,
+  removeCustomModel,
+  getAllModels,
+  maskApiKey,
+  getDisplayConfig,
+};