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

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

@@ -1,93 +1,60 @@
 ---
-description: Configure Plexor settings (API URL, mode, provider preferences)
+description: Configure Plexor settings (API URL, mode, provider preferences) (user)
 ---
 
 # Plexor Settings
 
-View and configure Plexor settings. Manages the connection to the Plexor API gateway.
+View and configure all Plexor settings.
 
-## Usage
+## Steps
 
-- `/plexor-settings` - Show current settings
-- `/plexor-settings api-url <url>` - Set the Plexor API URL
-- `/plexor-settings mode <eco|balanced|quality|passthrough>` - Set optimization mode
-- `/plexor-settings provider <auto|claude|openai|deepseek>` - Set provider preference
+**Step 1: Read current configuration**
 
-## Instructions
+Use the Read tool to read `~/.plexor/config.json`.
 
-1. Read ~/.plexor/config.json
-2. If no arguments, display current settings
-3. If setting a value, update the config file
-4. For api-url changes, remind user to set ANTHROPIC_BASE_URL
-
-## Config File Location
-
-~/.plexor/config.json
-
-## Config Schema
-
-```json
-{
-  "enabled": true,
-  "apiUrl": "http://localhost:8000",
-  "apiKey": "plx_...",
-  "mode": "balanced",
-  "preferredProvider": "auto",
-  "localCacheEnabled": true,
-  "timeout": 5000
-}
+If the file doesn't exist, show:
+```
+Plexor Settings
+===============
+No configuration found. Run /plexor-login to set up Plexor.
 ```
 
-## API URL Values
-
-- **Development**: `http://localhost:8000`
-- **Production**: `https://api.plexor.dev` (default)
+**Step 2: Display current settings**
 
-## Output Examples
+Show the current configuration:
 
-### Show settings:
-```
-┌─────────────────────────────────────────────┐
-│  Plexor Settings                            │
-├─────────────────────────────────────────────┤
-│  API URL: http://localhost:8000             │
-│  Mode: balanced                             │
-│  Provider: auto                             │
-│  Local Cache: enabled                       │
-│  Timeout: 5000ms                            │
-├─────────────────────────────────────────────┤
-│  Proxy Status: NOT ACTIVE                   │
-│                                             │
-│  To activate proxy, run:                    │
-│  export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"
-│  claude --continue                          │
-└─────────────────────────────────────────────┘
 ```
+Plexor Settings
+===============
+Enabled: [enabled - true/false]
+API URL: [apiUrl]
+API Key: plx_****[last 4 chars] (configured/not configured)
+Mode: [mode]
+Provider: [preferredProvider]
+Local Cache: [localCacheEnabled - enabled/disabled]
+Timeout: [timeout]ms
 
-### Set API URL:
-```
-/plexor-settings api-url http://localhost:8000
-```
+Quick Commands:
+- /plexor-enabled - Toggle proxy on/off
+- /plexor-mode - Change optimization mode
+- /plexor-provider - Change provider preference
+- /plexor-status - View usage statistics
 
-Output:
+Dashboard: https://plexor.dev/dashboard
 ```
-✓ API URL set to: http://localhost:8000
 
-To route all traffic through Plexor, run:
-  export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"
-  claude --continue
-```
+**Step 3: If user wants to change a setting**
 
-### Set API URL (production):
-```
-/plexor-settings api-url https://api.plexor.dev
-```
+If the user specifies they want to change something, use the `AskUserQuestion` tool:
 
-Output:
-```
-✓ API URL set to: https://api.plexor.dev
+Question: "Which setting would you like to change?"
+Header: "Setting"
+Options:
+1. **API URL** - Change the Plexor API endpoint
+2. **Mode** - Change optimization mode (eco/balanced/quality)
+3. **Provider** - Change preferred provider
+4. **Timeout** - Change request timeout
 
-To route all traffic through Plexor, run:
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/v1/gateway/anthropic"
-  claude --continue
-```
+Then update `~/.plexor/config.json` with the new value using the Write tool.
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-setup.md

