oy-cli 0.3.4__tar.gz → 0.3.5__tar.gz

{oy_cli-0.3.4 → oy_cli-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oy-cli
-Version: 0.3.4
+Version: 0.3.5
 Summary: Tiny local coding CLI with a small tool surface
 Author: oy-cli contributors
 License-Expression: Apache-2.0

{oy_cli-0.3.4 → oy_cli-0.3.5}/oy_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oy-cli
-Version: 0.3.4
+Version: 0.3.5
 Summary: Tiny local coding CLI with a small tool surface
 Author: oy-cli contributors
 License-Expression: Apache-2.0

{oy_cli-0.3.4 → oy_cli-0.3.5}/oy_cli.py

@@ -256,7 +256,7 @@ def abort(m, c=1):
 def clip_tokens(text, limit=MAX_TOOL_OUTPUT_TOKENS, tail=0):
     """Truncate *text* to *limit* tokens, optionally keeping *tail* tokens from the end."""
     e = get_tokenizer()
-    ids = e.encode(text)
+    ids = e.encode(text, disallowed_special=())
     n = len(ids)
     if n <= limit:
         return text
@@ -1536,7 +1536,7 @@ def truncate_str_to_tokens(text: str, max_tokens: int = MAX_MESSAGE_TOKENS) -> s
     characters were removed so the model knows the content was cut.
     """
     enc = get_tokenizer()
-    ids = enc.encode(text)
+    ids = enc.encode(text, disallowed_special=())
     if len(ids) <= max_tokens:
         return text
     kept = enc.decode(ids[:max_tokens])
@@ -1798,19 +1798,69 @@ def _setup_readline():
     atexit.register(readline.write_history_file, str(history_path))
 
 
+def _drain_stdin(timeout: float = 0.05) -> str:
+    """Read any data already buffered on stdin (e.g. the tail of a paste).
+
+    Uses select() with a short timeout.  Returns the extra text, or "".
+    Only works on real ttys; returns "" for piped stdin.
+    """
+    import select
+    if not sys.stdin.isatty():
+        return ""
+    chunks: list[str] = []
+    while True:
+        ready, _, _ = select.select([sys.stdin], [], [], timeout)
+        if not ready:
+            break
+        chunk = os.read(sys.stdin.fileno(), 4096)
+        if not chunk:
+            break
+        chunks.append(chunk.decode("utf-8", errors="replace"))
+        # After first chunk, use a tighter timeout for the rest.
+        timeout = 0.01
+    return "".join(chunks)
+
+
 def _read_input():
-    """Read user input, supporting \\ continuation for multi-line."""
+    '''Read user input, with automatic paste detection.
+
+    Input modes:
+    1. Single line  -- type and press Enter.
+    2. Paste        -- paste multiline text; lines that arrive within a
+       few milliseconds of Enter are collected automatically.
+    3. Block mode   -- start with ``"""`` to open a fenced block;
+       close it with ``"""`` on its own line.
+
+    Paste detection works by draining stdin right after readline returns.
+    During normal typing there is nothing buffered, so it is a no-op.
+    During a paste, the remaining lines are already queued up.
+    '''
     line = input("oy > ")
-    if not line.endswith("\\"):
-        return line
-    parts = [line[:-1]]
-    while True:
-        cont = input("... ")
-        if not cont.endswith("\\"):
+
+    # --- block mode: triple-quote fence (still supported) ------------------
+    stripped = line.strip()
+    if stripped == '"""' or stripped.startswith('"""'):
+        if stripped == '"""':
+            parts: list[str] = []
+        else:
+            parts = [stripped[3:]]
+        while True:
+            try:
+                cont = input('... ')
+            except EOFError:
+                break
+            if cont.strip() == '"""':
+                break
             parts.append(cont)
-            break
-        parts.append(cont[:-1])
-    return "\n".join(parts)
+        return "\n".join(parts)
+
+    # --- paste detection: drain any remaining buffered input ---------------
+    extra = _drain_stdin()
+    if extra:
+        # Strip trailing newline that the terminal added from the final Enter.
+        return line + "\n" + extra.rstrip("\n")
+
+    return line
 
 
 
@@ -1879,7 +1929,8 @@ def _chat_command(cmd, transcript, system_prompt, model_spec):
             "- `/clear` -- reset conversation (keeps system prompt)",
             "- `/quit` or `/exit` -- end session",
             "",
-            "Tip: end a line with `\\` to continue on the next line.",
+            "Tip: paste multiline text — extra lines are detected automatically.",
+            'Tip: type `"""` to start a multiline block, `"""` to end it.',
         ]), err=True)
         return True
     if cmd == "/tokens":

