@plexor-dev/claude-code-plugin 0.1.0-beta.2 → 0.1.0-beta.21

package/commands/plexor-login.md

@@ -1,87 +1,86 @@
 ---
-description: Authenticate with Plexor to enable optimization
+description: Authenticate with Plexor to enable optimization (user)
 ---
 
 # Plexor Login
 
 Authenticate with your Plexor account to enable LLM cost optimization.
 
-## Instructions
+## Steps
 
-1. Check if already authenticated by reading ~/.plexor/config.json
-2. If already authenticated and valid, show current account info and status
-3. If not authenticated, initiate device flow:
-   a. Call POST https://api.plexor.dev/v1/auth/device-code to get device_code and user_code
-   b. Display the user code and verification URL to the user
-   c. Open https://plexor.dev/auth/device in the user's browser
-   d. Poll POST https://api.plexor.dev/v1/auth/device-token every 5 seconds
-   e. On success, save API key to ~/.plexor/config.json
-   f. Verify the key works by calling GET https://api.plexor.dev/v1/user
+**Step 1: Check existing authentication**
 
-4. After successful authentication, configure the gateway:
-   a. Set ANTHROPIC_BASE_URL to route traffic through Plexor gateway
-   b. Inform user they need to restart Claude Code
+Use the Read tool to read `~/.plexor/config.json`.
 
-## Config File
+If the file exists and has `auth.api_key` that starts with "plx_", the user is already authenticated. Show them:
+```
+Plexor Login
+============
+Already authenticated!
+API Key: plx_****[last 4 chars]
+API URL: [apiUrl from config]
+Status: [Enabled/Disabled]
+
+Run /plexor-status to see your usage statistics.
+Run /plexor-logout to sign out.
+```
+
+**Step 2: If not authenticated, ask for API key**
 
-Location: ~/.plexor/config.json
+Ask the user to provide their Plexor API key. They can get one from:
+- https://plexor.dev/dashboard (if they have an account)
+- https://plexor.dev/signup (to create an account)
+
+Tell them: "Please provide your Plexor API key (starts with 'plx_'):"
+
+**Step 3: Save the configuration**
+
+Once the user provides an API key (or it was passed as an argument), use the Write tool to create/update `~/.plexor/config.json`:
 
 ```json
 {
   "version": 1,
   "auth": {
-    "api_key": "plx_...",
-    "email": "user@example.com",
-    "tier": "beta",
-    "authenticated_at": "2025-12-16T20:00:00Z"
+    "api_key": "[user's API key]",
+    "authenticated_at": "[current ISO timestamp]"
   },
   "settings": {
     "enabled": true,
+    "apiUrl": "https://api.plexor.dev",
     "preferred_provider": "auto",
-    "mode": "balanced"
+    "mode": "balanced",
+    "localCacheEnabled": true,
+    "timeout": 5000
   }
 }
 ```
 
-## Output (New User)
+**IMPORTANT**: If the user provided the API key as an argument (e.g., `/plexor-login plx_abc123`), use that key directly instead of asking for it.
 
-```
-Plexor Login
-============
+**Step 4: Verify the key works**
 
-1. Open this URL in your browser:
-   https://plexor.dev/auth/device
-
-2. Enter this code:
-   ABCD-1234
-
-Waiting for authentication... ✓
-
-✓ Authenticated as user@example.com
-✓ Plan: Beta ($1/month)
-✓ Plexor gateway configured
-
-To activate, run this in your terminal:
-
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/v1/gateway/anthropic"
-
-Then restart Claude Code. All prompts will be optimized automatically.
-
-Run /plexor-status to see your savings.
+Make a test request to verify authentication:
+```
+GET https://api.plexor.dev/api/users/me
+Authorization: Bearer [apiKey]
 ```
 
-## Output (Already Authenticated)
-
+If successful, show:
 ```
 Plexor Login
 ============
+Authentication successful!
 
