squeezr-ai 1.17.5 → 1.17.6

package/README.md

@@ -174,7 +174,7 @@ Squeezr uses cheap/free models for AI compression (the deterministic layer is pu
 ## CLI commands
 
 ```bash
-squeezr setup      # configure env vars, auto-start, CA trust
+squeezr setup      # configure env vars, auto-start, CA trust, install MCP server
 squeezr start      # start the proxy (auto-restarts if version mismatch after update)
 squeezr update     # kill old processes, install latest from npm, restart
 squeezr stop       # stop the proxy
@@ -184,10 +184,28 @@ squeezr config     # print current config
 squeezr ports      # change HTTP and MITM proxy ports
 squeezr gain       # estimate token savings for a directory
 squeezr discover   # detect which AI CLIs are installed
+squeezr mcp install    # register MCP server in Claude Code, Cursor, Windsurf, Cline
+squeezr mcp uninstall  # remove MCP server registration
 squeezr uninstall  # remove Squeezr completely (env vars, CA, auto-start, logs)
 squeezr version    # print version
 ```
 
+## MCP server
+
+Squeezr ships with a built-in MCP server (`squeezr-mcp`) that gives any MCP-capable AI CLI real-time awareness of Squeezr's state and control over it.
+
+**Installed automatically** by `squeezr setup` into Claude Code, Cursor, Windsurf, and Cline.
+
+Available MCP tools:
+
+| Tool | Description |
+|---|---|
+| `squeezr_status` | Is proxy running? Version, port, uptime, mode |
+| `squeezr_stats` | Token savings, compression %, cost saved, per-tool breakdown |
+| `squeezr_set_mode` | Change compression mode instantly (soft / normal / aggressive / critical) |
+| `squeezr_config` | Current thresholds, keepRecent, cache sizes |
+| `squeezr_habits` | Detect wasteful patterns this session (duplicate reads, high Bash count, cache efficiency) |
+
 ## Requirements
 
 - Node.js 18+ (compatible with Node.js 24)

package/bin/squeezr.js

@@ -199,10 +199,10 @@ Usage:
   squeezr discover         Show pattern coverage report (proxy must be running)
   squeezr status           Check if proxy is running
   squeezr config           Print config file path and current settings
+  squeezr mcp install      Register Squeezr MCP server in Claude Code, Cursor, Windsurf & Cline
+  squeezr mcp uninstall    Remove Squeezr MCP registration
   squeezr ports            Change HTTP and MITM proxy ports
   squeezr tunnel           Expose proxy via Cloudflare Tunnel for Cursor IDE
-  squeezr cursor           Start Cursor subscription MITM proxy (no BYOK needed)
-  squeezr cursor stop      Stop Cursor proxy and clean up system proxy settings
   squeezr update           Kill old processes, install latest from npm, restart
   squeezr uninstall        Remove Squeezr completely (env vars, CA, auto-start, logs)
   squeezr version          Print version
@@ -393,6 +393,100 @@ function showConfig() {
   }
 }
 
