git-copilot-commit 0.4.1__tar.gz → 0.4.3__tar.gz

{git_copilot_commit-0.4.1 → git_copilot_commit-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.4.1
+Version: 0.4.3
 Summary: Automatically generate and commit changes using copilot
 Author-email: Dheepak Krishnamurthy <1813121+kdheepak@users.noreply.github.com>
 License-File: LICENSE
@@ -104,44 +104,6 @@ Options:
   --help            Show this message and exit.
 ```
 
-### Authenticate
-
-```bash
-$ uvx git-copilot-commit authenticate --help
-Usage: git-copilot-commit authenticate [OPTIONS]
-
-  Autheticate with GitHub Copilot.
-
-Options:
-  --help  Show this message and exit.
-```
-
-### List models
-
-```bash
-$ uvx git-copilot-commit models --help
-Usage: git-copilot-commit models [OPTIONS]
-
-  List models available for chat in a table.
-
-Options:
-  --help  Show this message and exit.
-```
-
-### Configure
-
-```bash
-$ uvx git-copilot-commit config --help
-Usage: git-copilot-commit config [OPTIONS]
-
-  Manage application configuration.
-
-Options:
-  --set-default-model TEXT  Set default model for commit messages
-  --show                    Show current configuration
-  --help                    Show this message and exit.
-```
-
 ## Examples
 
 Commit all changes:
@@ -162,14 +124,6 @@ Use a specific model:
 uvx git-copilot-commit commit --model claude-3.5-sonnet
 ```
 
-Set and use a default model:
-
-```bash
-uvx git-copilot-commit config --set-default-model gpt-4o
-uvx git-copilot-commit commit
-uvx git-copilot-commit commit --model claude-3.5-sonnet
-```
-
 ## Commit Message Format
 
 Follows [Conventional Commits](https://www.conventionalcommits.org/):
@@ -199,15 +153,23 @@ Add a git alias by adding the following to your `~/.gitconfig`:
     ai-commit = "!f() { uvx git-copilot-commit commit $@; }; f"
 ```
 
-Now you can run:
+Now you can run to review the message before committing:
 
 ```bash
 git ai-commit
-git ai-commit --all --yes --model claude-3.5-sonnet
 ```
 
-Additionally, show more context in diffs by running the following command:
+Alternatively, you can stage all files and auto accept the commit message and
+specify which model should be used to generate the commit in one CLI invocation.
 
 ```bash
-git config --global diff.context 3
+git ai-commit --all --yes --model claude-3.5-sonnet
 ```
+
+> [!TIP]
+>
+> Show more context in diffs by running the following command:
+>
+> ```bash
+> git config --global diff.context 3
+> ```

{git_copilot_commit-0.4.1 → git_copilot_commit-0.4.3}/README.md

@@ -91,44 +91,6 @@ Options:
   --help            Show this message and exit.
 ```
 
-### Authenticate
-
-```bash
-$ uvx git-copilot-commit authenticate --help
-Usage: git-copilot-commit authenticate [OPTIONS]
-
-  Autheticate with GitHub Copilot.
-
-Options:
-  --help  Show this message and exit.
-```
-
-### List models
-
-```bash
-$ uvx git-copilot-commit models --help
-Usage: git-copilot-commit models [OPTIONS]
-
-  List models available for chat in a table.
-
-Options:
-  --help  Show this message and exit.
-```
-
-### Configure
-
-```bash
-$ uvx git-copilot-commit config --help
-Usage: git-copilot-commit config [OPTIONS]
-
-  Manage application configuration.
-
-Options:
-  --set-default-model TEXT  Set default model for commit messages
-  --show                    Show current configuration
-  --help                    Show this message and exit.
-```
-
 ## Examples
 
 Commit all changes:
@@ -149,14 +111,6 @@ Use a specific model:
 uvx git-copilot-commit commit --model claude-3.5-sonnet
 ```
 
-Set and use a default model:
-
-```bash
-uvx git-copilot-commit config --set-default-model gpt-4o
-uvx git-copilot-commit commit
-uvx git-copilot-commit commit --model claude-3.5-sonnet
-```
-
 ## Commit Message Format
 
 Follows [Conventional Commits](https://www.conventionalcommits.org/):
@@ -186,15 +140,23 @@ Add a git alias by adding the following to your `~/.gitconfig`:
     ai-commit = "!f() { uvx git-copilot-commit commit $@; }; f"
 ```
 
-Now you can run:
+Now you can run to review the message before committing:
 
 ```bash
 git ai-commit
-git ai-commit --all --yes --model claude-3.5-sonnet
 ```
 
-Additionally, show more context in diffs by running the following command:
+Alternatively, you can stage all files and auto accept the commit message and
+specify which model should be used to generate the commit in one CLI invocation.
 
 ```bash
-git config --global diff.context 3
+git ai-commit --all --yes --model claude-3.5-sonnet
 ```
+
+> [!TIP]
+>
+> Show more context in diffs by running the following command:
+>
+> ```bash
+> git config --global diff.context 3
+> ```

{git_copilot_commit-0.4.1 → git_copilot_commit-0.4.3}/src/git_copilot_commit/github_copilot.py

@@ -8,6 +8,7 @@ import secrets
 import time
 import uuid
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -17,7 +18,7 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
-APP_NAME = "git-copilot-commit"
+APP_NAME = "github-copilot-commit"
 DEFAULT_GITHUB_DOMAIN = "github.com"
 USER_AGENT = "GitHubCopilotChat/0.35.0"
 EDITOR_VERSION = "vscode/1.107.0"
@@ -28,6 +29,23 @@ CLIENT_ID = base64.b64decode("SXYxLmI1MDdhMDhjODdlY2ZlOTg=").decode()
 INITIAL_POLL_INTERVAL_MULTIPLIER = 1.2
 SLOW_DOWN_POLL_INTERVAL_MULTIPLIER = 1.4
 DEFAULT_MODEL_ID = "gpt-5.3-codex"
+DEFAULT_MODEL_PREFERENCES = (
+    "gpt-5.3-codex",
+    "gpt-5.4",
+    "claude-opus-4.6",
+    "claude-opus-4.5",
+    "claude-sonnet-4.6",
+    "claude-sonnet-4.5",
+    "gemini-2.5-pro",
+    "gpt-4.1",
+    "gpt-4o",
+)
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="General-purpose GitHub Copilot CLI.",
+)
 
 console = Console()
 console_err = Console(stderr=True)
@@ -133,6 +151,42 @@ class CopilotModel:
         )
 
 
