token-cut-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/.gitignore

@@ -15,3 +15,4 @@ graphify-out/
 .cache/
 data/
 *.db
+.cursor/mcp.json

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: token-cut-cli
-Version: 0.1.0
+Version: 0.1.2
 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

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/README.md

@@ -1,58 +1,58 @@
-# 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
+
+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 → token_cut_cli-0.1.2}/pyproject.toml

@@ -1,37 +1,37 @@
-[build-system]
-requires = ["hatchling>=1.25.0"]
-build-backend = "hatchling.build"
-
-[project]
-name = "token-cut-cli"
-version = "0.1.0"
-description = "Verify Token-Cut API integration from the terminal (no repo clone required)"
-readme = "README.md"
-requires-python = ">=3.10"
-license = { text = "MIT" }
-authors = [{ name = "Token-Cut" }]
-keywords = ["token-cut", "cursor", "copilot", "claude", "llm", "optimization"]
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Environment :: Console",
-  "Intended Audience :: Developers",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-]
-dependencies = ["httpx>=0.27.0"]
-
-[project.urls]
-Homepage = "https://www.token-cut.com"
-Documentation = "https://www.token-cut.com"
-
-[project.scripts]
-token-cut = "token_cut_cli.main:main"
-token-cut-mcp = "token_cut_cli.mcp_server:main"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/token_cut_cli"]
-
-[tool.hatch.build.targets.sdist]
-include = ["src/token_cut_cli", "README.md"]
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "token-cut-cli"
+version = "0.1.2"
+description = "Verify Token-Cut API integration from the terminal (no repo clone required)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Token-Cut" }]
+keywords = ["token-cut", "cursor", "copilot", "claude", "llm", "optimization"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+dependencies = ["httpx>=0.27.0"]
+
+[project.urls]
+Homepage = "https://www.token-cut.com"
+Documentation = "https://www.token-cut.com"
+
+[project.scripts]
+token-cut = "token_cut_cli.main:main"
+token-cut-mcp = "token_cut_cli.mcp_server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/token_cut_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/token_cut_cli", "README.md"]

token_cut_cli-0.1.2/src/token_cut_cli/__init__.py

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

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/src/token_cut_cli/__main__.py

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

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/src/token_cut_cli/client.py

@@ -1,82 +1,132 @@
-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()
+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).
+# Small public repo — fastapi/fastapi OOMs 512MB cloud pods during Graphify.
+DEFAULT_REPO_URL = "https://github.com/pallets/itsdangerous"
+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
+
+
+def is_valid_api_key_format(key: str) -> bool:
+    """Full cc_live_ key from dashboard — not placeholder or prefix-only."""
+    k = key.strip()
+    if not k.startswith("cc_live_"):
+        return False
+    if k in ("cc_live_YOUR_KEY", "cc_live_…", "cc_live_..."):
+        return False
+    if "…" in k or "..." in k:
+        return False
+    # generate_api_key uses secrets.token_urlsafe(32) after prefix
+    return len(k) >= 40
+
+
+def key_hint(key: str) -> str:
+    k = key.strip()
+    if len(k) <= 20:
+        return k[:8] + "…"
+    return f"{k[:16]}… ({len(k)} chars)"
+
+
+def parse_api_error(response: httpx.Response) -> str:
+    try:
+        body = response.json()
+        detail = body.get("detail")
+        if isinstance(detail, str):
+            return detail
+        if isinstance(detail, list) and detail:
+            first = detail[0]
+            if isinstance(first, dict) and "msg" in first:
+                return str(first["msg"])
+    except Exception:
+        pass
+    return response.text.strip() or f"HTTP {response.status_code}"
+
+
+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")
+        if not is_valid_api_key_format(self.key):
+            raise ValueError(
+                "Invalid TOKEN_CUT_API_KEY — need the full cc_live_… key from "
+                "Connect & Security (Generate API key). Not the placeholder or prefix only."
+            )
+        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:
+                detail = parse_api_error(r)
+                raise PermissionError(f"API key rejected (401): {detail}")
+            if r.status_code == 429:
+                detail = parse_api_error(r)
+                raise PermissionError(f"Plan limit reached (429): {detail}")
+            if r.status_code in (502, 503, 504):
+                detail = parse_api_error(r)
+                raise RuntimeError(
+                    f"Server overloaded or timed out ({r.status_code}): {detail}. "
+                    "Cloud graph builds run in the background — retry in 1–2 min, "
+                    "or use: token-cut verify --no-graph"
+                )
+            r.raise_for_status()
+            return r.json()

{token_cut_cli-0.1.0 → token_cut_cli-0.1.2}/src/token_cut_cli/main.py

