prabogo

Prabogo uses a hexagonal architecture (ports and adapters) to ensure a strict separation between core business logic and external infrastructure.

Core Components

• Domain Logic (internal/domain/): Contains the core business rules. It is technology-agnostic and only interacts with the outside world through Ports.
• Ports (internal/port/): Interfaces that define contracts for communication.
  • Inbound Ports: How the world talks to your app (e.g., HTTP, CLI, RabbitMQ consumers).
  • Outbound Ports: How your app talks to the world (e.g., Databases, HTTP clients, Redis).
• Adapters (internal/adapter/): Concrete implementations of ports.
  • Inbound Adapters: Handle incoming requests (e.g., Fiber for HTTP, Temporal for workflows).
  • Outbound Adapters: Handle outgoing requests (e.g., Postgres for DB, Redis for cache).
• Models (internal/model/): Shared data structures and entities used across the application.

Dependency Flow

To maintain decoupling, dependencies must always point inward:

1. Domain logic depends on ports (interfaces).
2. Adapters implement those ports.
3. The application wires the specific adapters to the ports at startup.

Prabogo uses Spec Kit to implement a Spec-Driven Development workflow. Instead of using traditional agent roles, you guide an AI agent (like GitHub Copilot) through a structured seven-step process using specific slash commands. This workflow separates the definition of what to build (requirements) from how to build it (technical implementation), ensuring that specifications are validated before any code is written.

The 7-Step Workflow

1. Define Constitution: Set core project rules.
2. Specify Requirements: Describe the feature's purpose and user needs.
3. Clarify Specification: Resolve ambiguities in the requirements.
4. Validate Specification: Generate a checklist to ensure the spec is complete.
5. Plan Implementation: Define the tech stack and architecture.
6. Generate Tasks: Create a dependency-ordered list of actionable tasks.
7. Analyze and Implement: Audit the plan for consistency, then execute the tasks.

1. /speckit.constitution [Rules]
2. /speckit.specify [Requirements]
3. /speckit.clarify [Ambiguities]
4. /speckit.checklist
5. /speckit.plan [Tech Stack]
6. /speckit.tasks
7. /speckit.analyze
   /speckit.implement

Prabogo utilizes Hexagonal Architecture (also known as the Ports and Adapters pattern) to isolate core business logic from external dependencies. This design ensures that the application can evolve independently of databases, APIs, or user interfaces.

Core Components

• Domain: The core business logic and rules. It is entirely independent of external systems or frameworks.
• Application: The layer responsible for coordinating activities and orchestrating the domain logic.
• Port: An interface that defines how the application communicates with the outside world. Ports act as the boundary for the core.
• Adapter: A component that implements a Port to connect the core to external technologies or systems.

Interaction Model

External entities interact with the application through specific adapters:

• REST: Interacts via RESTful APIs through an adapter.
• Message Broker: Communicates asynchronously via a messaging adapter.
• MCP Client: Invokes application tools through a Model Context Protocol (MCP) adapter.
• Database/Cache: Accessed through adapters for data persistence and retrieval.

By using this pattern, you can substitute real external systems with mocks or stubs during testing, allowing the core logic to be tested in isolation.

Prabogo provides specialized generators to automate the creation of boilerplate for models, migrations, and adapters. When providing a <name>, use snake_case (e.g., user_profile).

Models and Migrations

• prabogo-cli model <name>: Creates a new model structure.
• prabogo-cli migration-postgres <name>: Creates PostgreSQL migration files.

Inbound Adapters (Receiving Requests)

• prabogo-cli inbound-http-fiber <name>: Creates HTTP handler interfaces, Fiber adapters, and registry updates.
• prabogo-cli inbound-message-rabbitmq <name>: Creates RabbitMQ consumer interfaces and adapters.
• prabogo-cli inbound-command <name>: Creates CLI command handler interfaces and adapters.
• prabogo-cli inbound-workflow-temporal <name>: Creates Temporal workflow interfaces and adapters.

Outbound Adapters (Sending Requests)

• prabogo-cli outbound-database-postgres <name>: Creates PostgreSQL database interfaces and adapters.
• prabogo-cli outbound-http <name>: Creates HTTP client interfaces and adapters.
• prabogo-cli outbound-message-rabbitmq <name>: Creates RabbitMQ producer interfaces and adapters.
• prabogo-cli outbound-cache-redis <name>: Creates Redis cache interfaces and adapters.
• prabogo-cli outbound-workflow-temporal <name>: Creates Temporal workflow starter interfaces and adapters.