path: root/makima/src/daemon/api/directive.rs

//! Directive API methods.

use serde::Serialize;
use uuid::Uuid;

use super::client::{ApiClient, ApiError};
use super::supervisor::JsonValue;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateStepRequest {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub task_plan: Option<String>,
    pub depends_on: Vec<Uuid>,
    pub order_index: i32,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateGoalRequest {
    pub goal: String,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateStepDepsRequest {
    pub depends_on: Vec<Uuid>,
}

/// Percent-encode a string for use as a URL path segment.
///
/// Encodes all characters except unreserved characters (alphanumeric, `-`, `.`, `_`, `~`).
fn percent_encode_path(s: &str) -> String {
    let mut encoded = String::with_capacity(s.len());
    for byte in s.bytes() {
        match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
                encoded.push(byte as char);
            }
            _ => {
                encoded.push_str(&format!("%{:02X}", byte));
            }
        }
    }
    encoded
}

/// Request body for setting a single memory entry.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SetMemoryRequest {
    pub key: String,
    pub value: String,
}

/// A single entry within a batch set request.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchMemoryEntry {
    pub key: String,
    pub value: String,
}

/// Request body for setting multiple memory entries at once.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchSetMemoryRequest {
    pub entries: Vec<BatchMemoryEntry>,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MemorySetRequest {
    pub value: String,
}


impl ApiClient {
    /// List all directives.
    pub async fn list_directives(&self) -> Result<JsonValue, ApiError> {
        self.get("/api/v1/directives").await
    }

    /// Get a directive with its steps.
    pub async fn get_directive(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.get(&format!("/api/v1/directives/{}", directive_id)).await
    }

    /// Add a step to a directive.
    pub async fn directive_add_step(
        &self,
        directive_id: Uuid,
        req: CreateStepRequest,
    ) -> Result<JsonValue, ApiError> {
        self.post(&format!("/api/v1/directives/{}/steps", directive_id), &req).await
    }

    /// Remove a step from a directive.
    pub async fn directive_remove_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<(), ApiError> {
        self.delete(&format!("/api/v1/directives/{}/steps/{}", directive_id, step_id)).await
    }

    /// Set dependencies for a step.
    pub async fn directive_set_deps(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
        depends_on: Vec<Uuid>,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateStepDepsRequest { depends_on };
        self.put(&format!("/api/v1/directives/{}/steps/{}", directive_id, step_id), &req).await
    }

    /// Start a directive.
    pub async fn directive_start(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/start", directive_id)).await
    }

    /// Pause a directive.
    pub async fn directive_pause(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/pause", directive_id)).await
    }

    /// Advance the directive DAG.
    pub async fn directive_advance(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/advance", directive_id)).await
    }

