@plexor-dev/claude-code-plugin 0.1.0-beta.2 → 0.1.0-beta.4

package/commands/plexor-config.md

@@ -1,43 +1,42 @@
 ---
-description: Configure Plexor settings
+description: Configure Plexor settings (user)
 ---
 
 # Plexor Config
 
-Configure Plexor optimization settings.
+View and modify Plexor configuration. This is an alias for /plexor-settings.
 
-## Arguments
+## Steps
 
-$ARGUMENTS - Configuration command and value
+**Step 1: Read current configuration**
 
-## Supported Commands
-
-- `plexor-config show` - Show current configuration
-- `plexor-config enable` - Enable Plexor optimization
-- `plexor-config disable` - Disable Plexor optimization
-- `plexor-config cache on|off` - Enable/disable local cache
-- `plexor-config provider <name>` - Set preferred provider (anthropic, deepseek, auto)
-- `plexor-config reset` - Reset to default configuration
-
-## Instructions
-
-1. Parse the arguments to determine the command
-2. Read current config from ~/.plexor/config.json
-3. Apply the requested change
-4. Save updated config
-5. Display confirmation
-
-## Output
+Use the Read tool to read `~/.plexor/config.json`.
 
+If the file doesn't exist, show:
+```
+Plexor Config
+=============
+No configuration found. Run /plexor-login to set up Plexor.
 ```
-Plexor Configuration Updated
-============================
 
-Local cache: Enabled → Disabled
+**Step 2: Display current configuration**
 
-Current settings:
-├── Optimization: Enabled
-├── Local cache: Disabled
-├── Preferred provider: Auto
-└── Telemetry: Enabled
+```
+Plexor Config
+=============
+Enabled: [enabled]
+API URL: [apiUrl]
+API Key: [show "configured" if apiKey exists, otherwise "not configured"]
+Mode: [mode]
+Provider: [preferredProvider]
+Local Cache: [localCacheEnabled]
+Timeout: [timeout]ms
+
+Configuration file: ~/.plexor/config.json
+
+Other commands:
+- /plexor-settings - View/edit all settings
+- /plexor-mode - Change optimization mode
+- /plexor-provider - Change provider
+- /plexor-enabled - Enable/disable proxy
 ```

package/commands/plexor-enabled.md

@@ -1,36 +1,54 @@
 ---
-description: Enable or disable Plexor proxy (routes all traffic through Plexor API)
+description: Enable or disable Plexor proxy (routes all traffic through Plexor API) (user)
 ---
 
+# Plexor Enabled
+
 Toggle Plexor proxy mode on or off.
 
-**IMPORTANT**: Use the `AskUserQuestion` tool to present the user with these options:
+## Steps
+
+**Step 1: Read current configuration**
+
+Use the Read tool to read `~/.plexor/config.json` and check the current `enabled` status.
+
+**Step 2: Ask user what they want to do**
 
-Question: "Enable Plexor proxy? (routes all prompts through Plexor for optimization)"
+Use the `AskUserQuestion` tool to present options:
+
+Question: "Enable or disable Plexor proxy?"
 Header: "Proxy"
 Options:
-1. **Enable** - Route all traffic through Plexor API (60-90% cost savings)
-2. **Disable** - Direct to Anthropic (no optimization)
-
-After the user selects an option:
-
-### If Enable:
-1. Update ~/.plexor/config.json: `{"enabled": true}`
-2. Inform user to set environment variable:
-   ```
-   export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"
-   ```
-3. Tell user to restart Claude Code: `claude --continue`
-4. Explain benefits:
-   - 60-90% cost reduction via Mistral/DeepSeek/Gemini/OpenAI routing
-   - Automatic provider selection based on mode
-   - Session tracking and savings analytics
-
-### If Disable:
-1. Update ~/.plexor/config.json: `{"enabled": false}`
-2. Inform user to unset environment variable:
-   ```
-   unset ANTHROPIC_BASE_URL
-   ```
-3. Tell user to restart Claude Code: `claude --continue`
-4. Note: Prompts will go directly to Anthropic at full price
+1. **Enable** - Route traffic through Plexor for optimization (60-90% cost savings)
+2. **Disable** - Direct to Anthropic (no optimization, full price)
+
+**Step 3: Update the configuration**
+
+Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
+- If **Enable**: Set `"enabled": true`
+- If **Disable**: Set `"enabled": false`
+
+Keep all other settings unchanged.
+
+**Step 4: Show confirmation**
+
+If **Enabled**:
+```
+Plexor Proxy: ENABLED
+
+Benefits:
+- 60-90% cost reduction via intelligent provider routing
+- Automatic selection of Mistral/DeepSeek/Gemini based on task
+- Usage tracking and savings analytics
+
+Your prompts will now be routed through Plexor for optimization.
+Run /plexor-status to see your savings.
+```
+
+If **Disabled**:
+```
+Plexor Proxy: DISABLED
+
+Your prompts will go directly to Anthropic at full price.
+Run /plexor-enabled to re-enable optimization.
+```

