feat(sidebar): add last activity task sorting (#2762)
This commit is contained in:
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user