//! HTTP handlers for daemon-to-contract interaction.
//!
//! These endpoints allow tasks running in daemons to interact with their
//! associated contracts via the contract.sh script. Authentication is via
//! tool keys registered by the daemon when starting a task.
use axum::{
extract::{Path, State},
http::StatusCode,
response::IntoResponse,
Json,
};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use uuid::Uuid;
use crate::db::{models::FileSummary, repository};
use crate::llm::phase_guidance::{self, PhaseChecklist, TaskInfo};
use crate::server::auth::Authenticated;
use crate::server::messages::ApiError;
use crate::server::state::SharedState;
// =============================================================================
// Request/Response Types
// =============================================================================
/// Contract status response for daemon.
#[derive(Debug, Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ContractStatusResponse {
pub id: Uuid,
pub name: String,
pub phase: String,
pub status: String,
pub description: Option<String>,
}
/// Contract goals response.
#[derive(Debug, Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ContractGoalsResponse {
/// Description serves as goals for the contract
pub description: Option<String>,
pub phase: String,
pub phase_guidance: String,
}
/// Progress report request from daemon.
#[derive(Debug, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ProgressReportRequest {
pub message: String,
#[serde(default)]
pub task_id: Option<Uuid>,
}
/// Suggested action from server.
#[derive(Debug, Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct SuggestedActionResponse {
pub action: String,
pub description: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
}
/// Completion action request.
#[derive(Debug, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct CompletionActionRequest {
#[serde(default)]
pub task_id: Option<Uuid>,
#[serde(default)]
pub files_modified: Vec<String>,
#[serde(default)]
pub lines_added: i32,
#[serde(default)]
pub lines_removed: i32,
#[serde(default)]
pub has_code_changes: bool,
}
/// Recommended completion action.
#[derive(Debug, Clone, Serialize, ToSchema)]
#[serde(rename_all = "lowercase")]
pub enum CompletionAction {
Branch,
Merge,
Pr,
None,
}
impl std::fmt::Display for CompletionAction {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CompletionAction::Branch => write!(f, "branch"),
CompletionAction::Merge => write!(f, "merge"),
CompletionAction::Pr => write!(f, "pr"),
CompletionAction::None => write!(f, "none"),
}
}
}
/// Completion action response.
#[derive(Debug, Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct CompletionActionResponse {
pub action: String,
pub reason: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
}
/// Create file request from daemon.
#[derive(Debug, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct CreateFileRequest {
pub name: String,
pub content: String,
#[serde(default)]
pub template_id: Option<String>,
}
/// Update file request from daemon.
#[derive(Debug, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct DaemonUpdateFileRequest {
/// Content to update in the file (as markdown body element)
pub content: String,
}
// =============================================================================
// Handlers
// =============================================================================
/// Get contract status for daemon.
#[utoipa::path(
get,
path = "/api/v1/contracts/{id}/daemon/status",
params(
("id" = Uuid, Path, description = "Contract ID")
),
responses(
(status = 200, description = "Contract status", body = ContractStatusResponse),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_contract_status(
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::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(contract)) => Json(ContractStatusResponse {
id: contract.id,
name: contract.name,
phase: contract.phase,
status: contract.status,
description: contract.description,
})
.into_response(),
Ok(None) => (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response(),
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response()
}
}
}
/// Get phase deliverables checklist.
#[utoipa::path(
get,
path = "/api/v1/contracts/{id}/daemon/checklist",
params(
("id" = Uuid, Path, description = "Contract ID")
),
responses(
(status = 200, description = "Phase checklist", body = PhaseChecklist),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_contract_checklist(
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();
};
// Get contract
let contract = match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(c)) => c,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
};
// Get completed deliverables for the current phase
let completed_deliverables = contract.get_completed_deliverables(&contract.phase);
// Get tasks for this contract
let tasks = match repository::list_tasks_in_contract(pool, id, auth.owner_id).await {
Ok(t) => t
.into_iter()
.map(|t| TaskInfo {
name: t.name,
status: t.status,
})
.collect::<Vec<_>>(),
Err(e) => {
tracing::warn!("Failed to get tasks for contract {}: {}", id, e);
Vec::new()
}
};
// Check if repository is configured
let has_repository = match repository::list_contract_repositories(pool, id).await {
Ok(repos) => !repos.is_empty(),
Err(_) => false,
};
let checklist = phase_guidance::get_phase_checklist_for_type(&contract.phase, &completed_deliverables, &tasks, has_repository, &contract.contract_type);
Json(checklist).into_response()
}
/// Get contract goals.
#[utoipa::path(
get,
path = "/api/v1/contracts/{id}/daemon/goals",
params(
("id" = Uuid, Path, description = "Contract ID")
),
responses(
(status = 200, description = "Contract goals", body = ContractGoalsResponse),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_contract_goals(
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::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(contract)) => {
let deliverables = phase_guidance::get_phase_deliverables_for_type(&contract.phase, &contract.contract_type);
Json(ContractGoalsResponse {
description: contract.description,
phase: contract.phase,
phase_guidance: deliverables.guidance,
})
.into_response()
}
Ok(None) => (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response(),
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response()
}
}
}
/// Post progress report to contract.
#[utoipa::path(
post,
path = "/api/v1/contracts/{id}/daemon/report",
params(
("id" = Uuid, Path, description = "Contract ID")
),
request_body = ProgressReportRequest,
responses(
(status = 200, description = "Report received"),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn post_progress_report(
State(state): State<SharedState>,
Authenticated(auth): Authenticated,
Path(id): Path<Uuid>,
Json(req): Json<ProgressReportRequest>,
) -> 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 contract exists
match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(_)) => {}
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
}
// Log the report as a contract event
let event_type = "progress_report";
let payload = serde_json::json!({
"message": req.message,
"task_id": req.task_id,
});
if let Err(e) = repository::record_contract_event(pool, id, event_type, Some(payload)).await {
tracing::warn!("Failed to create contract event: {}", e);
}
Json(serde_json::json!({"status": "received"})).into_response()
}
/// Get suggested action based on contract state.
#[utoipa::path(
post,
path = "/api/v1/contracts/{id}/daemon/suggest-action",
params(
("id" = Uuid, Path, description = "Contract ID")
),
responses(
(status = 200, description = "Suggested action", body = SuggestedActionResponse),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_suggest_action(
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();
};
// Get contract
let contract = match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(c)) => c,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
};
// Get completed deliverables and tasks for checklist
let completed_deliverables = contract.get_completed_deliverables(&contract.phase);
let tasks = repository::list_tasks_in_contract(pool, id, auth.owner_id)
.await
.unwrap_or_default()
.into_iter()
.map(|t| TaskInfo {
name: t.name,
status: t.status,
})
.collect::<Vec<_>>();
let has_repository = repository::list_contract_repositories(pool, id)
.await
.map(|r| !r.is_empty())
.unwrap_or(false);
let checklist = phase_guidance::get_phase_checklist_for_type(&contract.phase, &completed_deliverables, &tasks, has_repository, &contract.contract_type);
// Determine suggested action based on checklist
let (action, description) = if !checklist.suggestions.is_empty() {
("follow_suggestion", checklist.suggestions.first().unwrap().clone())
} else if checklist.completion_percentage >= 100 {
("advance_phase", format!("Phase {} is complete, consider advancing to next phase", contract.phase))
} else {
("continue", format!("Continue working on {} phase ({}% complete)", contract.phase, checklist.completion_percentage))
};
Json(SuggestedActionResponse {
action: action.to_string(),
description,
data: None,
})
.into_response()
}
/// Get recommended completion action.
#[utoipa::path(
post,
path = "/api/v1/contracts/{id}/daemon/completion-action",
params(
("id" = Uuid, Path, description = "Contract ID")
),
request_body = CompletionActionRequest,
responses(
(status = 200, description = "Recommended completion action", body = CompletionActionResponse),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_completion_action(
State(state): State<SharedState>,
Authenticated(auth): Authenticated,
Path(id): Path<Uuid>,
Json(req): Json<CompletionActionRequest>,
) -> impl IntoResponse {
let Some(ref pool) = state.db_pool else {
return (
StatusCode::SERVICE_UNAVAILABLE,
Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
)
.into_response();
};
// Get contract
let contract = match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(c)) => c,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
};
// Determine completion action based on phase and changes
let has_changes = !req.files_modified.is_empty() || req.lines_added > 0 || req.lines_removed > 0;
let has_significant_changes = req.lines_added + req.lines_removed > 50;
let (action, reason) = match contract.phase.as_str() {
"research" | "specify" => {
if has_changes {
(CompletionAction::Merge, "Early phase changes can be merged directly".to_string())
} else {
(CompletionAction::None, "No changes to commit".to_string())
}
}
"plan" => {
if has_significant_changes {
(CompletionAction::Pr, "Significant planning changes require review".to_string())
} else if has_changes {
(CompletionAction::Merge, "Minor planning changes can be merged".to_string())
} else {
(CompletionAction::None, "No changes to commit".to_string())
}
}
"execute" => {
if req.has_code_changes {
(CompletionAction::Pr, "Code changes in execute phase require review".to_string())
} else if has_changes {
(CompletionAction::Branch, "Documentation changes can be branched".to_string())
} else {
(CompletionAction::None, "No changes to commit".to_string())
}
}
"review" => {
if has_changes {
(CompletionAction::Pr, "Review phase changes should be reviewed".to_string())
} else {
(CompletionAction::None, "No changes to commit".to_string())
}
}
_ => (CompletionAction::None, "Unknown phase".to_string()),
};
// Generate branch name based on contract
let branch_name = if matches!(action, CompletionAction::Branch | CompletionAction::Pr) {
let slug = contract.name.to_lowercase().replace(' ', "-");
Some(format!("contract/{}", slug))
} else {
None
};
Json(CompletionActionResponse {
action: action.to_string(),
reason,
branch_name,
})
.into_response()
}
/// List contract files for daemon.
#[utoipa::path(
get,
path = "/api/v1/contracts/{id}/daemon/files",
params(
("id" = Uuid, Path, description = "Contract ID")
),
responses(
(status = 200, description = "List of contract files", body = Vec<FileSummary>),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn list_contract_files(
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();
};
// Verify contract exists
match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(_)) => {}
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
}
match repository::list_files_in_contract(pool, id, auth.owner_id).await {
Ok(files) => Json(files).into_response(),
Err(e) => {
tracing::error!("Failed to list files for contract {}: {}", id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response()
}
}
}
/// Get a specific contract file.
#[utoipa::path(
get,
path = "/api/v1/contracts/{id}/daemon/files/{file_id}",
params(
("id" = Uuid, Path, description = "Contract ID"),
("file_id" = Uuid, Path, description = "File ID")
),
responses(
(status = 200, description = "File content"),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract or file not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn get_contract_file(
State(state): State<SharedState>,
Authenticated(auth): Authenticated,
Path((id, file_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 contract exists
match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(_)) => {}
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
}
// Get file and verify it belongs to this contract
match repository::get_file_for_owner(pool, file_id, auth.owner_id).await {
Ok(Some(file)) => {
if file.contract_id != Some(id) {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "File not found in this contract")),
)
.into_response();
}
Json(file).into_response()
}
Ok(None) => (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "File not found")),
)
.into_response(),
Err(e) => {
tracing::error!("Failed to get file {}: {}", file_id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response()
}
}
}
/// Update a contract file.
#[utoipa::path(
put,
path = "/api/v1/contracts/{id}/daemon/files/{file_id}",
params(
("id" = Uuid, Path, description = "Contract ID"),
("file_id" = Uuid, Path, description = "File ID")
),
request_body = DaemonUpdateFileRequest,
responses(
(status = 200, description = "File updated"),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract or file not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn update_contract_file(
State(state): State<SharedState>,
Authenticated(auth): Authenticated,
Path((id, file_id)): Path<(Uuid, Uuid)>,
Json(req): Json<DaemonUpdateFileRequest>,
) -> 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 contract exists
match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(_)) => {}
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
}
// Get file and verify it belongs to this contract
let file = match repository::get_file_for_owner(pool, file_id, auth.owner_id).await {
Ok(Some(f)) => f,
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "File not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get file {}: {}", file_id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
};
if file.contract_id != Some(id) {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "File not found in this contract")),
)
.into_response();
}
// Update the file with content parsed as markdown
let body = crate::llm::markdown_to_body(&req.content);
let update_req = crate::db::models::UpdateFileRequest {
name: None,
description: None,
transcript: None,
summary: None,
body: Some(body),
version: None,
repo_file_path: None,
};
match repository::update_file_for_owner(pool, file_id, auth.owner_id, update_req).await {
Ok(Some(updated)) => Json(updated).into_response(),
Ok(None) => (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "File not found")),
)
.into_response(),
Err(e) => {
tracing::error!("Failed to update file {}: {}", file_id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", format!("{}", e))),
)
.into_response()
}
}
}
/// Create a new contract file.
#[utoipa::path(
post,
path = "/api/v1/contracts/{id}/daemon/files",
params(
("id" = Uuid, Path, description = "Contract ID")
),
request_body = CreateFileRequest,
responses(
(status = 201, description = "File created"),
(status = 401, description = "Unauthorized", body = ApiError),
(status = 404, description = "Contract not found", body = ApiError),
(status = 503, description = "Database not configured", body = ApiError),
),
security(
("tool_key" = []),
("api_key" = [])
),
tag = "Contract Daemon"
)]
pub async fn create_contract_file(
State(state): State<SharedState>,
Authenticated(auth): Authenticated,
Path(id): Path<Uuid>,
Json(req): Json<CreateFileRequest>,
) -> 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 contract exists
match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
Ok(Some(_)) => {}
Ok(None) => {
return (
StatusCode::NOT_FOUND,
Json(ApiError::new("NOT_FOUND", "Contract not found")),
)
.into_response();
}
Err(e) => {
tracing::error!("Failed to get contract {}: {}", id, e);
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response();
}
};
// Create the file with content parsed as markdown
let body = crate::llm::markdown_to_body(&req.content);
let create_req = crate::db::models::CreateFileRequest {
contract_id: id,
name: Some(req.name),
description: None,
transcript: vec![],
location: None,
body,
repo_file_path: None,
contract_phase: None, // Will be looked up from contract's current phase
};
match repository::create_file_for_owner(pool, auth.owner_id, create_req).await {
Ok(file) => (StatusCode::CREATED, Json(file)).into_response(),
Err(e) => {
tracing::error!("Failed to create file for contract {}: {}", id, e);
(
StatusCode::INTERNAL_SERVER_ERROR,
Json(ApiError::new("DB_ERROR", e.to_string())),
)
.into_response()
}
}
}