package/commands/plexor-login.md

@@ -1,87 +1,76 @@
 ---
-description: Authenticate with Plexor to enable optimization
+description: Authenticate with Plexor to enable optimization (user)
 ---
 
 # Plexor Login
 
 Authenticate with your Plexor account to enable LLM cost optimization.
 
-## Instructions
+## Steps
 
-1. Check if already authenticated by reading ~/.plexor/config.json
-2. If already authenticated and valid, show current account info and status
-3. If not authenticated, initiate device flow:
-   a. Call POST https://api.plexor.dev/v1/auth/device-code to get device_code and user_code
-   b. Display the user code and verification URL to the user
-   c. Open https://plexor.dev/auth/device in the user's browser
-   d. Poll POST https://api.plexor.dev/v1/auth/device-token every 5 seconds
-   e. On success, save API key to ~/.plexor/config.json
-   f. Verify the key works by calling GET https://api.plexor.dev/v1/user
+**Step 1: Check existing authentication**
 
-4. After successful authentication, configure the gateway:
-   a. Set ANTHROPIC_BASE_URL to route traffic through Plexor gateway
-   b. Inform user they need to restart Claude Code
-
-## Config File
-
-Location: ~/.plexor/config.json
-
-```json
-{
-  "version": 1,
-  "auth": {
-    "api_key": "plx_...",
-    "email": "user@example.com",
-    "tier": "beta",
-    "authenticated_at": "2025-12-16T20:00:00Z"
-  },
-  "settings": {
-    "enabled": true,
-    "preferred_provider": "auto",
-    "mode": "balanced"
-  }
-}
-```
-
-## Output (New User)
+Use the Read tool to read `~/.plexor/config.json`.
 
+If the file exists and has an `apiKey` field that starts with "plx_", the user is already authenticated. Show them:
 ```
 Plexor Login
 ============
+Already authenticated!
+API Key: plx_****[last 4 chars]
+API URL: [apiUrl from config]
+Status: [Enabled/Disabled]
 
-1. Open this URL in your browser:
-   https://plexor.dev/auth/device
-
-2. Enter this code:
-   ABCD-1234
+Run /plexor-status to see your usage statistics.
+Run /plexor-logout to sign out.
+```
 
-Waiting for authentication... ✓
+**Step 2: If not authenticated, ask for API key**
 
-✓ Authenticated as user@example.com
-✓ Plan: Beta ($1/month)
-✓ Plexor gateway configured
+Ask the user to provide their Plexor API key. They can get one from:
+- https://plexor.dev/dashboard (if they have an account)
+- https://plexor.dev/signup (to create an account)
 
-To activate, run this in your terminal:
+Tell them: "Please provide your Plexor API key (starts with 'plx_'):"
 
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/v1/gateway/anthropic"
+**Step 3: Save the configuration**
 
-Then restart Claude Code. All prompts will be optimized automatically.
+Once the user provides an API key, use the Write tool to create/update `~/.plexor/config.json`:
 
-Run /plexor-status to see your savings.
+```json
+{
+  "enabled": true,
+  "apiUrl": "https://api.plexor.dev",
+  "apiKey": "[user's API key]",
+  "mode": "balanced",
+  "preferredProvider": "auto",
+  "localCacheEnabled": true,
+  "timeout": 5000
+}
 ```
 
-## Output (Already Authenticated)
+**Step 4: Verify the key works**
 
+Make a test request to verify authentication:
+```
+GET https://api.plexor.dev/api/users/me
+Authorization: Bearer [apiKey]
+```
+
+If successful, show:
 ```
 Plexor Login
 ============
+Authentication successful!
 
-Already authenticated as user@example.com
-Plan: Beta ($1/month)
-Status: Active
+Your API key has been saved to ~/.plexor/config.json
 
-Gateway URL: https://api.plexor.dev/v1/gateway/anthropic
+Next steps:
+1. Run /plexor-status to see your usage
+2. Run /plexor-enabled true to enable the proxy
+3. Start saving on LLM costs!
 
-Run /plexor-status to see your savings.
-Run /plexor-logout to sign out.
+Dashboard: https://plexor.dev/dashboard
 ```