-Already authenticated as user@example.com
-Plan: Beta ($1/month)
-Status: Active
+Your API key has been saved to ~/.plexor/config.json
 
-Gateway URL: https://api.plexor.dev/v1/gateway/anthropic
+Next steps:
+1. Run /plexor-status to see your usage
+2. Run /plexor-enabled true to enable the proxy
+3. Start saving on LLM costs!
 
-Run /plexor-status to see your savings.
-Run /plexor-logout to sign out.
+Dashboard: https://plexor.dev/dashboard
 ```
+
+If the API call fails, tell the user the key may be invalid and ask them to check it.
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-logout.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Logout Command
+ * Clear Plexor credentials and disable proxy
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+const CONFIG_PATH = path.join(PLEXOR_DIR, 'config.json');
+const SESSION_PATH = path.join(PLEXOR_DIR, 'session.json');
+const CACHE_PATH = path.join(PLEXOR_DIR, 'cache.json');
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function deleteFile(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch {
+    // Ignore errors
+  }
+  return false;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+
+  if (!config || !config.auth?.api_key) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Not Logged In                              │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  No active Plexor session found.            │`);
+    console.log(`│  Run /plexor-login to authenticate.         │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const clearCache = args.includes('--clear-cache') || args.includes('-c');
+
+  // Clear credentials
+  delete config.auth.api_key;
+  config.settings = config.settings || {};
+  config.settings.enabled = false;
+  saveConfig(config);
+
+  // Clear session
+  deleteFile(SESSION_PATH);
+
+  // Optionally clear cache
+  let cacheCleared = false;
+  if (clearCache) {
+    cacheCleared = deleteFile(CACHE_PATH);
+  }
+
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Logged Out                               │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ✓ API key removed                          │`);
+  console.log(`│  ✓ Plexor proxy disabled                    │`);
+  console.log(`│  ✓ Session cleared                          │`);
+  if (clearCache) {
+    console.log(`│  ${cacheCleared ? '✓' : '○'} Cache cleared                            │`);
+  }
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Run /plexor-login to re-authenticate.      │`);
+  if (!clearCache) {
+    console.log(`│  Use --clear-cache to also clear cache.     │`);
+  }
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-logout.md

@@ -1,50 +1,44 @@
 ---
-description: Log out from Plexor and clear credentials
+description: Log out from Plexor and clear credentials (user)
 ---
 
 # Plexor Logout
 
 Log out from your Plexor account and clear stored credentials.
 
-## Instructions
+## Steps
 
-1. Read the current configuration from ~/.plexor/config.json
-2. If not authenticated, inform the user they are not logged in
-3. If authenticated:
-   a. Clear the API key from the configuration
-   b. Preserve non-sensitive settings (mode, provider preferences)
-   c. Save the updated configuration
-4. Remind user to restore original Anthropic URL
-5. Display confirmation message
+**Step 1: Read current configuration**
 
-## Output
+Use the Read tool to read `~/.plexor/config.json`.
 
+If the file doesn't exist or has no `apiKey`, show:
 ```
 Plexor Logout
 =============
+You are not currently logged in.
+Run /plexor-login to authenticate.
+```
 
-✓ Successfully logged out
-✓ API key cleared from ~/.plexor/config.json
-
-To restore direct Anthropic access, run:
-
-  unset ANTHROPIC_BASE_URL
-
-Then restart Claude Code.
-
-Note: Your Plexor subscription is still active.
-To manage billing: https://plexor.dev/billing
+**Step 2: Clear the API key**
 
-To use Plexor again, run /plexor-login
-```
+If authenticated, use the Write tool to update `~/.plexor/config.json`:
+- Remove or clear the `apiKey` field (set to empty string "")
+- Keep all other settings (mode, preferredProvider, etc.)
 
-## Output (Not Logged In)
+**Step 3: Show confirmation**
 
 ```
 Plexor Logout
 =============
+Successfully logged out!
 
-You are not currently logged in.
+- API key cleared from ~/.plexor/config.json
+- Settings preserved (mode, provider preferences)
 
-Run /plexor-login to authenticate.
+To use Plexor again, run /plexor-login
+
+Dashboard: https://plexor.dev/dashboard
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-mode.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Mode Command
+ * Set optimization mode: eco, balanced, quality, passthrough
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+const VALID_MODES = ['eco', 'balanced', 'quality', 'passthrough'];
+
+const MODE_INFO = {
+  eco: {
+    description: 'Maximum savings (~$0.04/1M tokens)',
+    models: 'Ministral 3B, small models'
+  },
+  balanced: {
+    description: 'Good balance (~$0.15/1M tokens)',
+    models: 'DeepSeek, Gemini Flash, Mistral Small'
+  },
+  quality: {
+    description: 'Premium models (~$5/1M tokens)',
+    models: 'Claude Opus, Gemini Pro, Mistral Large'
+  },
+  passthrough: {
+    description: 'No optimization',
+    models: 'Direct to requested model'
+  }
+};
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentMode = config.settings?.mode || 'balanced';
+
+  // No args - show current mode and options
+  if (args.length === 0) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Optimization Mode                   │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Current: ${currentMode.padEnd(33)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Available modes:                           │`);
+
+    for (const mode of VALID_MODES) {
+      const marker = mode === currentMode ? '●' : '○';
+      const info = MODE_INFO[mode];
+      console.log(`│  ${marker} ${mode.padEnd(12)} ${info.description.substring(0, 26).padEnd(26)}│`);
+    }
+
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage: /plexor-mode <mode>                 │`);
+    console.log(`│  Example: /plexor-mode eco                  │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const newMode = args[0].toLowerCase();
+
+  if (!VALID_MODES.includes(newMode)) {
+    console.error(`Error: Invalid mode "${newMode}"`);
+    console.error(`Valid modes: ${VALID_MODES.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (newMode === currentMode) {
+    console.log(`Mode is already set to "${currentMode}"`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.mode = newMode;
+  saveConfig(config);
+
+  const info = MODE_INFO[newMode];
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Mode Updated                             │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Previous: ${currentMode.padEnd(32)}│`);
+  console.log(`│  New: ${newMode.padEnd(37)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ${info.description.padEnd(42)}│`);
+  console.log(`│  Models: ${info.models.substring(0, 34).padEnd(34)}│`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-mode.md

@@ -1,25 +1,49 @@
 ---
-description: Set Plexor optimization mode (eco/balanced/quality/passthrough)
+description: Set Plexor optimization mode (eco/balanced/quality/passthrough) (user)
 ---
 
-Set the Plexor optimization mode.
+# Plexor Mode
 
-**IMPORTANT**: Use the `AskUserQuestion` tool to present the user with these options:
+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 cost savings (Ministral 3B $0.04/$0.04 - cheapest)
-2. **balanced** - Cost-first with fallbacks (DeepSeek → Gemini Flash → Mistral → GPT-5-nano → Claude Haiku)
-3. **quality** - Premium models (Claude Opus 4.5 → Gemini Pro → Mistral Large → GPT-5.1)
-4. **passthrough** - No optimization, direct passthrough to requested model
-
-After the user selects an option:
-1. Update ~/.plexor/config.json with the selected mode
-2. Set the X-Plexor-Mode header for future requests
-3. Confirm the change and explain the cost/quality trade-offs
-
-Cost comparison (per 1M tokens input/output):
-- eco: Mistral Ministral 3B $0.04/$0.04 (cheapest)
-- balanced: DeepSeek $0.14/$0.28, Gemini 2.5 Flash $0.15/$0.60, Mistral Small $0.1/$0.3
-- quality: Claude Opus 4.5 $5/$25, Gemini 2.5 Pro $1.25/$10, Mistral Large $2/$6
+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.
+```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-provider.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Provider Command
+ * Force a specific LLM provider
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+const VALID_PROVIDERS = ['auto', 'claude', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'google'];
+
+const PROVIDER_INFO = {
+  auto: 'Automatic routing based on task and mode',
+  claude: 'Anthropic Claude models (alias for anthropic)',
+  anthropic: 'Anthropic Claude models',
+  openai: 'OpenAI GPT models',
+  deepseek: 'DeepSeek models (excellent for code)',
+  mistral: 'Mistral AI models',
+  gemini: 'Google Gemini models',
+  google: 'Google Gemini models (alias for gemini)'
+};
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function normalizeProvider(provider) {
+  const normalized = provider.toLowerCase();
+  if (normalized === 'claude') return 'anthropic';
+  if (normalized === 'google') return 'gemini';
+  return normalized;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentProvider = config.settings?.preferred_provider || 'auto';
+
+  // No args - show current provider and options
+  if (args.length === 0) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Provider Routing                    │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Current: ${currentProvider.padEnd(33)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Available providers:                       │`);
+
+    const displayProviders = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini'];
+    for (const provider of displayProviders) {
+      const marker = provider === currentProvider ? '●' : '○';
+      const info = PROVIDER_INFO[provider];
+      console.log(`│  ${marker} ${provider.padEnd(10)} ${info.substring(0, 29).padEnd(29)}│`);
+    }
+
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage: /plexor-provider <provider>         │`);
+    console.log(`│  Example: /plexor-provider deepseek         │`);
+    console.log(`│  Aliases: claude→anthropic, google→gemini   │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const inputProvider = args[0].toLowerCase();
+
+  if (!VALID_PROVIDERS.includes(inputProvider)) {
+    console.error(`Error: Invalid provider "${args[0]}"`);
+    console.error(`Valid providers: auto, anthropic, openai, deepseek, mistral, gemini`);
+    console.error(`Aliases: claude (→anthropic), google (→gemini)`);
+    process.exit(1);
+  }
+
+  const newProvider = normalizeProvider(inputProvider);
+
+  if (newProvider === currentProvider) {
+    console.log(`Provider is already set to "${currentProvider}"`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.preferred_provider = newProvider;
+  saveConfig(config);
+
+  const info = PROVIDER_INFO[newProvider];
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Provider Updated                         │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Previous: ${currentProvider.padEnd(32)}│`);
+  console.log(`│  New: ${newProvider.padEnd(37)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ${info.padEnd(42)}│`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-provider.md

@@ -1,25 +1,49 @@
 ---
-description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto)
+description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto) (user)
 ---
 
-Force Plexor to use a specific LLM provider or enable automatic routing.
+# Plexor Provider
 
-**IMPORTANT**: Use the `AskUserQuestion` tool to present the user with these options:
+Set your preferred LLM provider for Plexor routing.
 
-Question: "Which provider would you like to use?"
+## 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** - Automatic routing (cheapest first: Mistral → DeepSeek → Gemini → OpenAI → Claude)
-2. **mistral** - Force Mistral (Ministral 3B $0.04/$0.04, Small $0.1/$0.3, Large $2/$6)
-3. **deepseek** - Force DeepSeek ($0.14/$0.28 per MTok)
-4. **gemini** - Force Gemini (2.0 Flash $0.10/$0.40, 2.5 Flash $0.15/$0.60, 2.5 Pro $1.25/$10)
-5. **openai** - Force OpenAI (GPT-5-nano $0.05/$0.40, GPT-5.1 $1.25/$10)
-6. **claude** - Force Anthropic (Haiku 4.5 $1/$5, Sonnet 4.5 $3/$15, Opus 4.5 $5/$25)
-
-After the user selects an option:
-1. Update ~/.plexor/config.json with the selected provider
-2. Set the X-Plexor-Force-Provider header for future requests
-3. Confirm the change and explain:
-   - The cost implications of the selected provider
-   - Model that will be used (based on current mode)
-   - When automatic routing might be more beneficial
+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.
+```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.