@plexor-dev/claude-code-plugin 0.1.0-beta.15 → 0.1.0-beta.17

package/hooks/intercept.js

@@ -12,146 +12,152 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 
-// Inline implementations to avoid missing module errors
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const SESSION_PATH = path.join(process.env.HOME, '.plexor', 'session.json');
+/**
+ * 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}`;
+}
 
-const logger = {
-  debug: (msg) => process.env.PLEXOR_DEBUG && console.error(`[DEBUG] ${msg}`),
-  info: (msg) => console.error(msg),
-  error: (msg) => console.error(`[ERROR] ${msg}`)
-};
+// 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}`)
+  };
 
-const 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 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;
+  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 };
+      }
     }
-    return `cache_${hash}`;
-  },
-  get: async () => null,
-  setMetadata: async () => {}
-};
-
-// Session stats tracking
-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 createNewSession();
+  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();
     }
-    return session;
-  } catch {
-    return createNewSession();
-  }
-}
+  };
 
-function createNewSession() {
-  return {
+  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
+    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 {}
   };
-}
 
-function saveSessionStats(session) {
-  try {
-    const dir = path.dirname(SESSION_PATH);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+  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);
     }
-    session.last_activity = Date.now();
-    fs.writeFileSync(SESSION_PATH, JSON.stringify(session, null, 2));
-  } catch (err) {
-    logger.debug(`Failed to save session stats: ${err.message}`);
-  }
-}
-
-function updateSessionStats(result) {
-  const session = loadSessionStats();
-  session.requests++;
-  session.optimizations++;
-  session.original_tokens += result.original_tokens || 0;
-  session.optimized_tokens += result.optimized_tokens || 0;
-  session.tokens_saved += result.tokens_saved || 0;
-  session.baseline_cost += result.baseline_cost || 0;
-  session.actual_cost += result.estimated_cost || 0;
-  session.cost_saved += (result.baseline_cost || 0) - (result.estimated_cost || 0);
-  saveSessionStats(session);
-}
-
-function recordCacheHit() {
-  const session = loadSessionStats();
-  session.requests++;
-  session.cache_hits++;
-  saveSessionStats(session);
-}
-
-function recordPassthrough() {
-  const session = loadSessionStats();
-  session.requests++;
-  saveSessionStats(session);
-}
+  };
 
-// Placeholder PlexorClient
-class PlexorClient {
-  constructor(opts) {
-    this.apiKey = opts.apiKey;
-    this.baseUrl = opts.baseUrl;
-    this.timeout = opts.timeout;
-  }
+  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 () => {}
+  };
 
-  async optimize(params) {
-    // Return passthrough result - real API call would go here
-    const tokens = JSON.stringify(params.messages).length / 4;
-    return {
-      request_id: `req_${Date.now()}`,
-      original_tokens: Math.round(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
-    };
-  }
+  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() {
@@ -169,6 +175,8 @@ async function main() {
     const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
     if (baseUrl.includes('plexor')) {
       logger.debug('Plexor proxy detected via ANTHROPIC_BASE_URL, passing through');
+      // Note: Don't add _plexor metadata here - the proxy will add its own
+      // This passthrough is transparent to avoid double-processing
       return output(request);
     }
 
@@ -177,11 +185,12 @@ async function main() {
     // Must check before isAgenticRequest since all Claude Code requests have tools
     if (isSlashCommand(request)) {
       logger.debug('Slash command detected, passing through unchanged');
-      recordPassthrough();
+      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(),
@@ -194,11 +203,12 @@ async function main() {
     // Azure CLI, AWS CLI, kubectl, etc. need tools to be preserved
     if (requiresToolExecution(request)) {
       logger.debug('CLI tool execution detected, passing through unchanged');
-      recordPassthrough();
+      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(),
@@ -211,11 +221,12 @@ async function main() {
     // Modifying messages breaks the agent loop and causes infinite loops
     if (isAgenticRequest(request)) {
       logger.debug('Agentic request detected, passing through unchanged');
-      recordPassthrough();
+      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(),
@@ -228,12 +239,30 @@ async function main() {
 
     if (!settings.enabled) {
       logger.debug('Plexor disabled, passing through');
-      return output(request);
+      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.');
-      return output(request);
+      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({
@@ -251,10 +280,11 @@ async function main() {
 
     if (cachedResponse && settings.localCacheEnabled) {
       logger.info('[Plexor] Local cache hit');
-      recordCacheHit();
+      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
         }
@@ -311,7 +341,7 @@ async function main() {
     });
 
     // Update session stats
-    updateSessionStats(result);
+    session.recordOptimization(result);
 
     return output(optimizedRequest);
 
@@ -319,11 +349,15 @@ async function main() {
     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'
         }
@@ -332,9 +366,11 @@ async function main() {
       // 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'
           }
@@ -483,11 +519,10 @@ function isAgenticRequest(request) {
     }
   }
 
-  // Check for multi-turn conversations (likely agentic)
-  const assistantMessages = messages.filter(m => m.role === 'assistant');
-  if (assistantMessages.length > 2) {
-    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;
 }