+
+If the API call fails, tell the user the key may be invalid and ask them to check it.

package/commands/plexor-logout.md

@@ -1,50 +1,42 @@
 ---
-description: Log out from Plexor and clear credentials
+description: Log out from Plexor and clear credentials (user)
 ---
 
 # Plexor Logout
 
 Log out from your Plexor account and clear stored credentials.
 
-## Instructions
+## Steps
 
-1. Read the current configuration from ~/.plexor/config.json
-2. If not authenticated, inform the user they are not logged in
-3. If authenticated:
-   a. Clear the API key from the configuration
-   b. Preserve non-sensitive settings (mode, provider preferences)
-   c. Save the updated configuration
-4. Remind user to restore original Anthropic URL
-5. Display confirmation message
+**Step 1: Read current configuration**
 
-## Output
+Use the Read tool to read `~/.plexor/config.json`.
 
+If the file doesn't exist or has no `apiKey`, show:
 ```
 Plexor Logout
 =============
+You are not currently logged in.
+Run /plexor-login to authenticate.
+```
 
-✓ Successfully logged out
-✓ API key cleared from ~/.plexor/config.json
-
-To restore direct Anthropic access, run:
-
-  unset ANTHROPIC_BASE_URL
+**Step 2: Clear the API key**
 
-Then restart Claude Code.
+If authenticated, use the Write tool to update `~/.plexor/config.json`:
+- Remove or clear the `apiKey` field (set to empty string "")
+- Keep all other settings (mode, preferredProvider, etc.)
 
-Note: Your Plexor subscription is still active.
-To manage billing: https://plexor.dev/billing
-
-To use Plexor again, run /plexor-login
-```
-
-## Output (Not Logged In)
+**Step 3: Show confirmation**
 
 ```
 Plexor Logout
 =============
+Successfully logged out!
 
-You are not currently logged in.
+- API key cleared from ~/.plexor/config.json
+- Settings preserved (mode, provider preferences)
 
