codeyak 0.0.8__py3-none-any.whl

codeyak/__init__.py

@@ -0,0 +1,8 @@
+"""CodeYak - AI-powered code review tool."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("codeyak")
+except PackageNotFoundError:
+    __version__ = "0.0.0.dev0"

codeyak/__main__.py

@@ -0,0 +1,27 @@
+"""
+Entry point for running codeyak as a module.
+
+Supports both the new CLI interface and backwards-compatible direct invocation:
+    python -m codeyak review              # New: local review
+    python -m codeyak mr <MR_ID> [PROJECT_ID]  # New: MR review
+    python -m codeyak <MR_ID> [PROJECT_ID]     # Legacy: MR review
+"""
+
+import sys
+
+
+def main():
+    """Entry point that handles both CLI and legacy invocation."""
+    # Check if using legacy invocation (first arg is a number = MR_ID)
+    if len(sys.argv) > 1 and sys.argv[1].isdigit():
+        # Legacy mode: convert to new CLI format
+        # python -m codeyak <MR_ID> [PROJECT_ID] -> yak mr <MR_ID> [PROJECT_ID]
+        sys.argv = [sys.argv[0], "mr"] + sys.argv[1:]
+
+    # Import and run CLI
+    from .apps.cli import main as cli_main
+    cli_main()
+
+
+if __name__ == "__main__":
+    main()

codeyak/apps/__init__.py

@@ -0,0 +1,3 @@
+"""
+CodeYak applications.
+"""

codeyak/apps/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+CLI application for CodeYak.
+"""
+
+from .main import main
+
+__all__ = ["main"]

codeyak/apps/cli/configure.py

