@sesamespace/hivemind 0.1.0

package/packages/memory/src/src/tasks.rs

@@ -0,0 +1,321 @@
+use anyhow::Result;
+use arrow_array::{RecordBatch, RecordBatchIterator, StringArray};
+use arrow_schema::{DataType, Field, Schema};
+use chrono::Utc;
+use futures::stream::TryStreamExt;
+use lancedb::{connection::Connection, query::ExecutableQuery, query::QueryBase, Table};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+const TASKS_TABLE: &str = "tasks";
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct TaskRecord {
+    pub id: String,
+    pub context_name: String,
+    pub title: String,
+    pub description: String,
+    pub status: String,
+    pub blocked_by: String, // JSON array stored as string
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct TaskInput {
+    pub context_name: String,
+    pub title: String,
+    pub description: String,
+    #[serde(default = "default_status")]
+    pub status: String,
+    #[serde(default)]
+    pub blocked_by: Vec<String>,
+}
+
+fn default_status() -> String {
+    "planned".to_string()
+}
+
+#[derive(Debug, Deserialize)]
+pub struct TaskUpdate {
+    pub status: Option<String>,
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub blocked_by: Option<Vec<String>>,
+}
+
+pub struct TaskStore {
+    db: Connection,
+}
+
+impl TaskStore {
+    pub async fn new(db: Connection) -> Result<Self> {
+        let store = Self { db };
+        store.ensure_table().await?;
+        Ok(store)
+    }
+
+    fn schema() -> Arc<Schema> {
+        Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Utf8, false),
+            Field::new("context_name", DataType::Utf8, false),
+            Field::new("title", DataType::Utf8, false),
+            Field::new("description", DataType::Utf8, false),
+            Field::new("status", DataType::Utf8, false),
+            Field::new("blocked_by", DataType::Utf8, false),
+            Field::new("created_at", DataType::Utf8, false),
+            Field::new("updated_at", DataType::Utf8, false),
+        ]))
+    }
+
+    async fn ensure_table(&self) -> Result<()> {
+        let names = self.db.table_names().execute().await?;
+        if !names.contains(&TASKS_TABLE.to_string()) {
+            let schema = Self::schema();
+            let batch = RecordBatch::new_empty(schema.clone());
+            let batches = RecordBatchIterator::new(vec![Ok(batch)], schema);
+            self.db
+                .create_table(TASKS_TABLE, Box::new(batches))
+                .execute()
+                .await?;
+            tracing::info!("Created tasks table");
+        }
+        Ok(())
+    }
+
+    pub async fn create_task(&self, input: TaskInput) -> Result<TaskRecord> {
+        let id = uuid::Uuid::new_v4().to_string();
+        let now = Utc::now().to_rfc3339();
+        let blocked_by_json = serde_json::to_string(&input.blocked_by)?;
+
+        let task = TaskRecord {
+            id: id.clone(),
+            context_name: input.context_name.clone(),
+            title: input.title.clone(),
+            description: input.description.clone(),
+            status: input.status,
+            blocked_by: blocked_by_json.clone(),
+            created_at: now.clone(),
+            updated_at: now.clone(),
+        };
+
+        let schema = Self::schema();
+        let batch = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(StringArray::from(vec![task.id.as_str()])),
+                Arc::new(StringArray::from(vec![task.context_name.as_str()])),
+                Arc::new(StringArray::from(vec![task.title.as_str()])),
+                Arc::new(StringArray::from(vec![task.description.as_str()])),
+                Arc::new(StringArray::from(vec![task.status.as_str()])),
+                Arc::new(StringArray::from(vec![blocked_by_json.as_str()])),
+                Arc::new(StringArray::from(vec![task.created_at.as_str()])),
+                Arc::new(StringArray::from(vec![task.updated_at.as_str()])),
+            ],
+        )?;
+
+        let table = self.db.open_table(TASKS_TABLE).execute().await?;
+        let batches = RecordBatchIterator::new(vec![Ok(batch)], schema);
+        table.add(Box::new(batches)).execute().await?;
+
+        tracing::debug!("Created task {} in context {}", task.id, task.context_name);
+        Ok(task)
+    }
+
+    pub async fn list_tasks(
+        &self,
+        context: &str,
+        status_filter: Option<&str>,
+    ) -> Result<Vec<TaskRecord>> {
+        let table = self.db.open_table(TASKS_TABLE).execute().await?;
+
+        let filter = match status_filter {
+            Some(status) => format!("context_name = '{}' AND status = '{}'", context, status),
+            None => format!("context_name = '{}'", context),
+        };
+
+        let results = table.query().only_if(filter).execute().await?;
+
+        let mut tasks = Vec::new();
+        let batches: Vec<RecordBatch> = results.try_collect().await?;
+
+        for batch in &batches {
+            let ids = batch
+                .column_by_name("id")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let ctx_names = batch
+                .column_by_name("context_name")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let titles = batch
+                .column_by_name("title")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let descriptions = batch
+                .column_by_name("description")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let statuses = batch
+                .column_by_name("status")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let blocked_bys = batch
+                .column_by_name("blocked_by")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let created_ats = batch
+                .column_by_name("created_at")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            let updated_ats = batch
+                .column_by_name("updated_at")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+
+            for i in 0..batch.num_rows() {
+                tasks.push(TaskRecord {
+                    id: ids.value(i).to_string(),
+                    context_name: ctx_names.value(i).to_string(),
+                    title: titles.value(i).to_string(),
+                    description: descriptions.value(i).to_string(),
+                    status: statuses.value(i).to_string(),
+                    blocked_by: blocked_bys.value(i).to_string(),
+                    created_at: created_ats.value(i).to_string(),
+                    updated_at: updated_ats.value(i).to_string(),
+                });
+            }
+        }
+
+        // Sort by created_at
+        tasks.sort_by(|a, b| a.created_at.cmp(&b.created_at));
+
+        Ok(tasks)
+    }
+
+    pub async fn get_task(&self, id: &str) -> Result<Option<TaskRecord>> {
+        let table = self.db.open_table(TASKS_TABLE).execute().await?;
+        let results = table
+            .query()
+            .only_if(format!("id = '{}'", id))
+            .execute()
+            .await?;
+
+        let batches: Vec<RecordBatch> = results.try_collect().await?;
+        for batch in &batches {
+            if batch.num_rows() > 0 {
+                let ids = batch.column_by_name("id").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let ctx_names = batch.column_by_name("context_name").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let titles = batch.column_by_name("title").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let descriptions = batch.column_by_name("description").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let statuses = batch.column_by_name("status").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let blocked_bys = batch.column_by_name("blocked_by").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let created_ats = batch.column_by_name("created_at").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+                let updated_ats = batch.column_by_name("updated_at").unwrap().as_any().downcast_ref::<StringArray>().unwrap();
+
+                return Ok(Some(TaskRecord {
+                    id: ids.value(0).to_string(),
+                    context_name: ctx_names.value(0).to_string(),
+                    title: titles.value(0).to_string(),
+                    description: descriptions.value(0).to_string(),
+                    status: statuses.value(0).to_string(),
+                    blocked_by: blocked_bys.value(0).to_string(),
+                    created_at: created_ats.value(0).to_string(),
+                    updated_at: updated_ats.value(0).to_string(),
+                }));
+            }
+        }
+
+        Ok(None)
+    }
+
+    pub async fn update_task(&self, id: &str, update: TaskUpdate) -> Result<Option<TaskRecord>> {
+        let existing = self.get_task(id).await?;
+        let Some(mut task) = existing else {
+            return Ok(None);
+        };
+
+        // Apply updates
+        if let Some(status) = update.status {
+            task.status = status;
+        }
+        if let Some(title) = update.title {
+            task.title = title;
+        }
+        if let Some(description) = update.description {
+            task.description = description;
+        }
+        if let Some(blocked_by) = update.blocked_by {
+            task.blocked_by = serde_json::to_string(&blocked_by)?;
+        }
+        task.updated_at = Utc::now().to_rfc3339();
+
+        // Delete and reinsert
+        let table = self.db.open_table(TASKS_TABLE).execute().await?;
+        table.delete(&format!("id = '{}'", id)).await?;
+
+        let schema = Self::schema();
+        let batch = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(StringArray::from(vec![task.id.as_str()])),
+                Arc::new(StringArray::from(vec![task.context_name.as_str()])),
+                Arc::new(StringArray::from(vec![task.title.as_str()])),
+                Arc::new(StringArray::from(vec![task.description.as_str()])),
+                Arc::new(StringArray::from(vec![task.status.as_str()])),
+                Arc::new(StringArray::from(vec![task.blocked_by.as_str()])),
+                Arc::new(StringArray::from(vec![task.created_at.as_str()])),
+                Arc::new(StringArray::from(vec![task.updated_at.as_str()])),
+            ],
+        )?;
+
+        let batches = RecordBatchIterator::new(vec![Ok(batch)], schema);
+        table.add(Box::new(batches)).execute().await?;
+
+        Ok(Some(task))
+    }
+
+    /// Get the next available task for a context:
+    /// - Status is "planned" (not active/complete/archived)
+    /// - Not blocked by any incomplete tasks
+    pub async fn get_next_task(&self, context: &str) -> Result<Option<TaskRecord>> {
+        let planned = self.list_tasks(context, Some("planned")).await?;
+        let all_tasks = self.list_tasks(context, None).await?;
+
+        // Build a set of complete task IDs
+        let complete_ids: std::collections::HashSet<String> = all_tasks
+            .iter()
+            .filter(|t| t.status == "complete" || t.status == "archived")
+            .map(|t| t.id.clone())
+            .collect();
+
+        for task in planned {
+            let blocked_by: Vec<String> =
+                serde_json::from_str(&task.blocked_by).unwrap_or_default();
+
+            // Task is available if all blockers are complete
+            let is_blocked = blocked_by.iter().any(|b| !complete_ids.contains(b));
+            if !is_blocked {
+                return Ok(Some(task));
+            }
+        }
+
+        Ok(None)
+    }
+}