token-cut-cli 0.1.0__py3-none-any.whl

token_cut_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

token_cut_cli/__main__.py

@@ -0,0 +1,4 @@
+from token_cut_cli.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

token_cut_cli/client.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+DEFAULT_API_URL = "https://www.token-cut.com"
+# Public OSS repo used only for `token-cut verify` smoke test (no customer code).
+DEFAULT_REPO_URL = "https://github.com/fastapi/fastapi"
+DEFAULT_TIMEOUT = 120.0
+
+
+def api_base() -> str:
+    raw = (
+        os.getenv("TOKEN_CUT_API_URL")
+        or os.getenv("CONTEXT_CUT_API_URL")
+        or DEFAULT_API_URL
+    ).strip().rstrip("/")
+    return raw
+
+
+def api_key() -> str:
+    key = (
+        os.getenv("TOKEN_CUT_API_KEY")
+        or os.getenv("CONTEXT_CUT_API_KEY")
+        or ""
+    ).strip()
+    return key
+
+
+class TokenCutClient:
+    def __init__(
+        self,
+        base_url: str | None = None,
+        key: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base = (base_url or api_base()).rstrip("/")
+        self.key = (key or api_key()).strip()
+        self.timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        if not self.key:
+            raise ValueError("Missing API key")
+        return {"x-api-key": self.key, "Content-Type": "application/json"}
+
+    def health(self) -> dict[str, Any]:
+        with httpx.Client(timeout=30.0) as client:
+            r = client.get(f"{self.base}/health")
+            r.raise_for_status()
+            return r.json()
+
+    def optimize(
+        self,
+        prompt: str,
+        *,
+        repo_url: str | None = None,
+        repo_path: str | None = None,
+        use_graph: bool = True,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "prompt": prompt,
+            "use_graph": use_graph,
+            "auto_build_graph": True,
+        }
+        if repo_url:
+            body["repo_url"] = repo_url
+        if repo_path:
+            body["repo_path"] = repo_path
+        with httpx.Client(timeout=self.timeout) as client:
+            r = client.post(
+                f"{self.base}/v1/optimize",
+                headers=self._headers(),
+                json=body,
+            )
+            if r.status_code == 401:
+                raise PermissionError("Invalid or expired API key (401)")
+            if r.status_code == 429:
+                raise PermissionError("Plan limit reached (429)")
+            r.raise_for_status()
+            return r.json()

token_cut_cli/main.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from token_cut_cli import __version__
+from token_cut_cli.client import DEFAULT_API_URL, DEFAULT_REPO_URL, TokenCutClient
+from token_cut_cli.verify import run_verify
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="token-cut",
+        description="Token-Cut CLI — verify integration without cloning the repo",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    v = sub.add_parser(
+        "verify",
+        help="Check API key, optimize, and Graphify on a public repo (~1 min)",
+    )
+    v.add_argument(
+        "--api-url",
+        default=None,
+        help=f"API base URL (default: {DEFAULT_API_URL} or TOKEN_CUT_API_URL)",
+    )
+    v.add_argument(
+        "--key",
+        default=None,
+        help="cc_live_… key (default: TOKEN_CUT_API_KEY env)",
+    )
+    v.add_argument(
+        "--repo-url",
+        default=DEFAULT_REPO_URL,
+        help="Public GitHub/GitLab URL for graph test",
+    )
+    v.add_argument(
+        "--repo-path",
+        default=None,
+        help="Local repo path instead of --repo-url (optional)",
+    )
+    v.add_argument("-q", "--quiet", action="store_true", help="Minimal output")
+
+    o = sub.add_parser("optimize", help="Run one optimize call and print JSON")
+    o.add_argument("prompt", help="Prompt text")
+    o.add_argument("--api-url", default=None)
+    o.add_argument("--key", default=None)
+    o.add_argument("--repo-url", default=None)
+    o.add_argument("--repo-path", default=None)
+
+    m = sub.add_parser(
+        "mcp-config",
+        help="Print MCP JSON for Cursor / Claude (uses pip package, no git clone)",
+    )
+    m.add_argument("--api-url", default=None)
+    m.add_argument("--key", default=None)
+    m.add_argument("--repo-path", default=None, help="Default TOKEN_CUT_REPO_PATH in env")
+
+    args = parser.parse_args(argv)
+
+    try:
+        client = TokenCutClient(base_url=args.api_url, key=args.key)
+    except ValueError:
+        print(
+            "error: set TOKEN_CUT_API_KEY or pass --key cc_live_…",
+            file=sys.stderr,
+        )
+        return 2
+
+    if args.command == "verify":
+        return run_verify(
+            client,
+            repo_url=args.repo_url,
+            repo_path=args.repo_path,
+            quiet=args.quiet,
+        )
+
+    if args.command == "optimize":
+        data = client.optimize(
+            args.prompt,
+            repo_url=args.repo_url,
+            repo_path=args.repo_path,
+        )
+        print(json.dumps(data, indent=2))
+        return 0
+
+    if args.command == "mcp-config":
+        env: dict[str, str] = {
+            "TOKEN_CUT_API_URL": client.base,
+            "TOKEN_CUT_API_KEY": client.key,
+        }
+        if getattr(args, "repo_path", None):
+            env["TOKEN_CUT_REPO_PATH"] = args.repo_path
+        cfg = {
+            "mcpServers": {
+                "token-cut": {
+                    "command": sys.executable,
+                    "args": ["-m", "token_cut_cli.mcp_server"],
+                    "env": env,
+                }
+            }
+        }
+        print(json.dumps(cfg, indent=2))
+        print(
+            "\n# Paste into ~/.cursor/mcp.json or Claude Desktop config, then restart IDE.",
+            file=sys.stderr,
+        )
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

token_cut_cli/mcp_server.py

@@ -0,0 +1,170 @@
+"""Token-Cut MCP server — shipped in token-cut-cli (calls your cloud API with cc_live_ key)."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from token_cut_cli import __version__
+from token_cut_cli.client import DEFAULT_API_URL, api_base, api_key
+
+
+def _post(path: str, body: dict) -> dict:
+    import urllib.request
+
+    base = api_base().rstrip("/")
+    key = api_key()
+    if not key:
+        raise RuntimeError("Set TOKEN_CUT_API_KEY=cc_live_…")
+
+    req = urllib.request.Request(
+        f"{base}{path}",
+        data=json.dumps(body).encode(),
+        headers={"Content-Type": "application/json", "x-api-key": key},
+        method="POST",
+    )
+    timeout = int(os.getenv("TOKEN_CUT_HTTP_TIMEOUT", "360"))
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode())
+
+
+def _respond(obj: dict) -> None:
+    print(json.dumps(obj), flush=True)
+
+
+def _tool_list() -> dict:
+    return {
+        "tools": [
+            {
+                "name": "optimize_prompt",
+                "description": (
+                    "Optimize a prompt (Token-Cut cloud). Auto-builds graph.json when missing. "
+                    "Requires cc_live_ API key. IDE still runs the LLM on your plan."
+                ),
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "prompt": {"type": "string"},
+                        "repo_path": {"type": "string"},
+                        "repo_url": {"type": "string"},
+                        "auto_build_graph": {"type": "boolean"},
+                    },
+                    "required": ["prompt"],
+                },
+            },
+            {
+                "name": "build_repo_graph",
+                "description": "Build Graphify graph for a repo (Token-Cut cloud).",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "repo_path": {"type": "string"},
+                        "repo_url": {"type": "string"},
+                    },
+                },
+            },
+        ]
+    }
+
+
+def _env_repo_path() -> str | None:
+    return os.getenv("TOKEN_CUT_REPO_PATH") or os.getenv("CONTEXT_CUT_REPO_PATH")
+
+
+def _env_repo_url() -> str | None:
+    return os.getenv("TOKEN_CUT_REPO_URL") or os.getenv("CONTEXT_CUT_REPO_URL")
+
+
+def _handle_tools_call(msg: dict) -> None:
+    params = msg.get("params", {})
+    name = params.get("name")
+    args = params.get("arguments", {})
+    try:
+        if name == "optimize_prompt":
+            data = _post(
+                "/v1/optimize",
+                {
+                    "prompt": args["prompt"],
+                    "repo_path": args.get("repo_path") or _env_repo_path(),
+                    "repo_url": args.get("repo_url") or _env_repo_url(),
+                    "model": "gpt-4o",
+                    "use_graph": True,
+                    "auto_build_graph": args.get("auto_build_graph", True),
+                },
+            )
+            graph_line = ""
+            if data.get("graph_ready"):
+                built = " (built now)" if data.get("graph_built") else " (cached)"
+                graph_line = f"Graph: {data.get('graph_nodes', 0)} nodes{built}\n"
+            text = (
+                f"Reduction: {data['reduction_factor']}×\n"
+                f"Tokens: {data['original_tokens']} → {data['optimized_tokens']}\n"
+                f"Saved: ${data['cost_saved_usd']}\n"
+                f"{graph_line}\n"
+                f"{data['optimized_prompt'][:8000]}"
+            )
+        elif name == "build_repo_graph":
+            data = _post(
+                "/v1/graph/build",
+                {
+                    "repo_path": args.get("repo_path"),
+                    "repo_url": args.get("repo_url"),
+                },
+            )
+            text = json.dumps(data, indent=2)
+        else:
+            raise ValueError(f"Unknown tool: {name}")
+        _respond(
+            {
+                "jsonrpc": "2.0",
+                "id": msg.get("id"),
+                "result": {"content": [{"type": "text", "text": text}]},
+            }
+        )
+    except Exception as e:
+        _respond(
+            {
+                "jsonrpc": "2.0",
+                "id": msg.get("id"),
+                "error": {"code": -32000, "message": str(e)},
+            },
+        )
+
+
+def main() -> None:
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        msg = json.loads(line)
+        method = msg.get("method")
+        if method == "initialize":
+            _respond(
+                {
+                    "jsonrpc": "2.0",
+                    "id": msg.get("id"),
+                    "result": {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {"tools": {}},
+                        "serverInfo": {
+                            "name": "token-cut",
+                            "version": __version__,
+                        },
+                    },
+                }
+            )
+        elif method == "notifications/initialized":
+            continue
+        elif method == "tools/list":
+            _respond(
+                {"jsonrpc": "2.0", "id": msg.get("id"), "result": _tool_list()}
+            )
+        elif method == "tools/call":
+            _handle_tools_call(msg)
+        elif "id" in msg:
+            _respond({"jsonrpc": "2.0", "id": msg["id"], "result": {}})
+
+
+if __name__ == "__main__":
+    main()

token_cut_cli/verify.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from token_cut_cli.client import DEFAULT_REPO_URL, TokenCutClient
+
+VERIFY_PROMPT = (
+    "Explain how authentication and the optimize pipeline work in this repository. "
+    "Focus on api/app/ and the main entrypoints."
+)
+
+
+def _ok(msg: str) -> None:
+    print(f"  ✓ {msg}")
+
+
+def _fail(msg: str) -> None:
+    print(f"  ✗ {msg}", file=sys.stderr)
+
+
+def run_verify(
+    client: TokenCutClient,
+    *,
+    repo_url: str = DEFAULT_REPO_URL,
+    repo_path: str | None = None,
+    quiet: bool = False,
+) -> int:
+    if not quiet:
+        print(f"Token-Cut verify → {client.base}")
+        print(f"  repo: {repo_path or repo_url}")
+        print()
+
+    # 1. Health (non-fatal — some deployments only expose /v1/*)
+    try:
+        health = client.health()
+        version = health.get("version", "?")
+        _ok(f"API reachable (version {version})")
+    except Exception as e:
+        if not quiet:
+            print(f"  … health check skipped ({e})")
+
+    # 2. Auth + optimize + graph
+    try:
+        data = client.optimize(
+            VERIFY_PROMPT,
+            repo_url=repo_url if not repo_path else None,
+            repo_path=repo_path,
+            use_graph=True,
+        )
+    except PermissionError as e:
+        _fail(str(e))
+        print(
+            "\nGet a key: https://www.token-cut.com → Connect & Security",
+            file=sys.stderr,
+        )
+        return 2
+    except Exception as e:
+        _fail(f"Optimize failed: {e}")
+        return 3
+
+    original = int(data.get("original_tokens") or 0)
+    optimized = int(data.get("optimized_tokens") or 0)
+    graph_ready = bool(data.get("graph_ready"))
+    graph_built = bool(data.get("graph_built"))
+    nodes = int(data.get("graph_nodes") or 0)
+
+    _ok(f"API key accepted")
+    _ok(f"Optimize: {original} → {optimized} tokens")
+
+    if graph_ready:
+        cache = "built now" if graph_built else "cached"
+        _ok(f"Graphify: {nodes:,} nodes ({cache})")
+    else:
+        _fail("Graph not ready — check repo URL or Graphify on server")
+        return 4
+
+    if not quiet:
+        print()
+        if optimized < original:
+            pct = round(100 * (1 - optimized / max(original, 1)))
+            print(f"  Token reduction on prompt alone: ~{pct}%")
+        print("  Next: token-cut mcp-config  → paste into Cursor / Claude MCP settings")
+        print("        Your IDE subscription still runs the LLM.")
+
+    return 0
+
+
+def format_result_summary(data: dict[str, Any]) -> str:
+    return (
+        f"tokens={data.get('original_tokens')}→{data.get('optimized_tokens')} "
+        f"graph_nodes={data.get('graph_nodes')}"
+    )

token_cut_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: token-cut-cli
+Version: 0.1.0
+Summary: Verify Token-Cut API integration from the terminal (no repo clone required)
+Project-URL: Homepage, https://www.token-cut.com
+Project-URL: Documentation, https://www.token-cut.com
+Author: Token-Cut
+License: MIT
+Keywords: claude,copilot,cursor,llm,optimization,token-cut
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Description-Content-Type: text/markdown
+
+# token-cut-cli
+
+Public **client** for [Token-Cut](https://www.token-cut.com). Your proprietary API stays private; customers only get this thin CLI + MCP shim.
+
+## Business model
+
+| What | Public? | Paid? |
+|------|---------|-------|
+| This PyPI package (`token-cut-cli`) | Yes | Free to install |
+| `cc_live_…` API key | — | Yes (your Stripe plans) |
+| Optimization + Graphify on **your** API | Private server | Metered per key |
+
+The CLI cannot optimize without a valid key against **your** deployment.
+
+## Install
+
+```bash
+pip install token-cut-cli
+```
+
+Not on PyPI yet? Maintainer runs `./scripts/publish-cli.sh` from the repo root.  
+Until then:
+
+```bash
+cd cli && pip install .
+```
+
+## Verify integration (~1 min)
+
+```bash
+export TOKEN_CUT_API_KEY=cc_live_your_key
+token-cut verify
+```
+
+Calls `https://www.token-cut.com` (override with `TOKEN_CUT_API_URL`).
+
+## IDE setup (Cursor · Claude · Copilot)
+
+```bash
+export TOKEN_CUT_API_KEY=cc_live_your_key
+token-cut mcp-config > ~/.cursor/mcp.json
+# merge if file already exists — restart IDE
+```
+
+Uses `python -m token_cut_cli.mcp_server` from the installed package (no git clone).
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| `token-cut verify` | Test key + optimize + graph on a public sample repo |
+| `token-cut optimize "…"` | One-off optimize JSON |
+| `token-cut mcp-config` | Print MCP config for IDEs |
+| `token-cut-mcp` | MCP stdio server (called by IDE) |
+
+## Publish (maintainers)
+
+See [../docs/PYPI_PUBLISH.md](../docs/PYPI_PUBLISH.md).

token_cut_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+token_cut_cli/__init__.py,sha256=QTYqXqSTHFRkM9TEgpDFcHvwLbvqHDqvqfQ9EiXkcAM,23
+token_cut_cli/__main__.py,sha256=ZOTIMJIKCHdgAEnQD1IdjHB21MrU-CqL489m2CDbrYQ,97
+token_cut_cli/client.py,sha256=vnEHJbQ4SOSn4S4vGwpTPljqyjvhCFol7xLCo1d5iH8,2392
+token_cut_cli/main.py,sha256=Mq8S4Iz3vDZOEkyKvGU-aIlh0RAU-tSjvLhmCgV5pE0,3617
+token_cut_cli/mcp_server.py,sha256=HUWb5Qabh_LF29l-RUJ0Kf8LHX7S0Pd-9ALFejCtHCs,5711
+token_cut_cli/verify.py,sha256=fEigiSPnhRaCIwGhGmuEemHAwL-O6EoWkSKaqX-y8-Q,2785
+token_cut_cli-0.1.0.dist-info/METADATA,sha256=P_wv-2M1T84i6-K0gp28qqZEPsB-nHYz76MTMal9_-g,2277
+token_cut_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+token_cut_cli-0.1.0.dist-info/entry_points.txt,sha256=JfFOeccsIr36Vz57-Z2ZQDJXAkvZl12iMsCFfnvw5lw,100
+token_cut_cli-0.1.0.dist-info/RECORD,,

token_cut_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

token_cut_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+token-cut = token_cut_cli.main:main
+token-cut-mcp = token_cut_cli.mcp_server:main