git-aware-coding-agent 1.0.0__py3-none-any.whl

avos_cli/services/diff_summary_service.py

@@ -0,0 +1,141 @@
+"""Diff summary service for git diff analysis.
+
+Uses the REPLY_MODEL to summarize git diffs via the git_diff_agent.md
+prompt template. Summaries are held in-memory only and discarded after
+being injected into artifact content.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+
+from avos_cli.models.diff import DiffResult, DiffStatus
+from avos_cli.utils.logger import get_logger
+
+_log = get_logger("diff_summary_service")
+
+_AGENTS_DIR = Path(__file__).resolve().parent.parent / "agents"
+_GIT_DIFF_AGENT_PATH = _AGENTS_DIR / "git_diff_agent.md"
+
+_MAX_TOKENS = 1500
+_TEMPERATURE = 0.1
+_REQUEST_TIMEOUT = 60.0
+
+
+class DiffSummaryService:
+    """Summarizes git diffs using REPLY_MODEL via git_diff_agent.md prompt.
+
+    Takes resolved DiffResult objects, sends each diff to the LLM for
+    summarization, and returns a mapping of canonical_id to summary string.
+    Summaries are in-memory only -- no files written to disk.
+
+    Args:
+        api_key: API key for the reply model.
+        api_url: Endpoint URL (OpenAI-compatible chat completions).
+        model: Model identifier.
+    """
+
+    def __init__(self, api_key: str, api_url: str, model: str) -> None:
+        self._api_key = api_key
+        self._api_url = api_url.rstrip("/")
+        self._model = model
+        self._client = httpx.Client(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=_REQUEST_TIMEOUT,
+        )
+        self._prompt_template: str | None = None
+
+    def summarize_diffs(self, results: list[DiffResult]) -> dict[str, str]:
+        """Summarize resolved diffs using the git_diff_agent prompt.
+
+        Args:
+            results: List of DiffResult objects from DiffResolver.
+
+        Returns:
+            Dict mapping canonical_id to summary string for each successfully
+            summarized diff. Unresolved, suppressed, or failed diffs are skipped.
+        """
+        summaries: dict[str, str] = {}
+
+        for result in results:
+            if result.status != DiffStatus.RESOLVED:
+                continue
+
+            if result.diff_text is None or not result.diff_text.strip():
+                continue
+
+            summary = self._summarize_single(result.canonical_id, result.diff_text)
+            if summary:
+                summaries[result.canonical_id] = summary
+
+        return summaries
+
+    def _summarize_single(self, canonical_id: str, diff_text: str) -> str | None:
+        """Summarize a single diff via LLM call.
+
+        Args:
+            canonical_id: The canonical ID for logging.
+            diff_text: The raw git diff text.
+
+        Returns:
+            Summary string, or None on failure.
+        """
+        prompt = self._load_prompt(diff_text)
+        if not prompt:
+            _log.warning("Failed to load git_diff_agent prompt for %s", canonical_id)
+            return None
+
+        try:
+            body = {
+                "model": self._model,
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": _MAX_TOKENS,
+                "temperature": _TEMPERATURE,
+            }
+            response = self._client.post(self._api_url, json=body)
+            response.raise_for_status()
+            data = response.json()
+
+            choices = data.get("choices", [])
+            if not choices:
+                _log.warning("Empty choices in response for %s", canonical_id)
+                return None
+
+            content = choices[0].get("message", {}).get("content")
+            if not content:
+                _log.warning("No content in response for %s", canonical_id)
+                return None
+
+            return str(content).strip()
+
+        except httpx.HTTPStatusError as e:
+            _log.warning("HTTP error summarizing %s: %s", canonical_id, e)
+            return None
+        except httpx.TimeoutException as e:
+            _log.warning("Timeout summarizing %s: %s", canonical_id, e)
+            return None
+        except Exception as e:
+            _log.warning("Error summarizing %s: %s", canonical_id, e)
+            return None
+
+    def _load_prompt(self, diff_text: str) -> str:
+        """Load and format the git_diff_agent prompt template.
+
+        Args:
+            diff_text: The raw git diff to insert into the template.
+
+        Returns:
+            Formatted prompt string, or empty string on failure.
+        """
+        if self._prompt_template is None:
+            if not _GIT_DIFF_AGENT_PATH.exists():
+                _log.warning("git_diff_agent.md not found at %s", _GIT_DIFF_AGENT_PATH)
+                return ""
+            self._prompt_template = _GIT_DIFF_AGENT_PATH.read_text(encoding="utf-8")
+
+        return self._prompt_template.format(git_diff=diff_text)

avos_cli/services/git_client.py

@@ -0,0 +1,351 @@
+"""Local Git operations wrapper using subprocess.
+
+Provides commit log, branch detection, diff stats, remote parsing,
+modified file listing, and worktree detection. All commands use fixed
+templates (no shell interpolation) for safety.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from avos_cli.exceptions import (
+    DependencyUnavailableError,
+    RepositoryContextError,
+    ServiceParseError,
+)
+from avos_cli.utils.logger import get_logger
+
+_log = get_logger("git_client")
+_TIMEOUT = 30
+
+
+class GitClient:
+    """Wrapper for local Git CLI operations.
+
+    All methods accept a repo_path and shell out to the git binary.
+    Errors are normalized to typed exceptions.
+    """
+
+    def _run_git(self, args: list[str], cwd: Path) -> str:
+        """Execute a git command and return stdout.
+
+        Args:
+            args: Git subcommand and arguments (e.g. ['log', '--oneline']).
+            cwd: Working directory for the command.
+
+        Returns:
+            Stripped stdout string.
+
+        Raises:
+            DependencyUnavailableError: If git binary is not found.
+            RepositoryContextError: If cwd is not a git repo.
+            ServiceParseError: If the command fails unexpectedly.
+        """
+        cmd = ["git", *args]
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=str(cwd),
+                capture_output=True,
+                text=True,
+                timeout=_TIMEOUT,
+            )
+        except FileNotFoundError as e:
+            raise DependencyUnavailableError("git") from e
+        except subprocess.TimeoutExpired as e:
+            raise ServiceParseError(f"Git command timed out: {' '.join(cmd)}") from e
+
+        if result.returncode != 0:
+            stderr = result.stderr.strip()
+            if "not a git repository" in stderr.lower():
+                raise RepositoryContextError(f"Not a Git repository: {cwd}")
+            if result.returncode != 0 and stderr:
+                _log.debug("git stderr: %s", stderr)
+            if result.returncode != 0 and not result.stdout.strip():
+                return ""
+        return result.stdout.rstrip("\n\r")
+
+    def current_branch(self, repo_path: Path) -> str:
+        """Get the current branch name.
+
+        Args:
+            repo_path: Path to the git repository.
+
+        Returns:
+            Branch name string (e.g. 'main', 'feature/foo').
+        """
+        output = self._run_git(["rev-parse", "--abbrev-ref", "HEAD"], repo_path)
+        if not output:
+            raise ServiceParseError("Could not determine current branch")
+        return output
+
+    def user_name(self, repo_path: Path) -> str:
+        """Get the configured git user.name."""
+        return self._run_git(["config", "user.name"], repo_path)
+
+    def user_email(self, repo_path: Path) -> str:
+        """Get the configured git user.email."""
+        return self._run_git(["config", "user.email"], repo_path)
+
+    def commit_log(
+        self, repo_path: Path, since_date: str | None = None
+    ) -> list[dict[str, str]]:
+        """Get commit log as a list of dicts.
+
+        Args:
+            repo_path: Path to the git repository.
+            since_date: Optional ISO date string for lower bound filter.
+
+        Returns:
+            List of dicts with keys: hash, message, author, date.
+        """
+        args = [
+            "log",
+            "--format=%H|%s|%an|%aI",
+        ]
+        if since_date:
+            args.append(f"--since={since_date}")
+
+        output = self._run_git(args, repo_path)
+        if not output:
+            return []
+
+        commits: list[dict[str, str]] = []
+        for line in output.splitlines():
+            parts = line.split("|", 3)
+            if len(parts) >= 4:
+                commits.append({
+                    "hash": parts[0],
+                    "message": parts[1],
+                    "author": parts[2],
+                    "date": parts[3],
+                })
+        return commits
+
+    def commit_log_range(
+        self, repo_path: Path, old_sha: str, new_sha: str
+    ) -> list[dict[str, str]]:
+        """Get commits between two SHAs (exclusive old, inclusive new).
+
+        Used by hook-sync to get commits being pushed. The range old_sha..new_sha
+        returns commits reachable from new_sha but not from old_sha.
+
+        Args:
+            repo_path: Path to the git repository.
+            old_sha: Base commit SHA (exclusive). Use empty string for new branches.
+            new_sha: Target commit SHA (inclusive).
+
+        Returns:
+            List of dicts with keys: hash, message, author, date.
+            Returns empty list if range is invalid or empty.
+        """
+        if not new_sha:
+            return []
+
+        range_spec = f"{old_sha}..{new_sha}" if old_sha else new_sha
+
+        args = ["log", "--format=%H|%s|%an|%aI", range_spec]
+        output = self._run_git(args, repo_path)
+        if not output:
+            return []
+
+        commits: list[dict[str, str]] = []
+        for line in output.splitlines():
+            parts = line.split("|", 3)
+            if len(parts) >= 4:
+                commits.append({
+                    "hash": parts[0],
+                    "message": parts[1],
+                    "author": parts[2],
+                    "date": parts[3],
+                })
+        return commits
+
+    def diff_stats(self, repo_path: Path) -> str:
+        """Get diff stats for staged changes.
+
+        Args:
+            repo_path: Path to the git repository.
+
+        Returns:
+            Diff stat summary string, or empty string if clean.
+        """
+        return self._run_git(["diff", "--cached", "--stat"], repo_path)
+
+    def modified_files(self, repo_path: Path) -> list[str]:
+        """List files modified or untracked in the working directory.
+
+        Args:
+            repo_path: Path to the git repository.
+
+        Returns:
+            List of relative file paths.
+        """
+        output = self._run_git(
+            ["status", "--porcelain", "--untracked-files=all"],
+            repo_path,
+        )
+        if not output:
+            return []
+
+        files: list[str] = []
+        for line in output.splitlines():
+            # porcelain format: "XY filename" where XY is 2 status chars + 1 space
+            if len(line) >= 4:
+                path = line[3:]
+                if " -> " in path:
+                    path = path.split(" -> ", 1)[1]
+                files.append(path)
+        return files
+
+    def remote_origin(self, repo_path: Path) -> str | None:
+        """Extract org/repo from the origin remote URL.
+
+        Handles both HTTPS and SSH remote formats.
+
+        Args:
+            repo_path: Path to the git repository.
+
+        Returns:
+            'org/repo' string, or None if no origin remote.
+        """
+        output = self._run_git(["remote", "get-url", "origin"], repo_path)
+        if not output:
+            return None
+        return _parse_remote_url(output)
+
+    def worktree_add(self, repo_path: Path, path: Path, branch: str) -> Path:
+        """Create a new git worktree with a new branch.
+
+        Runs `git worktree add -b <branch> <path>`. The branch is created
+        from the current HEAD of repo_path.
+
+        Args:
+            repo_path: Path to the source git repository.
+            path: Filesystem path for the new worktree.
+            branch: Name of the new branch to create.
+
+        Returns:
+            Resolved Path to the created worktree directory.
+
+        Raises:
+            ServiceParseError: If git worktree add fails (path exists,
+                branch already checked out, etc.).
+            RepositoryContextError: If repo_path is not a git repo.
+        """
+        resolved = path.resolve()
+        result = subprocess.run(
+            ["git", "worktree", "add", "-b", branch, str(resolved)],
+            cwd=str(repo_path),
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT,
+        )
+        if result.returncode != 0:
+            stderr = result.stderr.strip()
+            if "not a git repository" in stderr.lower():
+                raise RepositoryContextError(f"Not a Git repository: {repo_path}")
+            raise ServiceParseError(
+                f"git worktree add failed: {stderr or 'unknown error'}"
+            )
+        return resolved
+
+    def worktree_list(self, repo_path: Path) -> list[Path]:
+        """List all worktree paths for the repository.
+
+        Parses `git worktree list --porcelain` output where each worktree
+        block starts with a `worktree <path>` line.
+
+        Args:
+            repo_path: Path to any worktree or the main repo.
+
+        Returns:
+            List of resolved Paths for all worktrees (including main).
+        """
+        output = self._run_git(["worktree", "list", "--porcelain"], repo_path)
+        paths: list[Path] = []
+        for line in output.splitlines():
+            if line.startswith("worktree "):
+                wt_path = line[len("worktree "):]
+                paths.append(Path(wt_path).resolve())
+        return paths
+
+    def is_worktree(self, repo_path: Path) -> bool:
+        """Check if the repo path is a git worktree (not the main repo).
+
+        Args:
+            repo_path: Path to check.
+
+        Returns:
+            True if the path is a worktree.
+        """
+        git_path = repo_path / ".git"
+        return git_path.is_file()
+
+    def commit_patch(self, repo_path: Path, sha: str) -> str:
+        """Get the unified diff patch for a single commit.
+
+        Uses `git show --format= <sha>` to get the patch. For merge commits,
+        uses first-parent diff (--first-parent) to avoid combined diff noise.
+
+        Args:
+            repo_path: Path to the git repository.
+            sha: Commit SHA (short or full).
+
+        Returns:
+            Unified diff text, or empty string if commit not found.
+        """
+        args = ["show", "--format=", "--first-parent", "-p", sha]
+        return self._run_git(args, repo_path)
+
+    def expand_short_sha(self, repo_path: Path, short_sha: str) -> str | None:
+        """Expand a short SHA to the full 40-character SHA.
+
+        Uses `git rev-parse <sha>` to resolve the full SHA.
+
+        Args:
+            repo_path: Path to the git repository.
+            short_sha: Short or full commit SHA.
+
+        Returns:
+            Full 40-character SHA, or None if not found or ambiguous.
+
+        Raises:
+            RepositoryContextError: If repo_path is not a git repo.
+        """
+        output = self._run_git(["rev-parse", short_sha], repo_path)
+        if not output or len(output) != 40:
+            return None
+        if not all(c in "0123456789abcdef" for c in output.lower()):
+            return None
+        return output
+
+
+def _parse_remote_url(url: str) -> str | None:
+    """Extract org/repo from a git remote URL.
+
+    Supports:
+    - https://github.com/org/repo.git
+    - git@github.com:org/repo.git
+    - https://github.com/org/repo
+
+    Args:
+        url: Remote URL string.
+
+    Returns:
+        'org/repo' string or None if unparseable.
+    """
+    # SSH format: git@github.com:org/repo.git
+    ssh_match = re.match(r"git@[^:]+:(.+?)(?:\.git)?$", url)
+    if ssh_match:
+        return ssh_match.group(1)
+
+    # HTTPS format: https://github.com/org/repo.git
+    https_match = re.match(r"https?://[^/]+/(.+?)(?:\.git)?$", url)
+    if https_match:
+        return https_match.group(1)
+
+    return None