Skip to content

armgit / kanzo

Public Imported from GitHub
0

Self-hosted, sharable kanban for humans and agents. One 4.7 MB binary, 5 MB of RAM, 10 to 60 tokens per agent reply, starts in 3 ms, zero setup.

Create a task in one write, so agents can't take it before it's human

emanuele-emed5c82d8a258
diff --git a/src/mcp.rs b/src/mcp.rs
index b097789..7c68329 100644
--- a/src/mcp.rs
+++ b/src/mcp.rs
@@ -455,14 +455,11 @@ impl Kanzo {
) -> Result<CallToolResult, ErrorData> {
Ok(self
.run_for(&ext, move |ctx, store| {
- let project = ctx.project(store, args.project.as_deref())?;
- let status = args.status.map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty());
- let description = args.description.as_deref().unwrap_or("");
- let mut t = store.create_task_in(project.id, status.as_deref(), &args.title, description)?;
- if args.tags.is_some() || args.human.is_some() {
- t = store
- .update_task(t.id, TaskPatch { tags: args.tags, human: args.human, ..Default::default() })?;
- }
+ let CreateTaskArgs { title, description, project, tags, status, human } = args;
+ let project = ctx.project(store, project.as_deref())?;
+ let status = status.map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty());
+ let patch = TaskPatch { description, status, tags, human, ..Default::default() };
+ let t = store.create_task_in(project.id, &title, patch)?;
Ok(format!("Created {} in {}: {}", t.key(), t.status, t.title))
})
.await)
diff --git a/src/store.rs b/src/store.rs
index 689680d..bedda95 100644
--- a/src/store.rs
+++ b/src/store.rs
@@ -581,25 +581,23 @@ impl Store {
}
#[cfg(test)]
- pub fn create_task(&self, project_id: i64, title: &str, description: &str) -> Result<Task> {
- self.create_task_in(project_id, None, title, description)
+ pub fn create_task(&self, project: i64, title: &str, description: &str) -> Result<Task> {
+ self.create_task_in(project, title, TaskPatch { description: Some(description.into()), ..Default::default() })
}
- pub fn create_task_in(
- &self,
- project_id: i64,
- status: Option<&str>,
- title: &str,
- description: &str,
- ) -> Result<Task> {
+ // One write, or an agent could take a task before it's human. Uses description, status, tags, human.
+ pub fn create_task_in(&self, project_id: i64, title: &str, patch: TaskPatch) -> Result<Task> {
let title = clean_title(title)?;
- let status = status.unwrap_or(STATUSES[0]);
+ let status = patch.status.as_deref().unwrap_or(STATUSES[0]);
self.check_status(status)?;
+ let description = patch.description.as_deref().unwrap_or("").trim();
+ let tags = clean_tags(patch.tags.as_deref().unwrap_or("")).join(",");
let id = self.write(|c| {
let position = Self::end_of_column(c, status, 0)?;
c.execute(
- "INSERT INTO tasks (project_id, title, description, status, position) VALUES (?1, ?2, ?3, ?4, ?5)",
- params![project_id, title, description.trim(), status, position],
+ "INSERT INTO tasks (project_id, title, description, status, position, tags, human) \
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+ params![project_id, title, description, status, position, tags, patch.human.unwrap_or(false)],
)?;
Ok(c.last_insert_rowid())
})?;
@@ -1258,8 +1256,10 @@ mod tests {
let api = s.create_project("api", "", None).unwrap();
let web = s.create_project("web", "", None).unwrap();
s.create_task(web.id, "web first", "").unwrap();
- let human = s.create_task(api.id, "Call the bank", "").unwrap();
- assert!(s.update_task(human.id, TaskPatch { human: Some(true), ..Default::default() }).unwrap().human);
+ let changes = s.changes().unwrap();
+ let patch = TaskPatch { human: Some(true), tags: Some("Bug, bug".into()), ..Default::default() };
+ let human = s.create_task_in(api.id, "Call the bank", patch).unwrap();
+ assert!(human.human && human.tags == ["bug"] && s.changes().unwrap() == changes + 1, "all in one write");
s.create_task(api.id, "api first", "").unwrap();
s.create_task(api.id, "api second", "").unwrap();
@@ -1269,6 +1269,7 @@ mod tests {
assert_eq!(s.next_task(Some(api.id)).unwrap().unwrap().title, "api second");
assert!(s.next_task(Some(api.id)).unwrap().is_none());
assert_eq!(s.get_task(human.id).unwrap().status, "todo");
+ assert!(!s.update_task(human.id, TaskPatch { human: Some(false), ..Default::default() }).unwrap().human);
}
#[test]
@@ -1279,9 +1280,10 @@ mod tests {
let s = Store::open(&dir.path().join("kanzo.db"), None).unwrap();
assert_eq!(s.statuses(), ["backlog", "todo", "doing", "review", "done"]);
let api = s.create_project("api", "", None).unwrap();
- let backlog = s.create_task_in(api.id, Some("backlog"), "later", "").unwrap();
+ let status = |s: &str| TaskPatch { status: Some(s.into()), ..Default::default() };
+ let backlog = s.create_task_in(api.id, "later", status("backlog")).unwrap();
assert_eq!(backlog.status, "backlog");
- assert!(s.create_task_in(api.id, Some("nope"), "x", "").is_err());
+ assert!(s.create_task_in(api.id, "x", status("nope")).is_err());
assert_eq!(s.create_task(api.id, "now", "").unwrap().status, "todo");
let t = s.next_task(None).unwrap().unwrap();
diff --git a/src/web.rs b/src/web.rs
index 923a4fd..7245bbf 100644
--- a/src/web.rs
+++ b/src/web.rs
@@ -499,14 +499,13 @@ async fn delete_project(State(home): Shared, Path(slug): Path<String>) -> Respon
struct NewTask {
project: String,
title: String,
- #[serde(default)]
- description: String,
+ description: Option<String>,
}
async fn create_task(State(home): Shared, Json(t): Json<NewTask>) -> Response {
with_store(home, move |_, s| {
let project = s.find_project(&t.project)?;
- s.create_task_in(project.id, None, &t.title, &t.description)
+ s.create_task_in(project.id, &t.title, TaskPatch { description: t.description, ..Default::default() })
})
.await
}