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

package/hooks/track-response.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Response Tracking Hook
+ *
+ * This script runs after the LLM response is received.
+ * It tracks response metrics for analytics and updates session stats.
+ *
+ * Issue #701 Fix: Now tracks ALL responses including passthroughs.
+ * Previously, responses without request_id would exit early without tracking,
+ * leading to "0 tokens" display and potential context issues.
+ *
+ * Input: JSON object with response content, tokens used, etc.
+ * Output: Passthrough (no modifications)
+ */
+
+const path = require('path');
+
+// Use lib modules
+let ConfigManager, SessionManager, LocalCache, Logger, ServerSync;
+try {
+  ConfigManager = require('../lib/config');
+  SessionManager = require('../lib/session');
+  LocalCache = require('../lib/cache');
+  Logger = require('../lib/logger');
+  // Issue #701: Phase 2 - Server sync for persistent session state
+  const serverSyncModule = require('../lib/server-sync');
+  ServerSync = serverSyncModule.getServerSync;
+} catch {
+  // Fallback inline implementations if lib not found
+  const fs = require('fs');
+  const CONFIG_PATH = path.join(process.env.HOME || '', '.plexor', 'config.json');
+  const SESSION_PATH = path.join(process.env.HOME || '', '.plexor', 'session.json');
+  const PLEXOR_DIR = path.join(process.env.HOME || '', '.plexor');
+  const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+
+  ConfigManager = class {
+    async load() {
+      try {
+        const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+        const cfg = JSON.parse(data);
+        return {
+          enabled: cfg.settings?.enabled ?? false,
+          apiKey: cfg.auth?.api_key
+        };
+      } catch {
+        return { enabled: false };
+      }
+    }
+  };
+
+  // Inline SessionManager for fallback (Issue #701: proper tracking)
+  SessionManager = class {
+    constructor() {
+      this.sessionPath = SESSION_PATH;
+    }
+
+    load() {
+      try {
+        const data = fs.readFileSync(this.sessionPath, 'utf8');
+        const session = JSON.parse(data);
+        if (Date.now() - session.last_activity > SESSION_TIMEOUT_MS) {
+          return this.createNew();
+        }
+        return session;
+      } catch {
+        return this.createNew();
+      }
+    }
+
+    createNew() {
+      const session = {
+        session_id: `session_${Date.now()}`,
+        started_at: new Date().toISOString(),
+        last_activity: Date.now(),
+        requests: 0, optimizations: 0, cache_hits: 0, passthroughs: 0,
+        original_tokens: 0, optimized_tokens: 0, tokens_saved: 0,
+        output_tokens: 0,  // Issue #701: Track output tokens
+        baseline_cost: 0, actual_cost: 0, cost_saved: 0
+      };
+      this.save(session);
+      return session;
+    }
+
+    save(session) {
+      try {
+        if (!fs.existsSync(PLEXOR_DIR)) {
+          fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+        }
+        session.last_activity = Date.now();
+        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2));
+      } catch {}
+    }
+
+    recordOptimization(result) {
+      const s = this.load();
+      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.output_tokens += result.output_tokens || 0;  // Issue #701
+      s.baseline_cost += result.baseline_cost || 0;
+      s.actual_cost += result.estimated_cost || result.actual_cost || 0;
+      s.cost_saved += (result.baseline_cost || 0) - (result.estimated_cost || result.actual_cost || 0);
+      this.save(s);
+      return s;
+    }
+
+    recordCacheHit() {
+      const s = this.load();
+      s.requests++;
+      s.cache_hits++;
+      this.save(s);
+      return s;
+    }
+
+    recordPassthrough(outputTokens = 0) {
+      const s = this.load();
+      s.requests++;
+      s.passthroughs = (s.passthroughs || 0) + 1;
+      s.output_tokens += outputTokens;  // Issue #701: Track output even for passthroughs
+      this.save(s);
+      return s;
+    }
+
+    getStats() {
+      return this.load();
+    }
+  };
+
+  LocalCache = class {
+    async getMetadata() { return null; }
+  };
+
+  Logger = class {
+    constructor(name) { this.name = name; }
+    info(msg, data) {
+      if (data) {
+        console.error(`[${this.name}] ${msg}`, JSON.stringify(data));
+      } else {
+        console.error(`[${this.name}] ${msg}`);
+      }
+    }
+    error(msg) { console.error(`[${this.name}] [ERROR] ${msg}`); }
+    debug(msg) {
+      if (process.env.PLEXOR_DEBUG) {
+        console.error(`[${this.name}] [DEBUG] ${msg}`);
+      }
+    }
+  };
+
+  // Issue #701: Fallback ServerSync that does nothing
+  ServerSync = () => ({
+    syncSession: async () => ({ synced: false, message: 'Server sync not available' }),
+    scheduleSync: () => {},
+    needsSync: () => false
+  });
+}
+
+const logger = new Logger('track-response');
+const config = new ConfigManager();
+const cache = new LocalCache();
+const session = new SessionManager();
+
+// Issue #701: Phase 2 - Initialize server sync (lazy, initialized on first use)
+let serverSync = null;
+
+async function getServerSync() {
+  if (serverSync) return serverSync;
+
+  try {
+    const settings = await config.load();
+    if (settings.apiKey && settings.enabled) {
+      serverSync = ServerSync({
+        apiKey: settings.apiKey,
+        baseUrl: settings.apiUrl || 'https://api.plexor.dev',
+        enabled: settings.serverSyncEnabled !== false
+      });
+    } else {
+      serverSync = ServerSync({ enabled: false });
+    }
+  } catch {
+    serverSync = ServerSync({ enabled: false });
+  }
+  return serverSync;
+}
+
+async function main() {
+  let response;
+  let input;
+
+  try {
+    input = await readStdin();
+    response = JSON.parse(input);
+
+    // Calculate output tokens for ALL responses (Issue #701)
+    const outputTokens = estimateOutputTokens(response);
+
+    // Get Plexor metadata if present
+    const plexorMeta = response._plexor;
+
+    // Issue #701: Track ALL responses, not just when enabled
+    // This ensures session stats are always accurate
+    if (plexorMeta) {
+      await trackResponseWithMetadata(plexorMeta, outputTokens);
+    } else {
+      // No Plexor metadata - still track the output tokens
+      session.recordPassthrough(outputTokens);
+      logger.debug('Response tracked without Plexor metadata');
+    }
+
+    // Issue #701: Phase 2 - Schedule server sync (non-blocking)
+    // This syncs local session stats to the server for persistence
+    try {
+      const sync = await getServerSync();
+      const localStats = session.getStats();
+      sync.scheduleSync(localStats);
+    } catch (syncError) {
+      // Server sync failures should not affect response passthrough
+      logger.debug(`Server sync scheduling failed: ${syncError.message}`);
+    }
+
+    // Pass through unchanged
+    return output(response);
+
+  } catch (error) {
+    logger.error(`Tracking error: ${error.message}`);
+
+    // On any error, try to pass through the response unchanged
+    if (response) {
+      return output(response);
+    } else if (input) {
+      try {
+        return output(JSON.parse(input));
+      } catch {
+        process.exit(1);
+      }
+    } else {
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Track response using Plexor metadata.
+ * Issue #701: Handles ALL source types, not just plexor_api.
+ */
+async function trackResponseWithMetadata(plexorMeta, outputTokens) {
+  const source = plexorMeta.source || 'unknown';
+  const requestId = plexorMeta.request_id;
+
+  logger.debug(`Tracking response: source=${source}, request_id=${requestId}`);
+
+  switch (source) {
+    case 'plexor_api':
+      // Full optimization was applied
+      session.recordOptimization({
+        original_tokens: plexorMeta.original_tokens || 0,
+        optimized_tokens: plexorMeta.optimized_tokens || 0,
+        tokens_saved: plexorMeta.tokens_saved || 0,
+        baseline_cost: plexorMeta.baseline_cost || 0,
+        estimated_cost: plexorMeta.estimated_cost || 0,
+        output_tokens: outputTokens
+      });
+      logger.info('[Plexor] Optimized response tracked', {
+        request_id: requestId,
+        input_tokens: plexorMeta.optimized_tokens,
+        output_tokens: outputTokens,
+        savings_percent: plexorMeta.savings_percent,
+        provider: plexorMeta.recommended_provider
+      });
+      break;
+
+    case 'local_cache':
+      session.recordCacheHit();
+      logger.info('[Plexor] Cache hit recorded', { request_id: requestId });
+      break;
+
+    case 'passthrough_agentic':
+    case 'passthrough_slash_command':
+    case 'passthrough_cli':
+    case 'passthrough_disabled':
+    case 'passthrough_no_auth':
+    case 'passthrough_error':
+    case 'passthrough':
+      // Passthrough - still track output tokens
+      session.recordPassthrough(outputTokens);
+      logger.debug(`Passthrough recorded: ${source}`, {
+        request_id: requestId,
+        reason: plexorMeta.reason,
+        output_tokens: outputTokens
+      });
+      break;
+
+    default:
+      // Unknown source - treat as passthrough
+      session.recordPassthrough(outputTokens);
+      logger.debug(`Unknown source tracked as passthrough: ${source}`, {
+        request_id: requestId,
+        output_tokens: outputTokens
+      });
+  }
+}
+
+/**
+ * Estimate output tokens from response content.
+ * Handles both string and structured content formats.
+ */
+function estimateOutputTokens(response) {
+  if (!response) return 0;
+
+  // Try to get content from various response formats
+  let text = '';
+
+  // Anthropic format: content array with text blocks
+  if (Array.isArray(response.content)) {
+    for (const block of response.content) {
+      if (block.type === 'text' && block.text) {
+        text += block.text;
+      } else if (block.type === 'tool_use') {
+        // Tool use blocks contribute to token count
+        text += JSON.stringify(block.input || {});
+      }
+    }
+  }
+  // Simple string content
+  else if (typeof response.content === 'string') {
+    text = response.content;
+  }
+  // OpenAI format: choices array
+  else if (response.choices && response.choices[0]) {
+    const choice = response.choices[0];
+    if (choice.message && choice.message.content) {
+      text = choice.message.content;
+    } else if (choice.text) {
+      text = choice.text;
+    }
+  }
+
+  if (!text) return 0;
+
+  // Approximate: ~4 characters per token (rough estimate)
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+
+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'));
+    }, 2000);
+  });
+}
+
+function output(data) {
+  const json = JSON.stringify(data);
+  process.stdout.write(json);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`[Plexor] Fatal error: ${error.message}`);
+  process.exit(1);
+});

