@tenex-chat/backend 0.9.4 → 0.9.6

package/src/llm/utils/ConfigurationManager.ts

@@ -1,4 +1,4 @@
-import type { LLMConfiguration, MetaModelConfiguration, MetaModelVariant, TenexLLMs } from "@/services/config/types";
+import type { LLMConfiguration, TenexLLMs } from "@/services/config/types";
 import { hasApiKey } from "@/llm/providers/key-manager";
 
 /**
@@ -9,25 +9,29 @@ type TenexLLMsWithProviders = TenexLLMs & {
 };
 import chalk from "chalk";
 import inquirer from "inquirer";
+import { inquirerTheme } from "@/utils/cli-theme";
+import * as display from "@/commands/setup/display";
 import { PROVIDER_IDS } from "@/llm/providers/provider-ids";
 import type { AISdkProvider } from "../types";
 import { ModelSelector } from "./ModelSelector";
 import { ProviderConfigUI } from "./ProviderConfigUI";
-import { listCodexModels, formatCodexModel } from "./codex-models";
+import { listCodexModels } from "./codex-models";
+import { variantListPrompt } from "./variant-list-prompt";
 
 /**
  * Manages LLM configuration CRUD operations
  */
 export class ConfigurationManager {
-    static async add(llmsConfig: TenexLLMsWithProviders, isFirstConfig = false): Promise<void> {
+    static async add(llmsConfig: TenexLLMsWithProviders, advanced = false): Promise<void> {
         const configuredProviders = Object.keys(llmsConfig.providers).filter(
-            (p) => hasApiKey(llmsConfig.providers[p]?.apiKey)
+            (p) => {
+                const key = llmsConfig.providers[p]?.apiKey;
+                return hasApiKey(key) || key === "none";
+            }
         );
 
         if (configuredProviders.length === 0) {
-            console.log(
-                chalk.yellow("⚠️  No providers configured. Please configure API keys first.")
-            );
+            display.hint("No providers configured. Please configure API keys first.");
             return;
         }
 
@@ -41,11 +45,13 @@ export class ConfigurationManager {
                     name: ProviderConfigUI.getProviderDisplayName(p),
                     value: p,
                 })),
+                theme: inquirerTheme,
             },
         ]);
 
         // Select model based on provider
         let model: string;
+        let modelDisplayName: string | undefined;
         let reasoningEffort: string | undefined;
 
         if (provider === "openrouter") {
@@ -53,68 +59,71 @@ export class ConfigurationManager {
         } else if (provider === "ollama") {
             model = await ModelSelector.selectOllamaModel();
         } else if (provider === PROVIDER_IDS.CODEX_APP_SERVER) {
-            // For Codex, show available models with reasoning efforts
             const result = await ConfigurationManager.selectCodexModel();
             model = result.model;
             reasoningEffort = result.reasoningEffort;
         } else {
-            const { inputModel } = await inquirer.prompt([
+            // Use models.dev list for Anthropic, OpenAI, and any other provider with data
+            const result = await ModelSelector.selectModelsDevModel(
+                provider,
+                ConfigurationManager.getDefaultModelForProvider(provider as AISdkProvider)
+            );
+            model = result.id;
+            modelDisplayName = result.name;
+        }
+
+        // Advanced settings (temperature, maxTokens) only when --advanced
+        let temperature: string | undefined;
+        let maxTokens: string | undefined;
+
+        if (advanced) {
+            const advancedAnswers = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "temperature",
+                    message: "Temperature (0-2, press enter to skip):",
+                    validate: (input: string) => {
+                        if (!input) return true;
+                        const num = Number.parseFloat(input);
+                        if (Number.isNaN(num) || num < 0 || num > 2)
+                            return "Temperature must be between 0 and 2";
+                        return true;
+                    },
+                    theme: inquirerTheme,
+                },
                 {
                     type: "input",
-                    name: "inputModel",
-                    message: "Enter model name:",
-                    default: ConfigurationManager.getDefaultModelForProvider(
-                        provider as AISdkProvider
-                    ),
+                    name: "maxTokens",
+                    message: "Max tokens (press enter to skip):",
                     validate: (input: string) => {
-                        if (!input.trim()) return "Model name is required";
+                        if (!input) return true;
+                        const num = Number.parseInt(input);
+                        if (Number.isNaN(num) || num <= 0)
+                            return "Max tokens must be a positive number";
                         return true;
                     },
+                    theme: inquirerTheme,
                 },
             ]);
-            model = inputModel;
+            temperature = advancedAnswers.temperature;
+            maxTokens = advancedAnswers.maxTokens;
         }
 
