agent-starter-pack 0.0.1b0__py3-none-any.whl

src/resources/setup_cicd/cicd_variables.tf

@@ -0,0 +1,36 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+variable "repository_owner" {
+  description = "Owner of the GitHub repository"
+  type        = string
+}
+
+variable "github_app_installation_id" {
+  description = "GitHub App Installation ID"
+  type        = string
+}
+
+variable "github_pat_secret_id" {
+  description = "GitHub PAT secret id in Cloud Secret Manager"
+  type        = string
+  default     = "github-pat"
+}
+
+variable "connection_exists" {
+  description = "Flag indicating if a Cloud Build connection already exists"
+  type        = bool
+  default     = false
+}
+

src/resources/setup_cicd/github.tf

@@ -0,0 +1,85 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+provider "github" {
+  token = data.google_secret_manager_secret_version.github_token.secret_data
+  owner = var.repository_owner
+}
+
+data "google_secret_manager_secret_version" "github_token" {
+  project = var.cicd_runner_project_id
+  secret  = var.github_pat_secret_id
+  version = "latest"
+}
+
+# Create the GitHub connection
+resource "google_cloudbuildv2_connection" "github_connection" {
+  count      = var.connection_exists ? 0 : 1
+  project    = var.cicd_runner_project_id
+  location   = var.region
+  name       = var.host_connection_name
+
+  github_config {
+    app_installation_id = var.github_app_installation_id
+    authorizer_credential {
+      oauth_token_secret_version = "projects/${var.cicd_runner_project_id}/secrets/${var.github_pat_secret_id}/versions/latest"
+    }
+  }
+  depends_on = [resource.google_project_service.cicd_services, resource.google_project_service.shared_services]
+}
+
+locals {
+  connection_name = var.host_connection_name
+}
+
+
+# Try to get existing repo
+data "github_repository" "existing_repo" {
+  full_name = "${var.repository_owner}/${var.repository_name}"
+}
+
+# Only create GitHub repo if it doesn't already exist
+resource "github_repository" "repo" {
+  count       = data.github_repository.existing_repo.repo_id == null ? 1 : 0
+  name        = var.repository_name
+  description = "Repository created by Terraform"
+  visibility  = "private"
+
+  has_issues      = true
+  has_wiki        = false
+  has_projects    = false
+  has_downloads   = false
+
+  allow_merge_commit = true
+  allow_squash_merge = true
+  allow_rebase_merge = true
+  
+  auto_init = false
+}
+
+
+resource "google_cloudbuildv2_repository" "repo" {
+  project  = var.cicd_runner_project_id
+  location = var.region
+  name     = var.repository_name
+  
+  parent_connection = "projects/${var.cicd_runner_project_id}/locations/${var.region}/connections/${local.connection_name}"
+  remote_uri       = "https://github.com/${var.repository_owner}/${var.repository_name}.git"
+  depends_on = [
+    resource.google_project_service.cicd_services,
+    resource.google_project_service.shared_services,
+    data.github_repository.existing_repo,
+    github_repository.repo
+  ]
+}

src/resources/setup_cicd/providers.tf

@@ -0,0 +1,39 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+terraform {
+  required_version = ">= 1.0.0"
+  required_providers {
+    google = {
+      source  = "hashicorp/google"
+      version = "< 7.0.0"
+    }
+    github = {
+      source  = "integrations/github"
+      version = "~> 6.5.0"
+    }
+  }
+}
+
+provider "google" {
+  alias                 = "staging_billing_override"
+  billing_project       = var.staging_project_id
+  user_project_override = true
+}
+
+provider "google" {
+  alias                 = "prod_billing_override"
+  billing_project       = var.prod_project_id
+  user_project_override = true
+}

src/utils/generate_locks.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utility script to generate lock files for all agent and deployment target combinations."""
+
+import logging
+import pathlib
+import shutil
+import subprocess
+import tempfile
+
+import click
+from jinja2 import Template
+from lock_utils import get_agent_configs, get_lock_filename
+
+
+def ensure_lock_dir() -> pathlib.Path:
+    """Ensure the locks directory exists and is empty.
+
+    Returns:
+        Path to the locks directory
+    """
+    lock_dir = pathlib.Path("src/resources/locks")
+
+    # Remove if exists
+    if lock_dir.exists():
+        shutil.rmtree(lock_dir)
+
+    # Create fresh directory
+    lock_dir.mkdir(parents=True)
+
+    return lock_dir
+
+
+def generate_pyproject(
+    template_path: pathlib.Path, deployment_target: str, extra_dependencies: list[str]
+) -> str:
+    """Generate pyproject.toml content from template.
+
+    Args:
+        template_path: Path to the pyproject.toml template
+        deployment_target: Target deployment platform
+        extra_dependencies: List of additional dependencies from .templateconfig.yaml
+    """
+    with open(template_path, encoding="utf-8") as f:
+        template = Template(f.read(), trim_blocks=True, lstrip_blocks=True)
+
+    # Convert list to proper format for template
+    context = {
+        "cookiecutter": {
+            "project_name": "locked-template",
+            "deployment_target": deployment_target,
+            # Ensure extra_dependencies is a list
+            "extra_dependencies": list(extra_dependencies)
+            if extra_dependencies
+            else [],
+        }
+    }
+
+    # Add debug logging
+    logging.debug(f"Template context: {context}")
+    result = template.render(context)
+    logging.debug(f"Generated pyproject.toml:\n{result}")
+
+    return result
+
+
+def generate_lock_file(pyproject_content: str, output_path: pathlib.Path) -> None:
+    """Generate uv.lock file from pyproject content."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_dir = pathlib.Path(tmpdir)
+
+        # Write temporary pyproject.toml
+        with open(tmp_dir / "pyproject.toml", "w", encoding="utf-8") as f:
+            f.write(pyproject_content)
+
+        # Run uv pip compile to generate lock file
+        subprocess.run(["uv", "lock"], cwd=tmp_dir, check=True)
+        # Replace locked-template with {{cookiecutter.project_name}} in generated lock file
+        lock_file_path = tmp_dir / "uv.lock"
+        with open(lock_file_path, "r+", encoding="utf-8") as f:
+            lock_content = f.read()
+            f.seek(0)
+            f.write(
+                lock_content.replace("locked-template", "{{cookiecutter.project_name}}")
+            )
+            f.truncate()
+
+        # Copy the generated lock file to output location
+        shutil.copy2(lock_file_path, output_path)
+
+
+@click.command()
+@click.option(
+    "--template",
+    type=click.Path(exists=True, path_type=pathlib.Path),
+    default="src/base_template/pyproject.toml",
+    help="Path to template pyproject.toml",
+)
+def main(template: pathlib.Path) -> None:
+    """Generate lock files for all agent and deployment target combinations."""
+    lock_dir = ensure_lock_dir()
+    agent_configs = get_agent_configs()
+
+    for agent_name, config in agent_configs.items():
+        for target in config.targets:
+            print(f"Generating lock file for {agent_name} with {target}...")
+
+            # Generate pyproject content
+            content = generate_pyproject(
+                template,
+                deployment_target=target,
+                extra_dependencies=config.dependencies,
+            )
+
+            # Generate lock file
+            output_path = lock_dir / get_lock_filename(agent_name, target)
+            generate_lock_file(content, output_path)
+            print(f"Generated {output_path}")
+
+
+if __name__ == "__main__":
+    main()

src/utils/lock_utils.py

