From 0c844a312933e035de2dff8bda769db485d79fe5 Mon Sep 17 00:00:00 2001 From: soryu Date: Thu, 5 Mar 2026 23:13:13 +0000 Subject: feat: soryu-co/soryu - makima: Filter phase orbs by contract type in PhaseProgressBar --- .../src/components/contracts/ContractDetail.tsx | 1 + .../src/components/contracts/ContractList.tsx | 2 +- .../src/components/contracts/PhaseProgressBar.tsx | 19 +++++++++++++------ 3 files changed, 15 insertions(+), 7 deletions(-) diff --git a/makima/frontend/src/components/contracts/ContractDetail.tsx b/makima/frontend/src/components/contracts/ContractDetail.tsx index 46b2212..02c129e 100644 --- a/makima/frontend/src/components/contracts/ContractDetail.tsx +++ b/makima/frontend/src/components/contracts/ContractDetail.tsx @@ -195,6 +195,7 @@ export function ContractDetail({
diff --git a/makima/frontend/src/components/contracts/ContractList.tsx b/makima/frontend/src/components/contracts/ContractList.tsx index 4388283..1eee6a3 100644 --- a/makima/frontend/src/components/contracts/ContractList.tsx +++ b/makima/frontend/src/components/contracts/ContractList.tsx @@ -153,7 +153,7 @@ export function ContractList({ )}
- +
{contract.fileCount > 0 && ( {contract.fileCount} files diff --git a/makima/frontend/src/components/contracts/PhaseProgressBar.tsx b/makima/frontend/src/components/contracts/PhaseProgressBar.tsx index 5ee7999..9589db9 100644 --- a/makima/frontend/src/components/contracts/PhaseProgressBar.tsx +++ b/makima/frontend/src/components/contracts/PhaseProgressBar.tsx @@ -1,7 +1,9 @@ -import type { ContractPhase } from "../../lib/api"; +import type { ContractPhase, ContractType } from "../../lib/api"; +import { getValidPhases } from "../../lib/api"; interface PhaseProgressBarProps { currentPhase: ContractPhase; + contractType?: ContractType; onPhaseClick?: (phase: ContractPhase) => void; readonly?: boolean; } @@ -46,14 +48,16 @@ const phaseColors: Record - {phases.map((phase, index) => { + {visiblePhases.map((phase, index) => { const isActive = phase === currentPhase; const isCompleted = index < currentIndex; const colors = phaseColors[phase]; @@ -97,7 +101,7 @@ export function PhaseProgressBar({ {/* Connector line */} - {index < phases.length - 1 && ( + {index < visiblePhases.length - 1 && (
- {phases.map((phase, index) => { + {visiblePhases.map((phase, index) => { const isActive = phase === currentPhase; const isCompleted = index < currentIndex; const colors = phaseColors[phase]; -- cgit v1.2.3 From 745b6f1b794e3d18f0ed42b1d261fc2bbcddb27e Mon Sep 17 00:00:00 2001 From: soryu Date: Thu, 5 Mar 2026 23:16:25 +0000 Subject: WIP: heartbeat checkpoint --- ...0260303000000_create_directive_order_groups.sql | 19 +++ makima/src/db/models.rs | 53 ++++++ makima/src/db/repository.rs | 187 ++++++++++++++++++++- makima/src/server/handlers/directives.rs | 3 + 4 files changed, 259 insertions(+), 3 deletions(-) create mode 100644 makima/migrations/20260303000000_create_directive_order_groups.sql diff --git a/makima/migrations/20260303000000_create_directive_order_groups.sql b/makima/migrations/20260303000000_create_directive_order_groups.sql new file mode 100644 index 0000000..8a382e5 --- /dev/null +++ b/makima/migrations/20260303000000_create_directive_order_groups.sql @@ -0,0 +1,19 @@ +-- Directive Order Groups (DOGs): Epic-like groupings of orders within a directive. +CREATE TABLE directive_order_groups ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + directive_id UUID NOT NULL REFERENCES directives(id) ON DELETE CASCADE, + owner_id UUID NOT NULL REFERENCES owners(id) ON DELETE CASCADE, + name VARCHAR(500) NOT NULL, + description TEXT, + status VARCHAR(32) NOT NULL DEFAULT 'open' + CHECK (status IN ('open', 'in_progress', 'done', 'archived')), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX IF NOT EXISTS idx_dog_directive_id ON directive_order_groups(directive_id); +CREATE INDEX IF NOT EXISTS idx_dog_owner_id ON directive_order_groups(owner_id); + +-- Add optional dog_id to orders +ALTER TABLE orders ADD COLUMN dog_id UUID REFERENCES directive_order_groups(id) ON DELETE SET NULL; +CREATE INDEX IF NOT EXISTS idx_orders_dog_id ON orders(dog_id); 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, /// Repository context pub repository_url: Option, + /// Optional DOG (Directive Order Group) this order belongs to + pub dog_id: Option, pub created_at: DateTime, pub updated_at: DateTime, } @@ -2943,6 +2945,8 @@ pub struct CreateOrderRequest { /// Directive ID is required for new orders. pub directive_id: Uuid, pub repository_url: Option, + /// Optional DOG (Directive Order Group) to assign this order to. + pub dog_id: Option, } /// Default empty JSON array for labels. @@ -2963,6 +2967,8 @@ pub struct UpdateOrderRequest { pub directive_id: Option, pub directive_step_id: Option, pub repository_url: Option, + /// Optional DOG (Directive Order Group) to assign/reassign this order to. + pub dog_id: Option, } /// Response for order list endpoint. @@ -2986,6 +2992,8 @@ pub struct OrderListQuery { pub priority: Option, /// Filter by linked directive ID pub directive_id: Option, + /// Filter by DOG (Directive Order Group) ID + pub dog_id: Option, /// Text search across title, description, and directive_name (case-insensitive) pub search: Option, } @@ -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, + /// Status: open, in_progress, done, archived + pub status: String, + pub created_at: DateTime, + pub updated_at: DateTime, +} + +/// 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, +} + +/// Request to update a Directive Order Group (DOG). +#[derive(Debug, Default, Deserialize, ToSchema)] +#[serde(rename_all = "camelCase")] +pub struct UpdateDirectiveOrderGroupRequest { + pub name: Option, + pub description: Option, + pub status: Option, +} + +/// Response for DOG list endpoint. +#[derive(Debug, Serialize, ToSchema)] +#[serde(rename_all = "camelCase")] +pub struct DirectiveOrderGroupListResponse { + pub dogs: Vec, + 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, + dog_id_filter: Option, search_filter: Option<&str>, ) -> Result, 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 { + 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, 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, 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, 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(¤t.name); + let description = req.description.as_deref().or(current.description.as_deref()); + let status = req.status.as_deref().unwrap_or(¤t.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 { + 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, 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, 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..e6ccfa3 100644 --- a/makima/src/server/handlers/directives.rs +++ b/makima/src/server/handlers/directives.rs @@ -14,6 +14,9 @@ use crate::db::models::{ 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}; -- cgit v1.2.3 From eed949c692cbce0229d07f49fe974aa57699f305 Mon Sep 17 00:00:00 2001 From: soryu Date: Thu, 5 Mar 2026 23:20:29 +0000 Subject: feat: soryu-co/soryu - makima: Add DOG database schema and backend CRUD --- makima/src/server/handlers/directives.rs | 583 +++++++++++++++++++++++++- makima/src/server/handlers/mesh_supervisor.rs | 1 + makima/src/server/handlers/orders.rs | 2 + makima/src/server/mod.rs | 13 + 4 files changed, 597 insertions(+), 2 deletions(-) diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs index e6ccfa3..d1edf7e 100644 --- a/makima/src/server/handlers/directives.rs +++ b/makima/src/server/handlers/directives.rs @@ -9,11 +9,10 @@ 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, @@ -1378,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, + Authenticated(auth): Authenticated, + Path(id): Path, +) -> 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, + Authenticated(auth): Authenticated, + Path(id): Path, + Json(req): Json, +) -> 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, + 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, + Authenticated(auth): Authenticated, + Path((id, dog_id)): Path<(Uuid, Uuid)>, + Json(req): Json, +) -> 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, + 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, + 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, + 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 = 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, Query, description = "Filter by order type"), ("priority" = Option, Query, description = "Filter by priority"), ("directive_id" = Option, Query, description = "Filter by directive ID"), + ("dog_id" = Option, Query, description = "Filter by DOG (Directive Order Group) ID"), ("search" = Option, 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", -- cgit v1.2.3 From b8ec238084d9d5b210a67bc8c8cbb9a293facf28 Mon Sep 17 00:00:00 2001 From: soryu Date: Thu, 5 Mar 2026 23:14:01 +0000 Subject: feat: soryu-co/soryu - makima: Add DOG frontend types, API client, and hooks --- makima/frontend/src/hooks/useDogs.ts | 112 +++++++++++++++++++++++++++++++++++ makima/frontend/src/lib/api.ts | 84 ++++++++++++++++++++++++++ 2 files changed, 196 insertions(+) create mode 100644 makima/frontend/src/hooks/useDogs.ts diff --git a/makima/frontend/src/hooks/useDogs.ts b/makima/frontend/src/hooks/useDogs.ts new file mode 100644 index 0000000..819219e --- /dev/null +++ b/makima/frontend/src/hooks/useDogs.ts @@ -0,0 +1,112 @@ +import { useState, useEffect, useCallback } from "react"; +import { + type DirectiveOrderGroup, + type CreateDOGRequest, + type UpdateDOGRequest, + listDogs, + createDog, + getDog, + updateDog as updateDogApi, + deleteDog as deleteDogApi, + pickUpDogOrders as pickUpDogOrdersApi, +} from "../lib/api"; + +export function useDogs(directiveId: string | undefined) { + const [dogs, setDogs] = useState([]); + const [loading, setLoading] = useState(true); + const [error, setError] = useState(null); + + const refresh = useCallback(async () => { + if (!directiveId) return; + try { + setLoading(true); + setError(null); + const res = await listDogs(directiveId); + setDogs(res.dogs); + } catch (e) { + setError(e instanceof Error ? e.message : "Failed to load DOGs"); + } finally { + setLoading(false); + } + }, [directiveId]); + + useEffect(() => { + refresh(); + }, [refresh]); + + const create = useCallback(async (req: CreateDOGRequest) => { + if (!directiveId) return null; + const dog = await createDog(directiveId, req); + await refresh(); + return dog; + }, [directiveId, refresh]); + + const update = useCallback(async (dogId: string, req: UpdateDOGRequest) => { + if (!directiveId) return; + await updateDogApi(directiveId, dogId, req); + await refresh(); + }, [directiveId, refresh]); + + const remove = useCallback(async (dogId: string) => { + if (!directiveId) return; + await deleteDogApi(directiveId, dogId); + await refresh(); + }, [directiveId, refresh]); + + const pickUpOrders = useCallback(async (dogId: string) => { + if (!directiveId) return null; + const result = await pickUpDogOrdersApi(directiveId, dogId); + await refresh(); + return result; + }, [directiveId, refresh]); + + return { dogs, loading, error, refresh, create, update, remove, pickUpOrders }; +} + +export function useDog(directiveId: string | undefined, dogId: string | undefined) { + const [dog, setDog] = useState(null); + const [loading, setLoading] = useState(true); + const [error, setError] = useState(null); + + const refresh = useCallback(async () => { + if (!directiveId || !dogId) return; + try { + setLoading(true); + setError(null); + const d = await getDog(directiveId, dogId); + setDog(d); + } catch (e) { + setError(e instanceof Error ? e.message : "Failed to load DOG"); + } finally { + setLoading(false); + } + }, [directiveId, dogId]); + + useEffect(() => { + setDog(null); + setError(null); + setLoading(true); + refresh(); + }, [directiveId, dogId]); // eslint-disable-line react-hooks/exhaustive-deps + + const update = useCallback(async (req: UpdateDOGRequest) => { + if (!directiveId || !dogId) return; + const d = await updateDogApi(directiveId, dogId, req); + setDog(d); + return d; + }, [directiveId, dogId]); + + const remove = useCallback(async () => { + if (!directiveId || !dogId) return; + await deleteDogApi(directiveId, dogId); + }, [directiveId, dogId]); + + const pickUpOrders = useCallback(async () => { + if (!directiveId || !dogId) return null; + const result = await pickUpDogOrdersApi(directiveId, dogId); + await refresh(); + return result; + }, [directiveId, dogId, refresh]); + + return { dog, loading, error, refresh, update, remove, pickUpOrders }; +} diff --git a/makima/frontend/src/lib/api.ts b/makima/frontend/src/lib/api.ts index 4923c1d..7968583 100644 --- a/makima/frontend/src/lib/api.ts +++ b/makima/frontend/src/lib/api.ts @@ -3386,6 +3386,85 @@ export async function pickUpOrders(directiveId: string): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs`); + if (!res.ok) throw new Error(`Failed to list DOGs: ${res.statusText}`); + return res.json(); +} + +export async function createDog(directiveId: string, req: CreateDOGRequest): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify(req), + }); + if (!res.ok) throw new Error(`Failed to create DOG: ${res.statusText}`); + return res.json(); +} + +export async function getDog(directiveId: string, dogId: string): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs/${dogId}`); + if (!res.ok) throw new Error(`Failed to get DOG: ${res.statusText}`); + return res.json(); +} + +export async function updateDog(directiveId: string, dogId: string, req: UpdateDOGRequest): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs/${dogId}`, { + method: "PATCH", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify(req), + }); + if (!res.ok) throw new Error(`Failed to update DOG: ${res.statusText}`); + return res.json(); +} + +export async function deleteDog(directiveId: string, dogId: string): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs/${dogId}`, { + method: "DELETE", + }); + if (!res.ok) throw new Error(`Failed to delete DOG: ${res.statusText}`); +} + +export async function pickUpDogOrders(directiveId: string, dogId: string): Promise { + const res = await authFetch(`${API_BASE}/api/v1/directives/${directiveId}/dogs/${dogId}/pick-up-orders`, { + method: "POST", + }); + if (!res.ok) throw new Error(`Failed to pick up DOG orders: ${res.statusText}`); + return res.json(); +} + // ============================================================================= // Orders API // ============================================================================= @@ -3406,6 +3485,7 @@ export interface Order { directiveId: string | null; directiveStepId: string | null; directiveName: string | null; + dogId: string | null; repositoryUrl: string | null; createdAt: string; updatedAt: string; @@ -3424,6 +3504,7 @@ export interface CreateOrderRequest { orderType?: OrderType; labels?: string[]; directiveId: string; + dogId?: string | null; repositoryUrl?: string | null; } @@ -3436,6 +3517,7 @@ export interface UpdateOrderRequest { labels?: string[]; directiveId?: string | null; directiveStepId?: string | null; + dogId?: string | null; repositoryUrl?: string | null; } @@ -3445,6 +3527,7 @@ export async function listOrders( priority?: OrderPriority, directiveId?: string, search?: string, + dogId?: string, ): Promise { const params = new URLSearchParams(); if (status) params.set("status", status); @@ -3452,6 +3535,7 @@ export async function listOrders( if (priority) params.set("priority", priority); if (directiveId) params.set("directiveId", directiveId); if (search) params.set("search", search); + if (dogId) params.set("dogId", dogId); const qs = params.toString(); const res = await authFetch(`${API_BASE}/api/v1/orders${qs ? `?${qs}` : ""}`); if (!res.ok) throw new Error(`Failed to list orders: ${res.statusText}`); -- cgit v1.2.3 From ae3bc57de7a240c3c8ab15080b405e8ea3e16ccb Mon Sep 17 00:00:00 2001 From: soryu Date: Thu, 5 Mar 2026 23:25:40 +0000 Subject: WIP: heartbeat checkpoint --- .../frontend/src/components/directives/DOGList.tsx | 381 +++++++++++++++++++++ .../src/components/directives/DirectiveDetail.tsx | 72 +++- .../frontend/src/components/orders/OrderDetail.tsx | 91 +++++ makima/frontend/src/routes/directives.tsx | 8 + makima/frontend/src/routes/orders.tsx | 3 + 5 files changed, 542 insertions(+), 13 deletions(-) create mode 100644 makima/frontend/src/components/directives/DOGList.tsx diff --git a/makima/frontend/src/components/directives/DOGList.tsx b/makima/frontend/src/components/directives/DOGList.tsx new file mode 100644 index 0000000..de59d7d --- /dev/null +++ b/makima/frontend/src/components/directives/DOGList.tsx @@ -0,0 +1,381 @@ +import { useState } from "react"; +import type { + DirectiveOrderGroup, + DOGStatus, + CreateDOGRequest, +} from "../../lib/api"; + +const DOG_STATUS_BADGE: Record = { + open: { color: "text-[#75aafc] border-[rgba(117,170,252,0.4)]", label: "OPEN" }, + in_progress: { color: "text-yellow-400 border-yellow-800", label: "IN PROGRESS" }, + done: { color: "text-emerald-400 border-emerald-800", label: "DONE" }, + archived: { color: "text-[#556677] border-[#2a3a5a]", label: "ARCHIVED" }, +}; + +const DOG_STATUS_OPTIONS: DOGStatus[] = ["open", "in_progress", "done", "archived"]; + +interface DOGListProps { + dogs: DirectiveOrderGroup[]; + loading: boolean; + onCreateDog: (req: CreateDOGRequest) => Promise; + onUpdateDog: (dogId: string, req: { name?: string; description?: string | null; status?: DOGStatus }) => Promise; + onDeleteDog: (dogId: string) => Promise; + onPickUpOrders: (dogId: string) => Promise; +} + +export function DOGList({ + dogs, + loading, + onCreateDog, + onUpdateDog, + onDeleteDog, + onPickUpOrders, +}: DOGListProps) { + const [showCreate, setShowCreate] = useState(false); + const [newName, setNewName] = useState(""); + const [newDesc, setNewDesc] = useState(""); + const [creating, setCreating] = useState(false); + + const handleCreate = async () => { + if (!newName.trim()) return; + setCreating(true); + try { + await onCreateDog({ + name: newName.trim(), + description: newDesc.trim() || null, + }); + setNewName(""); + setNewDesc(""); + setShowCreate(false); + } catch (e) { + console.error("Failed to create DOG:", e); + } finally { + setCreating(false); + } + }; + + if (loading) { + return ( +
+ Loading DOGs... +
+ ); + } + + return ( +
+ {/* Header + Create button */} +
+ + Order Groups ({dogs.length}) + + +
+ + {/* Create form */} + {showCreate && ( +
+
+ + setNewName(e.target.value)} + onKeyDown={(e) => { + if (e.key === "Enter" && newName.trim()) handleCreate(); + if (e.key === "Escape") setShowCreate(false); + }} + placeholder="Group name..." + autoFocus + className="w-full bg-[#0a1628] border border-[rgba(117,170,252,0.2)] rounded px-2 py-1.5 text-[11px] font-mono text-white placeholder:text-[#445566]" + /> +
+
+ +