{oy_cli-0.3.4 → oy_cli-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oy-cli"
-version = "0.3.4"
+version = "0.3.5"
 description = "Tiny local coding CLI with a small tool surface"
 readme = "README.md"
 requires-python = ">=3.14"

{oy_cli-0.3.4 → oy_cli-0.3.5}/shim.py

@@ -36,6 +36,7 @@ SHIM_GEMINI = "gemini"
 SHIM_BEDROCK = "bedrock"
 SHIM_MANTLE = "bedrock-mantle"
 SHIM_CLAUDE = "claude"
+SHIM_COPILOT = "copilot"
 SHIM_ORDER = (
     SHIM_OPENAI,
     SHIM_CODEX,
@@ -43,6 +44,7 @@ SHIM_ORDER = (
     SHIM_BEDROCK,
     SHIM_MANTLE,
     SHIM_CLAUDE,
+    SHIM_COPILOT,
 )
 KNOWN_SHIMS = set(SHIM_ORDER)
 
@@ -2486,6 +2488,160 @@ def _list_mantle_models(
     return _build_mantle_client(region, cwd).list_models()
 
 
+# ---------------------------------------------------------------------------
+# Copilot shim – uses the GitHub Copilot API (api.githubcopilot.com)
+# with a GitHub PAT obtained from COPILOT_GITHUB_TOKEN / GH_TOKEN /
+# GITHUB_TOKEN / `gh auth token`.  Set COPILOT_BASE_URL to override
+# (e.g. https://api.business.githubcopilot.com for enterprise).
+# Models that support /responses use that API; others fall back to
+# /chat/completions automatically.
+# ---------------------------------------------------------------------------
+
+_COPILOT_BASE_URL = os.environ.get(
+    "COPILOT_BASE_URL", "https://api.githubcopilot.com"
+)
+_COPILOT_INTEGRATION_ID = "copilot-developer-cli"
+_COPILOT_EDITOR_VERSION = "copilot-developer-cli/1.0.6"
+
+
+def _get_github_token() -> str | None:
+    """Return a GitHub PAT from env vars or the ``gh`` CLI, or *None*.
+
+    Checks (in order): ``COPILOT_GITHUB_TOKEN``, ``GH_TOKEN``,
+    ``GITHUB_TOKEN``, then ``gh auth token``.
+    """
+    for var in ("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"):
+        val = os.environ.get(var)
+        if isinstance(val, str) and val:
+            return val
+    gh = which("gh")
+    if not gh:
+        return None
+    try:
+        proc = subprocess.run(
+            [gh, "auth", "token"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        token = proc.stdout.strip()
+        return token if proc.returncode == 0 and token else None
+    except Exception:
+        return None
+
+
+def _copilot_default_headers() -> dict[str, str]:
+    return {
+        "Copilot-Integration-Id": _COPILOT_INTEGRATION_ID,
+        "Editor-Version": _COPILOT_EDITOR_VERSION,
+    }
+
+
+def _copilot_openai_pair(token: str) -> tuple[AsyncOpenAI, OpenAI]:
+    kwargs: dict[str, Any] = {
+        "api_key": token,
+        "base_url": _COPILOT_BASE_URL,
+        "max_retries": 0,
+        "default_headers": _copilot_default_headers(),
+    }
+    return AsyncOpenAI(**kwargs), OpenAI(**kwargs)
+
+
+def _require_copilot_env(_: Path | None = None) -> None:
+    _require_string(
+        _get_github_token(),
+        "No GitHub token found (set GH_TOKEN, GITHUB_TOKEN, or run `gh auth login`)",
+    )
+
+
+def _fetch_copilot_models_raw(token: str) -> list[JSONDict]:
+    """Fetch the full model metadata list from the Copilot API."""
+    resp = httpx.get(
+        f"{_COPILOT_BASE_URL}/models",
+        headers={
+            "Authorization": f"Bearer {token}",
+            **_copilot_default_headers(),
+        },
+        timeout=15,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data.get("data", []) if isinstance(data, dict) else []
+
+
+def _copilot_chat_model_ids(token: str) -> list[str]:
+    """Return sorted model IDs that support chat (not embeddings)."""
+    raw = _fetch_copilot_models_raw(token)
+    return sorted(
+        m["id"]
+        for m in raw
+        if isinstance(m.get("id"), str)
+        and m.get("capabilities", {}).get("type") == "chat"
+    )
+
+
+def _copilot_responses_model_ids(token: str) -> set[str]:
+    """Return model IDs that support the /responses endpoint."""
+    raw = _fetch_copilot_models_raw(token)
+    return {
+        m["id"]
+        for m in raw
+        if isinstance(m.get("id"), str)
+        and "/responses" in (m.get("supported_endpoints") or [])
+    }
+
+
+def _build_copilot_client(
+    region: str | None = None, cwd: Path | None = None
+) -> CompletionClient:
+    """Build a Copilot client that routes to /responses or /chat/completions."""
+    _ = region, cwd
+    token = _require_string(_get_github_token(), "No GitHub token found")
+    async_client, sync_client = _copilot_openai_pair(token)
+
+    # Probe which models support /responses vs /chat/completions
+    try:
+        responses_models = _copilot_responses_model_ids(token)
+    except Exception:
+        responses_models = set()
+
+    responses_inner = _openai_responses_client(
+        async_client, sync_client, fallback_models=None, default_models=None
+    )
+    chat_inner = _openai_chat_completions_client(
+        async_client, sync_client, tools_map=_tool_specs_to_openai
+    )
+
+    async def chat_completion(
+        model: str,
+        messages: list[ChatMessage],
+        tools: list[ToolSpec] | None = None,
+        tool_choice: str = "auto",
+        on_retry=None,
+    ) -> AssistantMessage:
+        inner = responses_inner if model in responses_models else chat_inner
+        return await inner.chat_completion(model, messages, tools, tool_choice, on_retry)
+
+    def list_models() -> list[str]:
+        try:
+            return _copilot_chat_model_ids(token)
+        except Exception:
+            return sorted(
+                m.id
+                for m in sync_client.models.list()
+                if not m.id.startswith("text-embedding")
+            )
+
+    return CompletionClient(chat_completion=chat_completion, list_models=list_models)
+
+
+def _list_copilot_models(
+    region: str | None = None, cwd: Path | None = None
+) -> list[str]:
+    _ = region, cwd
+    return _build_copilot_client(region, cwd).list_models()
+
+
 SHIM_SPECS: dict[str, ShimSpec] = {
     SHIM_OPENAI: ShimSpec(
         name=SHIM_OPENAI,
@@ -2523,6 +2679,12 @@ SHIM_SPECS: dict[str, ShimSpec] = {
         build_client=_build_claude_shim,
         list_models=_list_claude_models,
     ),
+    SHIM_COPILOT: ShimSpec(
+        name=SHIM_COPILOT,
+        ensure_env=_require_copilot_env,
+        build_client=_build_copilot_client,
+        list_models=_list_copilot_models,
+    ),
 }