@plexor-dev/claude-code-plugin 0.1.0-beta.14 → 0.1.0-beta.16

package/commands/plexor-status.md

@@ -4,66 +4,10 @@ description: Show Plexor optimization statistics and savings (user)
 
 # Plexor Status
 
-Display Plexor optimization statistics in a clean, professional format.
+Run this command to display Plexor statistics:
 
-## Instructions
-
-1. Read `~/.plexor/config.json` to get settings and API key
-2. Read `~/.plexor/session.json` to get current session stats (if exists and not expired after 30min inactivity)
-3. 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}`
-4. Output the formatted status box directly as text (not in a code block):
-
-```
-  ┌─────────────────────────────────────────────┐
-  │  Plexor Status                              │
-  ├─────────────────────────────────────────────┤
-  │  Account: {tier.name}                       │
-  │  Email: {email}                             │
-  │  Status: ● Active                           │
-  ├─────────────────────────────────────────────┤
-  │  This Session ({duration})                  │
-  │  ├── Requests: {session_requests}           │
-  │  ├── Optimizations: {session_optimizations} │
-  │  ├── Cache hits: {session_cache_hits}       │
-  │  ├── Tokens saved: {tokens} ({%})           │
-  │  └── Cost saved: ${session_cost_saved}      │
-  ├─────────────────────────────────────────────┤
-  │  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: {dashboard_url}
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-status.js
 ```
 
-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
-- Only show "This Session" section if session.json exists and is not expired (30min timeout)
-- Session duration format: "Xm" for minutes, "Xh Ym" for hours
+Use the Bash tool to execute this single command. Do not read files manually or format output yourself.

package/hooks/intercept.js

@@ -13,145 +13,138 @@
 const fs = require('fs');
 const path = require('path');
 
-// 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');
-
-const 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;
-    }
-    return `cache_${hash}`;
-  },
-  get: async () => null,
-  setMetadata: async () => {}
-};
+// 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}`)
+  };
 
-// Session stats tracking
-const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+  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 };
+      }
+    }
+  };
 
