@operor/cli 0.1.0

package/src/setup.ts

@@ -0,0 +1,712 @@
+import * as clack from '@clack/prompts';
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'node:fs';
+import { resolve as resolvePath, join } from 'node:path';
+import matter from 'gray-matter';
+import { readConfig, writeConfig, type AppConfig } from './config.js';
+import { AIProvider } from '@operor/llm';
+import { loadSkillCatalog, findSkillInCatalog, catalogEntryToConfig } from '@operor/skills';
+
+function detectApiKey(provider: string): string | undefined {
+  const envVars: Record<string, string[]> = {
+    openai: ['OPENAI_API_KEY'],
+    anthropic: ['ANTHROPIC_API_KEY'],
+    google: ['GOOGLE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY'],
+    groq: ['GROQ_API_KEY'],
+  };
+
+  const vars = envVars[provider] || [];
+  for (const varName of vars) {
+    const value = process.env[varName];
+    if (value) return value;
+  }
+  return undefined;
+}
+
+function maskApiKey(key: string): string {
+  if (key.length <= 8) return '••••••••';
+  return key.slice(0, 4) + '••••' + key.slice(-4);
+}
+
+export async function runQuickSetup(): Promise<void> {
+  console.clear();
+  clack.intro('Operor - Quick Setup');
+
+  // 1. LLM Provider
+  const llmProvider = await clack.select({
+    message: 'Choose your LLM provider',
+    options: [
+      { value: 'openai', label: 'OpenAI' },
+      { value: 'anthropic', label: 'Anthropic (Claude)' },
+      { value: 'google', label: 'Google (Gemini)' },
+      { value: 'groq', label: 'Groq' },
+      { value: 'ollama', label: 'Ollama (local)' },
+    ],
+  });
+
+  if (clack.isCancel(llmProvider)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // 2. API Key (skip for ollama)
+  let llmApiKey: string | symbol = '';
+  if (llmProvider !== 'ollama') {
+    const detectedKey = detectApiKey(llmProvider as string);
+    if (detectedKey) {
+      const useExisting = await clack.confirm({
+        message: `Found existing API key (${maskApiKey(detectedKey)}). Use it?`,
+        initialValue: true,
+      });
+      if (clack.isCancel(useExisting)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      llmApiKey = useExisting ? detectedKey : await clack.password({
+        message: 'Enter your API key',
+        validate: (value) => (!value ? 'API key is required' : undefined),
+      });
+    } else {
+      llmApiKey = await clack.password({
+        message: 'Enter your API key',
+        validate: (value) => (!value ? 'API key is required' : undefined),
+      });
+    }
+
+    if (clack.isCancel(llmApiKey)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+  }
+
+  // 3. Validate LLM credentials
+  const spinner = clack.spinner();
+  spinner.start('Validating LLM credentials');
+  try {
+    const provider = new AIProvider({
+      provider: llmProvider as any,
+      apiKey: llmApiKey as string,
+    });
+    await provider.complete([{ role: 'user', content: 'test' }]);
+    spinner.stop('LLM credentials validated');
+  } catch (error: any) {
+    spinner.stop('LLM validation failed');
+    clack.log.error(`Failed to validate LLM credentials: ${error.message}`);
+    process.exit(1);
+  }
+
+  // 4. Auto-set sensible defaults
+  const config: AppConfig = {
+    LLM_PROVIDER: llmProvider as string,
+    LLM_API_KEY: llmApiKey as string,
+    CHANNEL: 'mock',
+    MEMORY_TYPE: 'sqlite',
+    INTENT_CLASSIFIER: 'llm',
+    KB_ENABLED: 'true',
+    KB_EMBEDDING_PROVIDER: llmProvider as string,
+    KB_EMBEDDING_API_KEY: llmApiKey as string,
+    TRAINING_MODE_ENABLED: 'false',
+    ANALYTICS_ENABLED: 'true',
+  };
+
+  // Merge with any existing config to preserve extra keys
+  const existingConfig = readConfig();
+  const finalConfig = { ...existingConfig, ...config };
+  writeConfig(finalConfig);
+
+  // 5. Summary
+  clack.log.success('Configuration saved to .env');
+  clack.log.info(`  LLM Provider:    ${llmProvider}`);
+  clack.log.info(`  Channel:         mock (testing)`);
+  clack.log.info(`  Memory:          sqlite`);
+  clack.log.info(`  Intent:          llm`);
+  clack.log.info(`  Knowledge Base:  enabled`);
+  clack.log.info(`  Analytics:       enabled`);
+  clack.log.info(`  Training Mode:   disabled`);
+  clack.outro('Quick setup complete. Starting Operor...');
+}
+
+export async function runSetup(): Promise<void> {
+  console.clear();
+  clack.intro('Operor - Setup');
+
+  // Load existing config to use as defaults
+  const existingConfig = readConfig();
+
+  // LLM Provider
+  const llmProvider = await clack.select({
+    message: 'Choose your LLM provider',
+    options: [
+      { value: 'openai', label: 'OpenAI' },
+      { value: 'anthropic', label: 'Anthropic (Claude)' },
+      { value: 'google', label: 'Google (Gemini)' },
+      { value: 'groq', label: 'Groq' },
+      { value: 'ollama', label: 'Ollama (local)' },
+    ],
+    initialValue: existingConfig.LLM_PROVIDER || undefined,
+  });
+
+  if (clack.isCancel(llmProvider)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // Detect existing API key from .env or environment variables
+  const detectedKey = detectApiKey(llmProvider as string);
+  const existingApiKey = existingConfig.LLM_API_KEY || detectedKey;
+  let llmApiKey: string | symbol;
+
+  if (existingApiKey && llmProvider !== 'ollama') {
+    const useExisting = await clack.confirm({
+      message: `Found existing API key (${maskApiKey(existingApiKey)}). Use it?`,
+      initialValue: true,
+    });
+
+    if (clack.isCancel(useExisting)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+
+    if (useExisting) {
+      llmApiKey = existingApiKey;
+    } else {
+      llmApiKey = await clack.password({
+        message: 'Enter your API key',
+        validate: (value) => (!value ? 'API key is required' : undefined),
+      });
+    }
+  } else {
+    llmApiKey = await clack.password({
+      message: 'Enter your API key',
+      validate: (value) => {
+        if (llmProvider === 'ollama') return; // Ollama doesn't need API key
+        if (!value) return 'API key is required';
+      },
+    });
+  }
+
+  if (clack.isCancel(llmApiKey)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  const llmModel = await clack.text({
+    message: 'Enter model name (optional, press Enter for default)',
+    placeholder: getDefaultModel(llmProvider as string),
+    initialValue: existingConfig.LLM_MODEL || undefined,
+  });
+
+  if (clack.isCancel(llmModel)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // Validate LLM credentials
+  const spinner = clack.spinner();
+  spinner.start('Validating LLM credentials');
+  try {
+    const provider = new AIProvider({
+      provider: llmProvider as any,
+      apiKey: llmApiKey as string,
+      model: (llmModel as string) || undefined,
+    });
+    await provider.complete([{ role: 'user', content: 'test' }]);
+    spinner.stop('LLM credentials validated');
+  } catch (error: any) {
+    spinner.stop('LLM validation failed');
+    clack.log.error(`Failed to validate LLM credentials: ${error.message}`);
+    process.exit(1);
+  }
+
+  // Channel
+  const channel = await clack.select({
+    message: 'Choose your messaging channel',
+    options: [
+      { value: 'whatsapp', label: 'WhatsApp (Baileys)' },
+      { value: 'wati', label: 'WhatsApp via WATI (Business API)' },
+      { value: 'telegram', label: 'Telegram (grammY)' },
+      { value: 'mock', label: 'Mock (for testing)' },
+    ],
+    initialValue: existingConfig.CHANNEL || undefined,
+  });
+
+  if (clack.isCancel(channel)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // Channel-specific credentials (collected separately, merged into config later)
+  const channelConfig: AppConfig = {};
+
+  if (channel === 'telegram') {
+    const botToken = await clack.password({
+      message: 'Telegram Bot Token (from @BotFather)',
+      validate: (value) => (!value ? 'Bot token is required' : undefined),
+    });
+    if (clack.isCancel(botToken)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    channelConfig.TELEGRAM_BOT_TOKEN = botToken as string;
+  }
+
+  if (channel === 'wati') {
+    const apiToken = await clack.password({
+      message: 'WATI API Token (from your WATI dashboard)',
+      validate: (value) => (!value ? 'API token is required' : undefined),
+    });
+    if (clack.isCancel(apiToken)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+
+    const tenantId = await clack.text({
+      message: 'WATI Tenant ID',
+      validate: (value) => (!value ? 'Tenant ID is required' : undefined),
+      initialValue: existingConfig.WATI_TENANT_ID || undefined,
+    });
+    if (clack.isCancel(tenantId)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+
+    channelConfig.WATI_API_TOKEN = apiToken as string;
+    channelConfig.WATI_TENANT_ID = tenantId as string;
+  }
+
+  // MCP Skills
+  const enableSkills = await clack.confirm({
+    message: 'Configure MCP skills? (Shopify, Stripe, search, etc. via mcp.json)',
+    initialValue: existingConfig.SKILLS_ENABLED === 'true',
+  });
+
+  if (clack.isCancel(enableSkills)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  let selectedSkills: string[] = [];
+  if (enableSkills) {
+    const catalog = loadSkillCatalog();
+    const skillOptions = catalog.skills.map((s) => ({
+      value: s.name,
+      label: `${s.displayName} — ${s.description}`,
+    }));
+
+    const skills = await clack.multiselect({
+      message: 'Select MCP skills to enable (space to toggle)',
+      options: skillOptions,
+      required: false,
+    });
+    if (clack.isCancel(skills)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    selectedSkills = skills as string[];
+  }
+
+  // Memory backend
+  const memoryType = await clack.select({
+    message: 'Choose storage backend',
+    options: [
+      { value: 'sqlite', label: 'SQLite (recommended, zero config)' },
+      { value: 'memory', label: 'In-memory (data lost on restart)' },
+    ],
+    initialValue: existingConfig.MEMORY_TYPE || undefined,
+  });
+
+  if (clack.isCancel(memoryType)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // Intent classification
+  const intentClassifier = await clack.select({
+    message: 'Choose intent classification method',
+    options: [
+      { value: 'llm', label: 'LLM-based (uses your LLM provider)' },
+      { value: 'keyword', label: 'Keyword matching (no LLM cost)' },
+    ],
+    initialValue: existingConfig.INTENT_CLASSIFIER || undefined,
+  });
+
+  if (clack.isCancel(intentClassifier)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  // Knowledge Base
+  const kbEnabled = await clack.confirm({
+    message: 'Enable Knowledge Base (RAG)?',
+    initialValue: existingConfig.KB_ENABLED === 'true',
+  });
+
+  if (clack.isCancel(kbEnabled)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  let kbEmbeddingProvider: string | undefined;
+  let kbEmbeddingApiKey: string | undefined;
+  let kbEmbeddingModel: string | undefined;
+  let kbDbPath: string | undefined;
+
+  if (kbEnabled) {
+    const embProvider = await clack.select({
+      message: 'Embedding provider',
+      options: [
+        { value: 'openai', label: 'OpenAI (text-embedding-3-small, 1536d)' },
+        { value: 'google', label: 'Google (text-embedding-004, 768d)' },
+        { value: 'mistral', label: 'Mistral (mistral-embed, 1024d)' },
+        { value: 'cohere', label: 'Cohere (embed-english-v3.0, 1024d)' },
+        { value: 'ollama', label: 'Ollama (local, nomic-embed-text, 768d)' },
+      ],
+      initialValue: existingConfig.KB_EMBEDDING_PROVIDER || undefined,
+    });
+    if (clack.isCancel(embProvider)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    kbEmbeddingProvider = embProvider as string;
+
+    if (kbEmbeddingProvider !== 'ollama') {
+      const embKey = await clack.password({
+        message: 'Embedding API key (or Enter to reuse LLM key)',
+      });
+      if (clack.isCancel(embKey)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      kbEmbeddingApiKey = (embKey as string) || (llmApiKey as string);
+    }
+
+    const embModel = await clack.text({
+      message: 'Embedding model (optional, press Enter for default)',
+      placeholder: getDefaultEmbeddingModel(kbEmbeddingProvider),
+      initialValue: existingConfig.KB_EMBEDDING_MODEL || undefined,
+    });
+    if (clack.isCancel(embModel)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    kbEmbeddingModel = (embModel as string) || undefined;
+
+    const dbPath = await clack.text({
+      message: 'Knowledge base DB path',
+      placeholder: './knowledge.db',
+      initialValue: existingConfig.KB_DB_PATH || undefined,
+    });
+    if (clack.isCancel(dbPath)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    kbDbPath = (dbPath as string) || './knowledge.db';
+  }
+
+  // Training Mode
+  const trainingEnabled = await clack.confirm({
+    message: 'Enable training mode? (allows /teach command to add FAQ answers)',
+    initialValue: existingConfig.TRAINING_MODE_ENABLED === 'true',
+  });
+
+  if (clack.isCancel(trainingEnabled)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  let trainingWhitelist = '';
+  if (trainingEnabled) {
+    const whitelistInput = await clack.text({
+      message: 'Whitelist phone numbers for training (comma-separated, e.g. 85253332683,85291234567)',
+      placeholder: '85253332683,85291234567',
+      initialValue: existingConfig.TRAINING_MODE_WHITELIST || undefined,
+    });
+    if (clack.isCancel(whitelistInput)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    trainingWhitelist = (whitelistInput as string) || '';
+  }
+
+  // Training Copilot (requires KB to be enabled)
+  let copilotConfig: Partial<AppConfig> = {};
+  if (kbEnabled) {
+    const copilotEnabled = await clack.confirm({
+      message: 'Enable Training Copilot? (auto-tracks unanswered queries, suggests FAQ additions)',
+      initialValue: existingConfig.COPILOT_ENABLED !== 'false',
+    });
+
+    if (clack.isCancel(copilotEnabled)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+
+    if (copilotEnabled) {
+      copilotConfig.COPILOT_ENABLED = 'true';
+
+      const copilotDbPath = await clack.text({
+        message: 'Copilot database path',
+        placeholder: './copilot.db',
+        initialValue: existingConfig.COPILOT_DB_PATH || undefined,
+      });
+      if (clack.isCancel(copilotDbPath)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      copilotConfig.COPILOT_DB_PATH = (copilotDbPath as string) || './copilot.db';
+
+      const trackingThreshold = await clack.text({
+        message: 'Tracking threshold (KB score below which queries are tracked)',
+        placeholder: '0.70',
+        initialValue: existingConfig.COPILOT_TRACKING_THRESHOLD || undefined,
+      });
+      if (clack.isCancel(trackingThreshold)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      if (trackingThreshold) copilotConfig.COPILOT_TRACKING_THRESHOLD = trackingThreshold as string;
+
+      const autoSuggest = await clack.confirm({
+        message: 'Auto-generate LLM answer suggestions for unanswered queries?',
+        initialValue: existingConfig.COPILOT_AUTO_SUGGEST !== 'false',
+      });
+      if (clack.isCancel(autoSuggest)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      copilotConfig.COPILOT_AUTO_SUGGEST = autoSuggest ? 'true' : 'false';
+    } else {
+      copilotConfig.COPILOT_ENABLED = 'false';
+    }
+  }
+
+  // Analytics & Reporting (after Copilot)
+  let analyticsConfig: Partial<AppConfig> = {};
+  const analyticsEnabled = await clack.confirm({
+    message: 'Enable Analytics & Reporting? (tracks response times, token usage, conversation metrics)',
+    initialValue: existingConfig.ANALYTICS_ENABLED !== 'false',
+  });
+
+  if (clack.isCancel(analyticsEnabled)) {
+    clack.cancel('Setup cancelled');
+    process.exit(0);
+  }
+
+  if (analyticsEnabled) {
+    analyticsConfig.ANALYTICS_ENABLED = 'true';
+
+    const analyticsDbPath = await clack.text({
+      message: 'Analytics database path',
+      placeholder: './analytics.db',
+      initialValue: existingConfig.ANALYTICS_DB_PATH || undefined,
+    });
+    if (clack.isCancel(analyticsDbPath)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+    analyticsConfig.ANALYTICS_DB_PATH = (analyticsDbPath as string) || './analytics.db';
+
+    const digestEnabled = await clack.select({
+      message: 'Enable daily digest reports via WhatsApp?',
+      options: [
+        { value: 'daily', label: 'Yes, daily digest' },
+        { value: 'weekly', label: 'Weekly only' },
+        { value: 'both', label: 'Both daily and weekly' },
+        { value: 'false', label: 'No digest reports' },
+      ],
+      initialValue: existingConfig.ANALYTICS_DIGEST_ENABLED === 'true'
+        ? (existingConfig.ANALYTICS_DIGEST_SCHEDULE || 'daily')
+        : 'false',
+    });
+    if (clack.isCancel(digestEnabled)) {
+      clack.cancel('Setup cancelled');
+      process.exit(0);
+    }
+
+    if (digestEnabled !== 'false') {
+      analyticsConfig.ANALYTICS_DIGEST_ENABLED = 'true';
+      analyticsConfig.ANALYTICS_DIGEST_SCHEDULE = digestEnabled as string;
+
+      const digestTime = await clack.text({
+        message: 'Digest delivery time (HH:MM, 24h format)',
+        placeholder: '09:00',
+        initialValue: existingConfig.ANALYTICS_DIGEST_TIME || undefined,
+        validate: (value) => {
+          if (!value) return undefined; // accept default
+          if (!/^\d{2}:\d{2}$/.test(value)) return 'Use HH:MM format (e.g. 09:00)';
+        },
+      });
+      if (clack.isCancel(digestTime)) {
+        clack.cancel('Setup cancelled');
+        process.exit(0);
+      }
+      analyticsConfig.ANALYTICS_DIGEST_TIME = (digestTime as string) || '09:00';
+    } else {
+      analyticsConfig.ANALYTICS_DIGEST_ENABLED = 'false';
+    }
+  } else {
+    analyticsConfig.ANALYTICS_ENABLED = 'false';
+  }
+
+  // Build new config from wizard answers
+  const newConfig: AppConfig = {
+    LLM_PROVIDER: llmProvider as string,
+    LLM_API_KEY: llmApiKey as string,
+    LLM_MODEL: (llmModel as string) || undefined,
+    CHANNEL: channel as string,
+    SKILLS_ENABLED: enableSkills ? 'true' : 'false',
+    MEMORY_TYPE: memoryType as string,
+    INTENT_CLASSIFIER: intentClassifier as string,
+    ...channelConfig,
+    ...(kbEnabled && {
+      KB_ENABLED: 'true',
+      KB_DB_PATH: kbDbPath,
+      KB_EMBEDDING_PROVIDER: kbEmbeddingProvider,
+      KB_EMBEDDING_MODEL: kbEmbeddingModel,
+      KB_EMBEDDING_API_KEY: kbEmbeddingApiKey,
+    }),
+    TRAINING_MODE_ENABLED: trainingEnabled ? 'true' : 'false',
+    ...(trainingWhitelist && { TRAINING_MODE_WHITELIST: trainingWhitelist }),
+    ...copilotConfig,
+    ...analyticsConfig,
+  };
+
+  // Collect MCP skill-specific API keys and create mcp.json
+  if (enableSkills && selectedSkills.length > 0) {
+    const catalog = loadSkillCatalog();
+    const mcpSkills: any[] = [];
+
+    // Read existing mcp.json to determine which skills were removed
+    const mcpPath = resolvePath(process.cwd(), 'mcp.json');
+    let previousSkillNames: string[] = [];
+    try {
+      const existing = JSON.parse(readFileSync(mcpPath, 'utf-8'));
+      previousSkillNames = (existing.skills || []).map((s: any) => s.name);
+    } catch {
+      // No existing mcp.json — nothing was previously enabled
+    }
+
+    for (const skillName of selectedSkills) {
+      const entry = findSkillInCatalog(catalog, skillName);
+      if (!entry) continue;
+
+      // Prompt for each required env var
+      for (const [varName, spec] of Object.entries(entry.envVars)) {
+        if (!spec.required) continue;
+        const value = await clack.password({
+          message: `${entry.displayName}: ${spec.description}`,
+          validate: (v) => (!v ? `${varName} is required` : undefined),
+        });
+        if (clack.isCancel(value)) {
+          clack.cancel('Setup cancelled');
+          process.exit(0);
+        }
+        newConfig[varName] = value as string;
+      }
+
+      mcpSkills.push(catalogEntryToConfig(entry));
+    }
+
+    // Write mcp.json
+    const mcpConfig = { skills: mcpSkills };
+    writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+    clack.log.info('  MCP config saved to mcp.json');
+
+    // Sync skills to agent INSTRUCTIONS.md files
+    const addedSkills = selectedSkills.filter((s) => !previousSkillNames.includes(s));
+    const removedSkills = previousSkillNames.filter((s) => !selectedSkills.includes(s));
+    const agentsDir = resolvePath(process.cwd(), 'agents');
+    const updatedAgents = syncSkillsToAgents(agentsDir, addedSkills, removedSkills);
+    if (updatedAgents.length > 0) {
+      clack.log.info(`  Updated skills in: ${updatedAgents.join(', ')}`);
+    }
+  }
+
+  // Merge: existing config as base, wizard values on top.
+  // Preserves any keys the wizard doesn't prompt for (e.g. LLM_BASE_URL, custom keys).
+  const finalConfig = { ...existingConfig, ...newConfig };
+  writeConfig(finalConfig);
+  clack.outro('Config saved to .env. Starting Operor...');
+}
+
+/**
+ * Sync skill names into agent INSTRUCTIONS.md frontmatter.
+ * Only touches agents that already have a `skills:` field.
+ * If the resulting skills array is empty, removes the `skills` key entirely.
+ */
+export function syncSkillsToAgents(
+  agentsDir: string,
+  addedSkills: string[],
+  removedSkills: string[],
+): string[] {
+  if (addedSkills.length === 0 && removedSkills.length === 0) return [];
+
+  const updated: string[] = [];
+
+  let entries: string[];
+  try {
+    entries = readdirSync(agentsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+
+  for (const agentName of entries) {
+    const instrPath = join(agentsDir, agentName, 'INSTRUCTIONS.md');
+    if (!existsSync(instrPath)) continue;
+
+    const raw = readFileSync(instrPath, 'utf-8');
+    const parsed = matter(raw);
+
+    // Only touch agents that explicitly declare a skills array
+    if (!Array.isArray(parsed.data.skills)) continue;
+
+    const currentSkills: string[] = parsed.data.skills;
+    let newSkills = currentSkills.filter((s: string) => !removedSkills.includes(s));
+    for (const skill of addedSkills) {
+      if (!newSkills.includes(skill)) newSkills.push(skill);
+    }
+
+    // Check if anything changed
+    if (
+      newSkills.length === currentSkills.length &&
+      newSkills.every((s, i) => s === currentSkills[i])
+    ) {
+      continue;
+    }
+
+    // If empty after removals, drop the skills key so agent gets all tools
+    if (newSkills.length === 0) {
+      delete parsed.data.skills;
+    } else {
+      parsed.data.skills = newSkills;
+    }
+
+    writeFileSync(instrPath, matter.stringify(parsed.content, parsed.data));
+    updated.push(agentName);
+  }
+
+  return updated;
+}
+
+function getDefaultModel(provider: string): string {
+  const defaults: Record<string, string> = {
+    openai: 'gpt-5-mini',
+    anthropic: 'claude-3-5-sonnet-20241022',
+    google: 'gemini-2.0-flash-exp',
+    groq: 'llama-3.3-70b-versatile',
+    ollama: 'llama3.2',
+  };
+  return defaults[provider] || '';
+}
+
+function getDefaultEmbeddingModel(provider: string): string {
+  const defaults: Record<string, string> = {
+    openai: 'text-embedding-3-small',
+    google: 'text-embedding-004',
+    mistral: 'mistral-embed',
+    cohere: 'embed-english-v3.0',
+    ollama: 'nomic-embed-text',
+  };
+  return defaults[provider] || '';
+}