+@dataclass(slots=True)
+class GitHubViewer:
+    login: str
+    name: str | None = None
+    html_url: str | None = None
+    account_type: str | None = None
+    plan_name: str | None = None
+
+    @classmethod
+    def from_payload(cls, payload: dict[str, Any]) -> "GitHubViewer":
+        login = payload.get("login")
+        name = payload.get("name")
+        html_url = payload.get("html_url")
+        account_type = payload.get("type")
+        plan = payload.get("plan")
+
+        if not isinstance(login, str) or not login:
+            raise CopilotError("GitHub user endpoint did not return a login.")
+
+        plan_name: str | None = None
+        if isinstance(plan, dict):
+            raw_plan_name = plan.get("name")
+            if isinstance(raw_plan_name, str) and raw_plan_name:
+                plan_name = raw_plan_name
+
+        return cls(
+            login=login,
+            name=name if isinstance(name, str) and name else None,
+            html_url=html_url if isinstance(html_url, str) and html_url else None,
+            account_type=(
+                account_type if isinstance(account_type, str) and account_type else None
+            ),
+            plan_name=plan_name,
+        )
+
+
 def xdg_data_home() -> Path:
     value = os.environ.get("XDG_DATA_HOME")
     if value:
@@ -175,6 +229,12 @@ def get_urls(domain: str) -> dict[str, str]:
     }
 
 
+def get_github_api_base_url(domain: str) -> str:
+    if domain == DEFAULT_GITHUB_DOMAIN:
+        return "https://api.github.com"
+    return f"https://api.{domain}"
+
+
 def get_base_url_from_token(token: str) -> str | None:
     match = re.search(r"proxy-ep=([^;]+)", token)
     if not match:
