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

package/commands/plexor-status.js

@@ -0,0 +1,154 @@
+#!/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');
+
+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
+  }
+
+  // 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
+  const dashboardUrl = apiUrl.replace('.api.', '.').replace('/api', '') + '/dashboard.html';
+
+  // Output formatted status - each line is exactly 43 chars inner width
+  const line = (content) => `  │  ${content.padEnd(43)}│`;
+
+  console.log(`  ┌─────────────────────────────────────────────┐
+${line('Plexor Status')}
+  ├─────────────────────────────────────────────┤
+${line(`Account: ${tierName}`)}
+${line(`Email: ${email}`)}
+${line(`Status: ${status}`)}
+  ├─────────────────────────────────────────────┤
+${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);
+});

package/commands/plexor-status.md

@@ -1,46 +1,59 @@
 ---
-description: Show Plexor optimization statistics and savings
+description: Show Plexor optimization statistics and savings (user)
 ---
 
 # Plexor Status
 
-Display current Plexor status, configuration, and usage statistics.
+Display Plexor optimization statistics in a clean, professional format.
 
 ## Instructions
 
-1. Read the Plexor configuration from ~/.plexor/config.json
-2. If not authenticated, show a message to run /plexor-login
-3. If authenticated, call the Plexor API to get usage stats
-4. Display a formatted summary including:
-   - Account status (Free/Pro/Team)
-   - This session: requests optimized, tokens saved, estimated savings
-   - This week: total requests, total tokens saved, total savings
-   - Current settings: optimization enabled, local cache status
-
-## Output Format
+1. Read `~/.plexor/config.json` to get settings and API key
+2. Call the Plexor APIs to get user info and stats:
+   - `GET {apiUrl}/v1/user` with header `X-Plexor-Key: {api_key}`
+   - `GET {apiUrl}/v1/stats` with header `X-Plexor-Key: {api_key}`
+3. Output the formatted status box directly as text (not in a code block):
 
 ```
-┌─────────────────────────────────────────────┐
-│  Plexor Status                              │
-├─────────────────────────────────────────────┤
-│  Account: Pro ($19/mo)                      │
-│  Status: ● Active                           │
-├─────────────────────────────────────────────┤
-│  This Session                               │
-│  ├── Requests: 47                           │
-│  ├── Tokens saved: 12,847 (31%)             │
-│  └── Est. savings: $0.42                    │
-├─────────────────────────────────────────────┤
-│  This Week                                  │
-│  ├── Requests: 1,247                        │
-│  ├── Tokens saved: 482,938 (34%)            │
-│  └── Est. savings: $14.23                   │
-├─────────────────────────────────────────────┤
-│  Settings                                   │
-│  ├── Optimization: Enabled                  │
-│  ├── Local cache: Enabled                   │
-│  └── Provider routing: DeepSeek preferred   │
-└─────────────────────────────────────────────┘
+  ┌─────────────────────────────────────────────┐
+  │  Plexor Status                              │
+  ├─────────────────────────────────────────────┤
+  │  Account: {tier.name}                       │
+  │  Email: {email}                             │
+  │  Status: ● Active                           │
+  ├─────────────────────────────────────────────┤
+  │  This Week ({period.start} - {period.end})  │
+  │  ├── Requests: {total_requests}             │
+  │  ├── Original tokens: {original_tokens}     │
+  │  ├── Optimized tokens: {optimized_tokens}   │
+  │  ├── Tokens saved: {tokens_saved} ({%})     │
+  │  ├── Baseline cost: ${baseline_cost}        │
+  │  ├── Actual cost: ${total_cost}             │
+  │  └── Cost saved: ${cost_saved} ({%})        │
+  ├─────────────────────────────────────────────┤
+  │  Performance                                │
+  │  └── Cache hit rate: {cache_hit_rate}%      │
+  ├─────────────────────────────────────────────┤
+  │  Limits                                     │
+  │  ├── Monthly optimizations: {limit}         │
+  │  └── Monthly completions: {limit}           │
+  ├─────────────────────────────────────────────┤
+  │  Settings                                   │
+  │  ├── Optimization: {Enabled/Disabled}       │
+  │  ├── Local cache: {Enabled/Disabled}        │
+  │  ├── Mode: {mode}                           │
+  │  └── Provider routing: {provider}           │
+  └─────────────────────────────────────────────┘
 
-Dashboard: https://plexor.dev/dashboard
+  Dashboard: {dashboard_url}
 ```
+
+IMPORTANT:
+- Output ONLY the status box as plain text, exactly as shown above
+- Do NOT wrap in markdown code blocks
+- Do NOT add any commentary before or after
+- Format numbers with commas (e.g., 50,000)
+- Format costs with 2 decimals (e.g., $4.50)
+- Format dates as "Mon D" (e.g., "Jan 7")
+- Use "● Active" if enabled, "○ Inactive" if disabled
+- Multiply cache_hit_rate by 100 for percentage

package/hooks/intercept.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Interception Hook
+ *
+ * This script intercepts Claude Code prompts before they are sent to the LLM.
+ * It optimizes the prompt and optionally routes to a cheaper provider.
+ *
+ * Input: JSON object with messages, model, max_tokens, etc.
+ * Output: Modified JSON object with optimized messages
+ */
+
+const PlexorClient = require('../lib/plexor-client');
+const ConfigManager = require('../lib/config');
+const LocalCache = require('../lib/cache');
+const Logger = require('../lib/logger');
+
+const logger = new Logger('intercept');
+const config = new ConfigManager();
+const cache = new LocalCache();
+
+async function main() {
+  const startTime = Date.now();
+
+  try {
+    const input = await readStdin();
+    const request = JSON.parse(input);
+
+    // CRITICAL: Skip optimization for agentic/tool-using requests
+    // Modifying messages breaks the agent loop and causes infinite loops
+    if (isAgenticRequest(request)) {
+      logger.debug('Agentic request detected, passing through unchanged');
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          source: 'passthrough_agentic',
+          reason: 'tool_use_detected',
+          cwd: process.cwd(),
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    // CRITICAL: Skip optimization for slash commands (Issue #683)
+    // Slash commands like /plexor-status should pass through unchanged
+    if (isSlashCommand(request)) {
+      logger.debug('Slash command detected, passing through unchanged');
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          source: 'passthrough_slash_command',
+          reason: 'slash_command_detected',
+          cwd: process.cwd(),
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    // CRITICAL: Skip optimization for CLI commands requiring tool execution (Issue #683)
+    // Azure CLI, AWS CLI, kubectl, etc. need tools to be preserved
+    if (requiresToolExecution(request)) {
+      logger.debug('CLI tool execution detected, passing through unchanged');
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          source: 'passthrough_cli',
+          reason: 'cli_tool_execution_detected',
+          cwd: process.cwd(),
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    const settings = await config.load();
+
+    if (!settings.enabled) {
+      logger.debug('Plexor disabled, passing through');
+      return output(request);
+    }
+
+    if (!settings.apiKey) {
+      logger.info('Not authenticated. Run /plexor-login to enable optimization.');
+      return output(request);
+    }
+
+    const client = new PlexorClient({
+      apiKey: settings.apiKey,
+      baseUrl: settings.apiUrl || 'https://api.plexor.dev',
+      timeout: settings.timeout || 5000
+    });
+
+    const messages = extractMessages(request);
+    const model = request.model || 'claude-sonnet-4-20250514';
+    const maxTokens = request.max_tokens || 4096;
+
+    const cacheKey = cache.generateKey(messages);
+    const cachedResponse = await cache.get(cacheKey);
+
+    if (cachedResponse && settings.localCacheEnabled) {
+      logger.info('[Plexor] Local cache hit');
+      return output({
+        ...request,
+        _plexor: {
+          source: 'local_cache',
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    logger.debug('Calling Plexor API...');
+
+    const result = await client.optimize({
+      messages: messages,
+      model: model,
+      max_tokens: maxTokens,
+      task_hint: detectTaskType(messages),
+      context: {
+        session_id: request._session_id,
+        turn_number: request._turn_number,
+        cwd: process.cwd()
+      }
+    });
+
+    const savingsPercent = ((result.original_tokens - result.optimized_tokens) / result.original_tokens * 100).toFixed(1);
+
+    logger.info(`[Plexor] Optimized: ${result.original_tokens} → ${result.optimized_tokens} tokens (${savingsPercent}% saved)`);
+
+    if (result.recommended_provider !== 'anthropic') {
+      logger.info(`[Plexor] Recommended: ${result.recommended_provider} (~$${result.estimated_cost.toFixed(4)})`);
+    }
+
+    const optimizedRequest = {
+      ...request,
+      messages: result.optimized_messages,
+      plexor_cwd: process.cwd(),
+      _plexor: {
+        request_id: result.request_id,
+        original_tokens: result.original_tokens,
+        optimized_tokens: result.optimized_tokens,
+        tokens_saved: result.tokens_saved,
+        savings_percent: parseFloat(savingsPercent),
+        recommended_provider: result.recommended_provider,
+        recommended_model: result.recommended_model,
+        estimated_cost: result.estimated_cost,
+        baseline_cost: result.baseline_cost,
+        latency_ms: Date.now() - startTime,
+        source: 'plexor_api',
+        cwd: process.cwd()
+      }
+    };
+
+    await cache.setMetadata(result.request_id, {
+      original_tokens: result.original_tokens,
+      optimized_tokens: result.optimized_tokens,
+      recommended_provider: result.recommended_provider,
+      timestamp: Date.now()
+    });
+
+    return output(optimizedRequest);
+
+  } catch (error) {
+    logger.error(`[Plexor] Error: ${error.message}`);
+    logger.debug(error.stack);
+
+    try {
+      const input = await readStdin();
+      const request = JSON.parse(input);
+      return output({
+        ...request,
+        _plexor: {
+          error: error.message,
+          source: 'passthrough'
+        }
+      });
+    } catch {
+      process.exit(1);
+    }
+  }
+}
+
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+
+    process.stdin.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+
+    process.stdin.on('end', () => {
+      resolve(Buffer.concat(chunks).toString('utf8'));
+    });
+
+    process.stdin.on('error', reject);
+
+    setTimeout(() => {
+      reject(new Error('Stdin read timeout'));
+    }, 5000);
+  });
+}
+
+function output(data) {
+  const json = JSON.stringify(data);
+  process.stdout.write(json);
+  process.exit(0);
+}
+
+function extractMessages(request) {
+  if (Array.isArray(request.messages)) {
+    return request.messages;
+  }
+
+  if (request.prompt) {
+    return [{ role: 'user', content: request.prompt }];
+  }
+
+  if (request.system && request.user) {
+    return [
+      { role: 'system', content: request.system },
+      { role: 'user', content: request.user }
+    ];
+  }
+
+  return [];
+}
+
+function detectTaskType(messages) {
+  if (!messages || messages.length === 0) {
+    return 'general';
+  }
+
+  const lastUserMessage = [...messages]
+    .reverse()
+    .find(m => m.role === 'user');
+
+  if (!lastUserMessage) {
+    return 'general';
+  }
+
+  const content = lastUserMessage.content.toLowerCase();
+
+  if (/```|function|class|import|export|const |let |var |def |async |await/.test(content)) {
+    return 'code_generation';
+  }
+
+  if (/test|spec|jest|pytest|unittest|describe\(|it\(|expect\(/.test(content)) {
+    return 'test_generation';
+  }
+
+  if (/fix|bug|error|issue|debug|trace|exception|crash/.test(content)) {
+    return 'debugging';
+  }
+
+  if (/refactor|improve|optimize|clean|restructure/.test(content)) {
+    return 'refactoring';
+  }
+
+  if (/document|readme|comment|explain|docstring/.test(content)) {
+    return 'documentation';
+  }
+
+  if (/review|check|audit|assess|evaluate/.test(content)) {
+    return 'code_review';
+  }
+
+  if (/analyze|understand|what does|how does|explain/.test(content)) {
+    return 'analysis';
+  }
+
+  return 'general';
+}
+
+/**
+ * Detect if this is an agentic/tool-using request that should not be optimized.
+ * Modifying messages in agent loops breaks the loop detection and causes infinite loops.
+ */
+function isAgenticRequest(request) {
+  // Check if request has tools defined
+  if (request.tools && request.tools.length > 0) {
+    return true;
+  }
+
+  // Check if any message contains tool use or tool results
+  const messages = request.messages || [];
+  for (const msg of messages) {
+    // Tool use in content (Claude format)
+    if (msg.content && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'tool_use' || block.type === 'tool_result') {
+          return true;
+        }
+      }
+    }
+
+    // Tool role (OpenAI format)
+    if (msg.role === 'tool') {
+      return true;
+    }
+
+    // Function call (OpenAI format)
+    if (msg.function_call || msg.tool_calls) {
+      return true;
+    }
+  }
+
+  // Check for assistant messages with tool indicators
+  for (const msg of messages) {
+    if (msg.role === 'assistant' && msg.content) {
+      const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+      // Detect common tool use patterns in Claude Code
+      if (/\[Bash\]|\[Read\]|\[Write\]|\[Edit\]|\[Glob\]|\[Grep\]/.test(content)) {
+        return true;
+      }
+    }
+  }
+
+  // Check for multi-turn conversations (likely agentic)
+  const assistantMessages = messages.filter(m => m.role === 'assistant');
+  if (assistantMessages.length > 2) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Detect if this is a slash command request that should not be optimized.
+ * Slash commands like /plexor-status need to pass through unchanged.
+ */
+function isSlashCommand(request) {
+  const messages = request.messages || [];
+
+  // Check the last user message for slash command patterns
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === 'user') {
+      const content = typeof msg.content === 'string' ? msg.content : '';
+      // Detect slash commands at the start of user message
+      if (/^\/[a-z-]+/i.test(content.trim())) {
+        return true;
+      }
+      // Detect <command-name> tags (Claude Code skill invocation)
+      if (/<command-name>/.test(content)) {
+        return true;
+      }
+      // Detect plexor-related commands
+      if (/plexor-(?:status|login|logout|mode|provider|enabled|settings)/i.test(content)) {
+        return true;
+      }
+      break; // Only check last user message
+    }
+  }
+
+  // Check for system messages with skill instructions
+  for (const msg of messages) {
+    if (msg.role === 'system') {
+      const content = typeof msg.content === 'string' ? msg.content : '';
+      if (/# Plexor (?:Status|Login|Logout|Mode|Provider|Enabled|Settings)/i.test(content)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detect if this request involves CLI/shell commands that need tool execution.
+ * These should pass through to ensure proper tool calling behavior.
+ */
+function requiresToolExecution(request) {
+  const messages = request.messages || [];
+
+  // Check user messages for CLI command patterns
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      const content = typeof msg.content === 'string' ? msg.content : '';
+      const contentLower = content.toLowerCase();
+
+      // Azure CLI patterns
+      if (/\baz\s+(login|logout|group|account|vm|storage|webapp|aks|acr|keyvault|sql|cosmos|network)/i.test(content)) {
+        return true;
+      }
+
+      // Common CLI execution requests
+      if (/\b(run|execute|show|list|create|delete|update)\b.*\b(az|aws|gcloud|kubectl|docker|npm|git)\b/i.test(content)) {
+        return true;
+      }
+
+      // Direct command patterns
+      if (/^(az|aws|gcloud|kubectl|docker|npm|yarn|pip|cargo|go)\s+/m.test(content)) {
+        return true;
+      }
+
+      // Imperative CLI requests
+      if (/\b(list|show|get|describe)\s+(resource\s*groups?|rgs?|vms?|instances?|clusters?|pods?|containers?)/i.test(content)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+main().catch((error) => {
+  console.error(`[Plexor] Fatal error: ${error.message}`);
+  process.exit(1);
+});