@@ -1,116 +1,123 @@
-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())
+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")
+    v.add_argument(
+        "--no-graph",
+        action="store_true",
+        help="Only check API key + optimize (skip Graphify; safe on small Railway pods)",
+    )
+
+    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 as e:
+        print(f"error: {e}", file=sys.stderr)
+        print(
+            "  Set TOKEN_CUT_API_KEY or pass --key with the full key from the dashboard.",
+            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,
+            with_graph=not args.no_graph,
+        )
+
+    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-0.1.0 → token_cut_cli-0.1.2}/src/token_cut_cli/mcp_server.py

@@ -1,170 +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 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-0.1.2/src/token_cut_cli/verify.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import sys
+import time
+from typing import Any
+
+from token_cut_cli.client import (
+    DEFAULT_REPO_URL,
+    TokenCutClient,
+    is_valid_api_key_format,
+    key_hint,
+)
+
+AUTH_PROMPT = "Token-Cut verify: confirm API key and run prune/compress on this line."
+
+GRAPH_PROMPT = (
+    "List the main modules in this repository and how they connect. "
+    "Focus on entrypoints only."
+)
+
+
+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,
+    with_graph: bool = True,
+) -> int:
+    if not quiet:
+        print(f"Token-Cut verify → {client.base}")
+        print(f"  repo: {repo_path or repo_url}")
+        print(f"  key:  {key_hint(client.key)}")
+        print()
+
+    if not is_valid_api_key_format(client.key):
+        _fail(
+            "TOKEN_CUT_API_KEY is missing or not a full cc_live_… key "
+            "(dashboard shows only a prefix after signup — generate a new key)"
+        )
+        print(
+            "\n1. https://www.token-cut.com → Connect & Security → Log in\n"
+            "2. Click “Generate API key” and copy the full key (shown once)\n"
+            "3. export TOKEN_CUT_API_KEY='cc_live_…'\n"
+            "4. token-cut verify",
+            file=sys.stderr,
+        )
+        return 2
+
+    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})")
+
+    # Phase 1: auth + optimize without graph (fast, no clone on cloud)
+    try:
+        auth_data = client.optimize(
+            AUTH_PROMPT,
+            repo_url=None,
+            repo_path=None,
+            use_graph=False,
+        )
+    except PermissionError as e:
+        _fail(str(e))
+        print(
+            "\nFix: https://www.token-cut.com → Connect & Security → Generate API key\n"
+            "     export TOKEN_CUT_API_KEY='cc_live_…'  (full key, not prefix or JWT)",
+            file=sys.stderr,
+        )
+        return 2
+    except Exception as e:
+        _fail(f"Auth/optimize check failed: {e}")
+        return 3
+
+    _ok("API key accepted")
+    o1 = int(auth_data.get("original_tokens") or 0)
+    o2 = int(auth_data.get("optimized_tokens") or 0)
+    _ok(f"Optimize (no graph): {o1} → {o2} tokens")
+
+    if not with_graph:
+        if not quiet:
+            print("\n  Skipped graph test (--no-graph). For full Graphify: token-cut verify")
+        return 0
+
+    # Phase 2: graph path (cloud may build in background)
+    try:
+        data = client.optimize(
+            GRAPH_PROMPT,
+            repo_url=repo_url if not repo_path else None,
+            repo_path=repo_path,
+            use_graph=True,
+        )
+    except Exception as e:
+        _fail(f"Graph optimize failed: {e}")
+        print(
+            "\n  Production builds graphs in the background to avoid OOM.\n"
+            "  Wait 1–2 minutes and run token-cut verify again,\n"
+            "  or: token-cut verify --no-graph",
+            file=sys.stderr,
+        )
+        return 4
+
+    graph_ready = bool(data.get("graph_ready"))
+    graph_built = bool(data.get("graph_built"))
+    nodes = int(data.get("graph_nodes") or 0)
+    msg = str(data.get("graph_message") or data.get("message") or "")
+
+    if graph_ready:
+        cache = "built now" if graph_built else "cached"
+        _ok(f"Graphify: {nodes:,} nodes ({cache})")
+    elif "background" in msg.lower():
+        _ok("Graphify queued on server (background — avoids OOM)")
+        if not quiet:
+            print("  … waiting 90s then retrying once …")
+        time.sleep(90)
+        try:
+            retry = client.optimize(
+                GRAPH_PROMPT,
+                repo_url=repo_url if not repo_path else None,
+                repo_path=repo_path,
+                use_graph=True,
+            )
+            if retry.get("graph_ready"):
+                nodes = int(retry.get("graph_nodes") or 0)
+                _ok(f"Graphify ready after background build: {nodes:,} nodes")
+                graph_ready = True
+        except Exception:
+            pass
+        if not graph_ready:
+            print(
+                "\n  Graph still building. Re-run: token-cut verify  (in a few minutes)",
+                file=sys.stderr,
+            )
+            return 0
+    else:
+        _fail(f"Graph not ready — {msg or 'check repo URL'}")
+        return 4
+
+    if not quiet:
+        print()
+        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/src/token_cut_cli/__init__.py

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

token_cut_cli-0.1.0/src/token_cut_cli/verify.py

@@ -1,93 +0,0 @@
-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')}"
-    )