-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() {
@@ -177,7 +170,7 @@ 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(),
@@ -194,7 +187,7 @@ 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(),
@@ -211,7 +204,7 @@ 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(),
@@ -251,7 +244,7 @@ async function main() {
 
     if (cachedResponse && settings.localCacheEnabled) {
       logger.info('[Plexor] Local cache hit');
-      recordCacheHit();
+      session.recordCacheHit();
       return output({
         ...request,
         _plexor: {
@@ -311,7 +304,7 @@ async function main() {
     });
 
     // Update session stats
-    updateSessionStats(result);
+    session.recordOptimization(result);
 
     return output(optimizedRequest);
 

package/hooks/track-response.js

@@ -10,14 +10,56 @@
  * Output: Passthrough (no modifications)
  */
 
-const PlexorClient = require('../lib/plexor-client');
-const ConfigManager = require('../lib/config');
-const LocalCache = require('../lib/cache');
-const Logger = require('../lib/logger');
+const path = require('path');
+
+// Use lib modules
+let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
+try {
+  ConfigManager = require('../lib/config');
+  SessionManager = require('../lib/session');
+  LocalCache = require('../lib/cache');
+  Logger = require('../lib/logger');
+  PlexorClient = require('../lib/plexor-client');
+} catch {
+  // Fallback inline implementations if lib not found
+  const fs = require('fs');
+  const CONFIG_PATH = path.join(process.env.HOME || '', '.plexor', 'config.json');
+
+  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 };
+      }
+    }
+  };
+
+  SessionManager = class {
+    recordOptimization() {}
+    recordPassthrough() {}
+  };
+
+  LocalCache = class {
+    async getMetadata() { return null; }
+  };
+
+  Logger = class {
+    info(msg) { console.error(msg); }
+    error(msg) { console.error(`[ERROR] ${msg}`); }
+    debug() {}
+  };
+}
 
 const logger = new Logger('track-response');
 const config = new ConfigManager();
 const cache = new LocalCache();
+const session = new SessionManager();
 
 async function main() {
   try {
@@ -34,34 +76,45 @@ async function main() {
     // Check if this response has Plexor metadata
     const plexorMeta = response._plexor;
     if (!plexorMeta || !plexorMeta.request_id) {
+      // No Plexor metadata, but still record the request
+      session.recordPassthrough();
       return output(response);
     }
 
     // Get stored metadata for this request
     const metadata = await cache.getMetadata(plexorMeta.request_id);
-    if (!metadata) {
-      return output(response);
-    }
 
     // Calculate output tokens (approximate)
     const outputTokens = estimateTokens(response.content || '');
 
-    // Log response tracking
-    logger.info('[Plexor] Response tracked', {
-      request_id: plexorMeta.request_id,
-      input_tokens: metadata.optimized_tokens,
-      output_tokens: outputTokens,
-      provider: metadata.recommended_provider
-    });
-
-    // In production, we would send this data to the API for analytics
-    // For now, just log locally
+    // Update session stats with response data
+    if (plexorMeta.source === 'plexor_api') {
+      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
+      });
+
+      logger.info('[Plexor] Response tracked', {
+        request_id: plexorMeta.request_id,
+        input_tokens: plexorMeta.optimized_tokens,
+        output_tokens: outputTokens,
+        provider: plexorMeta.recommended_provider
+      });
+    } else if (plexorMeta.source === 'local_cache') {
+      session.recordCacheHit();
+      logger.info('[Plexor] Cache hit recorded');
+    } else {
+      session.recordPassthrough();
+    }
 
     // Pass through unchanged
     return output(response);
 
   } catch (error) {
-    logger.error(`[Plexor] Tracking error: ${error.message}`);
+    logger.error(`Tracking error: ${error.message}`);
 
     // On any error, pass through unchanged
     try {
@@ -100,6 +153,7 @@ function output(data) {
 }
 
 function estimateTokens(text) {
+  if (!text) return 0;
   // Approximate: ~4 characters per token
   return Math.max(1, Math.ceil(text.length / 4));
 }

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,25 @@
+/**
+ * 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
+
+const DEFAULT_API_URL = 'https://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;

package/lib/plexor-client.js

@@ -0,0 +1,122 @@
+/**
+ * Plexor API Client
+ *
+ * Handles communication with the Plexor optimization API.
+ */
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const { DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
+
+class PlexorClient {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || '';
+    this.baseUrl = options.baseUrl || DEFAULT_API_URL;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  }
+
+  async request(method, path, body = null) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const isHttps = url.protocol === 'https:';
+      const lib = isHttps ? https : http;
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname + url.search,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.apiKey,
+          'X-Plexor-Key': this.apiKey,
+          'User-Agent': 'plexor-claude-code-plugin/0.1.0'
+        },
+        timeout: this.timeout
+      };
+
+      const req = lib.request(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve(json);
+            } else {
+              reject(new Error(json.message || `HTTP ${res.statusCode}`));
+            }
+          } catch {
+            reject(new Error(`Invalid JSON response: ${data.substring(0, 100)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+
+      req.end();
+    });
+  }
+
+  async optimize(params) {
+    try {
+      const result = await this.request('POST', '/v1/optimize', {
+        messages: params.messages,
+        model: params.model,
+        max_tokens: params.max_tokens,
+        task_hint: params.task_hint,
+        context: params.context
+      });
+
+      return {
+        request_id: result.request_id || `req_${Date.now()}`,
+        original_tokens: result.original_tokens || 0,
+        optimized_tokens: result.optimized_tokens || 0,
+        tokens_saved: result.tokens_saved || 0,
+        optimized_messages: result.optimized_messages || params.messages,
+        recommended_provider: result.recommended_provider || 'anthropic',
+        recommended_model: result.recommended_model || params.model,
+        estimated_cost: result.estimated_cost || 0,
+        baseline_cost: result.baseline_cost || 0
+      };
+    } catch (error) {
+      // Return passthrough on error
+      const tokens = Math.round(JSON.stringify(params.messages).length / 4);
+      return {
+        request_id: `req_${Date.now()}`,
+        original_tokens: tokens,
+        optimized_tokens: tokens,
+        tokens_saved: 0,
+        optimized_messages: params.messages,
+        recommended_provider: 'anthropic',
+        recommended_model: params.model,
+        estimated_cost: 0,
+        baseline_cost: 0,
+        error: error.message
+      };
+    }
+  }
+
+  async getUser() {
+    return this.request('GET', '/v1/user');
+  }
+
+  async getStats() {
+    return this.request('GET', '/v1/stats');
+  }
+
+  async trackResponse(requestId, metrics) {
+    return this.request('POST', `/v1/track/${requestId}`, metrics);
+  }
+}
+
+module.exports = PlexorClient;

package/lib/session.js

@@ -0,0 +1,145 @@
+/**
+ * Plexor Session Manager
+ *
+ * Tracks session statistics for the current Claude Code session.
+ * Session expires after 30 minutes of inactivity.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { SESSION_PATH, PLEXOR_DIR, SESSION_TIMEOUT_MS } = require('./constants');
+
+class SessionManager {
+  constructor() {
+    this.sessionPath = SESSION_PATH;
+  }
+
+  load() {
+    try {
+      const data = fs.readFileSync(this.sessionPath, 'utf8');
+      const session = JSON.parse(data);
+
+      // Check if session has expired (30 min inactivity)
+      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,
+      original_tokens: 0,
+      optimized_tokens: 0,
+      tokens_saved: 0,
+      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));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  recordRequest(stats = {}) {
+    const session = this.load();
+    session.requests++;
+
+    if (stats.optimized) {
+      session.optimizations++;
+      session.original_tokens += stats.original_tokens || 0;
+      session.optimized_tokens += stats.optimized_tokens || 0;
+      session.tokens_saved += stats.tokens_saved || 0;
+      session.baseline_cost += stats.baseline_cost || 0;
+      session.actual_cost += stats.actual_cost || 0;
+      session.cost_saved += stats.cost_saved || 0;
+    }
+
+    if (stats.cache_hit) {
+      session.cache_hits++;
+    }
+
+    this.save(session);
+    return session;
+  }
+
+  recordOptimization(result) {
+    return this.recordRequest({
+      optimized: true,
+      original_tokens: result.original_tokens || 0,
+      optimized_tokens: result.optimized_tokens || 0,
+      tokens_saved: result.tokens_saved || 0,
+      baseline_cost: result.baseline_cost || 0,
+      actual_cost: result.estimated_cost || result.actual_cost || 0,
+      cost_saved: (result.baseline_cost || 0) - (result.estimated_cost || result.actual_cost || 0)
+    });
+  }
+
+  recordCacheHit() {
+    return this.recordRequest({ cache_hit: true });
+  }
+
+  recordPassthrough() {
+    return this.recordRequest({});
+  }
+
+  getStats() {
+    const session = this.load();
+    const duration = Date.now() - new Date(session.started_at).getTime();
+
+    return {
+      ...session,
+      duration_ms: duration,
+      duration_formatted: this.formatDuration(duration),
+      tokens_saved_percent: session.original_tokens > 0
+        ? ((session.tokens_saved / session.original_tokens) * 100).toFixed(1)
+        : '0.0',
+      cost_saved_percent: session.baseline_cost > 0
+        ? ((session.cost_saved / session.baseline_cost) * 100).toFixed(1)
+        : '0.0'
+    };
+  }
+
+  formatDuration(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60) {
+      return `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+  }
+
+  isExpired() {
+    try {
+      const data = fs.readFileSync(this.sessionPath, 'utf8');
+      const session = JSON.parse(data);
+      return Date.now() - session.last_activity > SESSION_TIMEOUT_MS;
+    } catch {
+      return true;
+    }
+  }
+}
+
+module.exports = SessionManager;

package/package.json

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