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

package/hooks/intercept.js

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Interception Hook - Phase 3 Hypervisor Architecture
+ *
+ * This script intercepts Claude Code requests before they reach the LLM.
+ *
+ * In HYPERVISOR MODE (ANTHROPIC_BASE_URL points to Plexor):
+ *   - All requests pass through unchanged
+ *   - Server handles all optimization, routing, and quality control
+ *   - Plugin just adds session tracking metadata
+ *   - This is the recommended setup for best user experience
+ *
+ * In PLUGIN MODE (direct to Anthropic):
+ *   - Plugin does local optimization (legacy behavior)
+ *   - Less reliable due to client-side state management
+ *
+ * Input: JSON object with messages, model, max_tokens, etc.
+ * Output: Passthrough (hypervisor mode) or optimized messages (plugin mode)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Generate a unique request ID for tracking.
+ * Format: pass_<timestamp>_<random> for passthrough requests
+ * This ensures every request can be tracked, even passthroughs.
+ * Issue #701: Missing request_id caused response tracking to fail.
+ */
+function generateRequestId(prefix = 'pass') {
+  const timestamp = Date.now().toString(36);
+  const random = crypto.randomBytes(4).toString('hex');
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// Try to load lib modules, fall back to inline implementations
+let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
+let config, session, cache, logger;
+
+try {
+  ConfigManager = require('../lib/config');
+  SessionManager = require('../lib/session');
+  LocalCache = require('../lib/cache');
+  Logger = require('../lib/logger');
+  PlexorClient = require('../lib/plexor-client');
+
+  config = new ConfigManager();
+  session = new SessionManager();
+  cache = new LocalCache();
+  logger = new Logger('intercept');
+} catch {
+  // Fallback inline implementations
+  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;
+
+  logger = {
+    debug: (msg) => process.env.PLEXOR_DEBUG && console.error(`[DEBUG] ${msg}`),
+    info: (msg) => console.error(msg),
+    error: (msg) => console.error(`[ERROR] ${msg}`)
+  };
+
+  config = {
+    load: async () => {
+      try {
+        const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+        const cfg = JSON.parse(data);
+        return {
+          enabled: cfg.settings?.enabled ?? false,
+          apiKey: cfg.auth?.api_key,
+          apiUrl: cfg.settings?.apiUrl || 'https://api.plexor.dev',
+          timeout: cfg.settings?.timeout || 5000,
+          localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
+          mode: cfg.settings?.mode || 'balanced'
+        };
+      } catch {
+        return { enabled: false };
+      }
+    }
+  };
+
+  const loadSession = () => {
+    try {
+      const data = fs.readFileSync(SESSION_PATH, 'utf8');
+      const s = JSON.parse(data);
+      if (Date.now() - s.last_activity > SESSION_TIMEOUT_MS) {
+        return createSession();
+      }
+      return s;
+    } catch {
+      return createSession();
+    }
+  };
+
+  const createSession = () => ({
+    session_id: `session_${Date.now()}`,
+    started_at: new Date().toISOString(),
+    last_activity: Date.now(),
+    requests: 0, optimizations: 0, cache_hits: 0,
+    original_tokens: 0, optimized_tokens: 0, tokens_saved: 0,
+    baseline_cost: 0, actual_cost: 0, cost_saved: 0
+  });
+
+  const saveSession = (s) => {
+    try {
+      const dir = path.dirname(SESSION_PATH);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      s.last_activity = Date.now();
+      fs.writeFileSync(SESSION_PATH, JSON.stringify(s, null, 2));
+    } catch {}
+  };
+
+  session = {
+    recordOptimization: (result) => {
+      const s = loadSession();
+      s.requests++; s.optimizations++;
+      s.original_tokens += result.original_tokens || 0;
+      s.optimized_tokens += result.optimized_tokens || 0;
+      s.tokens_saved += result.tokens_saved || 0;
+      s.baseline_cost += result.baseline_cost || 0;
+      s.actual_cost += result.estimated_cost || 0;
+      s.cost_saved += (result.baseline_cost || 0) - (result.estimated_cost || 0);
+      saveSession(s);
+    },
+    recordCacheHit: () => {
+      const s = loadSession(); s.requests++; s.cache_hits++; saveSession(s);
+    },
+    recordPassthrough: () => {
+      const s = loadSession(); s.requests++; saveSession(s);
+    }
+  };
+
+  cache = {
+    generateKey: (messages) => {
+      const str = JSON.stringify(messages);
+      let hash = 0;
+      for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash) + str.charCodeAt(i);
+        hash |= 0;
+      }
+      return `cache_${Math.abs(hash)}`;
+    },
+    get: async () => null,
+    setMetadata: async () => {}
+  };
+
+  PlexorClient = class {
+    constructor(opts) {
+      this.apiKey = opts.apiKey;
+      this.baseUrl = opts.baseUrl;
+      this.timeout = opts.timeout;
+    }
+    async optimize(params) {
+      const tokens = Math.round(JSON.stringify(params.messages).length / 4);
+      return {
+        request_id: `req_${Date.now()}`,
+        original_tokens: tokens,
+        optimized_tokens: Math.round(tokens * 0.7),
+        tokens_saved: Math.round(tokens * 0.3),
+        optimized_messages: params.messages,
+        recommended_provider: 'anthropic',
+        recommended_model: params.model,
+        estimated_cost: tokens * 0.00001,
+        baseline_cost: tokens * 0.00003
+      };
+    }
+  };
+}
+
+async function main() {
+  const startTime = Date.now();
+
+  let input;
+  let request;
+
+  try {
+    input = await readStdin();
+    request = JSON.parse(input);
+
+    // Phase 3 Hypervisor Mode Detection
+    // When ANTHROPIC_BASE_URL points to Plexor, all intelligence is server-side
+    // The plugin just passes through - server handles optimization, routing, quality
+    const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
+    const isHypervisorMode = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+
+    if (isHypervisorMode) {
+      // HYPERVISOR MODE: Server handles everything
+      // Just pass through with minimal metadata for session tracking
+      logger.debug('[Plexor] Hypervisor mode active - server handles all optimization');
+
+      // Add session tracking metadata (server will use this for analytics)
+      return output({
+        ...request,
+        _plexor_client: {
+          mode: 'hypervisor',
+          plugin_version: '0.1.0-beta.18',
+          cwd: process.cwd(),
+          timestamp: Date.now(),
+        }
+      });
+    }
+
+    // CRITICAL: Check for slash commands FIRST (before agentic check)
+    // Slash commands like /plexor-status should pass through unchanged
+    // Must check before isAgenticRequest since all Claude Code requests have tools
+    if (isSlashCommand(request)) {
+      logger.debug('Slash command detected, passing through unchanged');
+      session.recordPassthrough();
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          request_id: generateRequestId('slash'),  // Issue #701: Add request_id for tracking
+          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
+    // Azure CLI, AWS CLI, kubectl, etc. need tools to be preserved
+    if (requiresToolExecution(request)) {
+      logger.debug('CLI tool execution detected, passing through unchanged');
+      session.recordPassthrough();
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          request_id: generateRequestId('cli'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_cli',
+          reason: 'cli_tool_execution_detected',
+          cwd: process.cwd(),
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    // 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');
+      session.recordPassthrough();
+      return output({
+        ...request,
+        plexor_cwd: process.cwd(),
+        _plexor: {
+          request_id: generateRequestId('agent'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_agentic',
+          reason: 'tool_use_detected',
+          cwd: process.cwd(),
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    const settings = await config.load();
+
+    if (!settings.enabled) {
+      logger.debug('Plexor disabled, passing through');
+      session.recordPassthrough();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: generateRequestId('disabled'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_disabled',
+          reason: 'plexor_disabled',
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    if (!settings.apiKey) {
+      logger.info('Not authenticated. Run /plexor-login to enable optimization.');
+      session.recordPassthrough();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: generateRequestId('noauth'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_no_auth',
+          reason: 'not_authenticated',
+          latency_ms: Date.now() - startTime
+        }
+      });
+    }
+
+    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');
+      session.recordCacheHit();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: generateRequestId('cache'),  // Issue #701: Add request_id for tracking
+          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()
+    });
+
+    // Update session stats
+    session.recordOptimization(result);
+
+    return output(optimizedRequest);
+
+  } catch (error) {
+    logger.error(`[Plexor] Error: ${error.message}`);
+    logger.debug(error.stack);
+
+    const errorRequestId = generateRequestId('error');  // Issue #701: Add request_id for tracking
+
+    // Use already-parsed request if available, otherwise pass through raw
+    if (request) {
+      session.recordPassthrough();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: errorRequestId,
+          error: error.message,
+          source: 'passthrough_error'
+        }
+      });
+    } else if (input) {
+      // Try to parse the input we already read
+      try {
+        const req = JSON.parse(input);
+        session.recordPassthrough();
+        return output({
+          ...req,
+          _plexor: {
+            request_id: errorRequestId,
+            error: error.message,
+            source: 'passthrough_error'
+          }
+        });
+      } catch {
+        process.exit(1);
+      }
+    } else {
+      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;
+      }
+    }
+  }
+
+  // NOTE: Removed multi-turn check (Issue #701)
+  // Multi-turn conversations WITHOUT tool use are NOT agentic
+  // The old check caused normal conversations to be marked as agentic
+  // after just 2 assistant messages, leading to infinite loops
+
+  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);
+});