-        // Optional settings
-        const { temperature, maxTokens } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "temperature",
-                message: "Temperature (0-2, press enter to skip):",
-                validate: (input: string) => {
-                    if (!input) return true;
-                    const num = Number.parseFloat(input);
-                    if (Number.isNaN(num) || num < 0 || num > 2)
-                        return "Temperature must be between 0 and 2";
-                    return true;
-                },
-            },
-            {
-                type: "input",
-                name: "maxTokens",
-                message: "Max tokens (press enter to skip):",
-                validate: (input: string) => {
-                    if (!input) return true;
-                    const num = Number.parseInt(input);
-                    if (Number.isNaN(num) || num <= 0)
-                        return "Max tokens must be a positive number";
-                    return true;
-                },
-            },
-        ]);
+        // Default config name to provider/humanName (e.g. "anthropic/Claude Sonnet 4.6")
+        const defaultName = `${provider}/${modelDisplayName || model}`;
 
-        // Name the configuration
         const { name } = await inquirer.prompt([
             {
                 type: "input",
                 name: "name",
                 message: "Configuration name:",
-                default: isFirstConfig ? "default" : undefined,
+                default: defaultName,
                 validate: (input: string) => {
                     if (!input.trim()) return "Name is required";
                     if (llmsConfig.configurations[input]) return "Configuration already exists";
                     return true;
                 },
+                theme: inquirerTheme,
             },
         ]);
 
@@ -130,480 +139,93 @@ export class ConfigurationManager {
 
         llmsConfig.configurations[name] = config;
 
-        // Set as default if first or ask user
-        if (isFirstConfig || !llmsConfig.default) {
+        // Auto-set as default if first config or no default exists
+        if (!llmsConfig.default || Object.keys(llmsConfig.configurations).length === 1) {
             llmsConfig.default = name;
-            console.log(chalk.green(`✅ Configuration "${name}" created and set as default`));
+            display.success(`Configuration "${name}" created and set as default`);
         } else {
-            const { setAsDefault } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "setAsDefault",
-                    message: "Set as default configuration?",
-                    default: false,
-                },
-            ]);
-
-            if (setAsDefault) {
-                llmsConfig.default = name;
-            }
-            console.log(chalk.green(`✅ Configuration "${name}" created`));
+            display.success(`Configuration "${name}" created`);
         }
     }
 
     /**
-     * Create a meta model configuration with multiple variants
+     * Create a multi-modal configuration with multiple variants
      */