    /// Mark a step as completed.
    pub async fn directive_complete_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/complete", directive_id, step_id)).await
    }

    /// Mark a step as failed.
    pub async fn directive_fail_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/fail", directive_id, step_id)).await
    }

    /// Mark a step as skipped.
    pub async fn directive_skip_step(
        &self,
        directive_id: Uuid,
        step_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.post_empty(&format!("/api/v1/directives/{}/steps/{}/skip", directive_id, step_id)).await
    }

    /// Batch add steps to a directive.
    pub async fn directive_batch_add_steps(
        &self,
        directive_id: Uuid,
        steps: serde_json::Value,
    ) -> Result<JsonValue, ApiError> {
        self.post(
            &format!("/api/v1/directives/{}/steps/batch", directive_id),
            &steps,
        )
        .await
    }

    /// Update the directive's goal.
    pub async fn directive_update_goal(
        &self,
        directive_id: Uuid,
        goal: &str,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateGoalRequest { goal: goal.to_string() };
        self.put(&format!("/api/v1/directives/{}/goal", directive_id), &req).await
    }

    /// Update directive metadata (PR URL, PR branch, etc.)
    pub async fn directive_update(
        &self,
        directive_id: Uuid,
        pr_url: Option<String>,
        pr_branch: Option<String>,
    ) -> Result<JsonValue, ApiError> {
        let req = UpdateDirectiveMetadataRequest { pr_url, pr_branch };
        self.put(&format!("/api/v1/directives/{}", directive_id), &req).await
    }

    // ── Directive Memory ──────────────────────────────────────────────

    /// List all memory entries for a directive.
    pub async fn list_memories(&self, directive_id: Uuid) -> Result<JsonValue, ApiError> {
        self.get(&format!("/api/v1/directives/{}/memory", directive_id))
            .await
    }

    /// Get a single memory entry by key.
    pub async fn get_memory(
        &self,
        directive_id: Uuid,
        key: &str,
    ) -> Result<JsonValue, ApiError> {
        self.get(&format!(
            "/api/v1/directives/{}/memory/{}",
            directive_id,
            percent_encode_path(key)
        ))
        .await
    }

    /// Set (create or update) a single memory entry.
    pub async fn set_memory(
        &self,
        directive_id: Uuid,
        key: &str,
        value: &str,
    ) -> Result<JsonValue, ApiError> {
        let req = SetMemoryRequest {
            key: key.to_string(),
            value: value.to_string(),
        };
        self.put(&format!("/api/v1/directives/{}/memory", directive_id), &req)
            .await
    }

    /// Set multiple memory entries in a single request.
    pub async fn batch_set_memories(
        &self,
        directive_id: Uuid,
        entries: Vec<(String, String)>,
    ) -> Result<JsonValue, ApiError> {
        let req = BatchSetMemoryRequest {
            entries: entries
                .into_iter()
                .map(|(key, value)| BatchMemoryEntry { key, value })
                .collect(),
        };
        self.post(
            &format!("/api/v1/directives/{}/memory/batch", directive_id),
            &req,
        )
        .await
    }

    /// Delete a single memory entry by key.
    pub async fn delete_memory(
        &self,
        directive_id: Uuid,
        key: &str,
    ) -> Result<(), ApiError> {
        self.delete(&format!(
            "/api/v1/directives/{}/memory/{}",
            directive_id,
            percent_encode_path(key)
        ))
        .await
    }

    /// Clear all memory entries for a directive.
    pub async fn clear_memories(&self, directive_id: Uuid) -> Result<(), ApiError> {
        self.delete(&format!("/api/v1/directives/{}/memory", directive_id))
            .await
    }

    // ── CLI-facing Directive Memory aliases ──────────────────────────

    /// Set a memory key-value pair for a directive (CLI-facing).
    pub async fn directive_memory_set(
        &self,
        directive_id: Uuid,
        key: &str,
        value: &str,
    ) -> Result<JsonValue, ApiError> {
        let req = MemorySetRequest {
            value: value.to_string(),
        };
        self.put(
            &format!("/api/v1/directives/{}/memory/{}", directive_id, key),
            &req,
        )
        .await
    }

    /// Get a memory value by key for a directive (CLI-facing).
    pub async fn directive_memory_get(
        &self,
        directive_id: Uuid,
        key: &str,
    ) -> Result<JsonValue, ApiError> {
        self.get(&format!(
            "/api/v1/directives/{}/memory/{}",
            directive_id, key
        ))
        .await
    }

    /// List all memory key-value pairs for a directive (CLI-facing).
    pub async fn directive_memory_list(
        &self,
        directive_id: Uuid,
    ) -> Result<JsonValue, ApiError> {
        self.get(&format!("/api/v1/directives/{}/memory", directive_id))
            .await
    }

    /// Delete a memory key for a directive (CLI-facing).
    pub async fn directive_memory_delete(
        &self,
        directive_id: Uuid,
        key: &str,
    ) -> Result<(), ApiError> {
        self.delete(&format!(
            "/api/v1/directives/{}/memory/{}",
            directive_id, key
        ))
        .await
    }

    /// Clear all memory for a directive (CLI-facing).
    pub async fn directive_memory_clear(
        &self,
        directive_id: Uuid,
    ) -> Result<(), ApiError> {
        self.delete(&format!("/api/v1/directives/{}/memory", directive_id))
            .await
    }

    /// Batch set multiple memory key-value pairs for a directive (CLI-facing).
    pub async fn directive_memory_batch_set(
        &self,
        directive_id: Uuid,
        entries: serde_json::Value,
    ) -> Result<JsonValue, ApiError> {
        self.post(
            &format!("/api/v1/directives/{}/memory/batch", directive_id),
            &entries,
        )
        .await
    }
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateDirectiveMetadataRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pr_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pr_branch: Option<String>,
}