daggerverse

# Daggerverse - Reusable Dagger Modules

[![CI](https://github.com/telchak/daggerverse/actions/workflows/ci.yml/badge.svg)](https://github.com/telchak/daggerverse/actions/workflows/ci.yml)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
[![Dagger](https://img.shields.io/badge/Dagger-v0.20.3-1a1a2e.svg)](https://dagger.io)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=telchak_daggerverse&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=telchak_daggerverse)
[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=telchak_daggerverse&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=telchak_daggerverse)

A collection of small, independent, reusable [Dagger](https://github.com/dagger/dagger) modules and AI agents for CI/CD pipelines. Built with the [Dagger SDK](https://docs.dagger.io) and published on the [Daggerverse](https://daggerverse.dev).

## Modules

Reusable building blocks for CI/CD pipelines. Each module is independent and focused on a single concern.

| Module | Description |
|--------|-------------|
| [**calver**](calver/) | Calendar Versioning utilities |
| [**gcp-auth**](gcp-auth/) | GCP authentication (OIDC, Workload Identity Federation, Service Account) |
| [**gcp-artifact-registry**](gcp-artifact-registry/) | Artifact Registry container image operations |
| [**gcp-cloud-run**](gcp-cloud-run/) | Cloud Run service and job deployment |
| [**gcp-vertex-ai**](gcp-vertex-ai/) | Vertex AI model deployment |
| [**gcp-firebase**](gcp-firebase/) | Firebase Hosting deployment and preview channels |
| [**angular**](angular/) | Angular build, lint, test, and serve utilities |
| [**health-check**](health-check/) | HTTP and TCP container health checking |
| [**oidc-token**](oidc-token/) | OIDC token exchange utilities |
| [**python-build**](python-build/) | Python build, lint, test, and typecheck utilities |
| [**semver**](semver/) | Semantic Versioning with Conventional Commits |
| [**dagger-mcp**](dagger-mcp/) | MCP server for Dagger engine introspection — schema, GraphQL queries, SDK guidance |

## AI Agents

AI-powered development and operations agents built with Dagger's LLM support. Each agent provides specialized entrypoints (`assist`, `review`, `build`, `write-tests`, `upgrade`, `develop-github-issue`, `task`) and uses MCP servers for extended capabilities.

### [Angie](angie/) — Angular Development Agent

Code analysis, reviews, test writing, building, and upgrades for Angular projects.

| MCP Server | Package | Description |
|------------|---------|-------------|
| `angular` | [`@angular/cli mcp`](https://angular.dev/ai/mcp) | Built-in Angular CLI MCP — code generation, modernization, best practices, documentation search |

### [Monty](monty/) — Python Development Agent

Linting, formatting, testing, package auditing, and code reviews for Python projects.

| MCP Server | Package | Description |
|------------|---------|-------------|
| `python-lft` | [`python-lft-mcp[tools]`](https://github.com/Agent-Hellboy/python-lft-mcp) | Lint (ruff), format (black/ruff), test (pytest), and type-check (mypy). Installed from GitHub (not yet published to PyPI). |
| `pypi` | [`pypi-query-mcp-server`](https://github.com/loonghao/pypi-query-mcp-server) | Package intelligence — version tracking, dependency analysis, download stats |

### [Goose](goose/) — GCP Operations Agent

Deployment, troubleshooting, and observability across Cloud Run, Firebase Hosting, Vertex AI, and Artifact Registry.

| MCP Server | Package | Description |
|------------|---------|-------------|
| `gcloud` | [`@google-cloud/gcloud-mcp`](https://github.com/googleapis/gcloud-mcp) | Cloud Logging, Cloud Monitoring, Cloud Trace, Cloud Storage, and full gcloud CLI access |

Goose also integrates the [Google Developer Knowledge API](https://developers.googleblog.com/introducing-the-developer-knowledge-api-and-mcp-server/) as native Dagger functions (`search_gcp_docs`, `get_gcp_doc`, `batch_get_gcp_docs`) for real-time GCP documentation search. These are exposed as regular functions rather than an MCP server because Dagger currently only supports stdio-based MCP servers, and the Developer Knowledge API is HTTP-based.

### [Daggie](daggie/) — Dagger CI Specialist Agent

Creating, explaining, and debugging Dagger modules and pipelines across all SDKs (Python, TypeScript, Go).

| MCP Server | Module | Description |
|------------|--------|-------------|
| `dagger` | [`dagger-mcp`](dagger-mcp/) | Live Dagger engine introspection — schema, GraphQL queries, SDK translation guidance |

Daggie can also clone and read reference Dagger modules at runtime via `--module-urls` to learn patterns from existing implementations.

### Shared Agent Base (`_agent_base/`)

Angie, Monty, and Daggie share a common Python package ([`_agent_base/`](_agent_base/)) that provides the duplicated logic:

| Module | Purpose |
|--------|---------|
| `constants` | Blocked entrypoints and destructive tool lists |
| `workspace` | `read_file`, `edit_file`, `write_file`, `glob`, `grep` implementations |
| `llm_helpers` | LLM builders, context file reader, task sub-agent builder |
| `github_tools` | `suggest-github-fix`, `develop-github-issue`, PR code comments |
| `routing` | Router response parsing and function dispatch |

Each agent's `main.py` is a thin wrapper (~350 lines) that defines only what's unique: class name, constructor fields, MCP servers, prompt path, context file priority, and entrypoint signatures. The shared package is included via Dagger's `include` field in `dagger.json` and installed as a local Python dependency.

### Shared patterns

All agents follow the same design:
- **Workspace tools** (`read_file`, `edit_file`, `write_file`, `glob`, `grep`) for interacting with source code
- **Context files** for per-repo configuration (e.g. `ANGIE.md`, `MONTY.md`, `GOOSE.md`)
- **GitHub integration** via `develop-github-issue` to read an issue, route it to the right entrypoint, and open a PR
- **Blocked functions** to prevent LLM recursion on entrypoints

### Self-Improvement

All agents support a `--self-improve` constructor flag that creates a learning loop: the agent updates context files with discoveries made during the session, so it gets smarter across iterations.

| Mode | Behavior |
|------|----------|
| `off` (default) | No change — current behavior |
| `write` | Agent updates context files in the returned workspace directory |
| `commit` | Agent updates context files and creates a git commit in the returned workspace directory |

```bash
# Monty learns about your project as it works
dagger -m monty call assist \
  --source . \
  --self-improve=write \
  --assignment "Add a FastAPI health endpoint"
```

The agent writes to **two** context files:
- **Agent-specific file** (e.g. `MONTY.md`) — language/framework patterns, stack-specific conventions, tool gotchas
- **Shared file** (`AGENTS.md`) — project architecture, cross-cutting conventions, CI/CD patterns, team preferences

This separation prevents agent-specific knowledge from polluting shared context. When Monty discovers a Python async pattern, it goes in `MONTY.md`. When it discovers the project's folder structure, it goes in `AGENTS.md`.

**Reading** merges both files: the agent reads its own file (e.g. `MONTY.md`) plus the shared file (`AGENTS.md`, with `AGENT.md` and `CLAUDE.md` as legacy fallbacks). This applies to all directory-returning entrypoints (`assist`, `build`, `write-tests`, `upgrade`, `debug`).

## Installation

Install modules with a specific version:

```bash
dagger install github.com/telchak/daggerverse/calver@v1.0.0
dagger install github.com/telchak/daggerverse/gcp-auth@v1.0.0
```

Or use the latest from main (not recommended for production):

```bash
dagger install github.com/telchak/daggerverse/calver
```

## Quick Start

### CalVer - Generate versions

```bash
# Generate date-based version
dagger -m calver call generat

[truncated…]