feat(sidebar): add last activity task sorting (#2762)

This commit is contained in:
Carlos Florêncio
2026-08-18 10:15:42 +01:00
committed by GitHub
parent 270ddbff8f
commit 704f652f30
74 changed files with 2525 additions and 162 deletions
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"strings"
"time"
"github.com/kandev/kandev/internal/task/statussummary"
@@ -67,6 +68,116 @@ func (r *Repository) LoadTaskStatusSummaries(ctx context.Context, taskIDs []stri
return result, nil
}
// LoadTaskLastActivity returns the latest bounded activity timestamp for each
// requested task. Every source is filtered by task ID inside its union branch
// so the batch remains scoped and does not scan unrelated task history.
func (r *Repository) LoadTaskLastActivity(ctx context.Context, taskIDs []string) (map[string]time.Time, error) {
result := make(map[string]time.Time, len(taskIDs))
if len(taskIDs) == 0 {
return result, nil
}
for _, chunk := range chunkIDs(taskIDs, sqliteMaxHostParams/6) {
placeholders, ids := buildInPlaceholders(chunk)
query := `
WITH activity AS (
SELECT id AS task_id, created_at AS activity_at
FROM tasks
WHERE id IN (` + placeholders + `)
UNION ALL
SELECT id AS task_id, updated_at AS activity_at
FROM tasks
WHERE id IN (` + placeholders + `)
UNION ALL
SELECT task_id, created_at AS activity_at
FROM task_session_messages
WHERE task_id IN (` + placeholders + `)
AND author_type = 'user'
UNION ALL
SELECT task_id, queued_at AS activity_at
FROM queued_messages
WHERE task_id IN (` + placeholders + `)
AND queued_by NOT IN ('agent', 'workflow', 'server')
UNION ALL
SELECT task_id, started_at AS activity_at
FROM task_session_turns
WHERE task_id IN (` + placeholders + `)
AND started_at IS NOT NULL
UNION ALL
SELECT task_id, completed_at AS activity_at
FROM task_session_turns
WHERE task_id IN (` + placeholders + `)
AND completed_at IS NOT NULL
)
SELECT task_id, MAX(activity_at) AS activity_at
FROM activity
GROUP BY task_id`
args := make([]interface{}, 0, len(ids)*6)
for range 6 {
args = append(args, ids...)
}
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query), args...)
if err != nil {
return nil, fmt.Errorf("load task last activity: %w", err)
}
for rows.Next() {
var (
taskID string
rawActivityAt interface{}
)
if err := rows.Scan(&taskID, &rawActivityAt); err != nil {
_ = rows.Close()
return nil, fmt.Errorf("scan task last activity: %w", err)
}
activityAt, err := parseTaskActivityTime(rawActivityAt)
if err != nil {
_ = rows.Close()
return nil, fmt.Errorf("parse task last activity %q: %w", taskID, err)
}
result[taskID] = activityAt
}
if err := rows.Err(); err != nil {
_ = rows.Close()
return nil, fmt.Errorf("read task last activity: %w", err)
}
_ = rows.Close()
}
return result, nil
}
func parseTaskActivityTime(value interface{}) (time.Time, error) {
switch value := value.(type) {
case time.Time:
return value, nil
case string:
return parseTaskActivityTimeString(value)
case []byte:
return parseTaskActivityTimeString(string(value))
default:
return time.Time{}, fmt.Errorf("unsupported timestamp type %T", value)
}
}
func parseTaskActivityTimeString(value string) (time.Time, error) {
if parsed, err := time.Parse(time.RFC3339Nano, value); err == nil {
return parsed, nil
}
if normalized := strings.Replace(value, " ", "T", 1); normalized != value {
if parsed, err := time.Parse(time.RFC3339Nano, normalized); err == nil {
return parsed, nil
}
}
for _, layout := range []string{
"2006-01-02 15:04:05.999999999",
"2006-01-02 15:04:05",
} {
if parsed, err := time.ParseInLocation(layout, value, time.UTC); err == nil {
return parsed, nil
}
}
return time.Time{}, fmt.Errorf("invalid timestamp %q", value)
}
// CompareAndUpdateTaskStatusSummary inserts a new row or replaces an older
// semantic value. The revision and semantic comparison live in the same SQL
// statement, so concurrent source observations cannot overwrite a newer row.
@@ -5,6 +5,8 @@ import (
"testing"
"time"
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/statussummary"
"github.com/kandev/kandev/internal/testutil"
)
@@ -53,3 +55,76 @@ func TestPostgresTaskStatusSummarySchemaReplay(t *testing.T) {
t.Fatalf("postgres summary = %#v", loaded["task-summary-postgres"])
}
}
func TestPostgresTaskLastActivityBatch(t *testing.T) {
db := testutil.OpenIsolatedPostgres(t, testutil.PostgresDSNFromEnv(t))
repo, err := NewWithDB(db, db, nil)
if err != nil {
t.Fatalf("initialize postgres schema: %v", err)
}
ctx := context.Background()
base := time.Date(2026, time.August, 17, 10, 0, 0, 0, time.UTC)
if _, err := db.Exec(db.Rebind(`
INSERT INTO tasks (id, workspace_id, title, created_at, updated_at)
VALUES (?, ?, ?, ?, ?)
`), "task-activity-postgres", "workspace-activity-postgres", "Postgres activity", base, base.Add(time.Hour)); err != nil {
t.Fatalf("seed postgres task: %v", err)
}
if err := repo.CreateTaskSession(ctx, &models.TaskSession{ID: "session-activity-postgres", TaskID: "task-activity-postgres"}); err != nil {
t.Fatalf("create postgres session: %v", err)
}
completedAt := base.Add(3 * time.Hour)
if err := repo.CreateTurn(ctx, &models.Turn{
ID: "turn-activity-postgres", TaskSessionID: "session-activity-postgres", TaskID: "task-activity-postgres",
StartedAt: base.Add(2 * time.Hour), CompletedAt: &completedAt,
}); err != nil {
t.Fatalf("create postgres turn: %v", err)
}
if err := repo.CreateMessage(ctx, &models.Message{
ID: "message-activity-postgres", TaskSessionID: "session-activity-postgres", TaskID: "task-activity-postgres",
TurnID: "turn-activity-postgres", AuthorType: models.MessageAuthorUser, Content: "prompt",
CreatedAt: base.Add(4 * time.Hour),
}); err != nil {
t.Fatalf("create postgres message: %v", err)
}
queueRepo, err := messagequeue.NewSQLiteRepository(db, db)
if err != nil {
t.Fatalf("initialize postgres queue repository: %v", err)
}
queuedAt := base.Add(5 * time.Hour)
queuedTarget := &messagequeue.QueuedMessage{
ID: "queued-activity-postgres-user-target", SessionID: "session-activity-postgres", TaskID: "task-activity-postgres",
Content: "queued target", QueuedAt: queuedAt.Add(-time.Minute), QueuedBy: "user-1",
}
if err := queueRepo.Insert(ctx, queuedTarget, 10); err != nil {
t.Fatalf("insert postgres queued target: %v", err)
}
queuedSource := &messagequeue.QueuedMessage{
ID: "queued-activity-postgres-user", SessionID: "session-activity-postgres", TaskID: "task-activity-postgres",
Content: "queued prompt", QueuedAt: queuedAt, QueuedBy: "user-1",
}
if err := queueRepo.Insert(ctx, queuedSource, 10); err != nil {
t.Fatalf("insert postgres queued prompt: %v", err)
}
merged, err := queueRepo.MergeIntoAbove(ctx, queuedSource.SessionID, queuedSource.ID, queuedSource.QueuedBy)
if err != nil {
t.Fatalf("merge postgres queued prompts: %v", err)
}
if merged == nil || !merged.QueuedAt.Equal(queuedAt) {
t.Fatalf("merged postgres queued activity = %#v, want %s", merged, queuedAt)
}
if err := queueRepo.Insert(ctx, &messagequeue.QueuedMessage{
ID: "queued-activity-postgres-agent", SessionID: "session-activity-postgres", TaskID: "task-activity-postgres",
Content: "queued agent prompt", QueuedAt: base.Add(6 * time.Hour), QueuedBy: messagequeue.QueuedByAgent,
}, 10); err != nil {
t.Fatalf("insert postgres queued agent prompt: %v", err)
}
got, err := repo.LoadTaskLastActivity(ctx, []string{"task-activity-postgres"})
if err != nil {
t.Fatalf("load postgres task activity: %v", err)
}
if gotAt, ok := got["task-activity-postgres"]; !ok || !gotAt.Equal(queuedAt) {
t.Fatalf("postgres activity = %v, %v; want %v", gotAt, ok, queuedAt)
}
}
@@ -10,6 +10,8 @@ import (
"github.com/jmoiron/sqlx"
dbutil "github.com/kandev/kandev/internal/db"
"github.com/kandev/kandev/internal/orchestrator/messagequeue"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/statussummary"
)
@@ -151,6 +153,145 @@ func TestTaskStatusSummaryBatchCompareAndUpdate(t *testing.T) {
}
}
func TestTaskLastActivityBatch(t *testing.T) {
repo, db := newTaskStatusSummaryTestRepo(t)
ctx := context.Background()
base := time.Date(2026, time.August, 17, 10, 0, 0, 0, time.UTC)
seedTaskAt := func(taskID string, createdAt, updatedAt time.Time) {
t.Helper()
if _, err := db.Exec(db.Rebind(`
INSERT INTO tasks (id, workspace_id, title, created_at, updated_at)
VALUES (?, ?, ?, ?, ?)
`), taskID, "workspace-activity", taskID, createdAt, updatedAt); err != nil {
t.Fatalf("seed task %q: %v", taskID, err)
}
}
seedTaskAt("task-activity-turn", base, base.Add(time.Hour))
seedTaskAt("task-activity-active", base.Add(2*time.Hour), base.Add(3*time.Hour))
seedTaskAt("task-activity-no-session", base.Add(4*time.Hour), base.Add(5*time.Hour))
seedTaskAt("task-activity-queued", base.Add(4*time.Hour), base.Add(5*time.Hour))
queueRepo, err := messagequeue.NewSQLiteRepository(db, db)
if err != nil {
t.Fatalf("initialize queue repository: %v", err)
}
queuedAt := base.Add(9 * time.Hour)
queuedTargetAt := queuedAt.Add(-time.Minute)
queuedTarget := &messagequeue.QueuedMessage{
ID: "queued-activity-user-target", SessionID: "session-activity-queued", TaskID: "task-activity-queued",
Content: "queued target", QueuedAt: queuedTargetAt, QueuedBy: "user-1",
}
if err := queueRepo.Insert(ctx, queuedTarget, 10); err != nil {
t.Fatalf("insert queued user target: %v", err)
}
queuedSource := &messagequeue.QueuedMessage{
ID: "queued-activity-user", SessionID: "session-activity-queued", TaskID: "task-activity-queued",
Content: "queued prompt", QueuedAt: queuedAt, QueuedBy: "user-1",
}
if err := queueRepo.Insert(ctx, queuedSource, 10); err != nil {
t.Fatalf("insert queued user prompt: %v", err)
}
merged, err := queueRepo.MergeIntoAbove(ctx, queuedSource.SessionID, queuedSource.ID, queuedSource.QueuedBy)
if err != nil {
t.Fatalf("merge queued user prompts: %v", err)
}
if merged == nil || !merged.QueuedAt.Equal(queuedAt) {
t.Fatalf("merged queued activity = %#v, want %s", merged, queuedAt)
}
if err := queueRepo.Insert(ctx, &messagequeue.QueuedMessage{
ID: "queued-activity-agent", SessionID: "session-activity-queued", TaskID: "task-activity-queued",
Content: "queued agent prompt", QueuedAt: base.Add(12 * time.Hour), QueuedBy: messagequeue.QueuedByAgent,
}, 10); err != nil {
t.Fatalf("insert queued agent prompt: %v", err)
}
for _, session := range []*models.TaskSession{
{ID: "session-activity-turn", TaskID: "task-activity-turn"},
{ID: "session-activity-active", TaskID: "task-activity-active"},
} {
if err := repo.CreateTaskSession(ctx, session); err != nil {
t.Fatalf("create session %q: %v", session.ID, err)
}
}
completedAt := base.Add(8 * time.Hour)
if err := repo.CreateTurn(ctx, &models.Turn{
ID: "turn-activity-completed",
TaskSessionID: "session-activity-turn",
TaskID: "task-activity-turn",
StartedAt: base.Add(6 * time.Hour),
CompletedAt: &completedAt,
}); err != nil {
t.Fatalf("create completed turn: %v", err)
}
if err := repo.CreateMessage(ctx, &models.Message{
ID: "message-activity-user",
TaskSessionID: "session-activity-turn",
TaskID: "task-activity-turn",
TurnID: "turn-activity-completed",
AuthorType: models.MessageAuthorUser,
Content: "user prompt",
CreatedAt: base.Add(7 * time.Hour),
}); err != nil {
t.Fatalf("create user message: %v", err)
}
if err := repo.CreateMessage(ctx, &models.Message{
ID: "message-activity-agent",
TaskSessionID: "session-activity-turn",
TaskID: "task-activity-turn",
TurnID: "turn-activity-completed",
AuthorType: models.MessageAuthorAgent,
Content: "agent output",
CreatedAt: base.Add(12 * time.Hour),
}); err != nil {
t.Fatalf("create agent message: %v", err)
}
if err := repo.CreateTurn(ctx, &models.Turn{
ID: "turn-activity-active",
TaskSessionID: "session-activity-active",
TaskID: "task-activity-active",
StartedAt: base.Add(10 * time.Hour),
}); err != nil {
t.Fatalf("create active turn: %v", err)
}
if err := repo.CreateMessage(ctx, &models.Message{
ID: "message-activity-agent-active",
TaskSessionID: "session-activity-active",
TaskID: "task-activity-active",
TurnID: "turn-activity-active",
AuthorType: models.MessageAuthorAgent,
Content: "streamed output",
CreatedAt: base.Add(11 * time.Hour),
}); err != nil {
t.Fatalf("create active agent message: %v", err)
}
got, err := repo.LoadTaskLastActivity(ctx, []string{
"task-activity-turn",
"task-activity-active",
"task-activity-no-session",
"task-activity-queued",
"missing-task",
})
if err != nil {
t.Fatalf("load task activity: %v", err)
}
want := map[string]time.Time{
"task-activity-turn": completedAt,
"task-activity-active": base.Add(10 * time.Hour),
"task-activity-no-session": base.Add(5 * time.Hour),
"task-activity-queued": queuedAt,
}
if len(got) != len(want) {
t.Fatalf("activity rows = %#v, want %#v", got, want)
}
for taskID, wantAt := range want {
gotAt, ok := got[taskID]
if !ok || !gotAt.Equal(wantAt) {
t.Errorf("activity[%q] = %v, %v; want %v", taskID, gotAt, ok, wantAt)
}
}
}
func TestTaskStatusSummaryConcurrentUpdatesRemainMonotonic(t *testing.T) {
repo, db := newTaskStatusSummaryTestRepo(t)
ctx := context.Background()