fix: rename PyPI distribution to llm-tokenoptim (tokenoptim taken)

- PyPI package name: llm-tokenoptim  (pip install llm-tokenoptim)
- Python import stays: tokenoptim    (from tokenoptim import ...)
- CLI commands: both tokenoptim and llm-tokenoptim work
- Bump to v0.2.1
- Author name updated to venkatamanas raghupatruni
52 tests passing, ruff clean.

Author: Manas470

.github/FUNDING.yml

@@ -1,2 +1,2 @@
-# Support tokenoptim development
+# Support llm-tokenoptim development
 github: manasmourya

.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
         run: ruff check src/ tests/
 
       - name: Type check (mypy)
-        run: mypy src/tokenoptim --ignore-missing-imports
+        run: mypy src/llm-tokenoptim --ignore-missing-imports
         continue-on-error: true   # non-blocking until full annotation pass
 
       - name: Run tests

CHANGELOG.md

@@ -6,20 +6,20 @@ Format: [Semantic Versioning](https://semver.org/).
 ## [0.2.0] — 2026-05-19
 
 ### Added (CLI-first release)
-- `tokenoptim install-claude --level LEVEL` — append caveman skill to CLAUDE.md (auto-loaded by Claude Code)
-- `tokenoptim install-global` — install skill to ~/CLAUDE.md for all projects
-- `tokenoptim wrap --level LEVEL -- CMD` — inject skill into gemini, codex, aider, sgpt, llm, ollama, or any LLM CLI
-- `tokenoptim skill LEVEL` — print skill to stdout (pipeable anywhere)
+- `llm-tokenoptim install-claude --level LEVEL` — append caveman skill to CLAUDE.md (auto-loaded by Claude Code)
+- `llm-tokenoptim install-global` — install skill to ~/CLAUDE.md for all projects
+- `llm-tokenoptim wrap --level LEVEL -- CMD` — inject skill into gemini, codex, aider, sgpt, llm, ollama, or any LLM CLI
+- `llm-tokenoptim skill LEVEL` — print skill to stdout (pipeable anywhere)
 - `skills/` directory with 5 SKILL.md files: lite / standard / full / ultra / ancient
-- `bin/tokenoptim` — pure-bash wrapper (works without Python)
+- `bin/llm-tokenoptim` — pure-bash wrapper (works without Python)
 - `AsyncOptimizedClient` — full async/await client with streaming and batch support
 - `AsyncAnthropicProvider` and `AsyncOpenAIProvider` with `async_chat()` and `stream()`
 - `batch_chat()` — concurrent API calls with configurable semaphore
 - `RetryConfig` — exponential backoff for 429/5xx/timeout errors
 - `ResponseCache` — disk-backed LRU cache with TTL; survives restarts
 - `MLPromptCompressor` — LLMLingua integration for 40–60% ML-based compression
 - `benchmarks/run_benchmark.py` — reproducible benchmark against ShareGPT dataset
-- `[ml]` optional extra: `pip install "tokenoptim[ml]"`
+- `[ml]` optional extra: `pip install "llm-tokenoptim[ml]"`
 
 ### Fixed
 - Deduplicate min_len threshold reduced 80→40 (catches more realistic duplicates)
@@ -39,6 +39,6 @@ Format: [Semantic Versioning](https://semver.org/).
 - `OptimizedClient` — sync unified client
 - Providers: `AnthropicProvider`, `OpenAIProvider`, `OllamaProvider`
 - `SparkTokenOptimizer` + `compress_prompts_udf` — PySpark batch support
-- CLI: `tokenoptim compress / bench / levels`
+- CLI: `llm-tokenoptim compress / bench / levels`
 - GitHub Actions CI (Python 3.9–3.12)
 - 23 unit tests

CLAUDE.md

@@ -1,6 +1,6 @@
-# tokenoptim — token optimization skill
+# llm-tokenoptim — token optimization skill
 
-You are running with **tokenoptim standard compression** active.
+You are running with **llm-tokenoptim standard compression** active.
 
 ## Output rules
 
@@ -27,4 +27,4 @@ If the user prefixes their message with `[budget:N]`, target ≤N tokens in your
 
 ---
 
-*tokenoptim v0.2.0 — use `tokenoptim skill [lite|standard|full|ultra|ancient]` to switch levels*
+*llm-tokenoptim v0.2.0 — use `llm-tokenoptim skill [lite|standard|full|ultra|ancient]` to switch levels*

CONTRIBUTING.md

@@ -1,12 +1,12 @@
-# Contributing to tokenoptim
+# Contributing to llm-tokenoptim
 
 Thank you for taking the time to contribute.
 
 ## Setup
 
 ```bash
-git clone https://github.com/manasmourya/tokenoptim
-cd tokenoptim
+git clone https://github.com/manasmourya/llm-tokenoptim
+cd llm-tokenoptim
 pip install -e ".[dev]"
 ```
 
@@ -26,27 +26,27 @@ pytest tests/ -v
 
 1. **Tests pass**: `pytest tests/ -p no:cacheprovider`
 2. **Lint clean**: `ruff check src/ tests/`
-3. **Types check**: `mypy src/tokenoptim/`
+3. **Types check**: `mypy src/llm-tokenoptim/`
 4. **Benchmark still runs**: `python benchmarks/run_benchmark.py --no-download --samples 20`
 
 ## Adding a new provider
 
-1. Create `src/tokenoptim/providers/myprovider.py` — inherit from `BaseProvider`
+1. Create `src/llm-tokenoptim/providers/myprovider.py` — inherit from `BaseProvider`
 2. Implement `chat()`, `count_tokens()`, and `provider_name`
-3. Export from `src/tokenoptim/providers/__init__.py`
+3. Export from `src/llm-tokenoptim/providers/__init__.py`
 4. Add an async variant `myprovider_async.py` if the SDK supports it
 5. Add at least one test in `tests/`
 
 ## Adding a compression level
 
-- Output levels live in `src/tokenoptim/core/output_style.py` — add to `CompressionLevel` enum and `_PROMPTS` dict
-- Prompt levels live in `src/tokenoptim/core/compressor.py` — add to `LEVELS` tuple and `_apply_compression()`
+- Output levels live in `src/llm-tokenoptim/core/output_style.py` — add to `CompressionLevel` enum and `_PROMPTS` dict
+- Prompt levels live in `src/llm-tokenoptim/core/compressor.py` — add to `LEVELS` tuple and `_apply_compression()`
 
 ## Reporting bugs
 
 Please open an issue with:
 - Python version and OS
-- tokenoptim version (`python -c "import tokenoptim; print(tokenoptim.__version__)"`)
+- llm-tokenoptim version (`python -c "import llm-tokenoptim; print(llm-tokenoptim.__version__)"`)
 - Minimal reproducer
 - Expected vs actual behaviour
 

README.md

@@ -1,35 +1,35 @@
-# 🪨 tokenoptim
+# 🪨 llm-tokenoptim
 
 > **Cut LLM token costs by 40–75% — no API key required.**  
 > Works as a CLI tool for Claude Code, Gemini CLI, Codex, aider, and any LLM tool.  
 > Optional Python SDK for Anthropic · OpenAI · Ollama · PySpark batch.
 
-[![PyPI](https://img.shields.io/pypi/v/tokenoptim)](https://pypi.org/project/tokenoptim/)
-[![Python](https://img.shields.io/pypi/pyversions/tokenoptim)](https://pypi.org/project/tokenoptim/)
-[![CI](https://github.com/manasmourya/tokenoptim/actions/workflows/ci.yml/badge.svg)](https://github.com/manasmourya/tokenoptim/actions)
+[![PyPI](https://img.shields.io/pypi/v/llm-tokenoptim)](https://pypi.org/project/llm-tokenoptim/)
+[![Python](https://img.shields.io/pypi/pyversions/llm-tokenoptim)](https://pypi.org/project/llm-tokenoptim/)
+[![CI](https://github.com/manasmourya/llm-tokenoptim/actions/workflows/ci.yml/badge.svg)](https://github.com/manasmourya/llm-tokenoptim/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Downloads](https://img.shields.io/pypi/dm/tokenoptim)](https://pypi.org/project/tokenoptim/)
+[![Downloads](https://img.shields.io/pypi/dm/llm-tokenoptim)](https://pypi.org/project/llm-tokenoptim/)
 
 ---
 
 ## 30-second start (no API key needed)
 
 ```bash
-pip install tokenoptim
+pip install llm-tokenoptim
 
 # Inject caveman compression into Claude Code (auto-loaded via CLAUDE.md)
-tokenoptim install-claude --level full
+llm-tokenoptim install-claude --level full
 
 # Pipe skill into any LLM tool manually
-tokenoptim skill full | pbcopy          # macOS clipboard → paste into any chat
+llm-tokenoptim skill full | pbcopy          # macOS clipboard → paste into any chat
 
 # Wrap ANY LLM CLI tool — works with gemini, codex, aider, sgpt, llm, ollama
-tokenoptim wrap --level full -- gemini "explain kubernetes networking"
-tokenoptim wrap --level ultra -- claude "write a redis cache class"
-tokenoptim wrap --level standard -- aider --model gpt-4o
+llm-tokenoptim wrap --level full -- gemini "explain kubernetes networking"
+llm-tokenoptim wrap --level ultra -- claude "write a redis cache class"
+llm-tokenoptim wrap --level standard -- aider --model gpt-4o
 
 # Compress a verbose prompt before sending
-tokenoptim compress "Could you please help me understand what tokenization means in the context of large language models?"
+llm-tokenoptim compress "Could you please help me understand what tokenization means in the context of large language models?"
 ```
 
 **Five compression levels — no API, no GPU, <0.1ms overhead:**
@@ -50,7 +50,7 @@ tokenoptim compress "Could you please help me understand what tokenization means
 
 Every LLM API call burns money proportional to token count. Most teams waste tokens in predictable, fixable ways:
 
-| Waste source | Typical overhead | tokenoptim fix |
+| Waste source | Typical overhead | llm-tokenoptim fix |
 |---|---|---|
 | Verbose prompts ("Could you please help me...") | +15–30% input tokens | Regex prompt compressor |
 | Pleasantries in output ("Great question! Certainly!") | +40–75% output tokens | 6-level output compressor |
@@ -73,7 +73,7 @@ Every LLM API call burns money proportional to token count. Most teams waste tok
 | `medium` | 12% | 11% | 24% | <0.1ms |
 | `full` | 14% | 12% | 26% | <0.1ms |
 
-> **With LLMLingua ML backend** (`pip install "tokenoptim[ml]"`): 40–60% reduction on verbose prompts. Install the extra to unlock it — the library falls back to regex automatically if not present.
+> **With LLMLingua ML backend** (`pip install "llm-tokenoptim[ml]"`): 40–60% reduction on verbose prompts. Install the extra to unlock it — the library falls back to regex automatically if not present.
 
 ### Output Compression (via system prompt injection)
 
@@ -93,14 +93,14 @@ Every LLM API call burns money proportional to token count. Most teams waste tok
 
 ```bash
 # Core library — zero dependencies
-pip install tokenoptim
+pip install llm-tokenoptim
 
 # With providers
-pip install "tokenoptim[anthropic]"   # Claude (async + streaming)
-pip install "tokenoptim[openai]"      # OpenAI / Groq / Together
-pip install "tokenoptim[spark]"       # PySpark batch compression
-pip install "tokenoptim[ml]"          # LLMLingua ML compression (40-60%)
-pip install "tokenoptim[all]"         # Everything
+pip install "llm-tokenoptim[anthropic]"   # Claude (async + streaming)
+pip install "llm-tokenoptim[openai]"      # OpenAI / Groq / Together
+pip install "llm-tokenoptim[spark]"       # PySpark batch compression
+pip install "llm-tokenoptim[ml]"          # LLMLingua ML compression (40-60%)
+pip install "llm-tokenoptim[all]"         # Everything
 ```
 
 ---
@@ -110,7 +110,7 @@ pip install "tokenoptim[all]"         # Everything
 ### Compress a prompt — no LLM, no API key
 
 ```python
-from tokenoptim import PromptCompressor
+from llm-tokenoptim import PromptCompressor
 
 c = PromptCompressor(level="medium")
 compressed, stats = c.compress(
@@ -125,8 +125,8 @@ print(stats)
 
 ```python
 import asyncio
-from tokenoptim import AsyncOptimizedClient
-from tokenoptim.providers import AsyncAnthropicProvider
+from llm-tokenoptim import AsyncOptimizedClient
+from llm-tokenoptim.providers import AsyncAnthropicProvider
 
 async def main():
     client = AsyncOptimizedClient(
@@ -160,8 +160,8 @@ asyncio.run(main())
 ### Sync client (simpler, same optimizations)
 
 ```python
-from tokenoptim import OptimizedClient
-from tokenoptim.providers import AnthropicProvider
+from llm-tokenoptim import OptimizedClient
+from llm-tokenoptim.providers import AnthropicProvider
 
 client = OptimizedClient(
     provider=AnthropicProvider(),
@@ -176,8 +176,8 @@ print(resp["content"])
 ### ML-powered compression (40–60% input reduction)
 
 ```python
-# pip install "tokenoptim[ml]"
-from tokenoptim.core.ml_compressor import MLPromptCompressor
+# pip install "llm-tokenoptim[ml]"
+from llm-tokenoptim.core.ml_compressor import MLPromptCompressor
 
 c = MLPromptCompressor(target_token_rate=0.5)   # keep 50% → 50% reduction
 compressed, stats = c.compress(very_long_prompt)
@@ -190,10 +190,10 @@ Falls back to regex automatically if `llmlingua` is not installed.
 ### Response caching — avoid duplicate API calls
 
 ```python
-from tokenoptim import ResponseCache, OptimizedClient
-from tokenoptim.providers import AnthropicProvider
+from llm-tokenoptim import ResponseCache, OptimizedClient
+from llm-tokenoptim.providers import AnthropicProvider
 
-cache = ResponseCache(directory="~/.cache/tokenoptim", ttl_seconds=3600)
+cache = ResponseCache(directory="~/.cache/llm-tokenoptim", ttl_seconds=3600)
 provider = AnthropicProvider()
 
 messages = [{"role": "user", "content": "What is tokenization?"}]
@@ -237,7 +237,7 @@ client.clear_memory()     # Wipe history
 Automatic exponential backoff on 429 / 5xx — configured at construction:
 
 ```python
-from tokenoptim import RetryConfig, AsyncOptimizedClient
+from llm-tokenoptim import RetryConfig, AsyncOptimizedClient
 
 client = AsyncOptimizedClient(
     provider=...,
@@ -259,17 +259,17 @@ Compress millions of prompts before sending to any LLM:
 
 ```python
 from pyspark.sql import SparkSession
-from tokenoptim.spark import SparkTokenOptimizer
+from llm-tokenoptim.spark import SparkTokenOptimizer
 
-spark = SparkSession.builder.appName("tokenoptim").getOrCreate()
+spark = SparkSession.builder.appName("llm-tokenoptim").getOrCreate()
 df = spark.read.parquet("s3://bucket/raw-prompts/")
 
 optimizer = SparkTokenOptimizer(level="full", spark=spark)
 df_out = optimizer.compress_dataframe(df, prompt_col="prompt")
 df_out.write.parquet("s3://bucket/compressed-prompts/")
 optimizer.savings_report(df, df_out)
 
-# ━━━━ tokenoptim PySpark Savings Report ━━━━
+# ━━━━ llm-tokenoptim PySpark Savings Report ━━━━
 # Prompts processed    : 4,500,000
 # Total original tokens: 892,400,000
 # Total compressed     : 768,000,000
@@ -286,25 +286,25 @@ With the `[ml]` extra, LLMLingua runs as a Spark UDF on each executor — 40–6
 
 ```bash
 # ── Skill injection (primary use — no API key needed) ─────────────────────────
-tokenoptim skill [lite|standard|full|ultra|ancient]   # print skill to stdout
-tokenoptim install-claude --level full                 # append to ./CLAUDE.md
-tokenoptim install-global --level standard             # append to ~/CLAUDE.md
+llm-tokenoptim skill [lite|standard|full|ultra|ancient]   # print skill to stdout
+llm-tokenoptim install-claude --level full                 # append to ./CLAUDE.md
+llm-tokenoptim install-global --level standard             # append to ~/CLAUDE.md
 
 # ── Wrap any LLM CLI tool ─────────────────────────────────────────────────────
-tokenoptim wrap --level full    -- gemini  "explain kubernetes"
-tokenoptim wrap --level ultra   -- claude  "write a redis cache class"
-tokenoptim wrap --level full    -- codex   "refactor this function"
-tokenoptim wrap --level standard -- aider  --model gpt-4o
-tokenoptim wrap --level full    -- llm     "summarize this doc"
-tokenoptim wrap --level ultra   -- ollama  run llama3
+llm-tokenoptim wrap --level full    -- gemini  "explain kubernetes"
+llm-tokenoptim wrap --level ultra   -- claude  "write a redis cache class"
+llm-tokenoptim wrap --level full    -- codex   "refactor this function"
+llm-tokenoptim wrap --level standard -- aider  --model gpt-4o
+llm-tokenoptim wrap --level full    -- llm     "summarize this doc"
+llm-tokenoptim wrap --level ultra   -- ollama  run llama3
 
 # ── Prompt compression (Python regex, <0.1ms, no API) ────────────────────────
-tokenoptim compress "Could you please help me understand what a token is?"
-tokenoptim compress --level full --file my_prompt.txt --output compressed.txt
+llm-tokenoptim compress "Could you please help me understand what a token is?"
+llm-tokenoptim compress --level full --file my_prompt.txt --output compressed.txt
 
 # ── Benchmarks ────────────────────────────────────────────────────────────────
-tokenoptim bench --input prompts.txt        # benchmark one prompt per line
-tokenoptim levels                           # show all levels and savings
+llm-tokenoptim bench --input prompts.txt        # benchmark one prompt per line
+llm-tokenoptim levels                           # show all levels and savings
 python benchmarks/run_benchmark.py --samples 500
 ```
 
@@ -313,7 +313,7 @@ python benchmarks/run_benchmark.py --samples 500
 ## Architecture
 
 ```
-src/tokenoptim/
+src/llm-tokenoptim/
 ├── core/
 │   ├── compressor.py      # Regex prompt compression (3 levels, <0.1ms)
 │   ├── ml_compressor.py   # LLMLingua ML compression (optional, 40–60%)
@@ -331,7 +331,7 @@ src/tokenoptim/
 ├── spark/udf.py           # PySpark UDF + SparkTokenOptimizer
 ├── client.py              # OptimizedClient (sync)
 ├── async_client.py        # AsyncOptimizedClient (async + batch + stream)
-└── cli.py                 # tokenoptim CLI
+└── cli.py                 # llm-tokenoptim CLI
 ```
 
 ---
@@ -349,8 +349,8 @@ Output compression savings (40–75%) apply to the **output side** and are syste
 ## Contributing
 
 ```bash
-git clone https://github.com/manasmourya/tokenoptim
-cd tokenoptim
+git clone https://github.com/manasmourya/llm-tokenoptim
+cd llm-tokenoptim
 pip install -e ".[dev]"
 pytest tests/ -v
 python benchmarks/run_benchmark.py --no-download