@@ -0,0 +1,199 @@
+"""
+Interactive init flow for CodeYak configuration.
+
+This module provides functions to interactively configure CodeYak settings
+when users run commands without having configured the tool first.
+"""
+
+import os
+import tomllib
+from pathlib import Path
+
+import click
+import tomli_w
+from rich.panel import Panel
+
+from ...config import get_config_path, reset_settings
+from ...ui import console, BRAND_BORDER
+
+
+def _show_key_feedback(key: str, label: str) -> None:
+    """Show feedback about entered key without revealing it."""
+    if not key:
+        console.print(f"  [warning]Warning: No {label} was entered[/warning]")
+    elif len(key) < 10:
+        console.print(f"  [success]{label} entered[/success] [muted]({len(key)} characters)[/muted]")
+    else:
+        # Show first 4 and last 4 chars for verification
+        masked = f"{key[:4]}...{key[-4:]}"
+        console.print(f"  [success]{label} entered:[/success] {masked} [muted]({len(key)} characters)[/muted]")
+
+
+def _load_existing_config() -> dict:
+    """Load existing config if it exists, otherwise return empty dict."""
+    config_path = get_config_path()
+    if config_path.exists():
+        with open(config_path, "rb") as f:
+            return tomllib.load(f)
+    return {}
+
+
+def _save_config(config: dict) -> None:
+    """Save config to TOML file with restrictive permissions."""
+    config_path = get_config_path()
+
+    # Create parent directories if needed
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write config with restrictive permissions (owner read/write only)
+    with open(config_path, "wb") as f:
+        tomli_w.dump(config, f)
+
+    # Set file permissions to 600 (owner read/write only)
+    os.chmod(config_path, 0o600)
+
+
+def run_llm_init() -> None:
+    """Run interactive init flow for LLM (Azure OpenAI) configuration only."""
+    console.print()
+    console.print(Panel(
+        "[brand]LLM Provider[/brand]",
+        border_style=BRAND_BORDER,
+        padding=(0, 2)
+    ))
+    console.print("Available providers:")
+    console.print("  1. Azure OpenAI")
+    console.print()
+
+    # Azure OpenAI Endpoint
+    console.print("  [muted]Example: https://your-resource.openai.azure.com/[/muted]")
+    endpoint = click.prompt("  Azure OpenAI Endpoint", type=str)
+
+    # API Key
+    console.print()
+    console.print("  [muted]Found in Azure Portal > Your OpenAI Resource > Keys and Endpoint[/muted]")
+    api_key = click.prompt("  Azure OpenAI API Key", type=str, hide_input=True)
+    _show_key_feedback(api_key, "API Key")
+
+    # Deployment Name
+    console.print()
+    deployment_name = click.prompt(
+        "  Deployment Name", type=str, default="gpt-4o", show_default=True
+    )
+
+    # API Version
+    api_version = click.prompt(
+        "  API Version", type=str, default="2024-02-15-preview", show_default=True
+    )
+
+    # Load existing config and update with new values
+    config = _load_existing_config()
+    config["AZURE_OPENAI_ENDPOINT"] = endpoint
+    config["AZURE_OPENAI_API_KEY"] = api_key
+    config["AZURE_DEPLOYMENT_NAME"] = deployment_name
+    config["AZURE_OPENAI_API_VERSION"] = api_version
+
+    _save_config(config)
+    reset_settings()
+
+    config_path = get_config_path()
+    console.print()
+    console.print(f"[success]Configuration saved to {config_path}[/success]")
+
+
+def run_gitlab_init() -> None:
+    """Run interactive init flow for GitLab configuration only."""
+    console.print()
+    console.print(Panel(
+        "[brand]GitLab Configuration[/brand]",
+        border_style=BRAND_BORDER,
+        padding=(0, 2)
+    ))
+
+    # GitLab URL
+    gitlab_url = click.prompt(
+        "  GitLab URL", type=str, default="https://gitlab.com", show_default=True
+    )
+
+    # GitLab Token
+    console.print()
+    console.print("  [muted]Personal Access Token (create at GitLab > Settings > Access Tokens)[/muted]")
+    gitlab_token = click.prompt("  GitLab Token", type=str, hide_input=True)
+    _show_key_feedback(gitlab_token, "Token")
+
+    # Load existing config and update with new values
+    config = _load_existing_config()
+    config["GITLAB_URL"] = gitlab_url
+    config["GITLAB_TOKEN"] = gitlab_token
+
+    _save_config(config)
+    reset_settings()
+
+    console.print()
+    console.print(f"[success]Configuration saved to {get_config_path()}[/success]")
+
+
+def run_langfuse_init() -> None:
+    """Run interactive init flow for Langfuse configuration only."""
+    console.print()
+    console.print(Panel(
+        "[brand]Langfuse Configuration (Optional)[/brand]",
+        border_style=BRAND_BORDER,
+        padding=(0, 2)
+    ))
+    console.print("  [muted]Langfuse provides observability for your LLM calls.[/muted]")
+    console.print()
+
+    # Secret Key
+    secret_key = click.prompt("  Langfuse Secret Key", type=str, hide_input=True)
+    _show_key_feedback(secret_key, "Secret Key")
+
+    # Public Key
+    public_key = click.prompt("  Langfuse Public Key", type=str)
+
+    # Host
+    host = click.prompt(
+        "  Langfuse Host",
+        type=str,
+        default="https://cloud.langfuse.com",
+        show_default=True,
+    )
+
+    # Load existing config and update with new values
+    config = _load_existing_config()
+    config["LANGFUSE_SECRET_KEY"] = secret_key
+    config["LANGFUSE_PUBLIC_KEY"] = public_key
+    config["LANGFUSE_HOST"] = host
+
+    _save_config(config)
+    reset_settings()
+
+    console.print()
+    console.print(f"[success]Configuration saved to {get_config_path()}[/success]")
+
+
+def run_full_init(include_gitlab: bool = False) -> None:
+    """
+    Run the complete first-time setup flow.
+
+    Args:
+        include_gitlab: If True, also prompt for GitLab configuration.
+    """
+    console.print()
+    console.print("[info]Looks like you haven't configured CodeYak yet. Let's get you set up![/info]")
+
+    # Always configure LLM
+    run_llm_init()
+
+    # Optionally configure GitLab
+    if include_gitlab:
+        run_gitlab_init()
+
+    # Ask about Langfuse
+    console.print()
+    if click.confirm("Would you like to configure Langfuse for observability?", default=False):
+        run_langfuse_init()
+
+    console.print()
+    console.print("[info]Continuing with your command...[/info]")
+    console.print()