@@ -251,10 +311,63 @@ def request_json(
         raise CopilotError(f"Invalid JSON response from {url}.") from exc
 
 
+def iter_sse_events(response: httpx.Response, url: str):
+    event_name: str | None = None
+    data_lines: list[str] = []
+
+    def decode_event(raw_data: str, current_event: str | None) -> Any:
+        if raw_data == "[DONE]":
+            return None
+        try:
+            payload = json.loads(raw_data)
+        except json.JSONDecodeError as exc:
+            label = current_event or "message"
+            raise CopilotError(
+                f"Invalid SSE event payload from {url} ({label})."
+            ) from exc
+        if isinstance(payload, dict) and current_event and "type" not in payload:
+            payload = dict(payload)
+            payload["type"] = current_event
+        return payload
+
+    for raw_line in response.iter_lines():
+        line = raw_line if isinstance(raw_line, str) else raw_line.decode("utf-8")
+        if not line:
+            if data_lines:
+                current_event = event_name
+                raw_data = "\n".join(data_lines)
+                event_name = None
+                data_lines = []
+                payload = decode_event(raw_data, current_event)
+                if payload is not None:
+                    yield payload
+            else:
+                event_name = None
+            continue
+
+        if line.startswith(":"):
+            continue
+
+        field, _, value = line.partition(":")
+        if value.startswith(" "):
+            value = value[1:]
+
+        if field == "event":
+            event_name = value
+            continue
+        if field == "data":
+            data_lines.append(value)
+
+    if data_lines:
+        payload = decode_event("\n".join(data_lines), event_name)
+        if payload is not None:
+            yield payload
+
+
 def load_credentials() -> CopilotCredentials | None:
     path = credentials_path()
     if not path.exists():
-        return None
+        return
 
     try:
         raw = json.loads(path.read_text(encoding="utf-8"))
@@ -434,10 +547,34 @@ def refresh_copilot_token(
     )
 
 
+def fetch_github_viewer(
+    client: httpx.Client,
+    github_access_token: str,
+    domain: str,
+) -> GitHubViewer:
+    payload = request_json(
+        client,
+        "GET",
+        f"{get_github_api_base_url(domain)}/user",
+        headers={
+            "Accept": "application/vnd.github+json",
+            "Authorization": f"Bearer {github_access_token}",
+            "User-Agent": USER_AGENT,
+        },
+    )
+
+    if not isinstance(payload, dict):
+        raise CopilotError("GitHub user endpoint returned an invalid response.")
+
+    return GitHubViewer.from_payload(payload)
+
+
 def ensure_fresh_credentials(client: httpx.Client) -> CopilotCredentials:
     credentials = load_credentials()
     if credentials is None:
-        raise CopilotError("No cached Copilot credentials found.")
+        raise CopilotError(
+            f"No cached Copilot credentials found. Run `{Path(__file__).name} auth login` first."
+        )
 
     if not credentials.is_expired():
         return credentials
@@ -455,10 +592,11 @@ def copilot_request_headers(
     access_token: str,
     *,
     intent: str = "conversation-panel",
+    accept: str = "application/json",
 ) -> dict[str, str]:
     return {
         "Authorization": f"Bearer {access_token}",
-        "Accept": "application/json",
+        "Accept": accept,
         "Content-Type": "application/json",
         "User-Agent": USER_AGENT,
         "Editor-Version": EDITOR_VERSION,
@@ -518,6 +656,10 @@ def pick_model(
             )
         return by_id[requested_model]
 
+    for preferred_model in DEFAULT_MODEL_PREFERENCES:
+        if preferred_model in by_id:
+            return by_id[preferred_model]
+
     return models[0]
 
 
@@ -652,7 +794,7 @@ def chat_completion(
                 }
             ],
             "temperature": 0,
-            "max_tokens": 32,
+            "max_tokens": 1024,
             "stream": False,
         },
     )
@@ -672,6 +814,7 @@ def extract_response_text(payload: Any) -> str:
         raise CopilotError("Responses API returned no output.")
 
     parts: list[str] = []
+    refusals: list[str] = []
     for item in output:
         if not isinstance(item, dict):
             continue
@@ -684,12 +827,20 @@ def extract_response_text(payload: Any) -> str:
             text = block.get("text")
             if isinstance(text, str) and text.strip():
                 parts.append(text.strip())
+                continue
+            refusal = block.get("refusal")
+            if isinstance(refusal, str) and refusal.strip():
+                refusals.append(refusal.strip())
 
     joined = "\n".join(parts).strip()
     if joined:
         return joined
 