-    static async addMetaModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        // Get existing non-meta configurations to use as variants
+    static async addMultiModal(llmsConfig: TenexLLMsWithProviders): Promise<void> {
         const standardConfigs = Object.keys(llmsConfig.configurations).filter((name) => {
             const config = llmsConfig.configurations[name];
             return config.provider !== "meta";
         });
 
         if (standardConfigs.length < 2) {
-            console.log(
-                chalk.yellow(
-                    "⚠️  You need at least 2 standard LLM configurations to create a meta model."
-                )
-            );
-            console.log(
-                chalk.gray("   Create more configurations first with 'Add new configuration'.")
-            );
+            display.hint("You need at least 2 standard LLM configurations to create a multi-modal configuration.");
+            display.context("Create more configurations first with 'Add new configuration'.");
             return;
         }
 
-        console.log(chalk.cyan("\n=== Create Meta Model ===\n"));
-        console.log(
-            chalk.gray(
-                "Meta models let you switch between different models using keywords.\n" +
-                    "For example, starting a message with 'ultrathink' can trigger a more powerful model.\n"
-            )
+        display.blank();
+        display.step(0, 0, "Add Multi-Modal Configuration");
+        display.context(
+            "Multi-modal configurations let you switch between different models using keywords.\n" +
+            "For example, starting a message with 'ultrathink' can trigger a more powerful model."
         );
+        display.blank();
 
-        // Get meta model name
         const { metaName } = await inquirer.prompt([
             {
                 type: "input",
                 name: "metaName",
-                message: "Meta model name:",
+                message: "Multi-modal configuration name:",
                 validate: (input: string) => {
                     if (!input.trim()) return "Name is required";
                     if (llmsConfig.configurations[input]) return "Configuration already exists";
                     return true;
                 },
+                theme: inquirerTheme,
             },
         ]);
 
-        // Get optional description
-        const { description } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "description",
-                message: "Description (shown in system prompt, press enter to skip):",
-            },
-        ]);
-
-        // Create variants
-        const variants: Record<string, MetaModelVariant> = {};
-        let addMoreVariants = true;
-        let variantCount = 0;
-
-        console.log(chalk.cyan("\nNow let's add variants to your meta model.\n"));
-
-        while (addMoreVariants) {
-            variantCount++;
-            console.log(chalk.bold(`\n--- Variant ${variantCount} ---`));
-
-            // Variant name
-            const { variantName } = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "variantName",
-                    message: "Variant name (e.g., 'fast', 'standard', 'deep'):",
-                    validate: (input: string) => {
-                        if (!input.trim()) return "Name is required";
-                        if (variants[input]) return "Variant already exists";
-                        return true;
-                    },
-                },
-            ]);
-
-            // Select underlying model
-            const { model } = await inquirer.prompt([
-                {
-                    type: "select",
-                    name: "model",
-                    message: "Select underlying model for this variant:",
-                    choices: standardConfigs.map((n) => ({
-                        name: n,
-                        value: n,
-                    })),
-                },
-            ]);
-
-            // Keywords (comma-separated)
-            const { keywordsInput } = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "keywordsInput",
-                    message: "Trigger keywords (comma-separated, e.g., 'think,ponder'):",
-                },
-            ]);
-
-            const keywords = keywordsInput
-                ? keywordsInput
-                      .split(",")
-                      .map((k: string) => k.trim().toLowerCase())
-                      .filter((k: string) => k.length > 0)
-                : [];
-
-            // Variant description
-            const { variantDescription } = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "variantDescription",
-                    message: "Variant description (shown in system prompt):",
-                },
-            ]);
-
-            // Tier (priority)
-            const { tier } = await inquirer.prompt([
-                {
-                    type: "number",
-                    name: "tier",
-                    message: "Priority tier (higher = higher priority when keywords conflict):",
-                    default: variantCount,
-                },
-            ]);
-
-            // Optional system prompt
-            const { variantSystemPrompt } = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "variantSystemPrompt",
-                    message: "Additional system prompt (press enter to skip):",
-                },
-            ]);
-
-            // Create variant
-            const variant: MetaModelVariant = {
-                model,
-            };
-
-            if (keywords.length > 0) variant.keywords = keywords;
-            if (variantDescription) variant.description = variantDescription;
-            if (tier) variant.tier = tier;
-            if (variantSystemPrompt) variant.systemPrompt = variantSystemPrompt;
-
-            variants[variantName] = variant;
-
-            console.log(chalk.green(`✓ Added variant "${variantName}" → ${model}`));
-
-            // Ask if more variants
-            if (variantCount >= 2) {
-                const { addMore } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "addMore",
-                        message: "Add another variant?",
-                        default: false,
-                    },
-                ]);
-                addMoreVariants = addMore;
-            } else {
-                console.log(chalk.gray("(Meta models need at least 2 variants)"));
-            }
-        }
-
-        // Select default variant
-        const variantNames = Object.keys(variants);
-        const { defaultVariant } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "defaultVariant",
-                message: "Select default variant (used when no keyword matches):",
-                choices: variantNames.map((n) => ({
-                    name: n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        // Create meta model configuration
-        const metaConfig: MetaModelConfiguration = {
-            provider: "meta",
-            variants,
-            default: defaultVariant,
-        };
-
-        if (description) metaConfig.description = description;
+        const metaConfig = await variantListPrompt(metaName, standardConfigs);
 
         llmsConfig.configurations[metaName] = metaConfig;
 
-        // Ask if should be set as default
-        const { setAsDefault } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "setAsDefault",
-                message: "Set as default configuration?",
-                default: false,
-            },
-        ]);
-
-        if (setAsDefault) {
+        if (!llmsConfig.default) {
             llmsConfig.default = metaName;
         }
 
-        console.log(chalk.green(`\n✅ Meta model "${metaName}" created with ${variantCount} variants`));
-
-        // Show summary
-        console.log(chalk.cyan("\nVariant summary:"));
-        for (const [name, variant] of Object.entries(variants)) {
-            const keywords = variant.keywords?.length ? ` (triggers: ${variant.keywords.join(", ")})` : "";
-            const isDefault = name === defaultVariant ? chalk.yellow(" [default]") : "";
-            console.log(chalk.gray(`  • ${name} → ${variant.model}${keywords}${isDefault}`));
-        }
-    }
-
-    static async delete(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations to delete"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select configuration to delete:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.default ? `${n} (default)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        const { confirm } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "confirm",
-                message: `Are you sure you want to delete "${name}"?`,
-                default: false,
-            },
-        ]);
-
-        if (confirm) {
-            delete llmsConfig.configurations[name];
-
-            // Update default if needed
-            if (llmsConfig.default === name) {
-                const remaining = Object.keys(llmsConfig.configurations);
-                llmsConfig.default = remaining.length > 0 ? remaining[0] : undefined;
-
-                if (llmsConfig.default) {
-                    console.log(chalk.yellow(`Default changed to "${llmsConfig.default}"`));
-                }
-            }
-
-            console.log(chalk.green(`✅ Configuration "${name}" deleted`));
-        }
-    }
-
-    static async setDefault(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select default configuration:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.default ? `${n} (current default)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.default = name;
-        console.log(chalk.green(`✅ Default configuration set to "${name}"`));
-    }
-
-    static async setSummarizationModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select summarization model:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.summarization ? `${n} (current)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.summarization = name;
-        console.log(chalk.green(`✅ Summarization model set to "${name}"`));
-
-        // Offer to test the configuration
-        const { shouldTest } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "shouldTest",
-                message: "Would you like to test this configuration with generateObject?",
-                default: true,
-            },
-        ]);
-
-        if (shouldTest) {
-            const { ConfigurationTester } = await import("./ConfigurationTester");
-            await ConfigurationTester.testSummarization(llmsConfig, name);
-        }
-    }
-
-    static async setSupervisionModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select supervision model:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.supervision ? `${n} (current)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.supervision = name;
-        console.log(chalk.green(`✅ Supervision model set to "${name}"`));
-    }
-
-    static async setSearchModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select search model:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.search ? `${n} (current)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.search = name;
-        console.log(chalk.green(`✅ Search model set to "${name}"`));
-    }
-
-    static async setPromptCompilationModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select prompt compilation model:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.promptCompilation ? `${n} (current)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.promptCompilation = name;
-        console.log(chalk.green(`✅ Prompt compilation model set to "${name}"`));
-        console.log(chalk.gray("   This model is used to compile lessons into agent system prompts."));
-    }
-
-    static async setCompressionModel(llmsConfig: TenexLLMsWithProviders): Promise<void> {
-        const configNames = Object.keys(llmsConfig.configurations);
-
-        if (configNames.length === 0) {
-            console.log(chalk.yellow("⚠️  No configurations available"));
-            return;
-        }
-
-        const { name } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "name",
-                message: "Select compression model:",
-                choices: configNames.map((n) => ({
-                    name: n === llmsConfig.compression ? `${n} (current)` : n,
-                    value: n,
-                })),
-            },
-        ]);
-
-        llmsConfig.compression = name;
-        console.log(chalk.green(`✅ Compression model set to "${name}"`));
-        console.log(chalk.gray("   This model is used for conversation history compression."));
+        const variantCount = Object.keys(metaConfig.variants).length;
+        display.blank();
+        display.success(`Multi-modal configuration "${metaName}" created with ${variantCount} variants`);
     }
 
     /**
      * Select a Codex model and reasoning effort interactively
      */
     private static async selectCodexModel(): Promise<{ model: string; reasoningEffort?: string }> {
-        console.log(chalk.cyan("\nFetching available Codex models..."));
+        display.blank();
+        display.context("Fetching available Codex models...");
 
         try {
             const models = await listCodexModels();
 
             if (models.length === 0) {
-                console.log(chalk.yellow("No models found. Using default."));
+                display.hint("No models found. Using default.");
                 return { model: "gpt-5.1-codex-max" };
             }
 
-            // Show models with details
-            console.log(chalk.bold("\nAvailable Codex Models:"));
-            for (const model of models) {
-                console.log(chalk.gray(formatCodexModel(model)));
-            }
-            console.log("");
-
-            // Select model
             const { model } = await inquirer.prompt([
                 {
                     type: "select",
                     name: "model",
                     message: "Select model:",
-                    choices: models.map((m) => ({
-                        name: m.isDefault ? `${m.displayName} (default)` : m.displayName,
-                        value: m.id,
-                    })),
+                    choices: models.map((m) => {
+                        const defaultTag = m.isDefault ? chalk.dim(" (default)") : "";
+                        return {
+                            name: `${m.id}${defaultTag} ${chalk.dim(m.description)}`,
+                            value: m.id,
+                        };
+                    }),
+                    theme: inquirerTheme,
                 },
             ]);
 
@@ -626,12 +248,13 @@ export class ConfigurationManager {
                             value: e,
                         })),
                     ],
+                    theme: inquirerTheme,
                 },
             ]);
 
             return { model, reasoningEffort };
         } catch (error) {
-            console.log(chalk.yellow(`Could not fetch models: ${error}. Using default.`));
+            display.hint(`Could not fetch models: ${error}. Using default.`);
             return { model: "gpt-5.1-codex-max" };
         }
     }