@@ -0,0 +1,134 @@
+---
+description: First-time setup wizard for Plexor with Claude Code (user)
+---
+
+# Plexor Setup Wizard
+
+Guide users through first-time Plexor setup, handling both Claude MAX subscribers and API key users.
+
+## Steps
+
+**Step 1: Check if already configured**
+
+Use the Read tool to check if `~/.plexor/config.json` exists and has valid configuration.
+
+If configured, show:
+```
+Plexor Setup
+============
+Already configured!
+
+API URL: [apiUrl from config]
+Mode: [mode from config]
+Status: [Enabled/Disabled]
+
+Run /plexor-status to see your usage.
+Run /plexor-settings to modify configuration.
+```
+
+**Step 2: Ask about Claude MAX subscription**
+
+Use the AskUserQuestion tool:
+
+Question: "Do you have a Claude MAX subscription (Pro/Team/Enterprise)?"
+Header: "Subscription"
+Options:
+1. **Yes, I have Claude MAX** - I'm already logged into Claude Code with OAuth
+2. **No, I'll use a Plexor API key** - I want to use Plexor's provider routing
+
+**Step 3A: Claude MAX User Setup**
+
+If user selected "Yes, I have Claude MAX":
+
+1. Use the Write tool to create `~/.plexor/config.json`:
+```json
+{
+  "version": 1,
+  "auth": {
+    "mode": "oauth_passthrough",
+    "authenticated_at": "[current ISO timestamp]"
+  },
+  "settings": {
+    "enabled": true,
+    "apiUrl": "https://api.plexor.dev",
+    "mode": "balanced",
+    "localCacheEnabled": true
+  }
+}
+```
+
+2. Show the user:
+```
+Plexor Setup - Claude MAX User
+==============================
+Your Claude MAX subscription will be used with Plexor optimization.
+
+Add this to your shell profile (~/.bashrc or ~/.zshrc):
+
+  export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"
+
+Then restart your terminal or run: source ~/.bashrc
+
+How it works:
+- Claude Code sends your OAuth token through Plexor
+- Plexor optimizes prompts and tracks usage
+- You keep your MAX benefits ($0 cost, 20x rate limits)
+
+Run /plexor-status to verify setup.
+```
+
+**Step 3B: API Key User Setup**
+
+If user selected "No, I'll use a Plexor API key":
+
+1. Ask for their Plexor API key:
+   "Please provide your Plexor API key (starts with 'plx_')."
+   "Get one at: https://plexor.dev/dashboard"
+
+2. Once they provide the key, use the Write tool to create `~/.plexor/config.json`:
+```json
+{
+  "version": 1,
+  "auth": {
+    "api_key": "[user's API key]",
+    "mode": "api_key",
+    "authenticated_at": "[current ISO timestamp]"
+  },
+  "settings": {
+    "enabled": true,
+    "apiUrl": "https://api.plexor.dev",
+    "preferred_provider": "auto",
+    "mode": "balanced",
+    "localCacheEnabled": true
+  }
+}
+```
+
+3. Show the user:
+```
+Plexor Setup - API Key User
+===========================
+Your Plexor API key has been configured.
+
+Add these lines to your shell profile (~/.bashrc or ~/.zshrc):
+
+  export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"
+  export ANTHROPIC_API_KEY="[their plexor key]"
+
+Then restart your terminal or run: source ~/.bashrc
+
+How it works:
+- Requests route through Plexor gateway
+- Plexor picks the best provider (can save up to 90%)
+- Your Plexor key goes in ANTHROPIC_API_KEY (this is correct!)
+
+Run /plexor-status to verify setup.
+```
+
+**Step 4: Offer to auto-configure shell (optional)**
+
+Ask: "Would you like me to add this to your shell profile automatically?"
+
+If yes, use the Edit tool to append the export lines to `~/.bashrc` (or `~/.zshrc` if it exists).
+
+**IMPORTANT**: After completing setup, STOP. Do not run additional commands.

