@plexor-dev/claude-code-plugin 0.1.0-beta.7 → 0.1.0-beta.9

package/commands/plexor-status.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Status Command
+ * Displays formatted status with usage statistics and ANSI colors
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+
+// ANSI color codes
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  bgBlue: '\x1b[44m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgGray: '\x1b[100m',
+};
+
+async function main() {
+  // Read config
+  let config;
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    config = JSON.parse(data);
+  } catch (err) {
+    console.log(`${c.yellow}Not configured.${c.reset} Run ${c.cyan}/plexor-login${c.reset} 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(`${c.yellow}Not authenticated.${c.reset} Run ${c.cyan}/plexor-login${c.reset} 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
+  }
+
+  // Extract data
+  const email = user.email || 'Unknown';
+  const tierName = (user.tier?.name || 'Free').charAt(0).toUpperCase() + (user.tier?.name || 'free').slice(1);
+  const monthlyOpts = user.tier?.limits?.monthly_optimizations || 10000;
+  const monthlyComps = user.tier?.limits?.monthly_completions || 100000;
+
+  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);
+
+  // Calculate usage percentages for progress bars
+  const optsUsed = summary.total_optimizations || 0;
+  const compsUsed = summary.total_completions || 0;
+  const optsPct = Math.min((optsUsed / monthlyOpts) * 100, 100);
+  const compsPct = Math.min((compsUsed / monthlyComps) * 100, 100);
+
+  // Progress bar renderer
+  const progressBar = (pct, width = 30) => {
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    const color = pct < 50 ? c.bgBlue : pct < 80 ? c.bgYellow : c.bgGreen;
+    return `${color}${' '.repeat(filled)}${c.reset}${c.bgGray}${' '.repeat(empty)}${c.reset}`;
+  };
+
+  const status = enabled ? `${c.green}● Active${c.reset}` : `${c.gray}○ Inactive${c.reset}`;
+  const optStatus = enabled ? `${c.green}Enabled${c.reset}` : `${c.gray}Disabled${c.reset}`;
+  const cacheStatus = localCache ? `${c.green}Enabled${c.reset}` : `${c.gray}Disabled${c.reset}`;
+  const cacheRate = formatPct((summary.cache_hit_rate || 0) * 100);
+
+  // Build dashboard URL
+  const dashboardUrl = apiUrl.replace('.api.', '.').replace('/api', '') + '/dashboard.html';
+
+  // Savings highlight
+  const savingsPct = summary.cost_saved_percent || 0;
+  const savingsColor = savingsPct > 50 ? c.green : savingsPct > 20 ? c.yellow : c.white;
+
+  console.log(`
+${c.bold}${c.cyan}Plexor Status${c.reset}
+
+${c.bold}Account${c.reset}
+  ${c.gray}Tier:${c.reset}   ${c.cyan}${tierName}${c.reset}
+  ${c.gray}Email:${c.reset}  ${email}
+  ${c.gray}Status:${c.reset} ${status}
+
+${c.bold}This Week${c.reset} ${c.dim}(${weekRange})${c.reset}
+  ${c.gray}Requests:${c.reset}         ${formatNum(summary.total_requests)}
+  ${c.gray}Original tokens:${c.reset}  ${formatNum(summary.original_tokens)}
+  ${c.gray}Optimized tokens:${c.reset} ${formatNum(summary.optimized_tokens)}
+  ${c.gray}Tokens saved:${c.reset}     ${c.green}${formatNum(summary.tokens_saved)}${c.reset} ${c.dim}(${formatPct(summary.tokens_saved_percent)}%)${c.reset}
+  ${c.gray}Baseline cost:${c.reset}    $${formatCost(summary.baseline_cost)}
+  ${c.gray}Actual cost:${c.reset}      $${formatCost(summary.total_cost)}
+  ${c.gray}Cost saved:${c.reset}       ${savingsColor}$${formatCost(summary.cost_saved)}${c.reset} ${c.dim}(${formatPct(savingsPct)}%)${c.reset}
+
+${c.bold}Usage Limits${c.reset}
+  ${c.gray}Optimizations${c.reset}
+  ${progressBar(optsPct)} ${formatPct(optsPct)}% used
+  ${c.dim}${formatNum(optsUsed)} / ${formatNum(monthlyOpts)} this month${c.reset}
+
+  ${c.gray}Completions${c.reset}
+  ${progressBar(compsPct)} ${formatPct(compsPct)}% used
+  ${c.dim}${formatNum(compsUsed)} / ${formatNum(monthlyComps)} this month${c.reset}
+
+${c.bold}Performance${c.reset}
+  ${c.gray}Cache hit rate:${c.reset} ${cacheRate}%
+
+${c.bold}Settings${c.reset}
+  ${c.gray}Optimization:${c.reset}     ${optStatus}
+  ${c.gray}Local cache:${c.reset}      ${cacheStatus}
+  ${c.gray}Mode:${c.reset}             ${c.cyan}${mode}${c.reset}
+  ${c.gray}Provider routing:${c.reset} ${c.cyan}${provider}${c.reset}
+
+${c.dim}Dashboard:${c.reset} ${c.blue}${dashboardUrl}${c.reset}
+`);
+}
+
+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(`${c.red}Error:${c.reset} ${err.message}`);
+  process.exit(1);
+});

package/commands/plexor-status.md

@@ -4,95 +4,21 @@ description: Show Plexor optimization statistics and savings (user)
 
 # Plexor Status
 
-Show current Plexor proxy status, configuration, and usage statistics.
+Display Plexor optimization statistics with colors and progress bars.
 
-## Steps
+## Instructions
 
-**Step 1: Read the configuration file**
+Run the status script and show its output:
 
-Use the Read tool to read the file `~/.plexor/config.json`. If the file doesn't exist, tell the user to run `/plexor-login` first.
-
-**Step 2: Parse configuration and check authentication**
-
-The config file contains:
-- `enabled`: boolean - whether Plexor proxy is enabled
-- `apiUrl`: string - the API URL (e.g., "https://api.plexor.dev")
-- `apiKey`: string - the user's API key (starts with "plx_")
-- `mode`: string - optimization mode ("eco", "balanced", "quality", "passthrough")
-- `preferredProvider`: string - provider preference ("auto", "claude", "openai", etc.)
-- `localCacheEnabled`: boolean - whether local caching is enabled
-
-If `apiKey` is missing or empty, tell the user to run `/plexor-login` first.
-
-**Step 3: Call the APIs**
-
-First, get user info:
-```
-GET {apiUrl}/v1/user
-X-Plexor-Key: {apiKey}
-```
-
-Then, get usage statistics:
-```
-GET {apiUrl}/v1/stats
-X-Plexor-Key: {apiKey}
-```
-
-The stats response contains:
-- `summary.total_requests`: number of requests
-- `summary.original_tokens`: tokens before optimization
-- `summary.optimized_tokens`: tokens after optimization
-- `summary.tokens_saved`: tokens saved
-- `summary.tokens_saved_percent`: percentage saved
-- `summary.baseline_cost`: cost without optimization
-- `summary.total_cost`: actual cost
-- `summary.cost_saved`: money saved
-- `summary.cost_saved_percent`: percentage saved
-- `summary.cache_hit_rate`: cache hit rate
-- `period.start` / `period.end`: date range
-
-**Step 4: Display the status**
-
-Show the user a formatted status display:
-
-```
-┌─────────────────────────────────────────────┐
-│  Plexor Status                              │
-├─────────────────────────────────────────────┤
-│  Account: [tier from /v1/user]              │
-│  Email: [email from /v1/user]               │
-│  Status: ● Active                           │
-├─────────────────────────────────────────────┤
-│  This Week ([period.start] - [period.end])  │
-│  ├── Requests: [total_requests]             │
-│  ├── Original tokens: [original_tokens]     │
-│  ├── Optimized tokens: [optimized_tokens]   │
-│  ├── Tokens saved: [tokens_saved] ([tokens_saved_percent]%) │
-│  ├── Baseline cost: $[baseline_cost]        │
-│  ├── Actual cost: $[total_cost]             │
-│  └── Cost saved: $[cost_saved] ([cost_saved_percent]%) │
-├─────────────────────────────────────────────┤
-│  Performance                                │
-│  └── Cache hit rate: [cache_hit_rate]%      │
-├─────────────────────────────────────────────┤
-│  Limits                                     │
-│  ├── Monthly optimizations: [from tier]     │
-│  └── Monthly completions: [from tier]       │
-├─────────────────────────────────────────────┤
-│  Settings                                   │
-│  ├── Optimization: [Enabled/Disabled]       │
-│  ├── Local cache: [Enabled/Disabled]        │
-│  ├── Mode: [mode]                           │
-│  └── Provider routing: [preferredProvider]  │
-└─────────────────────────────────────────────┘
-
-Dashboard: [apiUrl]/dashboard
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-status.js
 ```
 
-Notes:
-- Use "● Active" (green dot) if enabled, "○ Inactive" if disabled
-- Format token counts with commas (e.g., 46,700)
-- Format costs with 2 decimal places (e.g., $8.02)
-- Multiply cache_hit_rate by 100 for percentage display
+The script outputs colored terminal UI with:
+- Account info and status
+- Weekly usage statistics
+- Progress bars for usage limits
+- Cost savings breakdown
+- Current settings
 
-If the API call fails, show the configuration status and mention the API is unavailable.
+Do not add commentary - the script output is the complete response.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.9",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "scripts": {

package/lib/constants.js

@@ -1,40 +0,0 @@
-/**
- * Plexor Claude Code Plugin - Constants
- */
-
-const path = require('path');
-const os = require('os');
-
-module.exports = {
-  // API endpoints
-  PLEXOR_API_URL: process.env.PLEXOR_API_URL || 'https://api.plexor.dev',
-  PLEXOR_GATEWAY_URL: process.env.PLEXOR_GATEWAY_URL || 'https://api.plexor.dev/v1',
-  PLEXOR_AUTH_URL: 'https://plexor.dev/auth/device',
-
-  // File paths
-  PLEXOR_CONFIG_DIR: process.env.PLEXOR_CONFIG_DIR || path.join(os.homedir(), '.plexor'),
-  PLEXOR_CONFIG_FILE: path.join(
-    process.env.PLEXOR_CONFIG_DIR || path.join(os.homedir(), '.plexor'),
-    'config.json'
-  ),
-  CLAUDE_COMMANDS_DIR: path.join(os.homedir(), '.claude', 'commands'),
-
-  // Config schema version
-  CONFIG_VERSION: 1,
-
-  // Default settings
-  DEFAULTS: {
-    enabled: true,
-    preferred_provider: 'auto',
-    telemetry: true,
-    local_cache: false
-  },
-
-  // API key prefix for identification
-  API_KEY_PREFIX: 'plx_',
-
-  // Timeouts (ms)
-  DEVICE_CODE_POLL_INTERVAL: 5000,
-  DEVICE_CODE_TIMEOUT: 900000, // 15 minutes
-  API_TIMEOUT: 30000
-};