package/lib/cache.js

@@ -0,0 +1,107 @@
+/**
+ * Plexor Local Cache
+ *
+ * Stores request/response metadata for cache hit detection.
+ */
+
+const fs = require('fs');
+const { CACHE_PATH, PLEXOR_DIR } = require('./constants');
+
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+class LocalCache {
+  constructor() {
+    this.cachePath = CACHE_PATH;
+    this.cache = this.load();
+  }
+
+  load() {
+    try {
+      const data = fs.readFileSync(this.cachePath, 'utf8');
+      return JSON.parse(data);
+    } catch {
+      return { entries: {}, metadata: {} };
+    }
+  }
+
+  save() {
+    try {
+      if (!fs.existsSync(PLEXOR_DIR)) {
+        fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+      }
+      fs.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  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)}`;
+  }
+
+  async get(key) {
+    const entry = this.cache.entries[key];
+    if (!entry) {
+      return null;
+    }
+
+    // Check if expired
+    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+      delete this.cache.entries[key];
+      this.save();
+      return null;
+    }
+
+    return entry.value;
+  }
+
+  async set(key, value) {
+    this.cache.entries[key] = {
+      value,
+      timestamp: Date.now()
+    };
+    this.cleanup();
+    this.save();
+  }
+
+  async getMetadata(requestId) {
+    return this.cache.metadata[requestId] || null;
+  }
+
+  async setMetadata(requestId, metadata) {
+    this.cache.metadata[requestId] = {
+      ...metadata,
+      timestamp: Date.now()
+    };
+    this.cleanupMetadata();
+    this.save();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const key of Object.keys(this.cache.entries)) {
+      if (now - this.cache.entries[key].timestamp > CACHE_TTL_MS) {
+        delete this.cache.entries[key];
+      }
+    }
+  }
+
+  cleanupMetadata() {
+    const now = Date.now();
+    const METADATA_TTL_MS = 60 * 60 * 1000; // 1 hour
+    for (const key of Object.keys(this.cache.metadata)) {
+      if (now - this.cache.metadata[key].timestamp > METADATA_TTL_MS) {
+        delete this.cache.metadata[key];
+      }
+    }
+  }
+}
+
+module.exports = LocalCache;

package/lib/config.js

@@ -0,0 +1,67 @@
+/**
+ * Plexor Configuration Manager
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_PATH, PLEXOR_DIR, DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
+
+class ConfigManager {
+  constructor() {
+    this.configPath = CONFIG_PATH;
+  }
+
+  async load() {
+    try {
+      const data = fs.readFileSync(this.configPath, 'utf8');
+      const cfg = JSON.parse(data);
+      return {
+        enabled: cfg.settings?.enabled ?? false,
+        apiKey: cfg.auth?.api_key || '',
+        apiUrl: cfg.settings?.apiUrl || DEFAULT_API_URL,
+        timeout: cfg.settings?.timeout || DEFAULT_TIMEOUT,
+        localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
+        mode: cfg.settings?.mode || 'balanced',
+        preferredProvider: cfg.settings?.preferred_provider || 'auto'
+      };
+    } catch {
+      return { enabled: false, apiKey: '', apiUrl: DEFAULT_API_URL };
+    }
+  }
+
+  async save(config) {
+    try {
+      if (!fs.existsSync(PLEXOR_DIR)) {
+        fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+      }
+
+      let existing = {};
+      try {
+        const data = fs.readFileSync(this.configPath, 'utf8');
+        existing = JSON.parse(data);
+      } catch {
+        existing = { version: 1, auth: {}, settings: {} };
+      }
+
+      const updated = {
+        ...existing,
+        settings: {
+          ...existing.settings,
+          enabled: config.enabled ?? existing.settings?.enabled,
+          apiUrl: config.apiUrl ?? existing.settings?.apiUrl,
+          timeout: config.timeout ?? existing.settings?.timeout,
+          localCacheEnabled: config.localCacheEnabled ?? existing.settings?.localCacheEnabled,
+          mode: config.mode ?? existing.settings?.mode,
+          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider
+        }
+      };
+
+      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = ConfigManager;

package/lib/constants.js

@@ -0,0 +1,26 @@
+/**
+ * Plexor Plugin Constants
+ */
+
+const path = require('path');
+
+const PLEXOR_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.plexor');
+const CONFIG_PATH = path.join(PLEXOR_DIR, 'config.json');
+const SESSION_PATH = path.join(PLEXOR_DIR, 'session.json');
+const CACHE_PATH = path.join(PLEXOR_DIR, 'cache.json');
+
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+// STAGING PACKAGE - uses staging API
+const DEFAULT_API_URL = 'https://staging.api.plexor.dev';
+const DEFAULT_TIMEOUT = 5000;
+
+module.exports = {
+  PLEXOR_DIR,
+  CONFIG_PATH,
+  SESSION_PATH,
+  CACHE_PATH,
+  SESSION_TIMEOUT_MS,
+  DEFAULT_API_URL,
+  DEFAULT_TIMEOUT
+};

package/lib/index.js

@@ -0,0 +1,19 @@
+/**
+ * Plexor Plugin Library
+ */
+
+const ConfigManager = require('./config');
+const SessionManager = require('./session');
+const LocalCache = require('./cache');
+const Logger = require('./logger');
+const PlexorClient = require('./plexor-client');
+const constants = require('./constants');
+
+module.exports = {
+  ConfigManager,
+  SessionManager,
+  LocalCache,
+  Logger,
+  PlexorClient,
+  ...constants
+};

package/lib/logger.js

@@ -0,0 +1,36 @@
+/**
+ * Plexor Logger
+ *
+ * Simple logger that outputs to stderr to avoid interfering with stdout JSON.
+ */
+
+class Logger {
+  constructor(component = 'plexor') {
+    this.component = component;
+    this.debug_enabled = process.env.PLEXOR_DEBUG === '1' || process.env.PLEXOR_DEBUG === 'true';
+  }
+
+  debug(msg, data = null) {
+    if (this.debug_enabled) {
+      const output = data ? `[DEBUG][${this.component}] ${msg} ${JSON.stringify(data)}` : `[DEBUG][${this.component}] ${msg}`;
+      console.error(output);
+    }
+  }
+
+  info(msg, data = null) {
+    const output = data ? `${msg} ${JSON.stringify(data)}` : msg;
+    console.error(output);
+  }
+
+  warn(msg, data = null) {
+    const output = data ? `[WARN][${this.component}] ${msg} ${JSON.stringify(data)}` : `[WARN][${this.component}] ${msg}`;
+    console.error(output);
+  }
+
+  error(msg, data = null) {
+    const output = data ? `[ERROR][${this.component}] ${msg} ${JSON.stringify(data)}` : `[ERROR][${this.component}] ${msg}`;
+    console.error(output);
+  }
+}
+
+module.exports = Logger;