package/commands/plexor-status.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Status Command
+ * Displays formatted status with usage statistics
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const SESSION_PATH = path.join(process.env.HOME, '.plexor', 'session.json');
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+function loadSessionStats() {
+  try {
+    const data = fs.readFileSync(SESSION_PATH, 'utf8');
+    const session = JSON.parse(data);
+    // Check if session has expired
+    if (Date.now() - session.last_activity > SESSION_TIMEOUT_MS) {
+      return null;
+    }
+    return session;
+  } catch {
+    return null;
+  }
+}
+
+async function main() {
+  // Read config
+  let config;
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    config = JSON.parse(data);
+  } catch (err) {
+    console.log('Not configured. Run /plexor-login first.');
+    process.exit(1);
+  }
+
+  const apiKey = config.auth?.api_key;
+  const enabled = config.settings?.enabled ?? false;
+  const mode = config.settings?.mode || 'balanced';
+  const provider = config.settings?.preferred_provider || 'auto';
+  const localCache = config.settings?.localCacheEnabled ?? false;
+  const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
+
+  if (!apiKey) {
+    console.log('Not authenticated. Run /plexor-login first.');
+    process.exit(1);
+  }
+
+  // Fetch user info and stats
+  let user = { email: 'Unknown', tier: { name: 'Free', limits: {} } };
+  let stats = { period: {}, summary: {} };
+
+  try {
+    [user, stats] = await Promise.all([
+      fetchJson(apiUrl, '/v1/user', apiKey),
+      fetchJson(apiUrl, '/v1/stats', apiKey)
+    ]);
+  } catch (err) {
+    // Continue with defaults if API fails
+  }
+
+  // Load session stats
+  const session = loadSessionStats();
+
+  // Extract data
+  const email = user.email || 'Unknown';
+  const tierName = user.tier?.name || 'Free';
+  const monthlyOpts = user.tier?.limits?.monthly_optimizations || '∞';
+  const monthlyComps = user.tier?.limits?.monthly_completions || '∞';
+
+  const period = stats.period || {};
+  const summary = stats.summary || {};
+
+  const formatDate = (iso) => {
+    if (!iso) return '?';
+    const d = new Date(iso);
+    return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  };
+  const weekRange = `${formatDate(period.start)} - ${formatDate(period.end)}`;
+
+  // Format numbers
+  const formatNum = (n) => (n || 0).toLocaleString();
+  const formatPct = (n) => (n || 0).toFixed(1);
+  const formatCost = (n) => (n || 0).toFixed(2);
+
+  const status = enabled ? '● Active' : '○ Inactive';
+  const optEnabled = enabled ? 'Enabled' : 'Disabled';
+  const cacheEnabled = localCache ? 'Enabled' : 'Disabled';
+  const cacheRate = formatPct((summary.cache_hit_rate || 0) * 100);
+
+  // Build dashboard URL from API URL
+  // API: https://api.plexor.dev or https://staging.api.plexor.dev
+  // Dashboard: https://plexor.dev/dashboard or https://staging.plexor.dev/dashboard
+  let dashboardUrl = 'https://plexor.dev/dashboard';
+  try {
+    const url = new URL(apiUrl);
+    // Remove 'api.' prefix from hostname if present
+    const host = url.hostname.replace(/^api\./, '').replace(/\.api\./, '.');
+    dashboardUrl = `${url.protocol}//${host}/dashboard`;
+  } catch {
+    // If URL parsing fails, use default
+  }
+
+  // Output formatted status - each line is exactly 43 chars inner width
+  const line = (content) => `  │  ${content.padEnd(43)}│`;
+
+  // Session stats formatting
+  const formatDuration = (startedAt) => {
+    if (!startedAt) return '0m';
+    const elapsed = Date.now() - new Date(startedAt).getTime();
+    const minutes = Math.floor(elapsed / 60000);
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+  };
+
+  const sessionDuration = session ? formatDuration(session.started_at) : '0m';
+  const sessionRequests = session ? formatNum(session.requests) : '0';
+  const sessionOptimizations = session ? formatNum(session.optimizations) : '0';
+  const sessionCacheHits = session ? formatNum(session.cache_hits) : '0';
+  const sessionTokensSaved = session ? formatNum(session.tokens_saved) : '0';
+  const sessionTokensSavedPct = session && session.original_tokens > 0
+    ? formatPct((session.tokens_saved / session.original_tokens) * 100)
+    : '0.0';
+  const sessionCostSaved = session ? formatCost(session.cost_saved) : '0.00';
+
+  // Build session section (only show if session exists)
+  const sessionSection = session ? `  ├─────────────────────────────────────────────┤
+${line(`This Session (${sessionDuration})`)}
+${line(`├── Requests: ${sessionRequests}`)}
+${line(`├── Optimizations: ${sessionOptimizations}`)}
+${line(`├── Cache hits: ${sessionCacheHits}`)}
+${line(`├── Tokens saved: ${sessionTokensSaved} (${sessionTokensSavedPct}%)`)}
+${line(`└── Cost saved: $${sessionCostSaved}`)}
+` : '';
+
+  console.log(`  ┌─────────────────────────────────────────────┐
+${line('Plexor Status')}
+  ├─────────────────────────────────────────────┤
+${line(`Account: ${tierName}`)}
+${line(`Email: ${email}`)}
+${line(`Status: ${status}`)}
+${sessionSection}  ├─────────────────────────────────────────────┤
+${line(`This Week (${weekRange})`)}
+${line(`├── Requests: ${formatNum(summary.total_requests)}`)}
+${line(`├── Original tokens: ${formatNum(summary.original_tokens)}`)}
+${line(`├── Optimized tokens: ${formatNum(summary.optimized_tokens)}`)}
+${line(`├── Tokens saved: ${formatNum(summary.tokens_saved)} (${formatPct(summary.tokens_saved_percent)}%)`)}
+${line(`├── Baseline cost: $${formatCost(summary.baseline_cost)}`)}
+${line(`├── Actual cost: $${formatCost(summary.total_cost)}`)}
+${line(`└── Cost saved: $${formatCost(summary.cost_saved)} (${formatPct(summary.cost_saved_percent)}%)`)}
+  ├─────────────────────────────────────────────┤
+${line('Performance')}
+${line(`└── Cache hit rate: ${cacheRate}%`)}
+  ├─────────────────────────────────────────────┤
+${line('Limits')}
+${line(`├── Monthly optimizations: ${formatNum(monthlyOpts)}`)}
+${line(`└── Monthly completions: ${formatNum(monthlyComps)}`)}
+  ├─────────────────────────────────────────────┤
+${line('Settings')}
+${line(`├── Optimization: ${optEnabled}`)}
+${line(`├── Local cache: ${cacheEnabled}`)}
+${line(`├── Mode: ${mode}`)}
+${line(`└── Provider routing: ${provider}`)}
+  └─────────────────────────────────────────────┘
+
+  Dashboard: ${dashboardUrl}
+`);
+}
+
+function fetchJson(apiUrl, endpoint, apiKey) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(`${apiUrl}${endpoint}`);
+
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method: 'GET',
+      headers: {
+        'X-Plexor-Key': apiKey
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error('Invalid response'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(5000, () => {
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+    req.end();
+  });
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});