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

avos_cli/cli/main.py

@@ -0,0 +1,504 @@
+"""CLI entry point for the avos command.
+
+Thin layer: parses arguments, resolves credentials from the environment,
+connected repo config (with env overlay), and delegates to orchestrators.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+
+from avos_cli import __version__
+from avos_cli.exceptions import AuthError
+from avos_cli.utils.dotenv_load import load_layers
+from avos_cli.utils.output import print_error
+
+if TYPE_CHECKING:
+    from avos_cli.services.diff_summary_service import DiffSummaryService
+    from avos_cli.services.github_client import GitHubClient
+    from avos_cli.services.reply_output_service import ReplyOutputService
+
+# Load .env: cwd, then repository root (beside avos_cli) with override so
+# GITHUB_TOKEN in project root wins, then ~/.avos/.env without overriding.
+load_layers()
+
+app = typer.Typer(
+    name="avos",
+    help="Developer memory CLI for repositories.",
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        typer.echo(f"avos {__version__}")
+        raise typer.Exit()
+
+
+def _first_env(*keys: str) -> str:
+    """Return the first non-empty env value for any of the given keys."""
+    for k in keys:
+        v = os.environ.get(k, "")
+        if v and isinstance(v, str):
+            return v.strip()
+    return ""
+
+
+def _github_client_or_exit(repo_root: Path) -> GitHubClient:
+    """Resolve GitHub client from connected config (overlay) and env; exit if missing."""
+    from avos_cli.services.github_client import github_client_for_repo
+
+    try:
+        return github_client_for_repo(repo_root)
+    except AuthError:
+        print_error(
+            "[AUTH_ERROR] GitHub token is required. Set GITHUB_TOKEN or use a layered .env; "
+            "it is not written to .avos/config.json."
+        )
+        raise typer.Exit(1) from None
+
+
+def _get_reply_model_config() -> tuple[str, str, str]:
+    """Get REPLY_MODEL configuration from environment.
+
+    Returns:
+        Tuple of (model, url, api_key). Empty strings if not configured.
+    """
+    model = _first_env("REPLY_MODEL", "reply_model")
+    url = _first_env("REPLY_MODEL_URL", "reply_model_URL", "reply_model_url")
+    api_key = _first_env("REPLY_MODEL_API_KEY", "reply_model_API_KEY", "reply_model_api_key")
+    return model, url, api_key
+
+
+def _make_reply_service() -> ReplyOutputService | None:
+    """Build ReplyOutputService from env if REPLY_MODEL, REPLY_MODEL_URL, REPLY_MODEL_API_KEY are set."""
+    model, url, api_key = _get_reply_model_config()
+    if model and url and api_key:
+        from avos_cli.services.reply_output_service import ReplyOutputService
+        return ReplyOutputService(api_key=api_key, api_url=url, model=model)
+    return None
+
+
+def _make_diff_summary_service() -> DiffSummaryService | None:
+    """Build DiffSummaryService from env if REPLY_MODEL config is available."""
+    model, url, api_key = _get_reply_model_config()
+    if model and url and api_key:
+        from avos_cli.services.diff_summary_service import DiffSummaryService
+
+        return DiffSummaryService(api_key=api_key, api_url=url, model=model)
+    return None
+
+
+def _github_client_optional(repo_root: Path) -> GitHubClient | None:
+    """Resolve GitHub client from connected config (overlay) and env; return None if missing."""
+    from avos_cli.services.github_client import github_client_for_repo
+
+    try:
+        return github_client_for_repo(repo_root)
+    except AuthError:
+        return None
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        help="Enable verbose debug output.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit machine-readable JSON output.",
+    ),
+) -> None:
+    """AVOS CLI - Developer memory for repositories."""
+    if ctx.invoked_subcommand is None:
+        help_text = ctx.get_help()
+        if "--version" not in help_text:
+            help_text = f"{help_text.rstrip()}\n\n--version  -v  Show version and exit.\n"
+        typer.echo(help_text)
+        raise typer.Exit(0)
+
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["json"] = json_output
+
+
+@app.command()
+def connect(
+    ctx: typer.Context,
+    repo: str | None = typer.Argument(
+        None,
+        help=(
+            "Repository slug in 'org/repo' format. "
+            "Omit to detect from git remote origin (GitHub HTTPS or SSH URL)."
+        ),
+    ),
+) -> None:
+    """Connect a repository to Avos Memory."""
+    from avos_cli.commands.connect import ConnectOrchestrator
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+    from avos_cli.services.git_client import GitClient
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    json_output = ctx.obj.get("json", False)
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        print_error("[AUTH_ERROR] AVOS_API_KEY environment variable is required.")
+        raise typer.Exit(1)
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    gh_client = _github_client_or_exit(repo_root)
+
+    orchestrator = ConnectOrchestrator(
+        git_client=GitClient(),
+        github_client=gh_client,
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        repo_root=repo_root,
+    )
+    code = orchestrator.run(repo, json_output=json_output)
+    raise typer.Exit(code)
+
+
+def _parse_since_days(value: str) -> int:
+    """Parse a '--since Nd' value like '90d' into integer days."""
+    cleaned = value.strip().lower()
+    if cleaned.endswith("d"):
+        cleaned = cleaned[:-1]
+    try:
+        days = int(cleaned)
+        if days <= 0:
+            raise typer.BadParameter("--since must be a positive number of days.")
+        return days
+    except ValueError as e:
+        raise typer.BadParameter(f"Invalid --since value: '{value}'. Expected format: '90d' or '90'.") from e
+
+
+@app.command()
+def ingest(
+    ctx: typer.Context,
+    repo: str = typer.Argument(..., help="Repository slug in 'org/repo' format."),
+    since: str = typer.Option("90d", "--since", help="Time window, e.g. '90d' for 90 days."),
+) -> None:
+    """Ingest repository history into Avos Memory."""
+    from avos_cli.commands.ingest import IngestOrchestrator
+    from avos_cli.config.hash_store import IngestHashStore
+    from avos_cli.config.lock import IngestLockManager
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+    from avos_cli.services.git_client import GitClient
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    json_output = ctx.obj.get("json", False)
+    since_days = _parse_since_days(since)
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        print_error("[AUTH_ERROR] AVOS_API_KEY environment variable is required.")
+        raise typer.Exit(1)
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    gh_client = _github_client_or_exit(repo_root)
+
+    avos_dir = repo_root / ".avos"
+    hash_store = IngestHashStore(avos_dir)
+    hash_store.load()
+
+    orchestrator = IngestOrchestrator(
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        github_client=gh_client,
+        git_client=GitClient(),
+        hash_store=hash_store,
+        lock_manager=IngestLockManager(avos_dir),
+        repo_root=repo_root,
+    )
+    code = orchestrator.run(repo, since_days=since_days, json_output=json_output)
+    raise typer.Exit(code)
+
+
+@app.command(name="ingest-pr")
+def ingest_pr(
+    ctx: typer.Context,
+    repo: str = typer.Argument(..., help="Repository slug in 'org/repo' format."),
+    pr_number: int = typer.Argument(..., help="PR number to ingest."),
+) -> None:
+    """Ingest a single PR into Avos Memory."""
+    from avos_cli.commands.ingest_pr import IngestPROrchestrator
+    from avos_cli.config.hash_store import IngestHashStore
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    json_output = ctx.obj.get("json", False)
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        print_error("[AUTH_ERROR] AVOS_API_KEY environment variable is required.")
+        raise typer.Exit(1)
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    gh_client = _github_client_or_exit(repo_root)
+
+    avos_dir = repo_root / ".avos"
+    hash_store = IngestHashStore(avos_dir)
+    hash_store.load()
+
+    orchestrator = IngestPROrchestrator(
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        github_client=gh_client,
+        hash_store=hash_store,
+        repo_root=repo_root,
+    )
+    code = orchestrator.run(repo, pr_number, json_output=json_output)
+    raise typer.Exit(code)
+
+
+@app.command()
+def ask(
+    ctx: typer.Context,
+    question: str = typer.Argument(..., help="Natural language question about the repository."),
+) -> None:
+    """Ask a question about the repository and get an evidence-backed answer."""
+    from avos_cli.commands.ask import AskOrchestrator
+    from avos_cli.config.manager import find_repo_root, load_config
+    from avos_cli.exceptions import (
+        ConfigurationNotInitializedError,
+        RepositoryContextError,
+    )
+    from avos_cli.services.llm_client import LLMClient
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    json_output = ctx.obj.get("json", False)
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        print_error("[AUTH_ERROR] AVOS_API_KEY environment variable is required.")
+        raise typer.Exit(1)
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    try:
+        config = load_config(repo_root)
+    except ConfigurationNotInitializedError as e:
+        print_error("[AUTH_ERROR] Repository not connected. Run 'avos connect org/repo' first.")
+        raise typer.Exit(1) from e
+
+    provider = config.llm.provider.lower()
+    if provider == "openai":
+        llm_api_key = os.environ.get("OPENAI_API_KEY", "")
+        if not llm_api_key:
+            print_error("[AUTH_ERROR] OPENAI_API_KEY environment variable is required for OpenAI.")
+            raise typer.Exit(1)
+    else:
+        llm_api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+        if not llm_api_key:
+            print_error("[AUTH_ERROR] ANTHROPIC_API_KEY environment variable is required for LLM synthesis.")
+            raise typer.Exit(1)
+
+    reply_service = _make_reply_service()
+    github_client = _github_client_optional(repo_root)
+    diff_summary_service = _make_diff_summary_service()
+    orchestrator = AskOrchestrator(
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        llm_client=LLMClient(api_key=llm_api_key, provider=provider),
+        repo_root=repo_root,
+        reply_service=reply_service,
+        github_client=github_client,
+        diff_summary_service=diff_summary_service,
+    )
+    code = orchestrator.run("_/_", question, json_output=json_output)
+    raise typer.Exit(code)
+
+
+@app.command()
+def history(
+    ctx: typer.Context,
+    subject: str = typer.Argument(..., help="Subject or topic for chronological history."),
+) -> None:
+    """Get a chronological history of a subject in the repository."""
+    from avos_cli.commands.history import HistoryOrchestrator
+    from avos_cli.config.manager import find_repo_root, load_config
+    from avos_cli.exceptions import (
+        ConfigurationNotInitializedError,
+        RepositoryContextError,
+    )
+    from avos_cli.services.llm_client import LLMClient
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    json_output = ctx.obj.get("json", False)
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        print_error("[AUTH_ERROR] AVOS_API_KEY environment variable is required.")
+        raise typer.Exit(1)
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    try:
+        config = load_config(repo_root)
+    except ConfigurationNotInitializedError as e:
+        print_error("[AUTH_ERROR] Repository not connected. Run 'avos connect org/repo' first.")
+        raise typer.Exit(1) from e
+
+    provider = config.llm.provider.lower()
+    if provider == "openai":
+        llm_api_key = os.environ.get("OPENAI_API_KEY", "")
+        if not llm_api_key:
+            print_error("[AUTH_ERROR] OPENAI_API_KEY environment variable is required for OpenAI.")
+            raise typer.Exit(1)
+    else:
+        llm_api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+        if not llm_api_key:
+            print_error("[AUTH_ERROR] ANTHROPIC_API_KEY environment variable is required for LLM synthesis.")
+            raise typer.Exit(1)
+
+    reply_service = _make_reply_service()
+    github_client = _github_client_optional(repo_root)
+    diff_summary_service = _make_diff_summary_service()
+    orchestrator = HistoryOrchestrator(
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        llm_client=LLMClient(api_key=llm_api_key, provider=provider),
+        repo_root=repo_root,
+        reply_service=reply_service,
+        github_client=github_client,
+        diff_summary_service=diff_summary_service,
+    )
+    code = orchestrator.run("_/_", subject, json_output=json_output)
+    raise typer.Exit(code)
+
+
+@app.command(name="hook-install")
+def hook_install(
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Overwrite existing pre-push hook."
+    ),
+) -> None:
+    """Install git hook for automatic commit sync on push."""
+    from avos_cli.commands.hook_install import HookInstallOrchestrator
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+    from avos_cli.services.git_client import GitClient
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    orchestrator = HookInstallOrchestrator(
+        git_client=GitClient(),
+        repo_root=repo_root,
+    )
+    code = orchestrator.run(force=force)
+    raise typer.Exit(code)
+
+
+@app.command(name="hook-uninstall")
+def hook_uninstall() -> None:
+    """Remove the avos pre-push git hook."""
+    from avos_cli.commands.hook_install import HookUninstallOrchestrator
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError as e:
+        print_error(f"[REPOSITORY_CONTEXT_ERROR] {e}")
+        raise typer.Exit(1) from e
+
+    orchestrator = HookUninstallOrchestrator(repo_root=repo_root)
+    code = orchestrator.run()
+    raise typer.Exit(code)
+
+
+@app.command(name="hook-sync", hidden=True)
+def hook_sync(
+    old_sha: str = typer.Argument(..., help="Base commit SHA (remote has this)."),
+    new_sha: str = typer.Argument(..., help="Target commit SHA (pushing this)."),
+) -> None:
+    """Sync commits to Avos Memory (called by pre-push hook)."""
+    from avos_cli.commands.hook_sync import HookSyncOrchestrator
+    from avos_cli.config.hash_store import IngestHashStore
+    from avos_cli.config.manager import find_repo_root
+    from avos_cli.exceptions import RepositoryContextError
+    from avos_cli.services.git_client import GitClient
+    from avos_cli.services.memory_client import AvosMemoryClient
+
+    api_key = os.environ.get("AVOS_API_KEY", "")
+    api_url = os.environ.get("AVOS_API_URL", "https://api.avos.ai")
+
+    if not api_key:
+        return
+
+    try:
+        repo_root = find_repo_root(Path.cwd())
+    except RepositoryContextError:
+        return
+
+    avos_dir = repo_root / ".avos"
+    hash_store = IngestHashStore(avos_dir)
+    hash_store.load()
+
+    orchestrator = HookSyncOrchestrator(
+        memory_client=AvosMemoryClient(api_key=api_key, api_url=api_url),
+        git_client=GitClient(),
+        hash_store=hash_store,
+        repo_root=repo_root,
+    )
+    code = orchestrator.run(old_sha, new_sha)
+    raise typer.Exit(code)
+
+
+if __name__ == "__main__":
+    app()

avos_cli/commands/__init__.py

@@ -0,0 +1 @@
+