mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-04-30 16:01:49 +08:00
e1c5e741ad
New `hermes kanban` CLI subcommand + `/kanban` slash command + skills for worker and orchestrator profiles. SQLite-backed task board (~/.hermes/kanban.db) shared across all profiles on the host. Zero changes to run_agent.py, no new core tools, no tool-schema bloat. Motivation: delegate_task is a function call — sync fork/join, anonymous subagent, no resumability, no human-in-the-loop. Kanban is the durable shape needed for research triage, scheduled ops, digital twins, engineering pipelines, and fleet work. They coexist (workers may call delegate_task internally). What this adds - hermes_cli/kanban_db.py — schema, CAS claim, dependency resolution, dispatcher, workspace resolution, worker-context builder. - hermes_cli/kanban.py — 15-verb CLI surface and shared run_slash() entry point used by both CLI and gateway. - skills/devops/kanban-worker — how a profile should work a claimed task. - skills/devops/kanban-orchestrator — "you are a dispatcher, not a worker" template with anti-temptation rules. - /kanban slash command wired into cli.py and gateway/run.py. Bypasses the running-agent guard (board writes don't touch agent state), so /kanban unblock can free a stuck worker mid-conversation. - Design spec at docs/hermes-kanban-v1-spec.pdf — comparative analysis vs Cline Kanban, Paperclip, NanoClaw, Gemini Enterprise; 8 patterns; 4 user stories; implementation plan; concurrency correctness. - Docs: website/docs/user-guide/features/kanban.md, CLI reference updated, sidebar entry added. Architecture highlights - Three planes: control (user + gateway), state (board + dispatcher), execution (pool of profile processes). - Every worker is a full OS process, spawned as `hermes -p <profile>`. No in-process subagent swarms — solves NanoClaw's SDK-lifecycle failure class. - Atomic claim via SQLite CAS in a BEGIN IMMEDIATE transaction; stale claims reclaimed 15 min after their TTL expires. - Tenant namespacing via one nullable column — one specialist fleet can serve many businesses with data isolation by workspace path. Tests: 60 targeted tests (schema, CAS atomicity, dependency resolution, dispatcher, workspace kinds, tenancy, CLI + slash surface). All pass hermetic via scripts/run_tests.sh.
211 lines
6.8 KiB
Python
211 lines
6.8 KiB
Python
"""Tests for the kanban CLI surface (hermes_cli.kanban)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from hermes_cli import kanban as kc
|
|
from hermes_cli import kanban_db as kb
|
|
|
|
|
|
@pytest.fixture
|
|
def kanban_home(tmp_path, monkeypatch):
|
|
home = tmp_path / ".hermes"
|
|
home.mkdir()
|
|
monkeypatch.setenv("HERMES_HOME", str(home))
|
|
monkeypatch.setattr(Path, "home", lambda: tmp_path)
|
|
kb.init_db()
|
|
return home
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Workspace flag parsing
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@pytest.mark.parametrize(
|
|
"value,expected",
|
|
[
|
|
("scratch", ("scratch", None)),
|
|
("worktree", ("worktree", None)),
|
|
("dir:/tmp/work", ("dir", "/tmp/work")),
|
|
],
|
|
)
|
|
def test_parse_workspace_flag_valid(value, expected):
|
|
assert kc._parse_workspace_flag(value) == expected
|
|
|
|
|
|
def test_parse_workspace_flag_expands_user():
|
|
kind, path = kc._parse_workspace_flag("dir:~/vault")
|
|
assert kind == "dir"
|
|
assert path.endswith("/vault")
|
|
assert not path.startswith("~")
|
|
|
|
|
|
@pytest.mark.parametrize("bad", ["cloud", "dir:", "", "worktree:/x"])
|
|
def test_parse_workspace_flag_rejects(bad):
|
|
if not bad:
|
|
# Empty -> defaults; not an error.
|
|
assert kc._parse_workspace_flag(bad) == ("scratch", None)
|
|
return
|
|
with pytest.raises(argparse.ArgumentTypeError):
|
|
kc._parse_workspace_flag(bad)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# run_slash smoke tests (end-to-end via the same entry both CLI and gateway use)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_run_slash_no_args_shows_usage(kanban_home):
|
|
out = kc.run_slash("")
|
|
assert "kanban" in out.lower()
|
|
assert "create" in out.lower() or "subcommand" in out.lower() or "action" in out.lower()
|
|
|
|
|
|
def test_run_slash_create_and_list(kanban_home):
|
|
out = kc.run_slash("create 'ship feature' --assignee alice")
|
|
assert "Created" in out
|
|
out = kc.run_slash("list")
|
|
assert "ship feature" in out
|
|
assert "alice" in out
|
|
|
|
|
|
def test_run_slash_create_with_parent_and_cascade(kanban_home):
|
|
# Parent then child via --parent
|
|
out1 = kc.run_slash("create 'parent' --assignee alice")
|
|
# Extract the "t_xxxx" id from "Created t_xxxx (ready, ...)"
|
|
import re
|
|
m = re.search(r"(t_[a-f0-9]+)", out1)
|
|
assert m
|
|
p = m.group(1)
|
|
out2 = kc.run_slash(f"create 'child' --assignee bob --parent {p}")
|
|
assert "todo" in out2 # child starts as todo
|
|
|
|
# Complete parent; list should promote child to ready
|
|
kc.run_slash(f"complete {p}")
|
|
# Explicit filter: child should now be ready (was todo before complete).
|
|
ready_list = kc.run_slash("list --status ready")
|
|
assert "child" in ready_list
|
|
|
|
|
|
def test_run_slash_show_includes_comments(kanban_home):
|
|
out = kc.run_slash("create 'x'")
|
|
import re
|
|
tid = re.search(r"(t_[a-f0-9]+)", out).group(1)
|
|
kc.run_slash(f"comment {tid} 'source is paywalled'")
|
|
show = kc.run_slash(f"show {tid}")
|
|
assert "source is paywalled" in show
|
|
|
|
|
|
def test_run_slash_block_unblock_cycle(kanban_home):
|
|
out = kc.run_slash("create 'x' --assignee alice")
|
|
import re
|
|
tid = re.search(r"(t_[a-f0-9]+)", out).group(1)
|
|
# Claim first so block() finds it running
|
|
kc.run_slash(f"claim {tid}")
|
|
assert "Blocked" in kc.run_slash(f"block {tid} 'need decision'")
|
|
assert "Unblocked" in kc.run_slash(f"unblock {tid}")
|
|
|
|
|
|
def test_run_slash_json_output(kanban_home):
|
|
out = kc.run_slash("create 'jsontask' --assignee alice --json")
|
|
payload = json.loads(out)
|
|
assert payload["title"] == "jsontask"
|
|
assert payload["assignee"] == "alice"
|
|
assert payload["status"] == "ready"
|
|
|
|
|
|
def test_run_slash_dispatch_dry_run_counts(kanban_home):
|
|
kc.run_slash("create 'a' --assignee alice")
|
|
kc.run_slash("create 'b' --assignee bob")
|
|
out = kc.run_slash("dispatch --dry-run")
|
|
assert "Spawned:" in out
|
|
|
|
|
|
def test_run_slash_context_output_format(kanban_home):
|
|
out = kc.run_slash("create 'tech spec' --assignee alice --body 'write an RFC'")
|
|
import re
|
|
tid = re.search(r"(t_[a-f0-9]+)", out).group(1)
|
|
kc.run_slash(f"comment {tid} 'remember to include performance section'")
|
|
ctx = kc.run_slash(f"context {tid}")
|
|
assert "tech spec" in ctx
|
|
assert "write an RFC" in ctx
|
|
assert "performance section" in ctx
|
|
|
|
|
|
def test_run_slash_tenant_filter(kanban_home):
|
|
kc.run_slash("create 'biz-a task' --tenant biz-a --assignee alice")
|
|
kc.run_slash("create 'biz-b task' --tenant biz-b --assignee alice")
|
|
a = kc.run_slash("list --tenant biz-a")
|
|
b = kc.run_slash("list --tenant biz-b")
|
|
assert "biz-a task" in a and "biz-b task" not in a
|
|
assert "biz-b task" in b and "biz-a task" not in b
|
|
|
|
|
|
def test_run_slash_usage_error_returns_message(kanban_home):
|
|
# Missing required argument for create
|
|
out = kc.run_slash("create")
|
|
assert "usage" in out.lower() or "error" in out.lower()
|
|
|
|
|
|
def test_run_slash_assign_reassigns(kanban_home):
|
|
out = kc.run_slash("create 'x' --assignee alice")
|
|
import re
|
|
tid = re.search(r"(t_[a-f0-9]+)", out).group(1)
|
|
assert "Assigned" in kc.run_slash(f"assign {tid} bob")
|
|
show = kc.run_slash(f"show {tid}")
|
|
assert "bob" in show
|
|
|
|
|
|
def test_run_slash_link_unlink(kanban_home):
|
|
a = kc.run_slash("create 'a'")
|
|
b = kc.run_slash("create 'b'")
|
|
import re
|
|
ta = re.search(r"(t_[a-f0-9]+)", a).group(1)
|
|
tb = re.search(r"(t_[a-f0-9]+)", b).group(1)
|
|
assert "Linked" in kc.run_slash(f"link {ta} {tb}")
|
|
# After link, b is todo
|
|
show = kc.run_slash(f"show {tb}")
|
|
assert "todo" in show
|
|
assert "Unlinked" in kc.run_slash(f"unlink {ta} {tb}")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Integration with the COMMAND_REGISTRY
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_kanban_is_resolvable():
|
|
from hermes_cli.commands import resolve_command
|
|
|
|
cmd = resolve_command("kanban")
|
|
assert cmd is not None
|
|
assert cmd.name == "kanban"
|
|
|
|
|
|
def test_kanban_bypasses_active_session_guard():
|
|
from hermes_cli.commands import should_bypass_active_session
|
|
|
|
assert should_bypass_active_session("kanban")
|
|
|
|
|
|
def test_kanban_in_autocomplete_table():
|
|
from hermes_cli.commands import COMMANDS, SUBCOMMANDS
|
|
|
|
assert "/kanban" in COMMANDS
|
|
subs = SUBCOMMANDS.get("/kanban") or []
|
|
assert "create" in subs
|
|
assert "dispatch" in subs
|
|
|
|
|
|
def test_kanban_not_gateway_only():
|
|
# kanban is available in BOTH CLI and gateway surfaces.
|
|
from hermes_cli.commands import COMMAND_REGISTRY
|
|
|
|
cmd = next(c for c in COMMAND_REGISTRY if c.name == "kanban")
|
|
assert not cmd.cli_only
|
|
assert not cmd.gateway_only
|