-Run /plexor-login to authenticate.
+To use Plexor again, run /plexor-login
+
+Dashboard: https://plexor.dev/dashboard
 ```

package/commands/plexor-mode.md

@@ -1,25 +1,47 @@
 ---
-description: Set Plexor optimization mode (eco/balanced/quality/passthrough)
+description: Set Plexor optimization mode (eco/balanced/quality/passthrough) (user)
 ---
 
-Set the Plexor optimization mode.
+# Plexor Mode
 
-**IMPORTANT**: Use the `AskUserQuestion` tool to present the user with these options:
+Set the Plexor optimization mode to control cost vs quality trade-offs.
+
+## Steps
+
+**Step 1: Read current configuration**
+
+Use the Read tool to read `~/.plexor/config.json` and check the current `mode` setting.
+
+**Step 2: Ask user which mode they want**
+
+Use the `AskUserQuestion` tool:
 
 Question: "Which optimization mode would you like to use?"
 Header: "Mode"
 Options:
-1. **eco** - Maximum cost savings (Ministral 3B $0.04/$0.04 - cheapest)
-2. **balanced** - Cost-first with fallbacks (DeepSeek → Gemini Flash → Mistral → GPT-5-nano → Claude Haiku)
-3. **quality** - Premium models (Claude Opus 4.5 → Gemini Pro → Mistral Large → GPT-5.1)
-4. **passthrough** - No optimization, direct passthrough to requested model
-
-After the user selects an option:
-1. Update ~/.plexor/config.json with the selected mode
-2. Set the X-Plexor-Mode header for future requests
-3. Confirm the change and explain the cost/quality trade-offs
-
-Cost comparison (per 1M tokens input/output):
-- eco: Mistral Ministral 3B $0.04/$0.04 (cheapest)
-- balanced: DeepSeek $0.14/$0.28, Gemini 2.5 Flash $0.15/$0.60, Mistral Small $0.1/$0.3
-- quality: Claude Opus 4.5 $5/$25, Gemini 2.5 Pro $1.25/$10, Mistral Large $2/$6
+1. **eco** - Maximum savings (~$0.04/1M tokens) - Uses Ministral 3B
+2. **balanced** - Good balance (~$0.15/1M) - DeepSeek, Gemini Flash, Mistral Small
+3. **quality** - Premium models (~$5/1M) - Claude Opus, Gemini Pro, Mistral Large
+4. **passthrough** - No optimization - Direct to requested model
+
+**Step 3: Update the configuration**
+
+Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
+- Set the `mode` field to the selected value: "eco", "balanced", "quality", or "passthrough"
+
+Keep all other settings unchanged.
+
+**Step 4: Show confirmation**
+
+```
+Plexor Mode: [SELECTED MODE]
+
+Mode Details:
+- eco: Maximum cost savings using Ministral 3B ($0.04/$0.04 per 1M tokens)
+- balanced: Cost-first with quality fallbacks (DeepSeek → Gemini Flash → Mistral)
+- quality: Premium models for complex tasks (Claude Opus, Gemini Pro)
+- passthrough: No optimization, direct to Anthropic
+
+Current mode: [mode]
+Run /plexor-status to see your savings.
+```

package/commands/plexor-provider.md

@@ -1,25 +1,47 @@
 ---
-description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto)
+description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto) (user)
 ---
 
-Force Plexor to use a specific LLM provider or enable automatic routing.
+# Plexor Provider
 
-**IMPORTANT**: Use the `AskUserQuestion` tool to present the user with these options:
+Set your preferred LLM provider for Plexor routing.
 
-Question: "Which provider would you like to use?"
+## Steps
+
+**Step 1: Read current configuration**
+
+Use the Read tool to read `~/.plexor/config.json` and check the current `preferredProvider` setting.
+
+**Step 2: Ask user which provider they prefer**
+
+Use the `AskUserQuestion` tool:
+
+Question: "Which LLM provider would you prefer?"
 Header: "Provider"
 Options:
-1. **auto** - Automatic routing (cheapest first: Mistral → DeepSeek → Gemini → OpenAI → Claude)
-2. **mistral** - Force Mistral (Ministral 3B $0.04/$0.04, Small $0.1/$0.3, Large $2/$6)
-3. **deepseek** - Force DeepSeek ($0.14/$0.28 per MTok)
-4. **gemini** - Force Gemini (2.0 Flash $0.10/$0.40, 2.5 Flash $0.15/$0.60, 2.5 Pro $1.25/$10)
-5. **openai** - Force OpenAI (GPT-5-nano $0.05/$0.40, GPT-5.1 $1.25/$10)
-6. **claude** - Force Anthropic (Haiku 4.5 $1/$5, Sonnet 4.5 $3/$15, Opus 4.5 $5/$25)
-
-After the user selects an option:
-1. Update ~/.plexor/config.json with the selected provider
-2. Set the X-Plexor-Force-Provider header for future requests
-3. Confirm the change and explain:
-   - The cost implications of the selected provider
-   - Model that will be used (based on current mode)
-   - When automatic routing might be more beneficial
+1. **auto** - Let Plexor choose the best provider based on task (Recommended)
+2. **deepseek** - Use DeepSeek models (cheapest, good for code)
+3. **mistral** - Use Mistral models (fast, good balance)
+4. **gemini** - Use Google Gemini models (good for analysis)
+
+**Step 3: Update the configuration**
+
+Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
+- Set `preferredProvider` to: "auto", "deepseek", "mistral", or "gemini"
+
+Keep all other settings unchanged.
+
+**Step 4: Show confirmation**
+
+```
+Plexor Provider: [SELECTED PROVIDER]
+
+Provider options:
+- auto: Plexor automatically selects the best provider for each task
+- deepseek: DeepSeek models ($0.14/$0.28 per 1M tokens) - Great for code
+- mistral: Mistral models ($0.10/$0.30 per 1M tokens) - Fast and versatile
+- gemini: Google Gemini ($0.075/$0.30 per 1M tokens) - Good for analysis
+
+Current provider: [preferredProvider]
+Run /plexor-status to see your usage.
+```

package/commands/plexor-settings.md

@@ -1,93 +1,58 @@
 ---
-description: Configure Plexor settings (API URL, mode, provider preferences)
+description: Configure Plexor settings (API URL, mode, provider preferences) (user)
 ---
 
 # Plexor Settings
 
-View and configure Plexor settings. Manages the connection to the Plexor API gateway.
+View and configure all Plexor settings.
 
-## Usage
+## Steps
 
-- `/plexor-settings` - Show current settings
-- `/plexor-settings api-url <url>` - Set the Plexor API URL
-- `/plexor-settings mode <eco|balanced|quality|passthrough>` - Set optimization mode
-- `/plexor-settings provider <auto|claude|openai|deepseek>` - Set provider preference
+**Step 1: Read current configuration**
 
-## Instructions
+Use the Read tool to read `~/.plexor/config.json`.
 
-1. Read ~/.plexor/config.json
-2. If no arguments, display current settings
-3. If setting a value, update the config file
-4. For api-url changes, remind user to set ANTHROPIC_BASE_URL
-
-## Config File Location
-
-~/.plexor/config.json
-
-## Config Schema
-
-```json
-{
-  "enabled": true,
-  "apiUrl": "http://localhost:8000",
-  "apiKey": "plx_...",
-  "mode": "balanced",
-  "preferredProvider": "auto",
-  "localCacheEnabled": true,
-  "timeout": 5000
-}
+If the file doesn't exist, show:
+```
+Plexor Settings
+===============
+No configuration found. Run /plexor-login to set up Plexor.
 ```
 
