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

avos_cli/commands/hook_install.py

@@ -0,0 +1,260 @@
+"""Hook install command for setting up automatic commit sync on git push.
+
+Installs a pre-push git hook that automatically syncs pushed commits
+to Avos Memory. This enables real-time team synchronization without
+requiring manual `avos ingest` runs.
+"""
+
+from __future__ import annotations
+
+import stat
+from pathlib import Path
+
+from avos_cli.config.manager import load_config
+from avos_cli.exceptions import (
+    AvosError,
+    ConfigurationNotInitializedError,
+)
+from avos_cli.services.git_client import GitClient
+from avos_cli.utils.logger import get_logger
+from avos_cli.utils.output import print_error, print_info, print_success, print_warning
+
+_log = get_logger("commands.hook_install")
+
+_PRE_PUSH_HOOK_SCRIPT = """\
+#!/bin/sh
+# =============================================================================
+# Avos Memory Auto-Sync Hook
+# =============================================================================
+# Installed by: avos hook-install
+# Purpose: Automatically sync pushed commits to Avos Memory
+#
+# This hook runs before git push and extracts commits being pushed,
+# then inserts them into Avos Memory for team synchronization.
+#
+# To uninstall: rm .git/hooks/pre-push
+# =============================================================================
+
+remote="$1"
+url="$2"
+
+# Read refs from stdin (format: local_ref local_sha remote_ref remote_sha)
+while read local_ref local_sha remote_ref remote_sha; do
+    # Skip if deleting a ref (local_sha is null)
+    if [ "$local_sha" = "0000000000000000000000000000000000000000" ]; then
+        continue
+    fi
+
+    # For new branches, remote_sha is null - use empty string
+    if [ "$remote_sha" = "0000000000000000000000000000000000000000" ]; then
+        remote_sha=""
+    fi
+
+    # Sync commits to Avos Memory (never blocks push)
+    avos hook-sync "$remote_sha" "$local_sha" 2>&1 || true
+done
+
+# Always allow push to proceed
+exit 0
+"""
+
+
+class HookInstallOrchestrator:
+    """Orchestrates installation of the pre-push git hook.
+
+    The hook enables automatic commit sync to Avos Memory on every
+    git push, allowing team members to see each other's work in
+    real-time via `avos ask` and `avos history`.
+
+    Args:
+        git_client: Local git operations wrapper.
+        repo_root: Path to the repository root.
+    """
+
+    def __init__(self, git_client: GitClient, repo_root: Path) -> None:
+        self._git = git_client
+        self._repo_root = repo_root
+
+    def run(self, force: bool = False, quiet: bool = False) -> int:
+        """Install the pre-push hook for automatic commit sync.
+
+        Args:
+            force: If True, overwrite existing hook without prompting.
+            quiet: If True, suppress all output (for auto-install from connect).
+
+        Returns:
+            Exit code: 0 on success, 1 on failure.
+        """
+        try:
+            config = load_config(self._repo_root)
+        except ConfigurationNotInitializedError:
+            if not quiet:
+                print_error(
+                    "[CONFIG_NOT_INITIALIZED] Repository not connected. "
+                    "Run 'avos connect org/repo' first."
+                )
+            return 1
+        except AvosError as e:
+            if not quiet:
+                print_error(f"[{e.code}] {e}")
+            return 1
+
+        hooks_dir = self._get_hooks_dir()
+        if hooks_dir is None:
+            if not quiet:
+                print_error("[REPOSITORY_CONTEXT_ERROR] Could not locate .git/hooks directory.")
+            return 1
+
+        hook_path = hooks_dir / "pre-push"
+
+        if hook_path.exists() and not force:
+            if self._is_avos_hook(hook_path):
+                if not quiet:
+                    print_info("Avos pre-push hook is already installed.")
+                return 0
+            else:
+                if not quiet:
+                    print_warning(
+                        "A pre-push hook already exists and was not installed by avos.\n"
+                        "Use --force to overwrite, or manually integrate avos hook-sync."
+                    )
+                _log.debug("Existing non-avos hook found, skipping auto-install")
+                return 1
+
+        try:
+            self._install_hook(hook_path)
+        except OSError as e:
+            if not quiet:
+                print_error(f"[HOOK_INSTALL_ERROR] Failed to install hook: {e}")
+            return 1
+
+        if not quiet:
+            print_success(f"Installed pre-push hook: {hook_path}")
+            print_info(
+                "Commits will now auto-sync to Avos Memory on every git push.\n"
+                f"Connected to memory: {config.memory_id}"
+            )
+        else:
+            _log.debug("Auto-installed pre-push hook at %s", hook_path)
+        return 0
+
+    def _get_hooks_dir(self) -> Path | None:
+        """Get the path to the git hooks directory.
+
+        Handles both regular repos (.git/hooks) and worktrees.
+
+        Returns:
+            Path to hooks directory, or None if not found.
+        """
+        git_path = self._repo_root / ".git"
+
+        if git_path.is_dir():
+            hooks_dir = git_path / "hooks"
+            hooks_dir.mkdir(exist_ok=True)
+            return hooks_dir
+
+        if git_path.is_file():
+            try:
+                content = git_path.read_text().strip()
+                if content.startswith("gitdir:"):
+                    gitdir = content[7:].strip()
+                    gitdir_path = Path(gitdir)
+                    if not gitdir_path.is_absolute():
+                        gitdir_path = (self._repo_root / gitdir_path).resolve()
+                    hooks_dir = gitdir_path / "hooks"
+                    hooks_dir.mkdir(exist_ok=True)
+                    return hooks_dir
+            except (OSError, ValueError):
+                pass
+
+        return None
+
+    def _is_avos_hook(self, hook_path: Path) -> bool:
+        """Check if an existing hook was installed by avos.
+
+        Args:
+            hook_path: Path to the hook file.
+
+        Returns:
+            True if the hook contains avos signature.
+        """
+        try:
+            content = hook_path.read_text()
+            return "avos hook-sync" in content or "Avos Memory Auto-Sync" in content
+        except OSError:
+            return False
+
+    def _install_hook(self, hook_path: Path) -> None:
+        """Write the pre-push hook script and make it executable.
+
+        Args:
+            hook_path: Path where the hook should be installed.
+
+        Raises:
+            OSError: If writing or chmod fails.
+        """
+        hook_path.write_text(_PRE_PUSH_HOOK_SCRIPT)
+        hook_path.chmod(hook_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        _log.info("Installed pre-push hook at %s", hook_path)
+
+
+class HookUninstallOrchestrator:
+    """Orchestrates removal of the pre-push git hook.
+
+    Args:
+        repo_root: Path to the repository root.
+    """
+
+    def __init__(self, repo_root: Path) -> None:
+        self._repo_root = repo_root
+
+    def run(self) -> int:
+        """Remove the avos pre-push hook if it exists.
+
+        Returns:
+            Exit code: 0 on success, 1 if hook wasn't avos-installed.
+        """
+        git_path = self._repo_root / ".git"
+        if git_path.is_dir():
+            hook_path = git_path / "hooks" / "pre-push"
+        elif git_path.is_file():
+            try:
+                content = git_path.read_text().strip()
+                if content.startswith("gitdir:"):
+                    gitdir = content[7:].strip()
+                    gitdir_path = Path(gitdir)
+                    if not gitdir_path.is_absolute():
+                        gitdir_path = (self._repo_root / gitdir_path).resolve()
+                    hook_path = gitdir_path / "hooks" / "pre-push"
+                else:
+                    print_error("[REPOSITORY_CONTEXT_ERROR] Invalid .git file format.")
+                    return 1
+            except OSError:
+                print_error("[REPOSITORY_CONTEXT_ERROR] Could not read .git file.")
+                return 1
+        else:
+            print_error("[REPOSITORY_CONTEXT_ERROR] No .git found.")
+            return 1
+
+        if not hook_path.exists():
+            print_info("No pre-push hook installed.")
+            return 0
+
+        try:
+            content = hook_path.read_text()
+            if "avos hook-sync" not in content and "Avos Memory Auto-Sync" not in content:
+                print_warning(
+                    "The existing pre-push hook was not installed by avos.\n"
+                    "Remove it manually if needed."
+                )
+                return 1
+        except OSError:
+            pass
+
+        try:
+            hook_path.unlink()
+            print_success("Removed avos pre-push hook.")
+            return 0
+        except OSError as e:
+            print_error(f"[HOOK_UNINSTALL_ERROR] Failed to remove hook: {e}")
+            return 1

avos_cli/commands/hook_sync.py

@@ -0,0 +1,231 @@
+"""Hook sync command for automatic commit memory insertion on git push.
+
+# =============================================================================
+# IMPORTANT: INGEST PIPELINE BYPASS
+# =============================================================================
+# This module bypasses the avos ingest pipeline and directly calls add_memory().
+#
+# WHY: To enable real-time commit sync on git push without GitHub API polling.
+#
+# CONSTRAINT: This MUST use the exact same data schema as avos ingest:
+#   - CommitArtifact model (avos_cli/models/artifacts.py)
+#   - CommitBuilder format (avos_cli/artifacts/commit_builder.py)
+#   - Hash store deduplication (avos_cli/config/hash_store.py)
+#
+# IF YOU CHANGE avos ingest commit handling, UPDATE THIS MODULE.
+# See: avos_cli/commands/ingest.py::_ingest_commits()
+# =============================================================================
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from avos_cli.artifacts.commit_builder import CommitBuilder
+from avos_cli.config.hash_store import IngestHashStore
+from avos_cli.config.manager import load_config
+from avos_cli.exceptions import (
+    AvosError,
+    ConfigurationNotInitializedError,
+)
+from avos_cli.models.artifacts import CommitArtifact
+from avos_cli.services.git_client import GitClient
+from avos_cli.services.memory_client import AvosMemoryClient
+from avos_cli.utils.logger import get_logger
+from avos_cli.utils.output import print_info, print_success
+
+_log = get_logger("commands.hook_sync")
+
+
+@dataclass
+class HookSyncResult:
+    """Result of hook sync operation.
+
+    Attributes:
+        processed: Total commits attempted.
+        stored: Commits successfully stored in Avos Memory.
+        skipped: Commits skipped due to deduplication.
+        failed: Commits that failed to store.
+    """
+
+    processed: int = 0
+    stored: int = 0
+    skipped: int = 0
+    failed: int = 0
+
+
+class HookSyncOrchestrator:
+    """Orchestrates commit sync on git push via pre-push hook.
+
+    # =========================================================================
+    # INGEST BYPASS NOTICE
+    # =========================================================================
+    # This orchestrator bypasses the full avos ingest pipeline.
+    # It directly inserts commits using the same schema as:
+    #   avos_cli/commands/ingest.py::_ingest_commits()
+    #
+    # If the ingest commit schema changes, this module MUST be updated.
+    # =========================================================================
+
+    Args:
+        memory_client: Avos Memory API client.
+        git_client: Local git operations wrapper.
+        hash_store: Content hash store for deduplication.
+        repo_root: Path to the repository root.
+    """
+
+    def __init__(
+        self,
+        memory_client: AvosMemoryClient,
+        git_client: GitClient,
+        hash_store: IngestHashStore,
+        repo_root: Path,
+    ) -> None:
+        self._memory = memory_client
+        self._git = git_client
+        self._hash_store = hash_store
+        self._repo_root = repo_root
+        self._commit_builder = CommitBuilder()
+
+    def run(self, old_sha: str, new_sha: str) -> int:
+        """Execute the hook sync flow for commits between two SHAs.
+
+        This is called by the pre-push hook with the old and new SHA
+        of the ref being pushed. It extracts commits in the range and
+        inserts them into Avos Memory.
+
+        Args:
+            old_sha: Base commit SHA (what remote has). Empty for new branches.
+            new_sha: Target commit SHA (what we're pushing).
+
+        Returns:
+            Exit code: 0 on success, 1 on precondition failure.
+            Note: We always return 0 to avoid blocking git push.
+        """
+        try:
+            config = load_config(self._repo_root)
+        except ConfigurationNotInitializedError:
+            _log.debug("No avos config found, skipping hook sync")
+            return 0
+        except AvosError as e:
+            _log.warning("Failed to load avos config: %s", e)
+            return 0
+
+        repo_slug = config.repo
+        memory_id = config.memory_id
+
+        if not repo_slug or not memory_id:
+            _log.debug("Missing repo or memory_id in config, skipping")
+            return 0
+
+        normalized_old = self._normalize_sha(old_sha)
+        normalized_new = self._normalize_sha(new_sha)
+
+        if not normalized_new:
+            _log.debug("No new SHA provided, skipping")
+            return 0
+
+        result = self._sync_commits(normalized_old, normalized_new, repo_slug, memory_id)
+
+        if result.stored > 0 or result.skipped > 0:
+            self._hash_store.save()
+
+        if result.stored > 0:
+            print_success(
+                f"[avos] Synced {result.stored} commit(s) to memory "
+                f"({result.skipped} skipped, {result.failed} failed)"
+            )
+        elif result.processed > 0 and result.skipped == result.processed:
+            print_info(f"[avos] All {result.skipped} commit(s) already in memory")
+
+        return 0
+
+    def _normalize_sha(self, sha: str) -> str:
+        """Normalize SHA, treating null SHA as empty string.
+
+        Args:
+            sha: SHA string, possibly the null SHA (all zeros).
+
+        Returns:
+            Empty string if null SHA, otherwise the original SHA.
+        """
+        if not sha:
+            return ""
+        if sha == "0" * 40:
+            return ""
+        return sha.strip()
+
+    def _sync_commits(
+        self, old_sha: str, new_sha: str, repo_slug: str, memory_id: str
+    ) -> HookSyncResult:
+        """Sync commits in the given range to Avos Memory.
+
+        # INGEST BYPASS: Uses same artifact schema as ingest._ingest_commits()
+
+        Args:
+            old_sha: Base SHA (exclusive). Empty for new branches.
+            new_sha: Target SHA (inclusive).
+            repo_slug: Repository identifier 'org/repo'.
+            memory_id: Target memory ID.
+
+        Returns:
+            HookSyncResult with counts.
+        """
+        result = HookSyncResult()
+
+        try:
+            commits = self._git.commit_log_range(self._repo_root, old_sha, new_sha)
+        except AvosError as e:
+            _log.warning("Failed to get commit range: %s", e)
+            return result
+
+        if not commits:
+            _log.debug("No commits in range %s..%s", old_sha[:8] if old_sha else "ROOT", new_sha[:8])
+            return result
+
+        for commit_data in commits:
+            result.processed += 1
+            try:
+                self._sync_single_commit(commit_data, repo_slug, memory_id, result)
+            except Exception as e:
+                _log.warning("Failed to sync commit %s: %s", commit_data.get("hash", "?")[:8], e)
+                result.failed += 1
+
+        return result
+
+    def _sync_single_commit(
+        self,
+        commit_data: dict[str, str],
+        repo_slug: str,
+        memory_id: str,
+        result: HookSyncResult,
+    ) -> None:
+        """Sync a single commit to Avos Memory.
+
+        # INGEST BYPASS: This follows the exact same pattern as
+        # avos_cli/commands/ingest.py::_ingest_commits() lines 282-298
+
+        Args:
+            commit_data: Dict with hash, message, author, date.
+            repo_slug: Repository identifier.
+            memory_id: Target memory ID.
+            result: Result object to update.
+        """
+        artifact = CommitArtifact(
+            repo=repo_slug,
+            hash=commit_data["hash"],
+            message=commit_data["message"],
+            author=commit_data["author"],
+            date=commit_data["date"],
+        )
+        text = self._commit_builder.build(artifact)
+        content_hash = self._commit_builder.content_hash(artifact)
+
+        if self._hash_store.contains(content_hash):
+            result.skipped += 1
+            return
+
+        self._memory.add_memory(memory_id=memory_id, content=text)
+        self._hash_store.add(content_hash, "commit", commit_data["hash"])
+        result.stored += 1