codeyak/apps/cli/main.py

@@ -0,0 +1,362 @@
+"""
+CLI for CodeYak - Local and MR code review.
+
+Usage:
+    yak review              # Review local uncommitted changes
+    yak mr <MR_ID> [PROJECT_ID]  # Review GitLab MR
+"""
+
+import os
+import sys
+from pathlib import Path
+
+import click
+
+from ... import __version__
+from ...config import (
+    get_settings,
+    is_gitlab_configured,
+    is_llm_configured,
+    is_langfuse_configured,
+    config_file_exists,
+)
+from .configure import run_full_init, run_gitlab_init, run_llm_init
+from ...infrastructure import GitLabAdapter, LocalGitAdapter, AzureAdapter
+from ...services import (
+    CodeReviewer,
+    GuidelinesProvider,
+    GuidelinesGenerator,
+    CodeProvider,
+    CodeReviewContextBuilder,
+    MergeRequestFeedbackPublisher,
+    ConsoleFeedbackPublisher,
+    SummaryGenerator,
+)
+from ...ui import console, RichProgressReporter, CIProgressReporter
+
+
+def ensure_llm_configured() -> None:
+    """Ensure LLM (Azure OpenAI) is configured. Triggers init if not."""
+    if is_llm_configured():
+        return
+
+    # Check if this is a CI/CD environment (no TTY)
+    if not sys.stdin.isatty():
+        click.echo(
+            "Error: Azure OpenAI is not configured. "
+            "Set AZURE_OPENAI_API_KEY and AZURE_OPENAI_ENDPOINT environment variables.",
+            err=True,
+        )
+        sys.exit(1)
+
+    # First time setup - no config file exists
+    if not config_file_exists():
+        run_full_init(include_gitlab=False)
+    else:
+        # Config file exists but LLM not configured
+        console.print()
+        console.print("[info]LLM provider is not configured. Let's set it up![/info]")
+        run_llm_init()
+        console.print()
+        console.print("[info]Continuing with your command...[/info]")
+        console.print()
+
+
+def ensure_gitlab_configured() -> None:
+    """Ensure GitLab is configured. Triggers init if not."""
+    # First ensure LLM is configured
+    ensure_llm_configured()
+
+    if is_gitlab_configured():
+        return
+
+    # Check if this is a CI/CD environment (no TTY)
+    if not sys.stdin.isatty():
+        click.echo(
+            "Error: GitLab is not configured. "
+            "Set GITLAB_TOKEN environment variable.",
+            err=True,
+        )
+        sys.exit(1)
+
+    # First time setup - no config file exists
+    if not config_file_exists():
+        run_full_init(include_gitlab=True)
+    else:
+        # Config file exists but GitLab not configured
+        console.print()
+        console.print("[info]GitLab integration is not configured. Let's set it up![/info]")
+        run_gitlab_init()
+        console.print()
+        console.print("[info]Continuing with your command...[/info]")
+        console.print()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="yak")
+def main():
+    """CodeYak - AI-powered code review tool."""
+    pass
+
+
+@main.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=None,
+    help="Path to git repository. Defaults to current directory."
+)
+def review(path: Path | None):
+    """Review local uncommitted changes."""
+    # Show banner first
+    progress = RichProgressReporter()
+    progress.banner("Codeyak", __version__)
+
+    # Ensure LLM is configured before proceeding
+    ensure_llm_configured()
+
+    repo_path = path or Path.cwd()
+
+    # Show observability status
+    obs_status = "ON" if is_langfuse_configured() else "OFF"
+    progress.info(f"Observability: {obs_status}")
+    progress.info(f"Reviewing uncommitted changes in {repo_path}...")
+
+    try:
+        # Initialize adapters
+        vcs = LocalGitAdapter(repo_path)
+        llm = AzureAdapter(
+            api_key=get_settings().AZURE_OPENAI_API_KEY,
+            endpoint=get_settings().AZURE_OPENAI_ENDPOINT,
+            deployment_name=get_settings().AZURE_DEPLOYMENT_NAME,
+            api_version=get_settings().AZURE_OPENAI_API_VERSION
+        )
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error initializing: {e}", err=True)
+        sys.exit(1)
+
+    langfuse_enabled = bool(
+        get_settings().LANGFUSE_SECRET_KEY and
+        get_settings().LANGFUSE_PUBLIC_KEY
+    )
+
+    langfuse = None
+    if langfuse_enabled:
+        from langfuse import Langfuse
+        langfuse = Langfuse(
+            secret_key=get_settings().LANGFUSE_SECRET_KEY,
+            public_key=get_settings().LANGFUSE_PUBLIC_KEY,
+            host=get_settings().LANGFUSE_HOST
+        )
+
+    # Initialize services - CodeProvider handles all MergeRequest construction
+    context = CodeReviewContextBuilder(
+        llm_client=llm,
+        repo_path=repo_path,
+        use_smart_context=True,
+        progress=progress,
+    )
+    guidelines = GuidelinesProvider(vcs)
+    code = CodeProvider(vcs)
+    feedback = ConsoleFeedbackPublisher()
+    summary = SummaryGenerator(llm, langfuse=langfuse)
+
+    bot = CodeReviewer(
+        context=context,
+        code=code,
+        guidelines=guidelines,
+        llm=llm,
+        feedback=feedback,
+        summary=summary,
+        langfuse=langfuse,
+        progress=progress,
+    )
+
+    bot.review_local_changes()
+
+    # Flush Langfuse traces
+    if langfuse:
+        langfuse.flush()
+
+
+@main.command()
+@click.argument("mr_id")
+@click.argument("project_id", required=False)
+def mr(mr_id: str, project_id: str | None):
+    """Review a GitLab merge request.
+
+    MR_ID is the merge request ID to review.
+    PROJECT_ID is optional (uses CI_PROJECT_ID env var if not provided).
+    """
+    # Ensure both LLM and GitLab are configured before proceeding
+    ensure_gitlab_configured()
+
+    # Get project ID from argument or environment
+    project_id = project_id or os.getenv("CI_PROJECT_ID")
+
+    if not project_id:
+        click.echo(
+            "Error: Project ID is required. "
+            "Pass it as the second argument or set CI_PROJECT_ID.",
+            err=True
+        )
+        sys.exit(1)
+
+    # Show observability status
+    obs_status = "[success]ON[/success]" if is_langfuse_configured() else "[muted]OFF[/muted]"
+    console.print(f"Observability: {obs_status}")
+    console.print(f"[info]Reviewing MR {mr_id} in project {project_id}...[/info]")
+
+    # Initialize adapters
+    try:
+        vcs = GitLabAdapter(
+            url=get_settings().GITLAB_URL,
+            token=get_settings().GITLAB_TOKEN,
+            project_id=project_id
+        )
+
+        llm = AzureAdapter(
+            api_key=get_settings().AZURE_OPENAI_API_KEY,
+            endpoint=get_settings().AZURE_OPENAI_ENDPOINT,
+            deployment_name=get_settings().AZURE_DEPLOYMENT_NAME,
+            api_version=get_settings().AZURE_OPENAI_API_VERSION
+        )
+    except Exception as e:
+        click.echo(f"Configuration Error: {e}", err=True)
+        sys.exit(1)
+
+    # Initialize Langfuse if configured
+    langfuse_enabled = bool(
+        get_settings().LANGFUSE_SECRET_KEY and
+        get_settings().LANGFUSE_PUBLIC_KEY
+    )
+
+    langfuse = None
+    if langfuse_enabled:
+        from langfuse import Langfuse
+        langfuse = Langfuse(
+            secret_key=get_settings().LANGFUSE_SECRET_KEY,
+            public_key=get_settings().LANGFUSE_PUBLIC_KEY,
+            host=get_settings().LANGFUSE_HOST
+        )
+
+    # Initialize services
+    # Use current directory as repo path - in CI, the repo is checked out
+    progress = CIProgressReporter()
+    context = CodeReviewContextBuilder(
+        llm_client=llm,
+        repo_path=Path.cwd(),
+        use_smart_context=True,
+        progress=progress,
+    )
+    guidelines = GuidelinesProvider(vcs)
+    code = CodeProvider(vcs)
+    feedback = MergeRequestFeedbackPublisher(vcs, mr_id)
+    summary = SummaryGenerator(llm, langfuse)
+
+    # Create reviewer and run
+    bot = CodeReviewer(
+        context=context,
+        guidelines=guidelines,
+        code=code,
+        feedback=feedback,
+        llm=llm,
+        summary=summary,
+        langfuse=langfuse,
+        progress=progress,
+    )
+
+    bot.review_merge_request(mr_id)
+
+    # Flush Langfuse traces
+    if langfuse:
+        langfuse.flush()
+
+    progress.success("Review complete.")
+
+
+@main.command()
+@click.option(
+    "--days",
+    type=int,
+    default=365,
+    help="Number of days of history to analyze (default: 365)"
+)
+def learn(days: int):
+    """Generate guidelines from git history analysis.
+
+    Analyzes commits to identify patterns of mistakes and problematic areas,
+    then generates codeyak guidelines to help avoid future issues.
+
+    Output is written to .codeyak/project.yaml
+    """
+    # Show banner first
+    progress = RichProgressReporter()
+    progress.banner("Codeyak", __version__)
+
+    # Ensure LLM is configured before proceeding
+    ensure_llm_configured()
+
+    repo_path = Path.cwd()
+
+    # Show observability status
+    obs_status = "ON" if is_langfuse_configured() else "OFF"
+    progress.info(f"Observability: {obs_status}")
+
+    # Verify we're in a git repository
+    try:
+        vcs = LocalGitAdapter(repo_path)
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        click.echo("The 'learn' command must be run inside a git repository.", err=True)
+        sys.exit(1)
+
+    progress.info(f"Analyzing git history for the last {days} days...")
+
+    # Initialize LLM adapter
+    try:
+        llm = AzureAdapter(
+            api_key=get_settings().AZURE_OPENAI_API_KEY,
+            endpoint=get_settings().AZURE_OPENAI_ENDPOINT,
+            deployment_name=get_settings().AZURE_DEPLOYMENT_NAME,
+            api_version=get_settings().AZURE_OPENAI_API_VERSION
+        )
+    except Exception as e:
+        click.echo(f"Error initializing LLM: {e}", err=True)
+        sys.exit(1)
+
+    # Initialize Langfuse if configured
+    langfuse = None
+    if get_settings().LANGFUSE_SECRET_KEY and get_settings().LANGFUSE_PUBLIC_KEY:
+        from langfuse import Langfuse
+        langfuse = Langfuse(
+            secret_key=get_settings().LANGFUSE_SECRET_KEY,
+            public_key=get_settings().LANGFUSE_PUBLIC_KEY,
+            host=get_settings().LANGFUSE_HOST
+        )
+
+    # Generate guidelines
+    generator = GuidelinesGenerator(vcs=vcs, llm=llm, langfuse=langfuse, progress=progress)
+    yaml_output = generator.generate_from_history(since_days=days)
+
+    # Create .codeyak/ directory if it doesn't exist
+    codeyak_dir = repo_path / ".codeyak"
+    codeyak_dir.mkdir(exist_ok=True)
+
+    # Write output to project.yaml
+    output_path = codeyak_dir / "project.yaml"
+    output_path.write_text(yaml_output)
+
+    progress.success(f"Guidelines written to {output_path}")
+    progress.info("Review and customize the generated guidelines before using them.")
+
+    # Flush Langfuse traces
+    if langfuse:
+        langfuse.flush()
+
+
+if __name__ == "__main__":
+    main()