ccoding 0.1.0__py3-none-any.whl

ccode/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .cli import main
+
+__version__ = "0.1.0"
+
+__all__ = ["main", "__version__"]

ccode/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

ccode/api.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import urllib.error
+import urllib.request
+from typing import Any
+
+from .config import MODEL_KEYS, mask_secret
+
+
+def _truncate_body(text: str, max_len: int = 200) -> str:
+    return f"{text[:max_len]}..." if len(text) > max_len else text
+
+
+def fetch_models(base_url: str, api_key: str) -> list[dict[str, str]]:
+    url = f"{base_url.rstrip('/')}/v1/models"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    request = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(request, timeout=10) as response:
+            status = response.getcode()
+            body_bytes = response.read()
+    except urllib.error.HTTPError as exc:
+        body = ""
+        try:
+            if exc.fp is not None:
+                body = exc.fp.read().decode("utf-8", "replace").strip()
+        except Exception:
+            body = ""
+        message = _truncate_body(body) or "No response body"
+        raise RuntimeError(f"HTTP {exc.code}: {message}") from exc
+    except (urllib.error.URLError, OSError) as exc:
+        raise RuntimeError(f"Request failed: {exc}") from exc
+
+    if status != 200:
+        body = body_bytes.decode("utf-8", "replace").strip()
+        message = _truncate_body(body) or "No response body"
+        raise RuntimeError(f"HTTP {status}: {message}")
+
+    try:
+        payload = json.loads(body_bytes.decode("utf-8", "replace"))
+    except ValueError as exc:
+        raise RuntimeError("Invalid JSON response") from exc
+
+    data = payload.get("data")
+    if not isinstance(data, list):
+        raise RuntimeError("Response JSON missing data array")
+
+    models: list[dict[str, str]] = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        model_id = item.get("id")
+        owned_by = item.get("owned_by")
+        if isinstance(model_id, str) and isinstance(owned_by, str):
+            models.append({"id": model_id, "owned_by": owned_by})
+
+    return models
+
+
+def validate_models(config: dict[str, Any], models: list[dict[str, str]]) -> bool:
+    valid = {(item["owned_by"], item["id"]) for item in models}
+    changed = False
+    for key in MODEL_KEYS:
+        entry = config["models"].get(key, {})
+        owned_by = entry.get("owned_by")
+        model_id = entry.get("id")
+        if not owned_by or not model_id or (owned_by, model_id) not in valid:
+            if entry.get("owned_by") is not None or entry.get("id") is not None:
+                config["models"][key] = {"owned_by": None, "id": None}
+                changed = True
+    return changed
+
+
+def build_models_by_owner(
+    models_data: list[dict[str, str]] | None,
+) -> dict[str, list[str]]:
+    by_owner: dict[str, list[str]] = {}
+    for item in models_data or []:
+        owned_by = item.get("owned_by")
+        model_id = item.get("id")
+        if not isinstance(owned_by, str) or not isinstance(model_id, str):
+            continue
+        by_owner.setdefault(owned_by, []).append(model_id)
+    for owner in by_owner:
+        by_owner[owner] = sorted(by_owner[owner])
+    return by_owner
+
+
+def owner_options(models_by_owner: dict[str, list[str]]) -> list[str]:
+    return sorted(models_by_owner.keys())
+
+
+def model_options(models_by_owner: dict[str, list[str]], owner: str) -> list[str]:
+    return models_by_owner.get(owner, [])
+
+
+def build_env(config: dict[str, Any], masked: bool = False) -> dict[str, str]:
+    env = os.environ.copy()
+    base_url = config.get("base_url", "")
+    api_key = config.get("api_key", "")
+    env["ANTHROPIC_BASE_URL"] = base_url
+    env["ANTHROPIC_AUTH_TOKEN"] = mask_secret(api_key) if masked else api_key
+    for key in MODEL_KEYS:
+        entry = config["models"].get(key, {})
+        model_id = entry.get("id")
+        if model_id:
+            env[f"ANTHROPIC_DEFAULT_{key.upper()}_MODEL"] = model_id
+    for key, value in config.get("toggles", {}).items():
+        env[key] = str(value)
+    return env
+
+
+def validate_launch_requirements(config: dict[str, Any]) -> str | None:
+    base_url = config.get("base_url", "").strip()
+    api_key = config.get("api_key", "").strip()
+    if not base_url or not api_key:
+        return "Base URL and API key are required."
+    for key in MODEL_KEYS:
+        entry = config["models"].get(key, {})
+        if not entry.get("owned_by") or not entry.get("id"):
+            return "OPUS, SONNET, and HAIKU selections are required."
+    return None
+
+
+def launch_claude(config: dict[str, Any], args: list[str]) -> str | None:
+    base_url = config.get("base_url", "").strip()
+    api_key = config.get("api_key", "").strip()
+    if not base_url or not api_key:
+        return "Missing base URL or API key."
+    env = build_env(config, masked=False)
+    try:
+        subprocess.run(["claude", *args], check=True, env=env)
+    except FileNotFoundError:
+        return "Could not find 'claude' on PATH."
+    except subprocess.CalledProcessError as exc:
+        return f"claude exited with code {exc.returncode}."
+    return None