-## API URL Values
-
-- **Development**: `http://localhost:8000`
-- **Production**: `https://api.plexor.dev` (default)
+**Step 2: Display current settings**
 
-## Output Examples
+Show the current configuration:
 
-### Show settings:
-```
-┌─────────────────────────────────────────────┐
-│  Plexor Settings                            │
-├─────────────────────────────────────────────┤
-│  API URL: http://localhost:8000             │
-│  Mode: balanced                             │
-│  Provider: auto                             │
-│  Local Cache: enabled                       │
-│  Timeout: 5000ms                            │
-├─────────────────────────────────────────────┤
-│  Proxy Status: NOT ACTIVE                   │
-│                                             │
-│  To activate proxy, run:                    │
-│  export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"
-│  claude --continue                          │
-└─────────────────────────────────────────────┘
 ```
+Plexor Settings
+===============
+Enabled: [enabled - true/false]
+API URL: [apiUrl]
+API Key: plx_****[last 4 chars] (configured/not configured)
+Mode: [mode]
+Provider: [preferredProvider]
+Local Cache: [localCacheEnabled - enabled/disabled]
+Timeout: [timeout]ms
 
-### Set API URL:
-```
-/plexor-settings api-url http://localhost:8000
-```
+Quick Commands:
+- /plexor-enabled - Toggle proxy on/off
+- /plexor-mode - Change optimization mode
+- /plexor-provider - Change provider preference
+- /plexor-status - View usage statistics
 
-Output:
+Dashboard: https://plexor.dev/dashboard
 ```
-✓ API URL set to: http://localhost:8000
 
-To route all traffic through Plexor, run:
-  export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"
-  claude --continue
-```
+**Step 3: If user wants to change a setting**
 
-### Set API URL (production):
-```
-/plexor-settings api-url https://api.plexor.dev
-```
+If the user specifies they want to change something, use the `AskUserQuestion` tool:
 
-Output:
-```
-✓ API URL set to: https://api.plexor.dev
+Question: "Which setting would you like to change?"
+Header: "Setting"
+Options:
+1. **API URL** - Change the Plexor API endpoint
+2. **Mode** - Change optimization mode (eco/balanced/quality)
+3. **Provider** - Change preferred provider
+4. **Timeout** - Change request timeout
 
-To route all traffic through Plexor, run:
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/v1/gateway/anthropic"
-  claude --continue
-```
+Then update `~/.plexor/config.json` with the new value using the Write tool.

package/commands/plexor-status.md

@@ -1,46 +1,61 @@
 ---
-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.
+Show current Plexor proxy status, configuration, and usage statistics.
 
-## Instructions
+## Steps
 
-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
+**Step 1: Read the configuration file**
 
-## Output Format
+Use the Read tool to read the file `~/.plexor/config.json`. If the file doesn't exist, tell the user to run `/plexor-login` first.
 
