@plexor-dev/claude-code-plugin-staging 0.1.0-beta.1

package/commands/plexor-login.md

@@ -0,0 +1,27 @@
+---
+description: Authenticate with Plexor to enable optimization (user)
+---
+
+# Plexor Login
+
+Run this command to authenticate with Plexor:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js
+```
+
+To login with an API key:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js plx_your_api_key_here
+```
+
+Use the Bash tool to execute this command.
+
+**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
+
+The command output is the complete response. Simply show the output and wait for the user's next input.

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

@@ -0,0 +1,27 @@
+---
+description: Log out from Plexor and clear credentials (user)
+---
+
+# Plexor Logout
+
+Run this command to log out and clear credentials:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js
+```
+
+To also clear the cache:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js --clear-cache
+```
+
+Use the Bash tool to execute this command.
+
+**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
+
+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

@@ -0,0 +1,27 @@
+---
+description: Set Plexor optimization mode (eco/balanced/quality/passthrough) (user)
+---
+
+# Plexor Mode
+
+Run this command to view or set the optimization mode:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-mode.js
+```
+
+To set a specific mode, pass it as an argument:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-mode.js balanced
+```
+
+Use the Bash tool to execute this command.
+
+**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
+
+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

@@ -0,0 +1,27 @@
+---
+description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto) (user)
+---
+
+# Plexor Provider
+
+Run this command to view or set the preferred provider:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js
+```
+
+To set a specific provider:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js deepseek
+```
+
+Use the Bash tool to execute this command.
+
+**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
+
+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();

package/commands/plexor-settings.md

@@ -0,0 +1,28 @@
+---
+description: Configure Plexor settings (API URL, mode, provider preferences) (user)
+---
+
+# Plexor Settings
+
+Run this command to view or update settings:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js
+```
+
+To update a setting:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js cache true
+node ~/.claude/plugins/plexor/commands/plexor-settings.js timeout 10000
+```
+
+Use the Bash tool to execute this command.
+
+**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
+
+The command output is the complete response. Simply show the output and wait for the user's next input.