ccode/cli.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import curses
+import sys
+
+from .ui import CursesApp
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = argv if argv is not None else sys.argv[1:]
+    app = CursesApp(args)
+    curses.wrapper(app.run)

ccode/config.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path.home() / ".ccode"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+DEFAULT_BASE_URL = "http://127.0.0.1:8317"
+MODEL_KEYS = ("opus", "sonnet", "haiku")
+MODEL_LABELS = {
+    "opus": "OPUS",
+    "sonnet": "SONNET",
+    "haiku": "HAIKU",
+}
+
+# toggles 的默认值：值统一用字符串存储
+DEFAULT_TOGGLES: dict[str, str] = {
+    "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
+    "DISABLE_COST_WARNINGS": "1",
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+}
+
+_ENV_SCHEMA: dict[str, Any] = {}
+_SCHEMA_KEYS: list[str] = []
+
+
+def load_env_schema() -> dict[str, Any]:
+    """加载 env_schema.json，返回 properties 字典，key 为变量名，value 含 description 等。"""
+    global _ENV_SCHEMA
+    if not _ENV_SCHEMA:
+        schema_path = Path(__file__).with_name("env_schema.json")
+        try:
+            _ENV_SCHEMA = json.loads(schema_path.read_text())
+        except (OSError, json.JSONDecodeError):
+            _ENV_SCHEMA = {}
+    return _ENV_SCHEMA.get("properties", {})
+
+
+def env_schema_keys() -> list[str]:
+    """返回所有已知环境变量名（有序）。"""
+    global _SCHEMA_KEYS
+    if not _SCHEMA_KEYS:
+        _SCHEMA_KEYS = sorted(load_env_schema().keys())
+    return _SCHEMA_KEYS
+
+
+def env_schema_description(key: str) -> str:
+    """返回某个变量的 description，不存在返回空字符串。"""
+    return load_env_schema().get(key, {}).get("description", "")
+
+
+def env_schema_enum(key: str) -> list[str]:
+    """返回某个变量的允许值列表，不存在返回空列表。"""
+    return load_env_schema().get(key, {}).get("enum", [])
+
+
+def default_config() -> dict[str, Any]:
+    return {
+        "base_url": DEFAULT_BASE_URL,
+        "api_key": "",
+        "models": {
+            "opus": {"owned_by": None, "id": None},
+            "sonnet": {"owned_by": None, "id": None},
+            "haiku": {"owned_by": None, "id": None},
+        },
+        "toggles": DEFAULT_TOGGLES.copy(),
+    }
+
+
+def load_config() -> dict[str, Any]:
+    config = default_config()
+    try:
+        raw = CONFIG_PATH.read_text()
+        data = json.loads(raw)
+    except FileNotFoundError:
+        return config
+    except (OSError, json.JSONDecodeError):
+        return config
+    if not isinstance(data, dict):
+        return config
+
+    base_url = data.get("base_url")
+    if isinstance(base_url, str):
+        config["base_url"] = base_url
+    api_key = data.get("api_key")
+    if isinstance(api_key, str):
+        config["api_key"] = api_key
+
+    models = data.get("models")
+    if isinstance(models, dict):
+        for key in MODEL_KEYS:
+            entry = models.get(key)
+            if isinstance(entry, dict):
+                owned_by = entry.get("owned_by")
+                model_id = entry.get("id")
+                config["models"][key]["owned_by"] = (
+                    owned_by if isinstance(owned_by, str) else None
+                )
+                config["models"][key]["id"] = model_id if isinstance(model_id, str) else None
+
+    toggles = data.get("toggles")
+    if isinstance(toggles, dict):
+        # 读取全部 key（包括用户自定义的），值统一转为字符串
+        new_toggles: dict[str, str] = {}
+        for k, v in toggles.items():
+            if isinstance(k, str):
+                if isinstance(v, bool):
+                    new_toggles[k] = "1" if v else "0"
+                elif isinstance(v, int):
+                    new_toggles[k] = str(v)
+                elif isinstance(v, str):
+                    new_toggles[k] = v
+        if new_toggles:
+            config["toggles"] = new_toggles
+
+    return config
+
+
+def save_config(config: dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(config, indent=2))
+
+
+def mask_secret(value: str) -> str:
+    if not value:
+        return "<unset>"
+    if len(value) <= 8:
+        return "*" * len(value)
+    return f"{value[:4]}...{value[-4:]}"
+
+
+def update_model_owner(config: dict[str, Any], key: str, owner: str | None) -> None:
+    config["models"][key] = {"owned_by": owner if owner else None, "id": None}
+    save_config(config)
+
+
+def update_model_id(
+    config: dict[str, Any], key: str, owner: str | None, model_id: str | None
+) -> None:
+    if owner and model_id:
+        config["models"][key] = {"owned_by": owner, "id": model_id}
+    else:
+        config["models"][key] = {"owned_by": owner if owner else None, "id": None}
+    save_config(config)