@grapine.ai/contextprune 0.1.0 → 0.1.1

package/README.md

@@ -1 +1,426 @@
-# Placeholder for @grapine.ai/contextprune
+# @grapine.ai/contextprune
+
+**Garbage collection for LLM context windows.**
+
+Sits between your application and the LLM API. Analyzes your `messages[]` array, removes dead weight — stale tool outputs, resolved errors, superseded reasoning — and returns a leaner version. Every API call costs less. The model stays focused on what actually matters.
+
+**100% local. No data sent anywhere. No LLM calls during compression.**
+
+```bash
+npm install @grapine.ai/contextprune
+```
+
+---
+
+## The problem
+
+Long LLM sessions fill up fast:
+
+```
+Turn  1  ████░░░░░░░░░░░░░░░░░░░░░░░░░░   12%   4,100 tokens
+Turn  5  ████████████░░░░░░░░░░░░░░░░░░   38%  12,800 tokens
+Turn 10  ████████████████████░░░░░░░░░░   58%  19,400 tokens
+Turn 15  ████████████████████████████░░   78%  26,100 tokens  ← quality degrades here
+Turn 20  ██████████████████████████████   91%  30,600 tokens  ← coherence cliff
+```
+
+Around 65–75% utilization, model behavior suddenly gets worse — the model loses track of earlier constraints, repeats itself, makes mistakes it wouldn't make with a clean context. Most developers hit this, get confused, and manually clear context — losing all the good state too.
+
+**With contextprune:**
+
+```
+Turn  1  ████░░░░░░░░░░░░░░░░░░░░░░░░░░   12%   4,100 tokens    —
+Turn  5  ████████████░░░░░░░░░░░░░░░░░░   38%  12,800 tokens    —
+Turn  6  ████░░░░░░░░░░░░░░░░░░░░░░░░░░   11%   3,700 tokens  ← compressed, 71% saved
+Turn 10  ██████████░░░░░░░░░░░░░░░░░░░░   28%   9,500 tokens    —
+Turn 11  ████░░░░░░░░░░░░░░░░░░░░░░░░░░   10%   3,200 tokens  ← compressed, 66% saved
+Turn 20  ████████████░░░░░░░░░░░░░░░░░░   34%  11,600 tokens    ← never exceeds 40%
+```
+
+---
+
+## Quick start
+
+```ts
+import { ContextPrune } from '@grapine.ai/contextprune';
+
+const cp = new ContextPrune({ model: 'claude-sonnet-4-5' });
+
+const result = await cp.compress(messages);
+// result.messages is a drop-in replacement for messages
+// result.summary.tokensSaved — tokens recovered
+// result.summary.savingsPercent — e.g. 0.47 = 47% saved
+```
+
+One line changes in your existing code:
+
+```ts
+// Before
+const response = await anthropic.messages.create({
+  model: 'claude-sonnet-4-5',
+  messages,          // ← growing unbounded
+  max_tokens: 8096,
+});
+
+// After
+const { messages: lean } = await cp.compress(messages);
+const response = await anthropic.messages.create({
+  model: 'claude-sonnet-4-5',
+  messages: lean,    // ← compressed
+  max_tokens: 8096,
+});
+```
+
+---
+
+## Installation
+
+```bash
+npm install @grapine.ai/contextprune
+```
+
+Requires Node 18+. No mandatory peer dependencies — tiktoken is used for token counting when available, otherwise falls back to a character estimate.
+
+---
+
+## CLI
+
+No code required. Run directly with `npx` — no install needed.
+
+### `analyze` — understand what's in your context
+
+```bash
+npx @grapine.ai/contextprune analyze ./session.json
+npx @grapine.ai/contextprune analyze ./session.jsonl   # Claude Code session transcripts too
+```
+
+```
+─── ContextPrune Analysis ──────────────────────────────────────────────────
+Model: claude-sonnet-4-5  |  Capacity: 200,000 tokens
+
+  ████████████████░░░░░░░░░░░░░░  56%  used  ·  112,266 / 200,000 tokens
+
+  [SUGGESTED] Context is 56% full. Compression available but not urgent.
+  Projected savings: 48,100 tokens (43%)  →  64,166 tokens after
+
+Classification Breakdown:
+  Outdated Tool Result    82 msgs   53,099 tokens  ████████████░  47%
+  Chat / Filler           54 msgs   24,446 tokens  ████████░░░░░  22%
+  Tool Result (active)    86 msgs   23,528 tokens  ████████░░░░░  21%
+  Final Answer             1 msgs   11,406 tokens  ████░░░░░░░░░  10%
+
+Compression Strategies:
+  Keep                 141 msgs   64,166 tokens
+  Remove                69 msgs   37,814 tokens  ← will be dropped
+  Trim to Key Output     8 msgs    8,320 tokens  ← key output preserved
+  Collapse to 1 Line     1 msgs    1,966 tokens  ← collapsed to marker
+
+Top Token Consumers:
+  #32  Final Answer             11,406 tokens   Preserved    no opportunity
+  #55  Outdated Tool Result      6,801 tokens   Remove       high opportunity
+  #48  Outdated Tool Result      4,992 tokens   Remove       high opportunity
+  #61  Tool Result (active)      4,210 tokens   Trim         medium opportunity
+```
+
+```bash
+# Also print a session brief — a compact handoff prompt for starting a new session
+npx @grapine.ai/contextprune analyze ./session.jsonl --brief
+```
+
+### `compress` — compress a messages file
+
+```bash
+npx @grapine.ai/contextprune compress ./session.json -o compressed.json
+```
+
+```
+✔ Compressed  112,266 → 64,166 tokens  (43% saved, 48,100 tokens recovered)
+
+Decisions:
+  Removed   69 messages  (Outdated Tool Result, Chat/Filler)
+  Trimmed    8 messages  (Tool Result — key output preserved)
+  Collapsed  1 message   (Reasoning chain → 1-line marker)
+  Kept     141 messages  (constraints, active errors, final answers)
+```
+
+Output is a standard JSON messages array — drop it straight into an API call:
+
+```ts
+const messages = JSON.parse(fs.readFileSync('compressed.json', 'utf-8'));
+await anthropic.messages.create({ model: 'claude-sonnet-4-5', messages, max_tokens: 8096 });
+```
+
+### `watch` — live dashboard in your browser
+
+```bash
+npx @grapine.ai/contextprune watch
+```
+
+Discovers all Claude Code sessions in `~/.claude/projects/` and opens an interactive picker:
+
+```
+  Select a Claude project to monitor:
+
+  › labs/contextprune  #b6c62a11  just now  ● active
+    labs/my-app        #a1d3f920  2h ago
+    work/api-service   #cc8801ab  1d ago
+
+  ↑↓ to navigate · Enter to select · Ctrl+C to cancel
+```
+
+Opens a browser tab and starts live monitoring. The dashboard updates every time the session file changes.
+
+```bash
+# Or point directly at a file
+npx @grapine.ai/contextprune watch --follow ~/.claude/projects/my-project/session.jsonl
+
+# Use a different port
+npx @grapine.ai/contextprune watch --port 8080
+```
+
+---
+
+## Dashboard
+
+A live browser dashboard that monitors your Claude Code sessions in real time. No configuration — run `npx @grapine.ai/contextprune watch` and it opens automatically.
+
+**Healthy Context Dashboard**
+
+![Healthy Context Dashboard](screenshots/cp_dashboard_healthy.jpg)
+
+
+
+**Context Compression Recommendation Dashboard**
+
+![Context Compression Recommendation Dashboard](screenshots/cp_dashboard_compression.jpg)
+
+**What the dashboard shows:**
+
+**Context Window** — utilization bar with colour-coded status (green → yellow → red). Switches to Compression Suggested / Compress Now badges as context fills up.
+
+**Session Cost** — cost per API call with input/output/cache breakdown, grouped by calendar day with proportional bars.
+
+**Classification Breakdown** — how your context is distributed across message types (Outdated Tool Result, Active Tool Result, Chat/Filler, Final Answer, etc.) with token counts and percentages.
+
+**Compression Strategies** — what contextprune would do right now: Keep / Remove / Trim / Collapse counts.
+
+**Compression Projection** — before/after utilization bars showing exactly how much would be recovered if you compressed now. Hidden when context is healthy.
+
+**Top Consumers** — the largest individual messages ranked by token count, with their classification and compression opportunity.
+
+**Session Brief** — auto-generated handoff prompt that appears at 65%+ utilization. One click copies a compact context summary you can paste into a new session to continue without losing state.
+
+**Desktop notifications** — opt-in alerts at 65% utilization, then every 5% increment until you compress.
+
+**Push data from your own process** (no file watching needed):
+
+```bash
+npx @grapine.ai/contextprune watch &
+
+curl -X POST http://localhost:4242/analyze \
+  -H 'Content-Type: application/json' \
+  -d '{ "messages": [...], "model": "gpt-4o" }'
+```
+
+Works with any provider — Anthropic, OpenAI, OpenRouter, Groq, or any messages array you construct yourself.
+
+---
+
+## Three ways to use it
+
+### 1. `compress(messages)` — explicit, you decide when
+
+```ts
+const result = await cp.compress(messages);
+
+console.log(result.summary.tokensSaved);       // 48100
+console.log(result.summary.savingsPercent);    // 0.43
+console.log(result.messages.length);           // fewer messages
+```
+
+Compresses unconditionally every time you call it. Use this when you explicitly decide compression is warranted — after a tool-heavy phase, on every N turns, or as part of a LangGraph compress node.
+
+### 2. `watch(client)` — automatic, zero changes to call sites
+
+```ts
+// Wrap once at startup
+const watched = cp.watch(anthropic);
+
+// Use exactly as before — compression fires automatically when context > 65%
+const response = await watched.messages.create({
+  model: 'claude-sonnet-4-5',
+  messages,
+  max_tokens: 8096,
+});
+```
+
+Works with Anthropic, OpenAI, and any OpenAI-compatible provider:
+
+```ts
+// OpenRouter
+const client = new OpenAI({ baseURL: 'https://openrouter.ai/api/v1', apiKey: '...' });
+const watched = cp.watch(client);
+await watched.chat.completions.create({ model: 'meta-llama/llama-3.3-70b-instruct', messages });
+
+// Groq
+const watched = cp.watch(new Groq());
+await watched.chat.completions.create({ model: 'llama3-70b-8192', messages });
+```
+
+### 3. `analyze(messages)` — read-only inspection
+
+```ts
+const analysis = await cp.analyze(messages);
+
+analysis.recommendation.urgency             // 'none' | 'suggested' | 'recommended' | 'critical'
+analysis.recommendation.projectedSavings    // tokens that would be saved
+analysis.sessionState.tokenBudget.utilizationPercent  // 0.56
+analysis.sessionBrief                       // markdown handoff prompt for context continuation
+```
+
+Never compresses — use this to build dashboards, gate on urgency, or log opportunities.
+
+---
+
+## LangGraph
+
+In a LangGraph agent, `state["messages"]` accumulates every tool result and intermediate step across all graph iterations. By call 20, a typical coding agent has 30–50k tokens of stale tool outputs.
+
+**Wrap the client — zero changes inside the graph:**
+
+```ts
+import { ContextPrune } from '@grapine.ai/contextprune';
+import Anthropic from '@anthropic-ai/sdk';
+
+const client = new ContextPrune({ model: 'claude-sonnet-4-5' }).watch(new Anthropic());
+
+// Every node compresses automatically, only when context > 65%
+function callModel(state: MessagesState) {
+  return client.messages.create({         // ← unchanged
+    model: 'claude-sonnet-4-5',
+    messages: state.messages,
+    max_tokens: 8096,
+  });
+}
+```
+
+**Or add a dedicated compress node:**
+
+```ts
+const cp = new ContextPrune({ model: 'claude-sonnet-4-5' });
+
+async function compressNode(state: MessagesState) {
+  const result = await cp.compress(state.messages);
+  return { messages: result.messages };
+}
+
+builder
+  .addNode('compress', compressNode)
+  .addEdge('tools', 'compress')   // compress after every tool cycle
+  .addEdge('compress', 'agent');
+```
+
+---
+
+## When it helps (and when it doesn't)
+
+**The core prerequisite:** there must be a growing `messages[]` array that gets passed to an LLM repeatedly.
+
+### ✓ It helps: single-agent accumulating loops
+
+```ts
+// ReAct / tool-calling loop — context grows with every iteration
+const messages: LLMMessage[] = [{ role: 'system', content: systemPrompt }];
+
+while (!done) {
+  const response = await llm.invoke(messages);
+  messages.push({ role: 'assistant', content: response.content });
+  const toolResult = await runTool(response);
+  messages.push({ role: 'user', content: toolResult });
+
+  // ← contextprune here: stale tool results removed before next call
+  const { messages: lean } = await cp.compress(messages);
+  messages.splice(0, messages.length, ...lean);
+}
+```
+
+By call 30, a typical agent has accumulated file reads, bash outputs, error traces, and intermediate reasoning that will never be referenced again. Every call pays for all of it. contextprune removes it.
+
+### ✗ It doesn't help: parallel stateless fan-out
+
+```ts
+// Each agent call is 2–3 messages built fresh, discarded after
+const [strategy, calendar, copy] = await Promise.all([
+  orchestrator.invoke([{ role: 'user', content: strategyPrompt }]),
+  strategist.invoke([{ role: 'user', content: calendarPrompt }]),
+  copywriter.invoke([{ role: 'user', content: copyPrompt }]),
+]);
+```
+
+Each call is constructed fresh and discarded. There is no accumulating history. Nothing to prune.
+
+**The diagnostic question:**
+
+> After N agent calls, is there a single `messages[]` array that is longer than it was at call 1?
+
+If yes — contextprune helps. If no — each call starts fresh, and contextprune has no leverage point.
+
+---
+
+## Compression modes
+
+| Mode | When compression runs | Default for |
+|------|----------------------|-------------|
+| `manual` | Always, unconditionally | `compress()` |
+| `auto` | Only when utilization ≥ `warningThreshold` | `watch()` |
+| `suggest-only` | Never — analysis only | `analyze()` |
+
+```ts
+const cp = new ContextPrune({
+  model: 'claude-sonnet-4-5',
+  options: {
+    warningThreshold:  0.65,   // start compressing at 65% full (default)
+    criticalThreshold: 0.80,   // compress aggressively at 80% (default)
+    compressionMode:   'auto', // only compress when needed
+  }
+});
+```
+
+---
+
+## What gets compressed
+
+| Message type | Strategy | Why |
+|---|---|---|
+| Outdated Tool Result | Remove | Not referenced in subsequent turns |
+| Fixed Error | Remove | Stack trace no longer needed |
+| Chain of Thought | Collapse to 1 line | Conclusion already in context |
+| Status Update | Collapse to 1 line | Acknowledged, no longer active |
+| Tool Result (active) | Trim to key output | Keep answer, drop verbose body |
+| Chat / Filler | Remove | Low relevance to current task |
+
+**Always preserved:** system prompts, user corrections, active errors, session goals, final answers.
+
+The classifier assigns one of 11 types to each message. Classification confidence gates compression aggressiveness — if the classifier is uncertain, the message is always preserved.
+
+---
+
+## Supported providers and models
+
+Token budgets are pre-configured for:
+
+| Provider | Models |
+|---|---|
+| Anthropic | Claude 4.x, Claude 3.x (all variants) |
+| OpenAI | GPT-4o, GPT-4.1, GPT-4-turbo, GPT-3.5, o1, o3 series |
+| Google | Gemini 2.5 Pro/Flash, Gemini 2.0, Gemini 1.5 |
+| Meta | Llama 3.3 / 3.1 (70B, 8B) |
+| Mistral | Mistral Large/Medium/Small, Mixtral, Codestral |
+| DeepSeek | DeepSeek Chat, DeepSeek Reasoner |
+| Cohere | Command R, Command R+ |
+| OpenRouter | All `provider/model` prefixed names |
+| Groq | Llama3, Mixtral, Gemma hosted models |
+
+Any unrecognized model string falls back to a 128k token budget.
+
+---

