Writing a Plugin

[package]
name = "common-tasks"
version.workspace = true
edition.workspace = true
license.workspace = true
publish.workspace = true

[dependencies]
anyhow.workspace = true
async-trait.workspace = true
axum.workspace = true
common-agent.workspace = true
commonos.workspace = true
serde.workspace = true
serde_json.workspace = true
sqlx.workspace = true

CREATE TABLE IF NOT EXISTS task_items (
    id         bigserial PRIMARY KEY,
    profile_id text NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
    title      text NOT NULL,
    done       boolean NOT NULL DEFAULT false,
    created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS task_items_profile_idx ON task_items (profile_id, done);

//! CommonTasks: a to-do list per profile.

use std::sync::Arc;

use async_trait::async_trait;
use axum::extract::{Query, State};
use axum::routing::get;
use axum::{Json, Router};
use common_agent::{ContextSource, Risk, Tool, ToolContext, ToolError};
use commonos::{ApiResult, Plugin, PluginContext};
use serde::Deserialize;
use serde_json::{json, Value};
use sqlx::PgPool;

pub struct CommonTasks;

/// `[plugins.tasks]` in `commonos.toml`.
#[derive(Debug, Clone, Deserialize)]
#[serde(default)]
pub struct TaskSettings {
    pub max_open: i64,
}

impl Default for TaskSettings {
    fn default() -> Self {
        Self { max_open: 20 }
    }
}

#[async_trait]
impl Plugin for CommonTasks {
    fn name(&self) -> &'static str {
        "tasks"
    }

    fn schema(&self) -> &'static str {
        include_str!("schema.sql")
    }

    async fn register(&self, ctx: &mut PluginContext) -> anyhow::Result<()> {
        let settings: TaskSettings = ctx.settings()?;
        let pool = ctx.store.pool().clone();
        ctx.tool(Arc::new(AddTask { pool: pool.clone(), settings }));
        ctx.context(Arc::new(OpenTasks { pool: pool.clone() }));
        ctx.routes(Router::new().route("/api/tasks", get(list_route)).with_state(pool));
        Ok(())
    }
}

struct AddTask {
    pool: PgPool,
    settings: TaskSettings,
}

#[async_trait]
impl Tool for AddTask {
    fn name(&self) -> &str {
        "add_task"
    }

    fn description(&self) -> &str {
        "Add an item to the person's to-do list. Use a short title that starts with a verb."
    }

    fn schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": { "title": { "type": "string" } },
            "required": ["title"]
        })
    }

    fn risk(&self) -> Risk {
        // Only this profile's own list changes.
        Risk::Read
    }

    async fn call(&self, ctx: &ToolContext, args: Value) -> Result<String, ToolError> {
        let title = args["title"]
            .as_str()
            .filter(|title| !title.trim().is_empty())
            .ok_or_else(|| ToolError::InvalidArgs("title is required".into()))?;
        let profile = &ctx.turn.profile_id;
        let open: i64 = sqlx::query_scalar(
            "SELECT count(*) FROM task_items WHERE profile_id = $1 AND NOT done",
        )
        .bind(profile)
        .fetch_one(&self.pool)
        .await
        .map_err(|e| ToolError::Failed(e.to_string()))?;
        if open >= self.settings.max_open {
            return Err(ToolError::Failed(format!(
                "the list already has {open} open tasks (max {})",
                self.settings.max_open
            )));
        }
        sqlx::query("INSERT INTO task_items (profile_id, title) VALUES ($1, $2)")
            .bind(profile)
            .bind(title.trim())
            .execute(&self.pool)
            .await
            .map_err(|e| ToolError::Failed(e.to_string()))?;
        Ok(format!("Added: {}", title.trim()))
    }
}

struct OpenTasks {
    pool: PgPool,
}

#[async_trait]
impl ContextSource for OpenTasks {
    fn name(&self) -> &str {
        "tasks"
    }

    async fn context(&self, profile_id: &str) -> anyhow::Result<String> {
        let titles: Vec<String> = sqlx::query_scalar(
            "SELECT title FROM task_items WHERE profile_id = $1 AND NOT done ORDER BY id",
        )
        .bind(profile_id)
        .fetch_all(&self.pool)
        .await?;
        if titles.is_empty() {
            return Ok(String::new());
        }
        Ok(format!("OPEN TASKS\n- {}", titles.join("\n- ")))
    }
}

#[derive(Deserialize)]
struct ListQuery {
    profile: String,
}

async fn list_route(State(pool): State<PgPool>, Query(query): Query<ListQuery>) -> ApiResult<Value> {
    let rows: Vec<(i64, String, bool)> = sqlx::query_as(
        "SELECT id, title, done FROM task_items WHERE profile_id = $1 ORDER BY id",
    )
    .bind(&query.profile)
    .fetch_all(&pool)
    .await?;
    let tasks: Vec<Value> = rows
        .into_iter()
        .map(|(id, title, done)| json!({ "id": id, "title": title, "done": done }))
        .collect();
    Ok(Json(json!({ "tasks": tasks })))
}

fn installed_plugins() -> Vec<Arc<dyn Plugin>> {
    vec![
        Arc::new(CommonBill),
        Arc::new(CommonMemory),
        Arc::new(CommonDelegate),
        Arc::new(CommonTasks),
    ]
}

[plugins]
enabled = ["bill", "memory", "delegate", "tasks"]

[plugins.tasks]
max_open = 10