+
+// ── squeezr mcp ───────────────────────────────────────────────────────────────
+
+async function mcpInstall() {
+  const mcpServerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'mcp.js')
+  const entry = {
+    type: 'stdio',
+    command: 'node',
+    args: [mcpServerPath],
+  }
+
+  const targets = [
+    {
+      name: 'Claude Code',
+      file: path.join(os.homedir(), '.claude.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Cursor',
+      file: path.join(os.homedir(), '.cursor', 'mcp.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Windsurf',
+      file: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+      key: 'mcpServers',
+    },
+    {
+      name: 'Cline / Roo-Cline',
+      file: path.join(os.homedir(), '.vscode', 'extensions', 'mcp_settings.json'),
+      key: 'mcpServers',
+    },
+  ]
+
+  let installed = 0
+
+  for (const target of targets) {
+    try {
+      // Only install into configs that already exist (user has that tool)
+      if (!fs.existsSync(target.file) && target.name !== 'Claude Code') continue
+
+      let cfg = {}
+      if (fs.existsSync(target.file)) {
+        try { cfg = JSON.parse(fs.readFileSync(target.file, 'utf-8')) } catch { cfg = {} }
+      }
+      cfg[target.key] = cfg[target.key] || {}
+      cfg[target.key].squeezr = entry
+
+      const dir = path.dirname(target.file)
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(target.file, JSON.stringify(cfg, null, 2))
+      console.log()
+      console.log('  ok ' + target.name + ': ' + target.file)
+    } catch (e) {
+      console.warn()
+      console.warn('  warn ' + target.name + ': ' + (e.message || e))
+  }
+
+  console.log()
+  console.log('MCP server registered in ' + installed + ' client(s).')
+  console.log('Server binary: ' + mcpServerPath)
+  console.log('')
+  console.log('Available tools in Claude/Codex/Cursor:')
+  console.log('  squeezr_status   — Check if Squeezr is running')
+  console.log('  squeezr_stats    — Real-time token savings')
+  console.log('  squeezr_set_mode — Change compression aggressiveness')
+  console.log('  squeezr_config   — Current configuration')
+  console.log('  squeezr_habits   — Wasteful pattern report')
+}
+
+async function mcpUninstall() {
+  const files = [
+    path.join(os.homedir(), '.claude.json'),
+    path.join(os.homedir(), '.cursor', 'mcp.json'),
+    path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    path.join(os.homedir(), '.vscode', 'extensions', 'mcp_settings.json'),
+  ]
+  let removed = 0
+  for (const file of files) {
+    if (!fs.existsSync(file)) continue
+    try {
+      const cfg = JSON.parse(fs.readFileSync(file, 'utf-8'))
+      if (cfg.mcpServers?.squeezr) {
+        delete cfg.mcpServers.squeezr
+        fs.writeFileSync(file, JSON.stringify(cfg, null, 2))
+        console.log()
+        removed++
+      }
+    } catch { /* ignore */ }
+  }
+  if (removed === 0) console.log('Squeezr MCP not found in any config.')
+  else console.log()
+}
+
 // ── squeezr ports ─────────────────────────────────────────────────────────────
 
 async function configurePorts() {
@@ -1256,162 +1350,6 @@ async function startTunnel() {
   process.on('SIGTERM', () => { child.kill(); process.exit(0) })
 }
 
-// ── squeezr cursor ───────────────────────────────────────────────────────────
-
-async function startCursorProxy() {
-  const port = getPort()
-  const mitmPort = getMitmPort(port)
-
-  // Verify main proxy is running first
-  const running = await new Promise(resolve => {
-    const req = http.get(`http://localhost:${port}/squeezr/health`, res => {
-      resolve(res.statusCode === 200)
-    })
-    req.on('error', () => resolve(false))
-    req.setTimeout(2000, () => { req.destroy(); resolve(false) })
-  })
-
-  if (!running) {
-    console.error(`Squeezr proxy is not running on port ${port}.`)
-    console.error('Start it first: squeezr start')
-    process.exit(1)
-  }
-
-  // Verify CA exists
-  const caDir = path.join(os.homedir(), '.squeezr', 'mitm-ca')
-  const caCertPath = path.join(caDir, 'ca.crt')
-  if (!fs.existsSync(caCertPath)) {
-    console.error('MITM CA certificate not found. Run `squeezr setup` first.')
-    process.exit(1)
-  }
-
-  console.log('Starting Cursor MITM proxy...')
-
-  const distPath = path.join(ROOT, 'dist', 'cursorMitm.js')
-  if (!fs.existsSync(distPath)) {
-    console.error(`Error: ${distPath} not found. Run 'npm run build' first.`)
-    process.exit(1)
-  }
-
-  const distUrl = process.platform === 'win32' ? 'file:///' + distPath.replace(/\\/g, '/') : distPath
-  const { startCursorMitm, getCursorMitmPort, getCursorStats } = await import(distUrl)
-
-  try {
-    await startCursorMitm()
-  } catch (err) {
-    console.error('Failed to start Cursor proxy:', err.message)
-    process.exit(1)
-  }
-
-  const actualPort = getCursorMitmPort()
-  const proxyConfigured = configureSystemProxy(actualPort)
-
-  console.log('')
-  console.log('╔══════════════════════════════════════════════════════════════════╗')
-  console.log(`║  Cursor MITM proxy active on port ${actualPort}                        ║`)
-  console.log('╠══════════════════════════════════════════════════════════════════╣')
-  console.log('║                                                                  ║')
-  console.log('║  Intercepting: api2.cursor.sh (chat, agent, composer)           ║')
-  console.log('║  Compressing:  conversation context via cursor-small            ║')
-  console.log('║  Everything else: transparent pass-through                       ║')
-  console.log('║                                                                  ║')
-  if (proxyConfigured) {
-    console.log('║  System proxy configured automatically.                         ║')
-    console.log('║  Cursor will route through Squeezr on next request.             ║')
-  } else {
-    console.log('║  ⚠ Could not set system proxy automatically.                   ║')
-    console.log('║  Set it manually:                                               ║')
-    if (process.platform === 'win32') {
-      console.log(`║    Settings > Network > Proxy > Manual: 127.0.0.1:${actualPort}     ║`)
-    } else if (process.platform === 'darwin') {
-      console.log(`║    networksetup -setsecurewebproxy Wi-Fi 127.0.0.1 ${actualPort}     ║`)
-    } else {
-      console.log(`║    export HTTPS_PROXY=http://127.0.0.1:${actualPort}                  ║`)
-    }
-  }
-  console.log('║                                                                  ║')
-  console.log('║  Press Ctrl+C to stop and clean up proxy settings               ║')
-  console.log('╚══════════════════════════════════════════════════════════════════╝')
-  console.log('')
-
-  const statsInterval = setInterval(() => {
-    const s = getCursorStats()
-    if (s.requests > 0) {
-      console.log(`[squeezr/cursor] Stats: ${s.requests} requests, ${s.compressed} compressed, -${s.charsSaved.toLocaleString()} chars saved`)
-    }
-  }, 30_000)
-
-  const cleanup = () => {
-    clearInterval(statsInterval)
-    console.log('\nStopping Cursor proxy...')
-    cleanSystemProxy()
-    const s = getCursorStats()
-    console.log(`Session: ${s.requests} requests, ${s.compressed} compressed, -${s.charsSaved.toLocaleString()} chars saved`)
-    process.exit(0)
-  }
-
-  process.on('SIGINT', cleanup)
-  process.on('SIGTERM', cleanup)
-}
-
-function configureSystemProxy(port) {
-  try {
-    if (process.platform === 'win32') {
-      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 1 /f`, { stdio: 'pipe' })
-      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyServer /t REG_SZ /d "127.0.0.1:${port}" /f`, { stdio: 'pipe' })
-      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyOverride /t REG_SZ /d "<local>;localhost;127.0.0.1" /f`, { stdio: 'pipe' })
-      return true
-    } else if (process.platform === 'darwin') {
-      try {
-        const services = execSync('networksetup -listallnetworkservices', { encoding: 'utf-8' })
-          .split('\n')
-          .filter(s => s.trim() && !s.startsWith('*') && !s.startsWith('An asterisk'))
-        for (const svc of services) {
-          try {
-            execSync(`networksetup -setsecurewebproxy "${svc.trim()}" 127.0.0.1 ${port}`, { stdio: 'pipe' })
-          } catch {}
-        }
-        return true
-      } catch { return false }
-    } else {
-      try {
-        execSync(`gsettings set org.gnome.system.proxy mode 'manual'`, { stdio: 'pipe' })
-        execSync(`gsettings set org.gnome.system.proxy.https host '127.0.0.1'`, { stdio: 'pipe' })
-        execSync(`gsettings set org.gnome.system.proxy.https port ${port}`, { stdio: 'pipe' })
-        return true
-      } catch { return false }
-    }
-  } catch {
-    return false
-  }
-}
-
-function cleanSystemProxy() {
-  try {
-    if (process.platform === 'win32') {
-      execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 0 /f`, { stdio: 'pipe' })
-    } else if (process.platform === 'darwin') {
-      try {
-        const services = execSync('networksetup -listallnetworkservices', { encoding: 'utf-8' })
-          .split('\n')
-          .filter(s => s.trim() && !s.startsWith('*') && !s.startsWith('An asterisk'))
-        for (const svc of services) {
-          try {
-            execSync(`networksetup -setsecurewebproxystate "${svc.trim()}" off`, { stdio: 'pipe' })
-          } catch {}
-        }
-      } catch {}
-    } else {
-      try {
-        execSync(`gsettings set org.gnome.system.proxy mode 'none'`, { stdio: 'pipe' })
-      } catch {}
-    }
-    console.log('System proxy settings cleaned up.')
-  } catch {
-    console.warn('Could not clean system proxy settings. You may need to disable manually.')
-  }
-}
-
 // ── CLI router ────────────────────────────────────────────────────────────────
 
 switch (command) {
@@ -1529,14 +1467,6 @@ switch (command) {
     await startTunnel()
     break
 
-  case 'cursor':
-    if (args[1] === 'stop') {
-      cleanSystemProxy()
-    } else {
-      await startCursorProxy()
-    }
-    break
-
   case 'uninstall':
     await uninstall()
     break
@@ -1544,6 +1474,12 @@ switch (command) {
     showConfig()
     break
 
+  case 'mcp': {
+    const subCmd = args[0] ?? 'install'
+    if (subCmd === 'uninstall') await mcpUninstall()
+    else await mcpInstall()
+    break
+  }
   case 'version':
   case '--version':
   case '-v':

package/dist/mcp.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Squeezr MCP Server
+ *
+ * Gives any MCP-compatible AI CLI (Claude Code, Cursor, Windsurf, Cline…)
+ * real-time awareness of Squeezr's state and control over it.
+ *
+ * Transport: stdio (universal — works with all MCP clients)
+ * Queries the Squeezr proxy via HTTP on localhost.
+ *
+ * Tools exposed:
+ *   squeezr_status   — Is proxy running? Port, version, uptime
+ *   squeezr_stats    — Token savings, compression %, by-tool breakdown
+ *   squeezr_set_mode — Change compression aggressiveness instantly
+ *   squeezr_config   — Current thresholds and settings
+ *   squeezr_habits   — Detected wasteful patterns this session
+ */
+export {};

package/dist/mcp.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+/**
+ * Squeezr MCP Server
+ *
+ * Gives any MCP-compatible AI CLI (Claude Code, Cursor, Windsurf, Cline…)
+ * real-time awareness of Squeezr's state and control over it.
+ *
+ * Transport: stdio (universal — works with all MCP clients)
+ * Queries the Squeezr proxy via HTTP on localhost.
+ *
+ * Tools exposed:
+ *   squeezr_status   — Is proxy running? Port, version, uptime
+ *   squeezr_stats    — Token savings, compression %, by-tool breakdown
+ *   squeezr_set_mode — Change compression aggressiveness instantly
+ *   squeezr_config   — Current thresholds and settings
+ *   squeezr_habits   — Detected wasteful patterns this session
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { createRequire } from 'node:module';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+// ── Resolve proxy port from squeezr.toml ─────────────────────────────────────
+function getProxyPort() {
+    try {
+        const tomlPath = join(__dirname, '..', 'squeezr.toml');
+        if (existsSync(tomlPath)) {
+            const toml = readFileSync(tomlPath, 'utf-8');
+            const m = toml.match(/^\s*port\s*=\s*(\d+)/m);
+            if (m)
+                return parseInt(m[1]);
+        }
+    }
+    catch { /* ignore */ }
+    return parseInt(process.env.SQUEEZR_PORT ?? '8080');
+}
+const BASE_URL = process.env.SQUEEZR_URL ?? `http://localhost:${getProxyPort()}`;
+// ── HTTP helpers ──────────────────────────────────────────────────────────────
+async function proxyGet(path) {
+    try {
+        const res = await fetch(`${BASE_URL}${path}`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function proxyPost(path, body) {
+    try {
+        const res = await fetch(`${BASE_URL}${path}`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+function fmtNum(n) {
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(1) + 'M';
+    if (n >= 1_000)
+        return (n / 1_000).toFixed(1) + 'K';
+    return String(n);
+}
+function fmtUptime(s) {
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ${s % 60}s`;
+    return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}
+// ── MCP Server setup ──────────────────────────────────────────────────────────
+const pkg = require('../package.json');
+const server = new Server({ name: 'squeezr', version: pkg.version }, { capabilities: { tools: {} } });
+// ── Tool definitions ──────────────────────────────────────────────────────────
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'squeezr_status',
+            description: 'Check if the Squeezr proxy is running. Returns version, port, uptime, ' +
+                'compression mode, and whether dry-run is active. ' +
+                'Call this first to confirm Squeezr is active before querying other tools.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'squeezr_stats',
+            description: 'Get real-time token compression statistics for the current Squeezr session. ' +
+                'Returns: tokens saved, chars saved, compression %, total requests, ' +
+                'session cache hits, cost saved estimate, and per-tool breakdown. ' +
+                'Use this to understand how much context Squeezr is saving right now.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'squeezr_set_mode',
+            description: 'Change Squeezr compression aggressiveness instantly without restarting. ' +
+                'Takes effect on the next request. Use "aggressive" or "critical" when ' +
+                'approaching context limits. Use "soft" when you need full fidelity on outputs.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    mode: {
+                        type: 'string',
+                        enum: ['soft', 'normal', 'aggressive', 'critical'],
+                        description: 'soft: minimal compression, last 10 results kept, no AI compression. ' +
+                            'normal: default (threshold 800 chars, last 3 kept). ' +
+                            'aggressive: threshold 200 chars, last 1 kept, AI compression on. ' +
+                            'critical: threshold 50 chars, everything compressed, max savings.',
+                    },
+                },
+                required: ['mode'],
+            },
+        },
+        {
+            name: 'squeezr_config',
+            description: 'Get the current Squeezr configuration: active compression mode, ' +
+                'threshold values, keepRecent setting, which tools are AI-skipped, ' +
+                'and whether AI compression is currently enabled.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'squeezr_habits',
+            description: 'Get a report of detected token-wasteful patterns in the current session. ' +
+                'Shows which deterministic patterns fired (duplicate reads, lock files, ' +
+                'repeated errors, large outputs) and how many tokens they saved or wasted. ' +
+                'Useful for improving how you use Claude to spend fewer tokens.',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+    ],
+}));
+// ── Tool handlers ─────────────────────────────────────────────────────────────
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    // ── squeezr_status ──────────────────────────────────────────────────────────
+    if (name === 'squeezr_status') {
+        const health = await proxyGet('/squeezr/health');
+        const stats = await proxyGet('/squeezr/stats');
+        if (!health) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            '❌ Squeezr proxy is NOT running.',
+                            '',
+                            `Expected at: ${BASE_URL}`,
+                            'Start it with: squeezr start',
+                            '',
+                            'Without Squeezr, your tool results are sent to the API uncompressed.',
+                        ].join('\n'),
+                    }],
+                isError: false,
+            };
+        }
+        const uptime = stats ? fmtUptime(stats.uptime_seconds ?? 0) : '?';
+        const mode = stats ? (stats.mode ?? 'normal') : 'normal';
+        const dryRun = stats ? stats.dry_run : false;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ Squeezr v${health.version ?? '?'} is running`,
+                        `   Port    : ${BASE_URL}`,
+                        `   Uptime  : ${uptime}`,
+                        `   Mode    : ${mode}${dryRun ? ' (dry-run)' : ''}`,
+                        `   Dashboard: ${BASE_URL}/squeezr/dashboard`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    // ── squeezr_stats ───────────────────────────────────────────────────────────
+    if (name === 'squeezr_stats') {
+        const data = await proxyGet('/squeezr/stats');
+        if (!data) {
+            return {
+                content: [{ type: 'text', text: '❌ Squeezr proxy is not running. Start with: squeezr start' }],
+                isError: false,
+            };
+        }
+        const savedTokens = data.total_saved_tokens ?? 0;
+        const savedChars = data.total_saved_chars ?? 0;
+        const pct = data.savings_pct ?? 0;
+        const requests = data.requests ?? 0;
+        const compressions = data.compressions ?? 0;
+        const cacheHits = data.session_cache_hits ?? 0;
+        const uptime = fmtUptime(data.uptime_seconds ?? 0);
+        const costUsd = (savedTokens / 1_000_000) * 3;
+        const byTool = data.by_tool ?? {};
+        const sessionCache = data.session_cache_size ?? 0;
+        const patternHits = data.pattern_hits ?? {};
+        const totalPatterns = Object.values(patternHits).reduce((s, v) => s + v, 0);
+        const toolLines = Object.entries(byTool)
+            .sort((a, b) => b[1].saved_tokens - a[1].saved_tokens)
+            .slice(0, 8)
+            .map(([tool, t]) => `   ${tool.padEnd(16)} ${fmtNum(t.saved_tokens).padStart(7)} tokens  ${t.avg_pct}% avg  ×${t.count}`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '📊 Squeezr Session Stats',
+                        '─'.repeat(40),
+                        `Tokens saved     : ${fmtNum(savedTokens)} (~${savedChars.toLocaleString()} chars)`,
+                        `Compression      : ${pct}% of tool results`,
+                        `Cost saved       : $${costUsd.toFixed(3)} (@ $3/MTok)`,
+                        `Requests         : ${requests} (${compressions} compressions)`,
+                        `Session cache    : ${cacheHits} hits (${sessionCache} entries)`,
+                        `Pattern hits     : ${totalPatterns.toLocaleString()}`,
+                        `Uptime           : ${uptime}`,
+                        '',
+                        toolLines.length > 0 ? 'By tool:\n' + toolLines.join('\n') : 'No tool results compressed yet.',
+                    ].join('\n'),
+                }],
+        };
+    }
+    // ── squeezr_set_mode ────────────────────────────────────────────────────────
+    if (name === 'squeezr_set_mode') {
+        const parsed = z.object({
+            mode: z.enum(['soft', 'normal', 'aggressive', 'critical']),
+        }).parse(args);
+        const modeInfo = {
+            soft: 'threshold=3000 chars, last 10 results uncompressed, AI off',
+            normal: 'threshold=800 chars, last 3 results uncompressed, AI on new blocks',
+            aggressive: 'threshold=200 chars, last 1 result uncompressed, AI on',
+            critical: 'threshold=50 chars, all results compressed, maximum savings',
+        };
+        const result = await proxyPost('/squeezr/config', { mode: parsed.mode });
+        if (!result) {
+            return {
+                content: [{ type: 'text', text: '❌ Squeezr proxy is not running. Start with: squeezr start' }],
+                isError: false,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ Compression mode set to: ${parsed.mode}`,
+                        `   ${modeInfo[parsed.mode]}`,
+                        '',
+                        parsed.mode === 'critical'
+                            ? '⚠️  Critical mode compresses everything aggressively. Switch back to normal when context pressure drops.'
+                            : parsed.mode === 'aggressive'
+                                ? '🔥 Aggressive mode active. Use when context is above 70%.'
+                                : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    }
+    // ── squeezr_config ──────────────────────────────────────────────────────────
+    if (name === 'squeezr_config') {
+        const data = await proxyGet('/squeezr/stats');
+        if (!data) {
+            return {
+                content: [{ type: 'text', text: '❌ Squeezr proxy is not running. Start with: squeezr start' }],
+                isError: false,
+            };
+        }
+        const mode = data.mode ?? 'normal';
+        const dryRun = data.dry_run ?? false;
+        const cacheStats = data.cache;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '⚙️  Squeezr Configuration',
+                        '─'.repeat(40),
+                        `Compression mode : ${mode}`,
+                        `Dry-run          : ${dryRun ? 'yes (no actual compression)' : 'no'}`,
+                        `LRU cache        : ${cacheStats?.size ?? '?'} entries | ${cacheStats?.hit_rate_pct ?? '?'}% hit rate`,
+                        `Session cache    : ${data.session_cache_size ?? '?'} entries`,
+                        `Expand store     : ${data.expand_store_size ?? '?'} entries`,
+                        '',
+                        'Modes available:',
+                        '  soft       — minimal, no AI compression',
+                        '  normal     — default balanced',
+                        '  aggressive — max useful compression',
+                        '  critical   — compress everything',
+                        '',
+                        `Change with: squeezr_set_mode({ mode: "aggressive" })`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    // ── squeezr_habits ──────────────────────────────────────────────────────────
+    if (name === 'squeezr_habits') {
+        const data = await proxyGet('/squeezr/stats');
+        if (!data) {
+            return {
+                content: [{ type: 'text', text: '❌ Squeezr proxy is not running. Start with: squeezr start' }],
+                isError: false,
+            };
+        }
+        const patternHits = data.pattern_hits ?? {};
+        const byTool = data.by_tool ?? {};
+        const habits = [];
+        // Detect lock file reads
+        const readTool = byTool['Read'] ?? byTool['read'];
+        if (readTool && readTool.count > 5) {
+            habits.push({
+                level: readTool.count > 20 ? '🔴' : '🟡',
+                msg: `Read tool called ${readTool.count}× this session. Check for lock file reads or repeated file reads.`,
+            });
+        }
+        // Detect read-dedup pattern hits (same file read multiple times)
+        if ((patternHits['readDedup'] ?? 0) > 0) {
+            habits.push({
+                level: '🟡',
+                msg: `${patternHits['readDedup']} duplicate file read(s) detected and collapsed. Consider using @file to pin frequently needed files.`,
+            });
+        }
+        // Detect high bash call count
+        const bashTool = byTool['Bash'] ?? byTool['bash'];
+        if (bashTool && bashTool.count > 30) {
+            habits.push({
+                level: '🟡',
+                msg: `Bash called ${bashTool.count}× — if repeatedly running the same command, consider using --watch mode.`,
+            });
+        }
+        // Detect low compression on Read (code quality concern)
+        if (readTool && readTool.avg_pct < 10 && readTool.count > 3) {
+            habits.push({
+                level: '🟢',
+                msg: `Read tool results have ${readTool.avg_pct}% compression (code files protected from AI summarization — this is correct).`,
+            });
+        }
+        // Session cache effectiveness
+        const cacheHits = data.session_cache_hits ?? 0;
+        const compressions = data.compressions ?? 0;
+        if (compressions > 0) {
+            const hitRate = Math.round((cacheHits / (cacheHits + compressions)) * 100);
+            if (hitRate > 50) {
+                habits.push({
+                    level: '🟢',
+                    msg: `Session cache ${hitRate}% hit rate — repeated tool results are being reused efficiently.`,
+                });
+            }
+        }
+        const totalSaved = data.total_saved_tokens ?? 0;
+        const requests = data.requests ?? 0;
+        if (habits.length === 0) {
+            habits.push({ level: '🟢', msg: 'No significant wasteful patterns detected this session.' });
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '🔍 Squeezr Habit Report (current session)',
+                        '─'.repeat(40),
+                        `Session: ${requests} requests | ${fmtNum(totalSaved)} tokens saved`,
+                        '',
+                        ...habits.map(h => `${h.level} ${h.msg}`),
+                        '',
+                        'Tip: use squeezr_set_mode to control compression aggressiveness.',
+                    ].join('\n'),
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true,
+    };
+});
+// ── Start server ──────────────────────────────────────────────────────────────
+const transport = new StdioServerTransport();
+await server.connect(transport);
+// stderr only — stdout is reserved for MCP protocol
+process.stderr.write(`[squeezr-mcp] Squeezr MCP server v${pkg.version} ready (proxy: ${BASE_URL})\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squeezr-ai",
-  "version": "1.17.5",
+  "version": "1.17.6",
   "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
   "keywords": [
     "claude",
@@ -23,7 +23,8 @@
   "homepage": "https://github.com/sergioramosv/Squeezr#readme",
   "type": "module",
   "bin": {
-    "squeezr": "bin/squeezr.js"
+    "squeezr": "bin/squeezr.js",
+    "squeezr-mcp": "dist/mcp.js"
   },
   "scripts": {
     "build": "tsc",
@@ -43,10 +44,12 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "@bufbuild/protobuf": "^2.11.0",
     "@hono/node-server": "^1.13.7",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "hono": "^4.7.5",
     "node-forge": "^1.4.0",
     "openai": "^4.93.0",
-    "smol-toml": "^1.3.1"
+    "smol-toml": "^1.3.1",
+    "zod": "^3.24.0"
   },
   "devDependencies": {
     "@types/node": "^22.14.0",