package/dist/cli/commands/analyze.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function analyzeCommand(): Command;

package/dist/cli/commands/analyze.js

@@ -0,0 +1,161 @@
+"use strict";
+// cli/commands/analyze.ts
+// npx contextprune analyze <file>
+// Reads a JSON messages file, runs full pipeline analysis, prints a table.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCommand = analyzeCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const index_1 = require("../../src/index");
+const parse_input_1 = require("../parse-input");
+const labels_1 = require("../labels");
+function analyzeCommand() {
+    return new commander_1.Command('analyze')
+        .description('Analyze a messages JSON file and show context breakdown')
+        .argument('<file>', 'Path to JSON file containing messages array')
+        .option('-m, --model <model>', 'Model to use for token counting', 'claude-sonnet-4-5')
+        .option('--json', 'Output raw JSON instead of formatted table')
+        .option('--brief', 'Print the session brief (handoff prompt for starting a new session)')
+        .action(async (file, opts) => {
+        const spinner = (0, ora_1.default)('Loading messages…').start();
+        let messages;
+        let actualInputTokens;
+        try {
+            ({ messages, actualInputTokens } = (0, parse_input_1.loadMessagesWithUsage)(file));
+        }
+        catch (err) {
+            spinner.fail(`Failed to read file: ${err.message}`);
+            process.exit(1);
+        }
+        spinner.text = 'Analyzing context…';
+        let analysis;
+        try {
+            const ck = new index_1.ContextPrune({ model: opts.model, options: { actualInputTokens } });
+            analysis = await ck.analyze(messages);
+        }
+        catch (err) {
+            spinner.fail(`Analysis failed: ${err.message}`);
+            process.exit(1);
+        }
+        spinner.succeed('Analysis complete.');
+        if (opts.json) {
+            console.log(JSON.stringify(analysis, null, 2));
+            return;
+        }
+        if (opts.brief) {
+            console.log(analysis.sessionBrief);
+            return;
+        }
+        printAnalysis(analysis);
+    });
+}
+function printAnalysis(analysis) {
+    const { annotatedMessages, breakdown, recommendation, sessionState } = analysis;
+    const budget = sessionState.tokenBudget;
+    // ── Header ─────────────────────────────────────────────────────────────────
+    console.log('\n' + chalk_1.default.bold.cyan('─── ContextPrune Analysis ──────────────────────────────'));
+    console.log(chalk_1.default.dim(`Model capacity: ${budget.modelMaxTokens.toLocaleString()} tokens`) +
+        `  |  ` +
+        chalk_1.default.dim(`Current usage: ${budget.currentUsage.toLocaleString()} tokens`) +
+        `  |  ` +
+        utilizationBadge(budget.utilizationPercent));
+    // ── Recommendation ─────────────────────────────────────────────────────────
+    const urgencyColors = {
+        none: chalk_1.default.dim,
+        suggested: chalk_1.default.blue,
+        recommended: chalk_1.default.yellow,
+        critical: chalk_1.default.red,
+    };
+    const urgencyLabels = {
+        none: 'HEALTHY',
+        suggested: 'SUGGESTED',
+        recommended: 'RECOMMENDED',
+        critical: 'CRITICAL',
+    };
+    const urgencyColor = urgencyColors[recommendation.urgency] ?? chalk_1.default.white;
+    const urgencyLabel = urgencyLabels[recommendation.urgency] ?? recommendation.urgency.toUpperCase();
+    console.log('\n' + urgencyColor(`[${urgencyLabel}] ${recommendation.message}`));
+    if (recommendation.projectedSavings > 0) {
+        console.log(chalk_1.default.green(`  Projected savings: ${recommendation.projectedSavings.toLocaleString()} tokens`) +
+            chalk_1.default.dim(` (${Math.round(recommendation.projectedSavingsPercent * 100)}%)`));
+    }
+    // ── Per-classification breakdown ───────────────────────────────────────────
+    console.log('\n' + chalk_1.default.bold('Classification Breakdown:'));
+    const rows = [];
+    for (const [cls, data] of Object.entries(breakdown.byClassification)) {
+        if (!data || data.count === 0)
+            continue;
+        const bar = tokenBar(data.percentOfTotal, 20);
+        rows.push([cls, data.count, data.tokens, bar]);
+    }
+    rows.sort((a, b) => (b[2] ?? 0) - (a[2] ?? 0));
+    for (const [cls, count, tokens, bar] of rows) {
+        console.log(`  ${chalk_1.default.cyan((0, labels_1.clsLabel)(cls).padEnd(28))}` +
+            `${String(count).padStart(4)} msgs  ` +
+            `${String(tokens.toLocaleString()).padStart(8)} tokens  ` +
+            chalk_1.default.green(bar));
+    }
+    // ── Per-strategy breakdown ─────────────────────────────────────────────────
+    console.log('\n' + chalk_1.default.bold('Compression Strategies:'));
+    for (const [strat, data] of Object.entries(breakdown.byCompressionStrategy)) {
+        if (!data || data.count === 0)
+            continue;
+        const saved = data.tokensBefore - data.tokensAfter;
+        const color = strat === 'PRESERVE' ? chalk_1.default.dim : chalk_1.default.yellow;
+        console.log(`  ${color((0, labels_1.stratLabel)(strat).padEnd(20))}` +
+            `${String(data.count).padStart(4)} msgs  ` +
+            (saved > 0 ? chalk_1.default.green(`−${saved.toLocaleString()} tokens`) : ''));
+    }
+    // ── Top consumers ──────────────────────────────────────────────────────────
+    console.log('\n' + chalk_1.default.bold('Top Token Consumers:') + chalk_1.default.dim('  (largest single API calls)'));
+    for (const consumer of analysis.topConsumers.slice(0, 5)) {
+        const opp = opportunityColor(consumer.compressionOpportunity);
+        console.log(`  Call ${String(consumer.originalIndex).padStart(3)}  ` +
+            `${chalk_1.default.cyan((0, labels_1.clsLabel)(consumer.classification).padEnd(25))}` +
+            `${String(consumer.tokenCount.toLocaleString()).padStart(7)} tokens  ` +
+            opp(`[${consumer.compressionOpportunity} opportunity]`));
+    }
+    // ── Per-message table (if short) ──────────────────────────────────────────
+    if (annotatedMessages.length <= 30) {
+        console.log('\n' + chalk_1.default.bold('Message Detail:'));
+        printMessageTable(annotatedMessages);
+    }
+    console.log('');
+}
+function printMessageTable(messages) {
+    console.log(chalk_1.default.dim('  Call Role       Classification              Tokens   Strategy            Score'));
+    console.log(chalk_1.default.dim('  ' + '─'.repeat(80)));
+    for (const m of messages) {
+        const role = m.original.role.padEnd(10);
+        const cls = (0, labels_1.clsLabel)(m.classification).padEnd(28);
+        const tok = String(m.tokenCount).padStart(6);
+        const strat = (0, labels_1.stratLabel)(m.compressionStrategy).padEnd(20);
+        const score = m.relevanceScore.toFixed(2);
+        const rowColor = m.compressionStrategy === 'PRESERVE' ? chalk_1.default.dim : chalk_1.default.white;
+        console.log(rowColor(`  ${String(m.originalIndex).padStart(4)}  ${role} ${cls} ${tok}   ${strat} ${score}`));
+    }
+}
+function utilizationBadge(pct) {
+    const label = `${Math.round(pct * 100)}% utilized`;
+    if (pct >= 0.80)
+        return chalk_1.default.bgRed.white(` ${label} `);
+    if (pct >= 0.65)
+        return chalk_1.default.bgYellow.black(` ${label} `);
+    return chalk_1.default.bgGreen.black(` ${label} `);
+}
+function tokenBar(pct, width) {
+    const filled = Math.round(pct * width);
+    return '█'.repeat(filled) + '░'.repeat(width - filled) + ` ${Math.round(pct * 100)}%`;
+}
+function opportunityColor(opp) {
+    switch (opp) {
+        case 'high': return chalk_1.default.red;
+        case 'medium': return chalk_1.default.yellow;
+        case 'low': return chalk_1.default.blue;
+        default: return chalk_1.default.dim;
+    }
+}