@@ -0,0 +1,82 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utilities for managing Poetry lock files and dependencies."""
+
+import pathlib
+from pathlib import Path
+from typing import NamedTuple
+
+import yaml
+
+
+class AgentConfig(NamedTuple):
+    """Configuration for an agent template."""
+
+    targets: set[str]
+    dependencies: list[str]
+
+
+def get_agent_configs(
+    agents_dir: pathlib.Path = pathlib.Path("agents"),
+) -> dict[str, AgentConfig]:
+    """Get all agents and their supported deployment targets.
+
+    Args:
+        agents_dir: Path to the agents directory
+
+    Returns:
+        Dictionary mapping agent names to their configuration
+    """
+    agent_configs = {}
+
+    for agent_dir in agents_dir.iterdir():
+        if not agent_dir.is_dir():
+            continue
+
+        config_file = agent_dir / "template" / ".templateconfig.yaml"
+        if not config_file.exists():
+            continue
+
+        with open(config_file, encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+
+        agent_name = agent_dir.name
+        settings = config.get("settings", {})
+
+        agent_configs[agent_name] = AgentConfig(
+            targets=set(settings.get("deployment_targets", [])),
+            dependencies=settings.get("extra_dependencies", []),
+        )
+
+    return agent_configs
+
+
+def get_lock_filename(agent_name: str, deployment_target: str) -> str:
+    """Generate the lock filename for a given agent and deployment target.
+
+    Args:
+        agent_name: Name of the agent
+        deployment_target: Target deployment platform
+
+    Returns:
+        Formatted lock filename
+    """
+    return f"uv-{agent_name}-{deployment_target}.lock"
+
+
+def get_lock_path(agent_name: str, deployment_target: str) -> Path:
+    """Get the path to the appropriate lock file."""
+    lock_filename = get_lock_filename(agent_name, deployment_target)
+    return Path("src/resources/locks") / lock_filename

src/utils/watch_and_rebuild.py

@@ -0,0 +1,190 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import pathlib
+import shutil
+import subprocess
+import time
+
+import click
+from rich.console import Console
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+console = Console()
+
+
+class TemplateHandler(FileSystemEventHandler):
+    def __init__(
+        self,
+        agent_name: str,
+        project_name: str,
+        deployment_target: str,
+        output_dir: str | None,
+        region: str,
+    ):
+        self.agent_name = agent_name
+        self.project_name = project_name
+        self.deployment_target = deployment_target
+        self.output_dir = output_dir
+        self.region = region
+        self.last_rebuild = 0
+        self.rebuild_cooldown = 1  # Seconds to wait between rebuilds
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+
+        # Implement cooldown to prevent multiple rapid rebuilds
+        current_time = time.time()
+        if current_time - self.last_rebuild < self.rebuild_cooldown:
+            return
+
+        self.last_rebuild = current_time
+
+        console.print(f"Detected change in {event.src_path}")
+        self.rebuild_template()
+
+    def rebuild_template(self):
+        try:
+            # Clean output directory
+            project_path = (
+                pathlib.Path(self.output_dir) / self.project_name
+                if self.output_dir
+                else pathlib.Path(self.project_name)
+            )
+
+            # Check if the project directory exists and remove it
+            if project_path.exists():
+                console.print(
+                    f"Removing existing directory: {project_path}", style="yellow"
+                )
+                shutil.rmtree(project_path)
+
+            # Rebuild using the CLI tool with agent and deployment target
+            cmd = [
+                "uv",
+                "run",
+                "-m",
+                "src.cli.main",
+                "create",
+                str(self.project_name),
+                "--agent",
+                self.agent_name,
+                "--deployment-target",
+                self.deployment_target,
+                "--output-dir",
+                str(self.output_dir) if self.output_dir else ".",
+                "--auto-approve",
+                "--region",
+                self.region,
+            ]
+            console.print(f"Executing: {' '.join(cmd)}", style="bold blue")
+            subprocess.run(cmd, check=True)
+
+            console.print("✨ Template rebuilt successfully!", style="bold green")
+
+        except subprocess.CalledProcessError as e:
+            console.print(f"Error rebuilding template: {e}", style="bold red")
+        except Exception as e:
+            console.print(f"Unexpected error: {e}", style="bold red")
+
+
+@click.command()
+@click.argument("agent")
+@click.argument("project_name")
+@click.option("--deployment-target", "-d", help="Deployment target to use")
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(),
+    default="target",
+    help="Output directory for the project",
+)
+@click.option("--debug", is_flag=True, help="Enable debug logging")
+@click.option("--region", default="us-central1", help="GCP region to use")
+def watch(
+    agent: str,
+    project_name: str,
+    deployment_target: str,
+    output_dir: str | None,
+    debug: bool,
+    region: str,
+):
+    """
+    Watch a agent's template and automatically rebuild when changes are detected.
+
+    agent: Name of the agent to watch (e.g., langgraph_base_react)
+    PROJECT_NAME: Name of the project to generate
+    """
+    if debug:
+        logging.basicConfig(level=logging.DEBUG)
+
+    # Get directories to watch
+    root_dir = pathlib.Path(__file__).parent.parent.parent.resolve()
+    src_dir = root_dir / "src"
+    agents_dir = root_dir / "agents"
+
+    if not agents_dir.exists():
+        raise click.BadParameter(f"agents directory not found: {agents_dir}")
+
+    if not src_dir.exists():
+        raise click.BadParameter(f"Source directory not found: {src_dir}")
+
+    # Create output directory if it doesn't exist
+    if output_dir:
+        output_path = pathlib.Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        console.print(f"Using output directory: {output_path}")
+
+    console.print(f"Watching agent: {agent}")
+    console.print(f"Deployment target: {deployment_target}")
+    console.print(f"Source directory: {src_dir}")
+    console.print(f"agents directory: {agents_dir}")
+    console.print(f"Project name: {project_name}")
+    console.print(f"Region: {region}")
+
+    event_handler = TemplateHandler(
+        agent_name=agent,
+        project_name=project_name,
+        deployment_target=deployment_target,
+        output_dir=output_dir,
+        region=region,
+    )
+
+    observer = Observer()
+    # Watch both src and agents directories
+    observer.schedule(event_handler, str(src_dir), recursive=True)
+    observer.schedule(event_handler, str(agents_dir), recursive=True)
+    observer.start()
+
+    try:
+        # Trigger initial build
+        console.print("\n🏗️ Performing initial build...", style="bold blue")
+        event_handler.rebuild_template()
+
+        console.print(
+            "\n🔍 Watching for changes (Press Ctrl+C to stop)...", style="bold blue"
+        )
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        console.print("\n⏹️ Stopping watch...", style="bold yellow")
+        observer.stop()
+    observer.join()
+
+
+if __name__ == "__main__":
+    watch()