@plexor-dev/claude-code-plugin 0.1.0-beta.3 → 0.1.0-beta.30

package/lib/settings-manager.js

@@ -0,0 +1,242 @@
+/**
+ * Claude Code Settings Manager
+ *
+ * Manages ~/.claude/settings.json to enable automatic Plexor routing.
+ *
+ * KEY DISCOVERY: Claude Code reads settings.json at runtime and the `env` block
+ * overrides environment variables. This allows the plugin to redirect ALL Claude
+ * Code sessions to Plexor without users manually setting environment variables.
+ *
+ * Reference: Claude Code v2.0.1+ behavior - settings.json env takes precedence
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
+const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+
+// Plexor gateway endpoints
+const PLEXOR_STAGING_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
+const PLEXOR_PROD_URL = 'https://api.plexor.dev/gateway/anthropic';
+
+class ClaudeSettingsManager {
+  constructor() {
+    this.settingsPath = SETTINGS_PATH;
+    this.claudeDir = CLAUDE_DIR;
+  }
+
+  /**
+   * Load current Claude settings
+   * @returns {Object} settings object or empty object if not found
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.settingsPath)) {
+        return {};
+      }
+      const data = fs.readFileSync(this.settingsPath, 'utf8');
+      return JSON.parse(data);
+    } catch (err) {
+      // Log unexpected errors (not ENOENT which is handled above)
+      if (err.code !== 'ENOENT') {
+        console.warn('Warning: Failed to load Claude settings:', err.message);
+      }
+      return {};
+    }
+  }
+
+  /**
+   * Save Claude settings
+   * @param {Object} settings - settings object to save
+   * @returns {boolean} success status
+   */
+  save(settings) {
+    try {
+      // Ensure .claude directory exists
+      if (!fs.existsSync(this.claudeDir)) {
+        fs.mkdirSync(this.claudeDir, { recursive: true });
+      }
+
+      fs.writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+      return true;
+    } catch (err) {
+      console.error('Failed to save Claude settings:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Enable Plexor routing by setting env vars in settings.json
+   *
+   * This is the KEY mechanism: setting ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN
+   * in the env block redirects ALL Claude Code sessions to Plexor automatically.
+   *
+   * @param {string} apiKey - Plexor API key (plx_*)
+   * @param {Object} options - { useStaging: boolean }
+   * @returns {boolean} success status
+   */
+  enablePlexorRouting(apiKey, options = {}) {
+    // Default to production. Use useStaging: true for staging keys.
+    const { useStaging = false } = options;
+    const apiUrl = useStaging ? PLEXOR_STAGING_URL : PLEXOR_PROD_URL;
+
+    try {
+      const settings = this.load();
+
+      // Initialize env block if doesn't exist
+      if (!settings.env) {
+        settings.env = {};
+      }
+
+      // Set the magic environment variables
+      // ANTHROPIC_AUTH_TOKEN has higher precedence than ANTHROPIC_API_KEY
+      settings.env.ANTHROPIC_BASE_URL = apiUrl;
+      settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+
+      const success = this.save(settings);
+
+      if (success) {
+        console.log(`✓ Plexor routing enabled`);
+        console.log(`  Base URL: ${apiUrl}`);
+        console.log(`  API Key: ${apiKey.substring(0, 12)}...`);
+        console.log(`\n  All Claude Code sessions will now route through Plexor.`);
+        console.log(`  Changes take effect immediately (no restart needed).`);
+      }
+
+      return success;
+    } catch (err) {
+      console.error('Failed to enable Plexor routing:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Disable Plexor routing by removing env vars from settings.json
+   *
+   * This restores direct connection to Anthropic API.
+   *
+   * @returns {boolean} success status
+   */
+  disablePlexorRouting() {
+    try {
+      const settings = this.load();
+
+      if (!settings.env) {
+        console.log('Plexor routing is not currently enabled.');
+        return true;
+      }
+
+      // Remove Plexor-specific env vars
+      delete settings.env.ANTHROPIC_BASE_URL;
+      delete settings.env.ANTHROPIC_AUTH_TOKEN;
+
+      // Clean up empty env block
+      if (Object.keys(settings.env).length === 0) {
+        delete settings.env;
+      }
+
+      const success = this.save(settings);
+
+      if (success) {
+        console.log('✓ Plexor routing disabled');
+        console.log('  Claude Code will now connect directly to Anthropic.');
+        console.log('  Changes take effect immediately (no restart needed).');
+      }
+
+      return success;
+    } catch (err) {
+      console.error('Failed to disable Plexor routing:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get current routing status
+   * @returns {Object} { enabled: boolean, baseUrl: string|null, hasToken: boolean }
+   */
+  getRoutingStatus() {
+    try {
+      const settings = this.load();
+
+      const baseUrl = settings.env?.ANTHROPIC_BASE_URL || null;
+      const hasToken = !!settings.env?.ANTHROPIC_AUTH_TOKEN;
+
+      // Check if routing to Plexor
+      const isPlexorRouting = baseUrl && (
+        baseUrl.includes('plexor') ||
+        baseUrl.includes('staging.api')
+      );
+
+      return {
+        enabled: isPlexorRouting,
+        baseUrl,
+        hasToken,
+        isStaging: baseUrl?.includes('staging') || false,
+        tokenPreview: hasToken ? settings.env.ANTHROPIC_AUTH_TOKEN.substring(0, 12) + '...' : null
+      };
+    } catch {
+      return { enabled: false, baseUrl: null, hasToken: false };
+    }
+  }
+
+  /**
+   * Update just the API key without changing other settings
+   * @param {string} apiKey - new Plexor API key
+   * @returns {boolean} success status
+   */
+  updateApiKey(apiKey) {
+    try {
+      const settings = this.load();
+
+      if (!settings.env) {
+        settings.env = {};
+      }
+
+      settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+      return this.save(settings);
+    } catch (err) {
+      console.error('Failed to update API key:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Switch between staging and production
+   * @param {boolean} useStaging - true for staging, false for production
+   * @returns {boolean} success status
+   */
+  setEnvironment(useStaging) {
+    try {
+      const settings = this.load();
+
+      if (!settings.env?.ANTHROPIC_BASE_URL) {
+        console.log('Plexor routing is not enabled. Run /plexor-login first.');
+        return false;
+      }
+
+      settings.env.ANTHROPIC_BASE_URL = useStaging ? PLEXOR_STAGING_URL : PLEXOR_PROD_URL;
+
+      const success = this.save(settings);
+      if (success) {
+        console.log(`✓ Switched to ${useStaging ? 'staging' : 'production'} environment`);
+      }
+      return success;
+    } catch (err) {
+      console.error('Failed to switch environment:', err.message);
+      return false;
+    }
+  }
+}
+
+// Export singleton instance and class
+const settingsManager = new ClaudeSettingsManager();
+
+module.exports = {
+  ClaudeSettingsManager,
+  settingsManager,
+  CLAUDE_DIR,
+  SETTINGS_PATH,
+  PLEXOR_STAGING_URL,
+  PLEXOR_PROD_URL
+};

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.30",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
+  "bin": {
+    "plexor-status": "./commands/plexor-status.js",
+    "plexor-enabled": "./commands/plexor-enabled.js",
+    "plexor-login": "./commands/plexor-login.js",
+    "plexor-logout": "./commands/plexor-logout.js"
+  },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "preuninstall": "node scripts/uninstall.js",
@@ -10,6 +16,7 @@
   },
   "files": [
     "commands/",
+    "hooks/",
     "scripts/",
     "lib/",
     "README.md",

package/scripts/plexor-cli.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# Plexor CLI - Claude Code with intelligent optimization
+# This wrapper auto-enables hypervisor mode for direct gateway routing
+
+# Colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
+
+CONFIG_FILE="$HOME/.plexor/config.json"
+
+# Auto-configure ANTHROPIC_BASE_URL if Plexor is enabled
+if [ -f "$CONFIG_FILE" ]; then
+    ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('enabled', False))" 2>/dev/null)
+    API_URL=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('apiUrl', ''))" 2>/dev/null)
+    API_KEY=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('auth',{}).get('api_key', ''))" 2>/dev/null)
+    MODE=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('mode', 'balanced'))" 2>/dev/null)
+
+    if [ "$ENABLED" = "True" ] && [ -n "$API_URL" ] && [ -n "$API_KEY" ]; then
+        # Set ANTHROPIC_BASE_URL to Plexor gateway (hypervisor mode)
+        export ANTHROPIC_BASE_URL="${API_URL}/gateway/anthropic/v1"
+        export ANTHROPIC_API_KEY="$API_KEY"
+
+        # Show Plexor branding
+        echo -e "${CYAN}"
+        cat << 'EOF'
+    ____  __
+   / __ \/ /__  _  ______  _____
+  / /_/ / / _ \| |/_/ __ \/ ___/
+ / ____/ /  __/>  </ /_/ / /
+/_/   /_/\___/_/|_|\____/_/
+
+EOF
+        echo -e "${NC}"
+        echo -e "${GREEN}●${NC} Hypervisor Mode: ${GREEN}Active${NC}"
+        echo -e "   Gateway: ${DIM}${ANTHROPIC_BASE_URL}${NC}"
+        echo -e "   Mode: ${MODE}"
+        echo ""
+    else
+        echo -e "${YELLOW}○${NC} Plexor: ${DIM}Disabled${NC} (run /plexor-login to enable)"
+        echo ""
+    fi
+fi
+
+# Launch claude with all arguments passed through
+exec claude "$@"

package/scripts/postinstall.js

@@ -10,24 +10,118 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execSync } = require('child_process');
 
+/**
+ * Get the correct home directory, accounting for sudo.
+ * When running with sudo, os.homedir() returns /root, but we want
+ * the actual user's home directory.
+ */
+function getHomeDir() {
+  // Check if running with sudo - SUDO_USER contains the original username
+  if (process.env.SUDO_USER) {
+    // On Linux/Mac, home directories are typically /home/<user> or /Users/<user>
+    const platform = os.platform();
+    if (platform === 'darwin') {
+      return path.join('/Users', process.env.SUDO_USER);
+    } else if (platform === 'linux') {
+      return path.join('/home', process.env.SUDO_USER);
+    }
+  }
+  return os.homedir();
+}
+
+/**
+ * Get uid/gid for the target user (handles sudo case).
+ * Returns null if not running with sudo or on Windows.
+ */
+function getTargetUserIds() {
+  const sudoUser = process.env.SUDO_USER;
+  if (!sudoUser || os.platform() === 'win32') {
+    return null;
+  }
+
+  try {
+    // Get uid and gid for the sudo user
+    const uid = parseInt(execSync(`id -u ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
+    const gid = parseInt(execSync(`id -g ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
+    return { uid, gid, user: sudoUser };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively chown a directory and all its contents.
+ */
+function chownRecursive(dirPath, uid, gid) {
+  if (!fs.existsSync(dirPath)) return;
+
+  const stat = fs.statSync(dirPath);
+  fs.chownSync(dirPath, uid, gid);
+
+  if (stat.isDirectory()) {
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      chownRecursive(path.join(dirPath, entry), uid, gid);
+    }
+  }
+}
+
+const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const CLAUDE_COMMANDS_DIR = path.join(os.homedir(), '.claude', 'commands');
-const PLEXOR_CONFIG_DIR = path.join(os.homedir(), '.plexor');
+const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
+const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
+const PLEXOR_CONFIG_FILE = path.join(PLEXOR_CONFIG_DIR, 'config.json');
+
+// Default configuration for new installs
+const DEFAULT_CONFIG = {
+  version: 1,
+  auth: {
+    mode: "pending",
+    authenticated_at: null
+  },
+  settings: {
+    enabled: true,
+    apiUrl: "https://api.plexor.dev",
+    mode: "balanced",
+    localCacheEnabled: true
+  }
+};
 
 function main() {
   try {
+    // Get target user info for chown (if running with sudo)
+    const targetUser = getTargetUserIds();
+
     // Create ~/.claude/commands/ if not exists
     fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/commands/ for JS executors
+    fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
+
     // Create ~/.plexor/ with secure permissions (owner only)
     fs.mkdirSync(PLEXOR_CONFIG_DIR, { recursive: true, mode: 0o700 });
 
-    // Get list of command files
-    const files = fs.readdirSync(COMMANDS_SOURCE)
+    // Create default config.json if it doesn't exist
+    let configCreated = false;
+    if (!fs.existsSync(PLEXOR_CONFIG_FILE)) {
+      fs.writeFileSync(
+        PLEXOR_CONFIG_FILE,
+        JSON.stringify(DEFAULT_CONFIG, null, 2),
+        { mode: 0o600 }
+      );
+      configCreated = true;
+    }
+
+    // Get list of command files (.md for Claude, .js for executors)
+    const mdFiles = fs.readdirSync(COMMANDS_SOURCE)
       .filter(f => f.endsWith('.md'));
+    const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
+      .filter(f => f.endsWith('.js'));
 
-    if (files.length === 0) {
+    if (mdFiles.length === 0) {
       console.error('No command files found in package. Installation may be corrupt.');
       process.exit(1);
     }
@@ -35,7 +129,8 @@ function main() {
     const installed = [];
     const backed_up = [];
 
-    for (const file of files) {
+    // Copy .md command files to ~/.claude/commands/
+    for (const file of mdFiles) {
       const src = path.join(COMMANDS_SOURCE, file);
       const dest = path.join(CLAUDE_COMMANDS_DIR, file);
 
@@ -55,34 +150,88 @@ function main() {
       installed.push(file.replace('.md', ''));
     }
 
-    // Print success message
+    // Copy .js executor files to ~/.claude/plugins/plexor/commands/
+    const jsInstalled = [];
+    for (const file of jsFiles) {
+      const src = path.join(COMMANDS_SOURCE, file);
+      const dest = path.join(PLEXOR_PLUGINS_DIR, file);
+      fs.copyFileSync(src, dest);
+      // Make executable
+      fs.chmodSync(dest, 0o755);
+      jsInstalled.push(file);
+    }
+
+    // Fix file ownership when running with sudo
+    // Files are created as root but should be owned by the original user
+    if (targetUser) {
+      const { uid, gid } = targetUser;
+      // Chown the .claude directory and all contents we created
+      chownRecursive(path.join(HOME_DIR, '.claude'), uid, gid);
+      // Chown the .plexor directory and all contents
+      chownRecursive(PLEXOR_CONFIG_DIR, uid, gid);
+    }
+
+    // Detect shell type
+    const shell = process.env.SHELL || '';
+    const isZsh = shell.includes('zsh');
+    const shellRc = isZsh ? '~/.zshrc' : '~/.bashrc';
+
+    // Print success message with clear onboarding steps
     console.log('');
-    console.log('  ╔═══════════════════════════════════════════════════════════╗');
-    console.log('  ║                                                           ║');
-    console.log('  ║   Plexor Claude Code Plugin installed successfully!       ║');
-    console.log('  ║                                                           ║');
-    console.log('  ╚═══════════════════════════════════════════════════════════╝');
+    console.log('  ╔═══════════════════════════════════════════════════════════════════╗');
+    console.log('  ║                                                                   ║');
+    console.log('  ║   Plexor Claude Code Plugin installed successfully!              ║');
+    console.log('  ║                                                                   ║');
+    console.log('  ╚═══════════════════════════════════════════════════════════════════╝');
     console.log('');
-    console.log('  Commands installed to ~/.claude/commands/:');
-    installed.forEach(cmd => {
-      console.log(`    /${cmd}`);
-    });
 
-    if (backed_up.length > 0) {
-      console.log('');
-      console.log('  Existing files backed up (.backup):');
-      backed_up.forEach(f => console.log(`    ${f}`));
+    if (configCreated) {
+      console.log('  ✓ Created ~/.plexor/config.json');
+    }
+    console.log(`  ✓ Installed ${installed.length} slash commands to ~/.claude/commands/`);
+    if (jsInstalled.length > 0) {
+      console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/`);
     }
+    if (targetUser) {
+      console.log(`  ✓ Set file ownership to ${targetUser.user}`);
+    }
+    console.log('');
 
+    // CRITICAL: Make the required step VERY obvious
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  REQUIRED: Run this command to enable Plexor routing:          │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  For Claude MAX users (OAuth):');
+    console.log('');
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    source ${shellRc}`);
+    console.log('');
+    console.log('  For API key users (get key at https://plexor.dev/dashboard):');
+    console.log('');
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    echo 'export ANTHROPIC_API_KEY="plx_your_key_here"' >> ${shellRc}`);
+    console.log(`    source ${shellRc}`);
     console.log('');
-    console.log('  Next steps:');
-    console.log('    1. Open Claude Code');
-    console.log('    2. Run /plexor-login to authenticate');
-    console.log('    3. Start saving on LLM costs!');
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  Then start Claude Code and run: /plexor-status                │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  Available commands:');
+    console.log('    /plexor-setup    - First-time setup wizard');
+    console.log('    /plexor-login    - Authenticate with API key');
+    console.log('    /plexor-status   - Check connection and see savings');
+    console.log('    /plexor-enabled  - Enable/disable Plexor routing');
     console.log('');
     console.log('  Documentation: https://plexor.dev/docs');
     console.log('');
 
+    if (backed_up.length > 0) {
+      console.log('  Note: Existing files backed up (.backup):');
+      backed_up.forEach(f => console.log(`    ${f}`));
+      console.log('');
+    }
+
   } catch (error) {
     console.error('');
     console.error('  Plexor plugin installation failed');

package/commands/plexor-config.md

@@ -1,42 +0,0 @@
----
-description: Configure Plexor settings (user)
----
-
-# Plexor Config
-
-View and modify Plexor configuration. This is an alias for /plexor-settings.
-
-## Steps
-
-**Step 1: Read current configuration**
-
-Use the Read tool to read `~/.plexor/config.json`.
-
-If the file doesn't exist, show:
-```
-Plexor Config
-=============
-No configuration found. Run /plexor-login to set up Plexor.
-```
-
-**Step 2: Display current configuration**
-
-```
-Plexor Config
-=============
-Enabled: [enabled]
-API URL: [apiUrl]
-API Key: [show "configured" if apiKey exists, otherwise "not configured"]
-Mode: [mode]
-Provider: [preferredProvider]
-Local Cache: [localCacheEnabled]
-Timeout: [timeout]ms
-
-Configuration file: ~/.plexor/config.json
-
-Other commands:
-- /plexor-settings - View/edit all settings
-- /plexor-mode - Change optimization mode
-- /plexor-provider - Change provider
-- /plexor-enabled - Enable/disable proxy
-```

package/commands/plexor-mode.md

@@ -1,47 +0,0 @@
----
-description: Set Plexor optimization mode (eco/balanced/quality/passthrough) (user)
----
-
-# Plexor Mode
-
-Set the Plexor optimization mode to control cost vs quality trade-offs.
-
-## Steps
-
-**Step 1: Read current configuration**
-
-Use the Read tool to read `~/.plexor/config.json` and check the current `mode` setting.
-
-**Step 2: Ask user which mode they want**
-
-Use the `AskUserQuestion` tool:
-
-Question: "Which optimization mode would you like to use?"
-Header: "Mode"
-Options:
-1. **eco** - Maximum savings (~$0.04/1M tokens) - Uses Ministral 3B
-2. **balanced** - Good balance (~$0.15/1M) - DeepSeek, Gemini Flash, Mistral Small
-3. **quality** - Premium models (~$5/1M) - Claude Opus, Gemini Pro, Mistral Large
-4. **passthrough** - No optimization - Direct to requested model
-
-**Step 3: Update the configuration**
-
-Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
-- Set the `mode` field to the selected value: "eco", "balanced", "quality", or "passthrough"
-
-Keep all other settings unchanged.
-
-**Step 4: Show confirmation**
-
-```
-Plexor Mode: [SELECTED MODE]
-
-Mode Details:
-- eco: Maximum cost savings using Ministral 3B ($0.04/$0.04 per 1M tokens)
-- balanced: Cost-first with quality fallbacks (DeepSeek → Gemini Flash → Mistral)
-- quality: Premium models for complex tasks (Claude Opus, Gemini Pro)
-- passthrough: No optimization, direct to Anthropic
-
-Current mode: [mode]
-Run /plexor-status to see your savings.
-```

package/commands/plexor-provider.md

@@ -1,47 +0,0 @@
----
-description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto) (user)
----
-
-# Plexor Provider
-
-Set your preferred LLM provider for Plexor routing.
-
-## Steps
-
-**Step 1: Read current configuration**
-
-Use the Read tool to read `~/.plexor/config.json` and check the current `preferredProvider` setting.
-
-**Step 2: Ask user which provider they prefer**
-
-Use the `AskUserQuestion` tool:
-
-Question: "Which LLM provider would you prefer?"
-Header: "Provider"
-Options:
-1. **auto** - Let Plexor choose the best provider based on task (Recommended)
-2. **deepseek** - Use DeepSeek models (cheapest, good for code)
-3. **mistral** - Use Mistral models (fast, good balance)
-4. **gemini** - Use Google Gemini models (good for analysis)
-
-**Step 3: Update the configuration**
-
-Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
-- Set `preferredProvider` to: "auto", "deepseek", "mistral", or "gemini"
-
-Keep all other settings unchanged.
-
-**Step 4: Show confirmation**
-
-```
-Plexor Provider: [SELECTED PROVIDER]
-
-Provider options:
-- auto: Plexor automatically selects the best provider for each task
-- deepseek: DeepSeek models ($0.14/$0.28 per 1M tokens) - Great for code
-- mistral: Mistral models ($0.10/$0.30 per 1M tokens) - Fast and versatile
-- gemini: Google Gemini ($0.075/$0.30 per 1M tokens) - Good for analysis
-
-Current provider: [preferredProvider]
-Run /plexor-status to see your usage.
-```