summaryrefslogtreecommitdiff
path: root/makima/src
diff options
context:
space:
mode:
Diffstat (limited to 'makima/src')
-rw-r--r--makima/src/db/models.rs53
-rw-r--r--makima/src/db/repository.rs187
-rw-r--r--makima/src/server/handlers/directives.rs586
-rw-r--r--makima/src/server/handlers/mesh_supervisor.rs1
-rw-r--r--makima/src/server/handlers/orders.rs2
-rw-r--r--makima/src/server/mod.rs13
6 files changed, 837 insertions, 5 deletions
diff --git a/makima/src/db/models.rs b/makima/src/db/models.rs
index 32e55f0..97657dc 100644
--- a/makima/src/db/models.rs
+++ b/makima/src/db/models.rs
@@ -2925,6 +2925,8 @@ pub struct Order {
pub directive_name: Option<String>,
/// Repository context
pub repository_url: Option<String>,
+ /// Optional DOG (Directive Order Group) this order belongs to
+ pub dog_id: Option<Uuid>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
@@ -2943,6 +2945,8 @@ pub struct CreateOrderRequest {
/// Directive ID is required for new orders.
pub directive_id: Uuid,
pub repository_url: Option<String>,
+ /// Optional DOG (Directive Order Group) to assign this order to.
+ pub dog_id: Option<Uuid>,
}
/// Default empty JSON array for labels.
@@ -2963,6 +2967,8 @@ pub struct UpdateOrderRequest {
pub directive_id: Option<Uuid>,
pub directive_step_id: Option<Uuid>,
pub repository_url: Option<String>,
+ /// Optional DOG (Directive Order Group) to assign/reassign this order to.
+ pub dog_id: Option<Uuid>,
}
/// Response for order list endpoint.
@@ -2986,6 +2992,8 @@ pub struct OrderListQuery {
pub priority: Option<String>,
/// Filter by linked directive ID
pub directive_id: Option<Uuid>,
+ /// Filter by DOG (Directive Order Group) ID
+ pub dog_id: Option<Uuid>,
/// Text search across title, description, and directive_name (case-insensitive)
pub search: Option<String>,
}
@@ -2997,4 +3005,49 @@ pub struct LinkDirectiveRequest {
pub directive_id: Uuid,
}
+// =============================================================================
+// Directive Order Group (DOG) Types
+// =============================================================================
+
+/// A Directive Order Group (DOG) — an epic-like grouping of orders within a directive.
+/// DOGs allow organizing related orders under a common theme or goal.
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DirectiveOrderGroup {
+ pub id: Uuid,
+ pub directive_id: Uuid,
+ pub owner_id: Uuid,
+ pub name: String,
+ pub description: Option<String>,
+ /// Status: open, in_progress, done, archived
+ pub status: String,
+ pub created_at: DateTime<Utc>,
+ pub updated_at: DateTime<Utc>,
+}
+
+/// Request to create a new Directive Order Group (DOG).
+#[derive(Debug, Deserialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateDirectiveOrderGroupRequest {
+ pub name: String,
+ pub description: Option<String>,
+}
+
+/// Request to update a Directive Order Group (DOG).
+#[derive(Debug, Default, Deserialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateDirectiveOrderGroupRequest {
+ pub name: Option<String>,
+ pub description: Option<String>,
+ pub status: Option<String>,
+}
+
+/// Response for DOG list endpoint.
+#[derive(Debug, Serialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DirectiveOrderGroupListResponse {
+ pub dogs: Vec<DirectiveOrderGroup>,
+ pub total: i64,
+}
+
diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs
index f14bc66..57e8a78 100644
--- a/makima/src/db/repository.rs
+++ b/makima/src/db/repository.rs
@@ -15,6 +15,7 @@ use super::models::{
CreateDirectiveRequest, CreateDirectiveStepRequest, DirectiveGoalHistory,
UpdateDirectiveRequest, UpdateDirectiveStepRequest,
CreateOrderRequest, Order, UpdateOrderRequest,
+ CreateDirectiveOrderGroupRequest, DirectiveOrderGroup, UpdateDirectiveOrderGroupRequest,
File, FileSummary, FileVersion, HistoryEvent, HistoryQueryFilters,
MeshChatConversation, MeshChatMessageRecord, PhaseChangeResult, PhaseConfig,
PhaseDefinition, SupervisorHeartbeatRecord, SupervisorState,
@@ -6122,8 +6123,8 @@ pub async fn create_order(
sqlx::query_as::<_, Order>(
r#"
- INSERT INTO orders (owner_id, title, description, priority, status, order_type, labels, directive_id, repository_url)
- VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+ INSERT INTO orders (owner_id, title, description, priority, status, order_type, labels, directive_id, repository_url, dog_id)
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
RETURNING *
"#,
)
@@ -6136,6 +6137,7 @@ pub async fn create_order(
.bind(&req.labels)
.bind(req.directive_id)
.bind(&req.repository_url)
+ .bind(req.dog_id)
.fetch_one(pool)
.await
}
@@ -6148,6 +6150,7 @@ pub async fn list_orders(
type_filter: Option<&str>,
priority_filter: Option<&str>,
directive_id_filter: Option<Uuid>,
+ dog_id_filter: Option<Uuid>,
search_filter: Option<&str>,
) -> Result<Vec<Order>, sqlx::Error> {
// Build dynamic query with optional filters
@@ -6170,6 +6173,10 @@ pub async fn list_orders(
query.push_str(&format!(" AND directive_id = ${}", param_idx));
param_idx += 1;
}
+ if dog_id_filter.is_some() {
+ query.push_str(&format!(" AND dog_id = ${}", param_idx));
+ param_idx += 1;
+ }
if search_filter.is_some() {
query.push_str(&format!(
" AND (title ILIKE ${p} OR description ILIKE ${p} OR directive_name ILIKE ${p})",
@@ -6193,6 +6200,9 @@ pub async fn list_orders(
if let Some(d) = directive_id_filter {
q = q.bind(d);
}
+ if let Some(d) = dog_id_filter {
+ q = q.bind(d);
+ }
if let Some(s) = search_filter {
q = q.bind(format!("%{}%", s));
}
@@ -6244,13 +6254,14 @@ pub async fn update_order(
let directive_id = req.directive_id.or(current.directive_id);
let directive_step_id = req.directive_step_id.or(current.directive_step_id);
let repository_url = req.repository_url.as_deref().or(current.repository_url.as_deref());
+ let dog_id = req.dog_id.or(current.dog_id);
sqlx::query_as::<_, Order>(
r#"
UPDATE orders
SET title = $3, description = $4, priority = $5, status = $6,
order_type = $7, labels = $8, directive_id = $9, directive_step_id = $10,
- repository_url = $11, updated_at = NOW()
+ repository_url = $11, dog_id = $12, updated_at = NOW()
WHERE id = $1 AND owner_id = $2
RETURNING *
"#,
@@ -6266,6 +6277,7 @@ pub async fn update_order(
.bind(directive_id)
.bind(directive_step_id)
.bind(repository_url)
+ .bind(dog_id)
.fetch_optional(pool)
.await
}
@@ -6517,3 +6529,172 @@ pub async fn reconcile_directive_orders(
Ok(rows.len() as i64)
}
+// =============================================================================
+// Directive Order Group (DOG) CRUD
+// =============================================================================
+
+/// Create a new Directive Order Group (DOG) for the given owner and directive.
+pub async fn create_directive_order_group(
+ pool: &PgPool,
+ directive_id: Uuid,
+ owner_id: Uuid,
+ req: CreateDirectiveOrderGroupRequest,
+) -> Result<DirectiveOrderGroup, sqlx::Error> {
+ sqlx::query_as::<_, DirectiveOrderGroup>(
+ r#"
+ INSERT INTO directive_order_groups (directive_id, owner_id, name, description)
+ VALUES ($1, $2, $3, $4)
+ RETURNING *
+ "#,
+ )
+ .bind(directive_id)
+ .bind(owner_id)
+ .bind(&req.name)
+ .bind(&req.description)
+ .fetch_one(pool)
+ .await
+}
+
+/// List all DOGs for a given directive (owner-scoped).
+pub async fn list_directive_order_groups(
+ pool: &PgPool,
+ directive_id: Uuid,
+ owner_id: Uuid,
+) -> Result<Vec<DirectiveOrderGroup>, sqlx::Error> {
+ sqlx::query_as::<_, DirectiveOrderGroup>(
+ r#"
+ SELECT * FROM directive_order_groups
+ WHERE directive_id = $1 AND owner_id = $2
+ ORDER BY created_at DESC
+ "#,
+ )
+ .bind(directive_id)
+ .bind(owner_id)
+ .fetch_all(pool)
+ .await
+}
+
+/// Get a single DOG by ID (owner-scoped).
+pub async fn get_directive_order_group(
+ pool: &PgPool,
+ id: Uuid,
+ owner_id: Uuid,
+) -> Result<Option<DirectiveOrderGroup>, sqlx::Error> {
+ sqlx::query_as::<_, DirectiveOrderGroup>(
+ r#"SELECT * FROM directive_order_groups WHERE id = $1 AND owner_id = $2"#,
+ )
+ .bind(id)
+ .bind(owner_id)
+ .fetch_optional(pool)
+ .await
+}
+
+/// Update a DOG (owner-scoped). Uses fetch-then-update pattern for partial updates.
+pub async fn update_directive_order_group(
+ pool: &PgPool,
+ id: Uuid,
+ owner_id: Uuid,
+ req: UpdateDirectiveOrderGroupRequest,
+) -> Result<Option<DirectiveOrderGroup>, sqlx::Error> {
+ let current = sqlx::query_as::<_, DirectiveOrderGroup>(
+ r#"SELECT * FROM directive_order_groups WHERE id = $1 AND owner_id = $2"#,
+ )
+ .bind(id)
+ .bind(owner_id)
+ .fetch_optional(pool)
+ .await?;
+
+ let current = match current {
+ Some(c) => c,
+ None => return Ok(None),
+ };
+
+ let name = req.name.as_deref().unwrap_or(&current.name);
+ let description = req.description.as_deref().or(current.description.as_deref());
+ let status = req.status.as_deref().unwrap_or(&current.status);
+
+ sqlx::query_as::<_, DirectiveOrderGroup>(
+ r#"
+ UPDATE directive_order_groups
+ SET name = $3, description = $4, status = $5, updated_at = NOW()
+ WHERE id = $1 AND owner_id = $2
+ RETURNING *
+ "#,
+ )
+ .bind(id)
+ .bind(owner_id)
+ .bind(name)
+ .bind(description)
+ .bind(status)
+ .fetch_optional(pool)
+ .await
+}
+
+/// Delete a DOG (owner-scoped). Returns true if a row was deleted.
+pub async fn delete_directive_order_group(
+ pool: &PgPool,
+ id: Uuid,
+ owner_id: Uuid,
+) -> Result<bool, sqlx::Error> {
+ let result = sqlx::query(
+ r#"DELETE FROM directive_order_groups WHERE id = $1 AND owner_id = $2"#,
+ )
+ .bind(id)
+ .bind(owner_id)
+ .execute(pool)
+ .await?;
+
+ Ok(result.rows_affected() > 0)
+}
+
+/// List orders belonging to a specific DOG (owner-scoped).
+pub async fn list_orders_by_dog(
+ pool: &PgPool,
+ dog_id: Uuid,
+ owner_id: Uuid,
+) -> Result<Vec<Order>, sqlx::Error> {
+ sqlx::query_as::<_, Order>(
+ r#"
+ SELECT * FROM orders
+ WHERE dog_id = $1 AND owner_id = $2
+ ORDER BY created_at DESC
+ "#,
+ )
+ .bind(dog_id)
+ .bind(owner_id)
+ .fetch_all(pool)
+ .await
+}
+
+/// Get available orders for pickup filtered to a specific DOG.
+/// Like `get_available_orders_for_pickup` but only returns orders belonging to the given DOG.
+pub async fn get_available_orders_for_dog_pickup(
+ pool: &PgPool,
+ owner_id: Uuid,
+ directive_id: Uuid,
+ dog_id: Uuid,
+) -> Result<Vec<Order>, sqlx::Error> {
+ sqlx::query_as::<_, Order>(
+ r#"
+ SELECT *
+ FROM orders
+ WHERE owner_id = $1
+ AND dog_id = $3
+ AND status IN ('open', 'in_progress')
+ AND (directive_id IS NULL OR directive_id = $2)
+ ORDER BY CASE priority
+ WHEN 'critical' THEN 0
+ WHEN 'high' THEN 1
+ WHEN 'medium' THEN 2
+ WHEN 'low' THEN 3
+ ELSE 4
+ END ASC, created_at ASC
+ "#,
+ )
+ .bind(owner_id)
+ .bind(directive_id)
+ .bind(dog_id)
+ .fetch_all(pool)
+ .await
+}
+
diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs
index 992affe..d1edf7e 100644
--- a/makima/src/server/handlers/directives.rs
+++ b/makima/src/server/handlers/directives.rs
@@ -9,11 +9,13 @@ use axum::{
use uuid::Uuid;
use crate::db::models::{
- CleanupResponse, CleanupTasksResponse, CreateDirectiveRequest, CreateTaskRequest,
+ CleanupResponse, CreateDirectiveRequest, CreateTaskRequest,
CreateDirectiveStepRequest, Directive, DirectiveListResponse,
DirectiveStep, DirectiveWithSteps, PickUpOrdersResponse,
UpdateDirectiveRequest, UpdateDirectiveStepRequest, UpdateGoalRequest,
- UpdateOrderRequest,
+ CreateDirectiveOrderGroupRequest, DirectiveOrderGroup,
+ DirectiveOrderGroupListResponse, UpdateDirectiveOrderGroupRequest,
+ OrderListResponse,
};
use crate::db::repository;
use crate::orchestration::directive::{build_cleanup_prompt, build_order_pickup_prompt};
@@ -1375,3 +1377,583 @@ pub async fn pick_up_orders(
})
.into_response()
}
+
+// =============================================================================
+// Directive Order Group (DOG) CRUD
+// =============================================================================
+
+/// List all DOGs for a directive.
+#[utoipa::path(
+ get,
+ path = "/api/v1/directives/{id}/dogs",
+ params(("id" = Uuid, Path, description = "Directive ID")),
+ responses(
+ (status = 200, description = "List of DOGs", body = DirectiveOrderGroupListResponse),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn list_dogs(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path(id): Path<Uuid>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ match repository::list_directive_order_groups(pool, id, auth.owner_id).await {
+ Ok(dogs) => {
+ let total = dogs.len() as i64;
+ Json(DirectiveOrderGroupListResponse { dogs, total }).into_response()
+ }
+ Err(e) => {
+ tracing::error!("Failed to list DOGs: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("LIST_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// Create a new DOG for a directive.
+#[utoipa::path(
+ post,
+ path = "/api/v1/directives/{id}/dogs",
+ params(("id" = Uuid, Path, description = "Directive ID")),
+ request_body = CreateDirectiveOrderGroupRequest,
+ responses(
+ (status = 201, description = "DOG created", body = DirectiveOrderGroup),
+ (status = 400, description = "Invalid directive", body = ApiError),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn create_dog(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path(id): Path<Uuid>,
+ Json(req): Json<CreateDirectiveOrderGroupRequest>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ // Verify the directive exists and belongs to this owner
+ match repository::get_directive_for_owner(pool, auth.owner_id, id).await {
+ Ok(Some(_)) => {}
+ Ok(None) => {
+ return (
+ StatusCode::BAD_REQUEST,
+ Json(ApiError::new(
+ "INVALID_DIRECTIVE",
+ "directive_id must reference a valid directive owned by you",
+ )),
+ )
+ .into_response();
+ }
+ Err(e) => {
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("VALIDATION_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ }
+
+ match repository::create_directive_order_group(pool, id, auth.owner_id, req).await {
+ Ok(dog) => (StatusCode::CREATED, Json(dog)).into_response(),
+ Err(e) => {
+ tracing::error!("Failed to create DOG: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("CREATE_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// Get a DOG by ID.
+#[utoipa::path(
+ get,
+ path = "/api/v1/directives/{id}/dogs/{dog_id}",
+ params(
+ ("id" = Uuid, Path, description = "Directive ID"),
+ ("dog_id" = Uuid, Path, description = "DOG ID"),
+ ),
+ responses(
+ (status = 200, description = "DOG details", body = DirectiveOrderGroup),
+ (status = 404, description = "Not found", body = ApiError),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn get_dog(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path((id, dog_id)): Path<(Uuid, Uuid)>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ let _ = id; // directive_id is in the path for REST nesting but we scope by owner_id
+
+ match repository::get_directive_order_group(pool, dog_id, auth.owner_id).await {
+ Ok(Some(dog)) => Json(dog).into_response(),
+ Ok(None) => (
+ StatusCode::NOT_FOUND,
+ Json(ApiError::new("NOT_FOUND", "DOG not found")),
+ )
+ .into_response(),
+ Err(e) => {
+ tracing::error!("Failed to get DOG: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("GET_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// Update a DOG.
+#[utoipa::path(
+ patch,
+ path = "/api/v1/directives/{id}/dogs/{dog_id}",
+ params(
+ ("id" = Uuid, Path, description = "Directive ID"),
+ ("dog_id" = Uuid, Path, description = "DOG ID"),
+ ),
+ request_body = UpdateDirectiveOrderGroupRequest,
+ responses(
+ (status = 200, description = "DOG updated", body = DirectiveOrderGroup),
+ (status = 404, description = "Not found", body = ApiError),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn update_dog(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path((id, dog_id)): Path<(Uuid, Uuid)>,
+ Json(req): Json<UpdateDirectiveOrderGroupRequest>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ let _ = id; // directive_id is in the path for REST nesting but we scope by owner_id
+
+ // Validate status if provided
+ if let Some(ref status) = req.status {
+ if !["open", "in_progress", "done", "archived"].contains(&status.as_str()) {
+ return (
+ StatusCode::BAD_REQUEST,
+ Json(ApiError::new(
+ "VALIDATION_FAILED",
+ "status must be one of: open, in_progress, done, archived",
+ )),
+ )
+ .into_response();
+ }
+ }
+
+ match repository::update_directive_order_group(pool, dog_id, auth.owner_id, req).await {
+ Ok(Some(dog)) => Json(dog).into_response(),
+ Ok(None) => (
+ StatusCode::NOT_FOUND,
+ Json(ApiError::new("NOT_FOUND", "DOG not found")),
+ )
+ .into_response(),
+ Err(e) => {
+ tracing::error!("Failed to update DOG: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("UPDATE_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// Delete a DOG.
+#[utoipa::path(
+ delete,
+ path = "/api/v1/directives/{id}/dogs/{dog_id}",
+ params(
+ ("id" = Uuid, Path, description = "Directive ID"),
+ ("dog_id" = Uuid, Path, description = "DOG ID"),
+ ),
+ responses(
+ (status = 204, description = "Deleted"),
+ (status = 404, description = "Not found", body = ApiError),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn delete_dog(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path((id, dog_id)): Path<(Uuid, Uuid)>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ let _ = id; // directive_id is in the path for REST nesting but we scope by owner_id
+
+ match repository::delete_directive_order_group(pool, dog_id, auth.owner_id).await {
+ Ok(true) => StatusCode::NO_CONTENT.into_response(),
+ Ok(false) => (
+ StatusCode::NOT_FOUND,
+ Json(ApiError::new("NOT_FOUND", "DOG not found")),
+ )
+ .into_response(),
+ Err(e) => {
+ tracing::error!("Failed to delete DOG: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("DELETE_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// List orders belonging to a specific DOG.
+#[utoipa::path(
+ get,
+ path = "/api/v1/directives/{id}/dogs/{dog_id}/orders",
+ params(
+ ("id" = Uuid, Path, description = "Directive ID"),
+ ("dog_id" = Uuid, Path, description = "DOG ID"),
+ ),
+ responses(
+ (status = 200, description = "List of orders in the DOG", body = OrderListResponse),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn list_dog_orders(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path((id, dog_id)): Path<(Uuid, Uuid)>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ let _ = id; // directive_id is in the path for REST nesting but we scope by owner_id
+
+ match repository::list_orders_by_dog(pool, dog_id, auth.owner_id).await {
+ Ok(orders) => {
+ let total = orders.len() as i64;
+ Json(OrderListResponse { orders, total }).into_response()
+ }
+ Err(e) => {
+ tracing::error!("Failed to list orders for DOG: {}", e);
+ (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("LIST_FAILED", &e.to_string())),
+ )
+ .into_response()
+ }
+ }
+}
+
+/// Pick up orders for a specific DOG. Like the directive pick-up-orders
+/// endpoint but filtered to orders belonging to the specified DOG.
+#[utoipa::path(
+ post,
+ path = "/api/v1/directives/{id}/dogs/{dog_id}/pick-up-orders",
+ params(
+ ("id" = Uuid, Path, description = "Directive ID"),
+ ("dog_id" = Uuid, Path, description = "DOG ID"),
+ ),
+ responses(
+ (status = 200, description = "Orders picked up for planning", body = PickUpOrdersResponse),
+ (status = 404, description = "Directive or DOG not found", body = ApiError),
+ (status = 401, description = "Unauthorized", body = ApiError),
+ (status = 503, description = "Database not configured", body = ApiError),
+ ),
+ security(("bearer_auth" = []), ("api_key" = [])),
+ tag = "Directive Order Groups"
+)]
+pub async fn pick_up_dog_orders(
+ State(state): State<SharedState>,
+ Authenticated(auth): Authenticated,
+ Path((id, dog_id)): Path<(Uuid, Uuid)>,
+) -> impl IntoResponse {
+ let Some(ref pool) = state.db_pool else {
+ return (
+ StatusCode::SERVICE_UNAVAILABLE,
+ Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
+ )
+ .into_response();
+ };
+
+ // Verify directive ownership and get directive with steps
+ let (directive, mut steps) =
+ match repository::get_directive_with_steps_for_owner(pool, auth.owner_id, id).await {
+ Ok(Some((d, s))) => (d, s),
+ Ok(None) => {
+ return (
+ StatusCode::NOT_FOUND,
+ Json(ApiError::new("NOT_FOUND", "Directive not found")),
+ )
+ .into_response();
+ }
+ Err(e) => {
+ tracing::error!("Failed to get directive: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("GET_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ };
+
+ // Verify the DOG exists and belongs to this owner
+ match repository::get_directive_order_group(pool, dog_id, auth.owner_id).await {
+ Ok(Some(_)) => {}
+ Ok(None) => {
+ return (
+ StatusCode::NOT_FOUND,
+ Json(ApiError::new("NOT_FOUND", "DOG not found")),
+ )
+ .into_response();
+ }
+ Err(e) => {
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("GET_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ }
+
+ // Auto-remove completed steps that were already included in a PR
+ if directive.pr_url.is_some() || directive.pr_branch.is_some() {
+ match crate::orchestration::directive::remove_already_merged_steps(pool, id).await {
+ Ok(count) if count > 0 => {
+ tracing::info!("Auto-removed {} completed steps already in PR for directive {}", count, id);
+ steps = match repository::list_directive_steps(pool, id).await {
+ Ok(s) => s,
+ Err(e) => {
+ tracing::error!("Failed to re-fetch steps after cleanup: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("REFETCH_STEPS_FAILED", &e.to_string())),
+ ).into_response();
+ }
+ };
+ }
+ Err(e) => {
+ tracing::warn!("Failed to auto-remove merged steps for directive {}: {}", id, e);
+ }
+ _ => {}
+ }
+ }
+
+ // Reconcile existing orders
+ match repository::reconcile_directive_orders(pool, auth.owner_id, id).await {
+ Ok(count) => {
+ if count > 0 {
+ tracing::info!("Reconciled {} orders for directive {}", count, id);
+ }
+ }
+ Err(e) => {
+ tracing::warn!("Failed to reconcile directive orders: {}", e);
+ }
+ }
+
+ // Fetch available orders filtered to this DOG
+ let orders = match repository::get_available_orders_for_dog_pickup(pool, auth.owner_id, id, dog_id).await {
+ Ok(o) => o,
+ Err(e) => {
+ tracing::error!("Failed to fetch available orders for DOG: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("FETCH_ORDERS_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ };
+
+ // If no orders available, return early
+ if orders.is_empty() {
+ return Json(PickUpOrdersResponse {
+ message: "No orders available to plan for this DOG".to_string(),
+ order_count: 0,
+ task_id: None,
+ })
+ .into_response();
+ }
+
+ let order_count = orders.len() as i64;
+ let order_ids: Vec<Uuid> = orders.iter().map(|o| o.id).collect();
+
+ // Get generation and goal history for the planning prompt
+ let generation =
+ match repository::get_directive_max_generation(pool, id).await {
+ Ok(g) => g + 1,
+ Err(e) => {
+ tracing::error!("Failed to get max generation: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("GENERATION_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ };
+
+ let goal_history = match repository::get_directive_goal_history(pool, id, 3).await {
+ Ok(h) => h,
+ Err(e) => {
+ tracing::warn!("Failed to get goal history: {}", e);
+ vec![]
+ }
+ };
+
+ // Build the specialized planning prompt
+ let plan = build_order_pickup_prompt(&directive, &steps, &orders, generation, &goal_history);
+
+ // Link orders to the directive
+ if let Err(e) =
+ repository::bulk_link_orders_to_directive(pool, auth.owner_id, &order_ids, id).await
+ {
+ tracing::error!("Failed to link orders to directive: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("LINK_ORDERS_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+
+ // Mark picked-up orders as in_progress
+ if let Err(e) =
+ repository::bulk_update_order_status(pool, auth.owner_id, &order_ids, "in_progress").await
+ {
+ tracing::warn!("Failed to update order status to in_progress: {}", e);
+ }
+
+ // Create the planning task
+ let req = CreateTaskRequest {
+ contract_id: None,
+ name: format!("Pick up DOG orders: {}", directive.title),
+ description: Some("Directive order group pickup planning task".to_string()),
+ plan,
+ parent_task_id: None,
+ is_supervisor: false,
+ priority: 0,
+ repository_url: directive.repository_url.clone(),
+ base_branch: directive.base_branch.clone(),
+ target_branch: None,
+ merge_mode: None,
+ target_repo_path: None,
+ completion_action: None,
+ continue_from_task_id: None,
+ copy_files: None,
+ checkpoint_sha: None,
+ branched_from_task_id: None,
+ conversation_history: None,
+ supervisor_worktree_task_id: None,
+ directive_id: Some(directive.id),
+ directive_step_id: None,
+ };
+
+ let task = match repository::create_task_for_owner(pool, auth.owner_id, req).await {
+ Ok(t) => t,
+ Err(e) => {
+ tracing::error!("Failed to create DOG pickup planning task: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("CREATE_TASK_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+ };
+
+ // Assign as orchestrator task
+ if let Err(e) = repository::assign_orchestrator_task(pool, id, task.id).await {
+ tracing::error!("Failed to assign orchestrator task: {}", e);
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(ApiError::new("ASSIGN_TASK_FAILED", &e.to_string())),
+ )
+ .into_response();
+ }
+
+ // Cancel old planning tasks
+ let cancelled = repository::cancel_old_planning_tasks(pool, id, task.id).await;
+ if let Ok(count) = cancelled {
+ if count > 0 {
+ tracing::info!(
+ directive_id = %id,
+ cancelled_count = count,
+ "Cancelled old planning tasks superseded by DOG order pickup"
+ );
+ }
+ }
+
+ // Set directive to active if draft/idle/paused
+ match directive.status.as_str() {
+ "draft" | "idle" | "paused" => {
+ if let Err(e) = repository::set_directive_status(pool, auth.owner_id, id, "active").await
+ {
+ tracing::warn!("Failed to set directive status to active: {}", e);
+ }
+ }
+ _ => {}
+ }
+
+ // Advance ready steps
+ let _ = repository::advance_directive_ready_steps(pool, id).await;
+
+ Json(PickUpOrdersResponse {
+ message: format!("Planning {} orders from DOG", order_count),
+ order_count,
+ task_id: Some(task.id),
+ })
+ .into_response()
+}
diff --git a/makima/src/server/handlers/mesh_supervisor.rs b/makima/src/server/handlers/mesh_supervisor.rs
index 9d2dce7..ebde52b 100644
--- a/makima/src/server/handlers/mesh_supervisor.rs
+++ b/makima/src/server/handlers/mesh_supervisor.rs
@@ -3222,6 +3222,7 @@ pub async fn create_order_for_task(
labels: request.labels,
directive_id,
repository_url,
+ dog_id: None,
};
match repository::create_order(pool, owner_id, order_req).await {
diff --git a/makima/src/server/handlers/orders.rs b/makima/src/server/handlers/orders.rs
index 1251f79..03719cb 100644
--- a/makima/src/server/handlers/orders.rs
+++ b/makima/src/server/handlers/orders.rs
@@ -32,6 +32,7 @@ use crate::server::state::SharedState;
("type" = Option<String>, Query, description = "Filter by order type"),
("priority" = Option<String>, Query, description = "Filter by priority"),
("directive_id" = Option<Uuid>, Query, description = "Filter by directive ID"),
+ ("dog_id" = Option<Uuid>, Query, description = "Filter by DOG (Directive Order Group) ID"),
("search" = Option<String>, Query, description = "Text search across title, description, and directive name"),
),
responses(
@@ -62,6 +63,7 @@ pub async fn list_orders(
query.order_type.as_deref(),
query.priority.as_deref(),
query.directive_id,
+ query.dog_id,
query.search.as_deref(),
)
.await
diff --git a/makima/src/server/mod.rs b/makima/src/server/mod.rs
index b84b90e..6321518 100644
--- a/makima/src/server/mod.rs
+++ b/makima/src/server/mod.rs
@@ -249,6 +249,19 @@ pub fn make_router(state: SharedState) -> Router {
.route("/directives/{id}/cleanup", post(directives::cleanup_directive))
.route("/directives/{id}/create-pr", post(directives::create_pr))
.route("/directives/{id}/pick-up-orders", post(directives::pick_up_orders))
+ // Directive Order Group (DOG) endpoints
+ .route(
+ "/directives/{id}/dogs",
+ get(directives::list_dogs).post(directives::create_dog),
+ )
+ .route(
+ "/directives/{id}/dogs/{dog_id}",
+ get(directives::get_dog)
+ .patch(directives::update_dog)
+ .delete(directives::delete_dog),
+ )
+ .route("/directives/{id}/dogs/{dog_id}/orders", get(directives::list_dog_orders))
+ .route("/directives/{id}/dogs/{dog_id}/pick-up-orders", post(directives::pick_up_dog_orders))
// Order endpoints
.route(
"/orders",
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-20 23:32:58 +0000