-    raise CopilotError(f"Responses API output did not contain text: {payload}")
+    joined_refusals = "\n".join(refusals).strip()
+    if joined_refusals:
+        return joined_refusals
+
+    raise CopilotError("Responses API output did not contain text.")
 
 
 def responses_completion(
@@ -699,32 +850,137 @@ def responses_completion(
     model: CopilotModel,
     prompt: str,
 ) -> str:
-    payload = request_json(
-        client,
-        "POST",
-        f"{credentials.base_url()}/responses",
-        headers=copilot_request_headers(
-            credentials.copilot_token, intent="conversation-edits"
-        ),
-        json_body={
-            "model": model.id,
-            "input": [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "input_text",
-                            "text": prompt,
-                        }
-                    ],
-                }
-            ],
-            "stream": False,
-            "store": False,
-            "max_output_tokens": 1024,
-        },
-    )
-    return extract_response_text(payload)
+    url = f"{credentials.base_url()}/responses"
+    request_body = {
+        "model": model.id,
+        "input": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "input_text",
+                        "text": prompt,
+                    }
+                ],
+            }
+        ],
+        "stream": True,
+        "store": False,
+    }
+
+    text_parts: list[str] = []
+    final_response: dict[str, Any] | None = None
+
+    try:
+        with client.stream(
+            "POST",
+            url,
+            headers=copilot_request_headers(
+                credentials.copilot_token,
+                intent="conversation-edits",
+                accept="text/event-stream",
+            ),
+            json=request_body,
+        ) as response:
+            if response.is_error:
+                detail = response.read().decode("utf-8", errors="replace").strip()
+                if len(detail) > 400:
+                    detail = f"{detail[:397]}..."
+                suffix = f": {detail}" if detail else ""
+                raise CopilotError(
+                    f"{response.status_code} {response.reason_phrase}{suffix}"
+                )
+
+            content_type = response.headers.get("content-type", "")
+            if "text/event-stream" not in content_type:
+                body = response.read()
+                try:
+                    payload = json.loads(body)
+                except ValueError as exc:
+                    detail = body.decode("utf-8", errors="replace").strip()
+                    if len(detail) > 400:
+                        detail = f"{detail[:397]}..."
+                    raise CopilotError(
+                        f"Expected an SSE stream from {url}, got {content_type or 'unknown content type'}: {detail}"
+                    ) from exc
+                return extract_response_text(payload)
+
+            for event in iter_sse_events(response, url):
+                if not isinstance(event, dict):
+                    continue
+
+                event_type = event.get("type")
+                if event_type == "response.output_text.delta":
+                    delta = event.get("delta")
+                    if isinstance(delta, str) and delta:
+                        text_parts.append(delta)
+                    continue
+
+                if event_type == "response.output_text.done" and not text_parts:
+                    text = event.get("text")
+                    if isinstance(text, str) and text.strip():
+                        text_parts.append(text)
+                    continue
+
+                if event_type == "error":
+                    error = event.get("error")
+                    if isinstance(error, dict):
+                        message = error.get("message")
+                        code = error.get("code")
+                        if isinstance(message, str) and message.strip():
+                            prefix = (
+                                f"{code}: " if isinstance(code, str) and code else ""
+                            )
+                            raise CopilotError(
+                                f"Responses stream error: {prefix}{message.strip()}"
+                            )
+                    raise CopilotError("Responses stream returned an error event.")
+
+                if event_type in {
+                    "response.completed",
+                    "response.failed",
+                    "response.incomplete",
+                }:
+                    response_payload = event.get("response")
+                    if isinstance(response_payload, dict):
+                        final_response = response_payload
+    except httpx.HTTPError as exc:
+        raise CopilotError(f"Request failed for {url}: {exc}") from exc
+
+    text = "".join(text_parts).strip()
+    if final_response is None:
+        if text:
+            return text
+        raise CopilotError("Responses stream ended without a terminal response event.")
+
+    status = final_response.get("status")
+    if status == "failed":
+        error = final_response.get("error")
+        if isinstance(error, dict):
+            message = error.get("message")
+            code = error.get("code")
+            if isinstance(message, str) and message.strip():
+                prefix = f"{code}: " if isinstance(code, str) and code else ""
+                raise CopilotError(
+                    f"Responses API request failed: {prefix}{message.strip()}"
+                )
+        raise CopilotError("Responses API request failed.")
+
+    if status == "incomplete":
+        details = final_response.get("incomplete_details")
+        reason = "unknown"
+        if isinstance(details, dict):
+            raw_reason = details.get("reason")
+            if isinstance(raw_reason, str) and raw_reason.strip():
+                reason = raw_reason.strip()
+        if text:
+            return f"{text}\n\n[Response incomplete: {reason}]"
+        raise CopilotError(f"Responses API response was incomplete: {reason}.")
+
+    if text:
+        return text
+
+    return extract_response_text(final_response)
 
 
 def complete_text_prompt(
@@ -763,12 +1019,100 @@ def print_model_table(models: list[CopilotModel]) -> None:
     console.print(table)
 
 
-def fail(message: str) -> None:
-    console_err.print(f"[red]Error:[/red] {message}")
-    raise typer.Exit(1)
+def format_relative_duration(delta_seconds: int) -> str:
+    remaining = abs(delta_seconds)
+    units = (
+        ("d", 86_400),
+        ("h", 3_600),
+        ("m", 60),
+        ("s", 1),
+    )
+    parts: list[str] = []
+    for suffix, width in units:
+        if remaining < width and suffix != "s":
+            continue
+        value, remaining = divmod(remaining, width)
+        if value == 0 and suffix != "s":
+            continue
+        parts.append(f"{value}{suffix}")
+        if len(parts) == 2:
+            break
+
+    if not parts:
+        parts.append("0s")
+
+    text = " ".join(parts)
+    if delta_seconds < 0:
+        return f"{text} ago"
+    return f"in {text}"
+
+
+def format_unix_timestamp(timestamp: int) -> str:
+    try:
+        formatted = datetime.fromtimestamp(timestamp).astimezone()
+    except (OSError, OverflowError, ValueError):
+        return str(timestamp)
+
+    delta_seconds = int(timestamp - time.time())
+    return (
+        f"{formatted.strftime('%Y-%m-%d %H:%M:%S %Z')} "
+        f"({format_relative_duration(delta_seconds)})"
+    )
 
 
-def login(enterprise_domain: str | None = None, force: bool = False) -> None:
+def print_login_summary(
+    domain: str,
+    credentials: CopilotCredentials,
+    github_viewer: GitHubViewer | None = None,
+    models: list[CopilotModel] | None = None,
+) -> None:
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="cyan", no_wrap=True)
+    table.add_column(style="white")
+
+    table.add_row("GitHub host", domain)
+
+    if github_viewer is not None:
+        identity = github_viewer.login
+        if github_viewer.name and github_viewer.name != github_viewer.login:
+            identity = f"{identity} ({github_viewer.name})"
+        table.add_row("GitHub user", identity)
+        if github_viewer.account_type:
+            table.add_row("Account type", github_viewer.account_type)
+        if github_viewer.plan_name:
+            table.add_row("GitHub plan", github_viewer.plan_name)
+        if github_viewer.html_url:
+            table.add_row("GitHub profile", github_viewer.html_url)
+
+    table.add_row("Copilot base URL", credentials.base_url())
+    table.add_row(
+        "Copilot token expires",
+        format_unix_timestamp(credentials.copilot_expires_at),
+    )
+
+    if models is not None:
+        default_model = pick_model(models)
+        table.add_row("Available models", str(len(models)))
+        table.add_row(
+            "Default model",
+            f"{default_model.id} ({infer_api_surface(default_model)})",
+        )
+
+    console.print(Panel.fit(table, title="Login Summary"))
+
+
+def login(
+    enterprise_domain: str | None = typer.Option(
+        None,
+        "--enterprise-domain",
+        help="GitHub Enterprise hostname. Omit for github.com.",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Replace any cached Copilot credentials without prompting.",
+    ),
+) -> None:
     """Authenticate with GitHub and cache Copilot credentials locally."""
     normalized_domain = normalize_domain(enterprise_domain)
     if enterprise_domain and not normalized_domain:
@@ -804,9 +1148,29 @@ def login(enterprise_domain: str | None = None, force: bool = False) -> None:
             client, github_access_token, normalized_domain
         )
         path = save_credentials(credentials)
+        github_viewer: GitHubViewer | None = None
+        available_models: list[CopilotModel] | None = None
+        warnings: list[str] = []
+
+        try:
+            github_viewer = fetch_github_viewer(client, github_access_token, domain)
+        except CopilotError as exc:
+            warnings.append(f"Could not fetch GitHub account details: {exc}")
+
+        try:
+            available_models = list_models(client, credentials)
+        except CopilotError as exc:
+            warnings.append(f"Could not fetch Copilot model summary: {exc}")
 
     console.print(f"[green]Saved Copilot credentials to[/green] {path}")
-    console.print(f"[green]Resolved Copilot base URL:[/green] {credentials.base_url()}")
+    print_login_summary(
+        domain,
+        credentials,
+        github_viewer=github_viewer,
+        models=available_models,
+    )
+    for warning in warnings:
+        console.print(f"[yellow]Warning:[/yellow] {warning}")
 
 
 def ask(prompt: str, model: str | None = None) -> str: