@plexor-dev/claude-code-plugin 0.1.0-beta.20 → 0.1.0-beta.22

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

@@ -4,41 +4,24 @@ description: Log out from Plexor and clear credentials (user)
 
 # Plexor Logout
 
-Log out from your Plexor account and clear stored credentials.
+Run this command to log out and clear credentials:
 
-## Steps
-
-**Step 1: Read current configuration**
-
-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.
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js
 ```
 
-**Step 2: Clear the API key**
-
-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.)
-
-**Step 3: Show confirmation**
+To also clear the cache:
 
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js --clear-cache
 ```
-Plexor Logout
-=============
-Successfully logged out!
 
-- API key cleared from ~/.plexor/config.json
-- Settings preserved (mode, provider preferences)
+Use the Bash tool to execute this command.
 
-To use Plexor again, run /plexor-login
-
-Dashboard: https://plexor.dev/dashboard
-```
+**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
+- Read any files
+- Explore the codebase
+- Run additional commands
+- Ask follow-up questions
 
-**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.
+The command output is the complete response. Simply show the output and wait for the user's next input.

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

@@ -4,46 +4,24 @@ description: Set Plexor optimization mode (eco/balanced/quality/passthrough) (us
 
 # Plexor Mode
 
-Set the Plexor optimization mode to control cost vs quality trade-offs.
+Run this command to view or set the optimization mode:
 
-## 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.
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-mode.js
+```
 
-**Step 4: Show confirmation**
+To set a specific mode, pass it as an argument:
 
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-mode.js balanced
 ```
-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
+Use the Bash tool to execute this command.
 
-Current mode: [mode]
-Run /plexor-status to see your savings.
-```
+**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
+- Read any files
+- Explore the codebase
+- Run additional commands
+- Ask follow-up questions
 
-**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.
+The command output is the complete response. Simply show the output and wait for the user's next input.

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

@@ -4,46 +4,24 @@ description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemin
 
 # Plexor Provider
 
-Set your preferred LLM provider for Plexor routing.
+Run this command to view or set the preferred provider:
 
-## 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.
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js
+```
 
-**Step 4: Show confirmation**
+To set a specific provider:
 
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js deepseek
 ```
-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
+Use the Bash tool to execute this command.
 
-Current provider: [preferredProvider]
-Run /plexor-status to see your usage.
-```
+**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
+- Read any files
+- Explore the codebase
+- Run additional commands
+- Ask follow-up questions
 
-**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.
+The command output is the complete response. Simply show the output and wait for the user's next input.

package/commands/plexor-settings.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Settings Command
+ * View and update Plexor configuration settings
+ */
+
+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 SETTING_KEYS = {
+  'api-url': 'apiUrl',
+  'apiurl': 'apiUrl',
+  'url': 'apiUrl',
+  'timeout': 'timeout',
+  'cache': 'localCacheEnabled',
+  'local-cache': 'localCacheEnabled'
+};
+
+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 parseValue(key, value) {
+  const normalizedKey = SETTING_KEYS[key.toLowerCase()] || key;
+
+  switch (normalizedKey) {
+    case 'localCacheEnabled':
+      return ['true', 'on', 'yes', '1'].includes(value.toLowerCase());
+    case 'timeout':
+      const num = parseInt(value, 10);
+      if (isNaN(num) || num < 1000 || num > 60000) {
+        throw new Error('Timeout must be between 1000-60000ms');
+      }
+      return num;
+    case 'apiUrl':
+      if (!value.startsWith('http://') && !value.startsWith('https://')) {
+        throw new Error('API URL must start with http:// or https://');
+      }
+      return value;
+    default:
+      return value;
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const settings = config.settings || {};
+
+  // No args - show current settings
+  if (args.length === 0) {
+    const enabled = settings.enabled ?? false;
+    const mode = settings.mode || 'balanced';
+    const provider = settings.preferred_provider || 'auto';
+    const apiUrl = settings.apiUrl || 'https://api.plexor.dev';
+    const timeout = settings.timeout || 5000;
+    const cache = settings.localCacheEnabled ?? false;
+    const hasApiKey = !!config.auth?.api_key;
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Settings                            │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Authentication                             │`);
+    console.log(`│  └── API Key: ${(hasApiKey ? 'Configured' : 'Not set').padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Proxy                                      │`);
+    console.log(`│  ├── Enabled: ${(enabled ? 'Yes' : 'No').padEnd(29)}│`);
+    console.log(`│  └── API URL: ${apiUrl.substring(0, 29).padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Optimization                               │`);
+    console.log(`│  ├── Mode: ${mode.padEnd(32)}│`);
+    console.log(`│  └── Provider: ${provider.padEnd(27)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Performance                                │`);
+    console.log(`│  ├── Local Cache: ${(cache ? 'Enabled' : 'Disabled').padEnd(24)}│`);
+    console.log(`│  └── Timeout: ${(timeout + 'ms').padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Modify settings:                           │`);
+    console.log(`│    /plexor-settings <key> <value>           │`);
+    console.log(`│                                             │`);
+    console.log(`│  Available keys:                            │`);
+    console.log(`│    api-url, timeout, cache                  │`);
+    console.log(`│                                             │`);
+    console.log(`│  Other commands:                            │`);
+    console.log(`│    /plexor-mode     - Set optimization mode │`);
+    console.log(`│    /plexor-provider - Set provider routing  │`);
+    console.log(`│    /plexor-enabled  - Enable/disable proxy  │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // Get setting
+  if (args.length === 1) {
+    const key = args[0].toLowerCase();
+    const normalizedKey = SETTING_KEYS[key] || key;
+    const value = settings[normalizedKey];
+
+    if (value === undefined) {
+      console.error(`Unknown setting: ${args[0]}`);
+      console.error(`Available: api-url, timeout, cache`);
+      process.exit(1);
+    }
+
+    console.log(`${normalizedKey}: ${value}`);
+    return;
+  }
+
+  // Set setting
+  const key = args[0].toLowerCase();
+  const normalizedKey = SETTING_KEYS[key];
+
+  if (!normalizedKey) {
+    console.error(`Unknown setting: ${args[0]}`);
+    console.error(`Available: api-url, timeout, cache`);
+    process.exit(1);
+  }
+
+  try {
+    const value = parseValue(key, args[1]);
+    const oldValue = settings[normalizedKey];
+
+    config.settings = config.settings || {};
+    config.settings[normalizedKey] = value;
+    saveConfig(config);
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✓ Setting Updated                          │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Key: ${normalizedKey.padEnd(37)}│`);
+    console.log(`│  Previous: ${String(oldValue ?? 'not set').substring(0, 32).padEnd(32)}│`);
+    console.log(`│  New: ${String(value).substring(0, 37).padEnd(37)}│`);
+    console.log(`└─────────────────────────────────────────────┘`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();