package/dist/cli/commands/compress.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function compressCommand(): Command;

package/dist/cli/commands/compress.js

@@ -0,0 +1,65 @@
+"use strict";
+// cli/commands/compress.ts
+// npx contextprune compress <file> [-o output.json]
+// Reads a messages JSON file, compresses it, writes the compressed result.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressCommand = compressCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const index_1 = require("../../src/index");
+const parse_input_1 = require("../parse-input");
+function compressCommand() {
+    return new commander_1.Command('compress')
+        .description('Compress a messages JSON file and output the result')
+        .argument('<file>', 'Path to JSON file containing messages array')
+        .option('-m, --model <model>', 'Model to use for token counting', 'claude-sonnet-4-5')
+        .option('-o, --output <file>', 'Output file path (default: stdout)')
+        .option('--mode <mode>', 'Compression mode: auto | manual | suggest-only', 'manual')
+        .action(async (file, opts) => {
+        const spinner = (0, ora_1.default)('Loading messages…').start();
+        let messages;
+        try {
+            messages = (0, parse_input_1.loadMessages)(file);
+        }
+        catch (err) {
+            spinner.fail(`Failed to read file: ${err.message}`);
+            process.exit(1);
+        }
+        spinner.text = 'Compressing…';
+        try {
+            const ck = new index_1.ContextPrune({
+                model: opts.model,
+                options: {
+                    compressionMode: opts.mode,
+                },
+            });
+            const result = await ck.compress(messages);
+            spinner.succeed('Compression complete.');
+            const { summary } = result;
+            console.log(chalk_1.default.green(`  Tokens: ${summary.tokensBefore.toLocaleString()} → ${summary.tokensAfter.toLocaleString()}`) +
+                chalk_1.default.dim(`  (−${summary.tokensSaved.toLocaleString()}, ${Math.round(summary.savingsPercent * 100)}% saved)`) +
+                `  Messages: ${messages.length} → ${result.messages.length}`);
+            const output = JSON.stringify(result.messages, null, 2);
+            if (opts.output) {
+                (0, fs_1.writeFileSync)(opts.output, output, 'utf-8');
+                console.log(chalk_1.default.dim(`  Written to ${opts.output}`));
+            }
+            else {
+                console.log(output);
+            }
+            console.log(chalk_1.default.dim(`\n  ℹ  This output is a compressed messages array — it does not modify your live Claude Code session.\n`) +
+                chalk_1.default.dim(`     To use it, pass the result as the messages array in your next API call:\n`) +
+                chalk_1.default.dim(`       const result = JSON.parse(fs.readFileSync('${opts.output ?? 'output.json'}'));\n`) +
+                chalk_1.default.dim(`       await anthropic.messages.create({ model: '...', messages: result, max_tokens: 8096 });`));
+        }
+        catch (err) {
+            spinner.fail(`Compression failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/watch.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function watchCommand(): Command;