+**Step 2: Parse configuration and check authentication**
+
+The config file contains:
+- `enabled`: boolean - whether Plexor proxy is enabled
+- `apiUrl`: string - the API URL (e.g., "https://api.plexor.dev")
+- `apiKey`: string - the user's API key (starts with "plx_")
+- `mode`: string - optimization mode ("eco", "balanced", "quality", "passthrough")
+- `preferredProvider`: string - provider preference ("auto", "claude", "openai", etc.)
+- `localCacheEnabled`: boolean - whether local caching is enabled
+
+If `apiKey` is missing or empty, tell the user to run `/plexor-login` first.
+
+**Step 3: Call the stats API**
+
+Make a request to get usage statistics:
 ```
-┌─────────────────────────────────────────────┐
-│  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   │
-└─────────────────────────────────────────────┘
+GET {apiUrl}/api/users/me/usage
+Authorization: Bearer {apiKey}
+```
+
+Note: The apiKey IS the bearer token - use it directly in the Authorization header.
+
+**Step 4: Display the status**
+
+Show the user a formatted status display like this:
+
+```
+Plexor Status
+=============
+Account: [tier from API response, e.g., "Pro" or "Free"]
+Status: [Enabled/Disabled based on config.enabled]
+
+This Session
+  Requests: [totalRequests from API]
+  Tokens saved: [tokensUsed from API]
+  Est. savings: $[costSavings from API]
+
+Settings
+  Mode: [config.mode]
+  Provider: [config.preferredProvider]
+  Local cache: [Enabled/Disabled based on config.localCacheEnabled]
+  API URL: [config.apiUrl]
 
 Dashboard: https://plexor.dev/dashboard
 ```
+
+If the API call fails, show the configuration status and mention the API is unavailable.

package/hooks/intercept.js

@@ -0,0 +1,299 @@
+#!/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
+        }
+      });
+    }
+
+    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;
+}
+
+main().catch((error) => {
+  console.error(`[Plexor] Fatal error: ${error.message}`);
+  process.exit(1);
+});

package/hooks/track-response.js

@@ -0,0 +1,110 @@
+#!/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.
+ *
+ * Input: JSON object with response content, tokens used, etc.
+ * 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 logger = new Logger('track-response');
+const config = new ConfigManager();
+const cache = new LocalCache();
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const response = JSON.parse(input);
+
+    const settings = await config.load();
+
+    // If Plexor is disabled or no API key, just pass through
+    if (!settings.enabled || !settings.apiKey) {
+      return output(response);
+    }
+
+    // Check if this response has Plexor metadata
+    const plexorMeta = response._plexor;
+    if (!plexorMeta || !plexorMeta.request_id) {
+      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
+
+    // Pass through unchanged
+    return output(response);
+
+  } catch (error) {
+    logger.error(`[Plexor] Tracking error: ${error.message}`);
+
+    // On any error, pass through unchanged
+    try {
+      const input = await readStdin();
+      return output(JSON.parse(input));
+    } 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'));
+    }, 2000);
+  });
+}
+
+function output(data) {
+  const json = JSON.stringify(data);
+  process.stdout.write(json);
+  process.exit(0);
+}
+
+function estimateTokens(text) {
+  // Approximate: ~4 characters per token
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+
+main().catch((error) => {
+  console.error(`[Plexor] Fatal error: ${error.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "scripts": {
@@ -10,6 +10,7 @@
   },
   "files": [
     "commands/",
+    "hooks/",
     "scripts/",
     "lib/",
     "README.md",

package/lib/constants.js

@@ -1,40 +0,0 @@
-/**
- * Plexor Claude Code Plugin - Constants
- */
-
-const path = require('path');
-const os = require('os');
-
-module.exports = {
-  // API endpoints
-  PLEXOR_API_URL: process.env.PLEXOR_API_URL || 'https://api.plexor.dev',
-  PLEXOR_GATEWAY_URL: process.env.PLEXOR_GATEWAY_URL || 'https://api.plexor.dev/v1',
-  PLEXOR_AUTH_URL: 'https://plexor.dev/auth/device',
-
-  // File paths
-  PLEXOR_CONFIG_DIR: process.env.PLEXOR_CONFIG_DIR || path.join(os.homedir(), '.plexor'),
-  PLEXOR_CONFIG_FILE: path.join(
-    process.env.PLEXOR_CONFIG_DIR || path.join(os.homedir(), '.plexor'),
-    'config.json'
-  ),
-  CLAUDE_COMMANDS_DIR: path.join(os.homedir(), '.claude', 'commands'),
-
-  // Config schema version
-  CONFIG_VERSION: 1,
-
-  // Default settings
-  DEFAULTS: {
-    enabled: true,
-    preferred_provider: 'auto',
-    telemetry: true,
-    local_cache: false
-  },
-
-  // API key prefix for identification
-  API_KEY_PREFIX: 'plx_',
-
-  // Timeouts (ms)
-  DEVICE_CODE_POLL_INTERVAL: 5000,
-  DEVICE_CODE_TIMEOUT: 900000, // 15 minutes
-  API_TIMEOUT: 30000
-};