Carlos Florêncio
821 lines
32 KiB
Go
821 lines
32 KiB
Go
package sqlite
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
|
|
"github.com/kandev/kandev/internal/analytics/models"
|
|
"github.com/kandev/kandev/internal/db/dialect"
|
|
taskmodels "github.com/kandev/kandev/internal/task/models"
|
|
)
|
|
|
|
// Automation runs are hidden from human-facing surfaces by their origin rather
|
|
// than by is_ephemeral, so every aggregate here has to say so explicitly. Built
|
|
// from the same constant the task and office repositories build theirs from —
|
|
// spelling the literal out per query is how one of them gets missed.
|
|
const (
|
|
andNotAutomationOrigin = ` AND COALESCE(origin, '') != '` + taskmodels.TaskOriginAutomationRun + `'`
|
|
andNotAutomationOriginT = ` AND COALESCE(t.origin, '') != '` + taskmodels.TaskOriginAutomationRun + `'`
|
|
)
|
|
|
|
// parseTimeString parses time strings in various SQLite formats
|
|
func parseTimeString(s string) time.Time {
|
|
if s == "" {
|
|
return time.Time{}
|
|
}
|
|
// Try various common SQLite datetime formats
|
|
formats := []string{
|
|
time.RFC3339,
|
|
time.RFC3339Nano,
|
|
"2006-01-02 15:04:05",
|
|
"2006-01-02T15:04:05Z",
|
|
"2006-01-02T15:04:05.000Z",
|
|
"2006-01-02 15:04:05.000",
|
|
"2006-01-02T15:04:05",
|
|
}
|
|
for _, format := range formats {
|
|
if t, err := time.Parse(format, s); err == nil {
|
|
return t
|
|
}
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
// rangeStartArg turns a range boundary into a value the timestamp columns can
|
|
// actually be compared against, and into an untyped nil for an open-ended range
|
|
// so the `? IS NULL` arm of each predicate matches.
|
|
//
|
|
// It has to bind the time.Time rather than a formatted string. These columns are
|
|
// written by handing the driver a time.Time, which SQLite stores as
|
|
// "2006-01-02 15:04:05.999999999-07:00", and their TIMESTAMP declaration gives
|
|
// them NUMERIC affinity — a text bound parameter is never coerced, so `>=` is a
|
|
// plain string comparison. Formatting the boundary as RFC3339 put a "T" where
|
|
// every stored value has a space, and "T" sorts above " ", so rows dated on the
|
|
// boundary day compared below the threshold whatever their time: each range
|
|
// silently lost its first day.
|
|
func rangeStartArg(start *time.Time) any {
|
|
if start == nil {
|
|
return nil
|
|
}
|
|
return start.UTC()
|
|
}
|
|
|
|
func rangeStartPredicate(driver, column string) string {
|
|
return fmt.Sprintf("(%s IS NULL OR %s >= ?)", dialect.NullableTimestamp(driver, "?"), column)
|
|
}
|
|
|
|
// GetTaskStats retrieves aggregated statistics for tasks in a workspace.
|
|
func (r *Repository) GetTaskStats(
|
|
ctx context.Context,
|
|
workspaceID string,
|
|
start *time.Time,
|
|
limit int,
|
|
) ([]*models.TaskStats, error) {
|
|
startArg := rangeStartArg(start)
|
|
if limit <= 0 {
|
|
limit = 200
|
|
}
|
|
|
|
drv := r.ro.DriverName()
|
|
dur := dialect.DurationMs(drv, "turn.completed_at", "turn.started_at")
|
|
|
|
query := fmt.Sprintf(`
|
|
SELECT
|
|
t.id, t.title, t.workspace_id, t.workflow_id, t.state,
|
|
COALESCE(session_stats.session_count, 0) as session_count,
|
|
COALESCE(session_stats.turn_count, 0) as turn_count,
|
|
COALESCE(session_stats.message_count, 0) as message_count,
|
|
COALESCE(session_stats.user_message_count, 0) as user_message_count,
|
|
COALESCE(session_stats.tool_call_count, 0) as tool_call_count,
|
|
COALESCE(turn_stats.active_duration_ms, 0) as total_duration_ms,
|
|
COALESCE(turn_stats.active_duration_ms, 0) as active_duration_ms,
|
|
COALESCE(turn_stats.elapsed_span_ms, 0) as elapsed_span_ms,
|
|
t.created_at, session_stats.last_completed_at
|
|
FROM tasks t
|
|
LEFT JOIN (
|
|
SELECT s.task_id,
|
|
COUNT(DISTINCT s.id) as session_count,
|
|
COUNT(DISTINCT turn.id) as turn_count,
|
|
COUNT(DISTINCT msg.id) as message_count,
|
|
COUNT(DISTINCT CASE WHEN msg.author_type = 'user' THEN msg.id END) as user_message_count,
|
|
COUNT(DISTINCT CASE WHEN msg.type LIKE 'tool_%%' THEN msg.id END) as tool_call_count,
|
|
MAX(s.completed_at) as last_completed_at
|
|
FROM task_sessions s
|
|
LEFT JOIN task_session_turns turn ON turn.task_session_id = s.id
|
|
LEFT JOIN task_session_messages msg ON msg.task_session_id = s.id
|
|
WHERE `+rangeStartPredicate(drv, "s.started_at")+`
|
|
GROUP BY s.task_id
|
|
) session_stats ON session_stats.task_id = t.id
|
|
LEFT JOIN (
|
|
SELECT s.task_id,
|
|
SUM(CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END) as active_duration_ms,
|
|
%s as elapsed_span_ms
|
|
FROM task_sessions s
|
|
LEFT JOIN task_session_turns turn ON turn.task_session_id = s.id
|
|
WHERE `+rangeStartPredicate(drv, "s.started_at")+`
|
|
GROUP BY s.task_id
|
|
) turn_stats ON turn_stats.task_id = t.id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "t.created_at")+`
|
|
ORDER BY t.updated_at DESC
|
|
LIMIT ?
|
|
`, dur, dialect.DurationMs(
|
|
drv,
|
|
"MAX(CASE WHEN turn.completed_at IS NOT NULL THEN turn.completed_at END)",
|
|
"MIN(CASE WHEN turn.completed_at IS NOT NULL THEN turn.started_at END)",
|
|
))
|
|
|
|
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query),
|
|
startArg, startArg, startArg, startArg,
|
|
workspaceID, startArg, startArg, limit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
return r.scanTaskStats(rows)
|
|
}
|
|
|
|
func (r *Repository) scanTaskStats(rows *sql.Rows) ([]*models.TaskStats, error) {
|
|
var results []*models.TaskStats
|
|
for rows.Next() {
|
|
var stat models.TaskStats
|
|
var completedAtStr sql.NullString
|
|
var createdAtStr string
|
|
var totalDurationMs float64
|
|
var activeDurationMs float64
|
|
var elapsedSpanMs float64
|
|
err := rows.Scan(
|
|
&stat.TaskID, &stat.TaskTitle, &stat.WorkspaceID, &stat.WorkflowID, &stat.State,
|
|
&stat.SessionCount, &stat.TurnCount, &stat.MessageCount,
|
|
&stat.UserMessageCount, &stat.ToolCallCount, &totalDurationMs,
|
|
&activeDurationMs, &elapsedSpanMs,
|
|
&createdAtStr, &completedAtStr,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stat.TotalDurationMs = int64(totalDurationMs)
|
|
stat.ActiveDurationMs = int64(activeDurationMs)
|
|
stat.ElapsedSpanMs = int64(elapsedSpanMs)
|
|
stat.CreatedAt = parseTimeString(createdAtStr)
|
|
if completedAtStr.Valid && completedAtStr.String != "" {
|
|
parsedTime := parseTimeString(completedAtStr.String)
|
|
if !parsedTime.IsZero() {
|
|
stat.CompletedAt = &parsedTime
|
|
}
|
|
}
|
|
results = append(results, &stat)
|
|
}
|
|
return results, rows.Err()
|
|
}
|
|
|
|
// Outlier bounds for the "average turn size" metric. Determined empirically
|
|
// from prod data: durations under cleanTurnMinDurationMs are no-op/aborted
|
|
// turns and durations at or above cleanTurnMaxDurationMs are zombie turns
|
|
// whose completed_at was backfilled across an agent restart. Both classes
|
|
// badly skew the mean — excluding them drops avg duration from ~1062s to
|
|
// ~289s on a ~4k-turn sample. The duration filter is half-open
|
|
// [cleanTurnMinDurationMs, cleanTurnMaxDurationMs).
|
|
const (
|
|
cleanTurnMinDurationMs = 1000
|
|
cleanTurnMaxDurationMs = 3600000
|
|
cleanTurnMinMessages = 1
|
|
)
|
|
|
|
// GetGlobalStats retrieves workspace-wide aggregated statistics.
|
|
// Implemented as a single query over 5 CTEs (tasks, sessions, turns,
|
|
// clean_turn, messages). The four count/sum CTEs each scan their underlying
|
|
// table at most once per request; clean_turn additionally issues one
|
|
// index-only message-count subquery per qualifying turn (kept correlated to
|
|
// stay portable between the SQLite and Postgres dialects).
|
|
func (r *Repository) GetGlobalStats(ctx context.Context, workspaceID string, start *time.Time) (*models.GlobalStats, error) {
|
|
startArg := rangeStartArg(start)
|
|
|
|
drv := r.ro.DriverName()
|
|
dur := dialect.DurationMs(drv, "turn.completed_at", "turn.started_at")
|
|
|
|
query := fmt.Sprintf(`
|
|
WITH
|
|
task_agg AS (
|
|
SELECT
|
|
COUNT(*) AS total_tasks,
|
|
SUM(CASE WHEN t.archived_at IS NOT NULL
|
|
OR ws.position = (SELECT MAX(ws2.position) FROM workflow_steps ws2 WHERE ws2.workflow_id = ws.workflow_id)
|
|
THEN 1 ELSE 0 END) AS completed_tasks,
|
|
SUM(CASE WHEN t.state = 'IN_PROGRESS' AND t.archived_at IS NULL THEN 1 ELSE 0 END) AS in_progress_tasks
|
|
FROM tasks t
|
|
LEFT JOIN workflow_steps ws ON ws.id = t.workflow_step_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "t.created_at")+`
|
|
),
|
|
session_agg AS (
|
|
SELECT COUNT(*) AS total_sessions
|
|
FROM task_sessions s
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
),
|
|
turn_agg AS (
|
|
SELECT
|
|
COUNT(*) AS total_turns,
|
|
COALESCE(SUM(CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END), 0) AS total_duration_ms
|
|
FROM task_session_turns turn
|
|
JOIN task_sessions s ON s.id = turn.task_session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
),
|
|
clean_turn_agg AS (
|
|
SELECT
|
|
AVG(dur_ms) AS avg_turn_duration_ms,
|
|
AVG(msg_count) AS avg_messages_per_turn
|
|
FROM (
|
|
SELECT
|
|
%s AS dur_ms,
|
|
(SELECT COUNT(*) FROM task_session_messages m WHERE m.turn_id = turn.id) AS msg_count
|
|
FROM task_session_turns turn
|
|
JOIN task_sessions s ON s.id = turn.task_session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
AND turn.completed_at IS NOT NULL
|
|
) clean
|
|
WHERE dur_ms >= %d AND dur_ms < %d AND msg_count >= %d
|
|
),
|
|
message_agg AS (
|
|
SELECT
|
|
COUNT(*) AS total_messages,
|
|
SUM(CASE WHEN msg.author_type = 'user' THEN 1 ELSE 0 END) AS total_user_messages,
|
|
SUM(CASE WHEN msg.type LIKE 'tool_%%' THEN 1 ELSE 0 END) AS total_tool_calls
|
|
FROM task_session_messages msg
|
|
JOIN task_sessions s ON s.id = msg.task_session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
)
|
|
SELECT
|
|
task_agg.total_tasks, task_agg.completed_tasks, task_agg.in_progress_tasks,
|
|
session_agg.total_sessions,
|
|
turn_agg.total_turns,
|
|
message_agg.total_messages, message_agg.total_user_messages, message_agg.total_tool_calls,
|
|
turn_agg.total_duration_ms,
|
|
clean_turn_agg.avg_turn_duration_ms, clean_turn_agg.avg_messages_per_turn
|
|
FROM task_agg, session_agg, turn_agg, clean_turn_agg, message_agg
|
|
`, dur, dur, cleanTurnMinDurationMs, cleanTurnMaxDurationMs, cleanTurnMinMessages)
|
|
|
|
var stats models.GlobalStats
|
|
var totalDurationMs float64
|
|
var completedTasks, inProgressTasks sql.NullInt64
|
|
var userMessages, toolCalls sql.NullInt64
|
|
var avgTurnDurationMs, avgMessagesPerTurn sql.NullFloat64
|
|
err := r.ro.QueryRowContext(ctx, r.ro.Rebind(query),
|
|
workspaceID, startArg, startArg, // task_agg
|
|
workspaceID, startArg, startArg, // session_agg
|
|
workspaceID, startArg, startArg, // turn_agg
|
|
workspaceID, startArg, startArg, // clean_turn_agg
|
|
workspaceID, startArg, startArg, // message_agg
|
|
).Scan(
|
|
&stats.TotalTasks, &completedTasks, &inProgressTasks,
|
|
&stats.TotalSessions, &stats.TotalTurns,
|
|
&stats.TotalMessages, &userMessages, &toolCalls,
|
|
&totalDurationMs,
|
|
&avgTurnDurationMs, &avgMessagesPerTurn,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stats.CompletedTasks = int(completedTasks.Int64)
|
|
stats.InProgressTasks = int(inProgressTasks.Int64)
|
|
stats.TotalUserMessages = int(userMessages.Int64)
|
|
stats.TotalToolCalls = int(toolCalls.Int64)
|
|
stats.TotalDurationMs = int64(totalDurationMs)
|
|
stats.AvgTurnDurationMs = int64(avgTurnDurationMs.Float64)
|
|
stats.AvgMessagesPerTurn = avgMessagesPerTurn.Float64
|
|
|
|
if stats.TotalTasks > 0 {
|
|
stats.AvgTurnsPerTask = float64(stats.TotalTurns) / float64(stats.TotalTasks)
|
|
stats.AvgMessagesPerTask = float64(stats.TotalMessages) / float64(stats.TotalTasks)
|
|
stats.AvgDurationMsPerTask = stats.TotalDurationMs / int64(stats.TotalTasks)
|
|
}
|
|
|
|
return &stats, nil
|
|
}
|
|
|
|
// GetDailyActivity retrieves daily activity statistics for the last N days
|
|
func (r *Repository) GetDailyActivity(ctx context.Context, workspaceID string, days int) ([]*models.DailyActivity, error) {
|
|
drv := r.ro.DriverName()
|
|
dateStart := dialect.DateNowMinusDays(drv, "?")
|
|
datePlus := dialect.DatePlusOneDay(drv, "date")
|
|
curDate := dialect.CurrentDate(drv)
|
|
dateOfTurn := dialect.DateOf(drv, "turn.started_at")
|
|
dateOfMsg := dialect.DateOf(drv, "msg.created_at")
|
|
|
|
query := fmt.Sprintf(`
|
|
WITH RECURSIVE dates(date) AS (
|
|
SELECT %s
|
|
UNION ALL
|
|
SELECT %s FROM dates WHERE date < %s
|
|
)
|
|
SELECT
|
|
d.date,
|
|
COALESCE(activity.turn_count, 0) as turn_count,
|
|
COALESCE(activity.message_count, 0) as message_count,
|
|
COALESCE(activity.task_count, 0) as task_count
|
|
FROM dates d
|
|
LEFT JOIN (
|
|
SELECT
|
|
%s as activity_date,
|
|
COUNT(DISTINCT turn.id) as turn_count,
|
|
COUNT(DISTINCT msg.id) as message_count,
|
|
COUNT(DISTINCT t.id) as task_count
|
|
FROM task_session_turns turn
|
|
JOIN task_sessions s ON s.id = turn.task_session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
LEFT JOIN task_session_messages msg ON msg.task_session_id = s.id
|
|
AND %s = %s
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+`
|
|
GROUP BY %s
|
|
) activity ON activity.activity_date = d.date
|
|
ORDER BY d.date ASC
|
|
`, dateStart, datePlus, curDate, dateOfTurn, dateOfMsg, dateOfTurn, dateOfTurn)
|
|
|
|
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query), days-1, workspaceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var results []*models.DailyActivity
|
|
for rows.Next() {
|
|
var activity models.DailyActivity
|
|
if err := rows.Scan(&activity.Date, &activity.TurnCount, &activity.MessageCount, &activity.TaskCount); err != nil {
|
|
return nil, err
|
|
}
|
|
results = append(results, &activity)
|
|
}
|
|
|
|
return results, rows.Err()
|
|
}
|
|
|
|
// GetCompletedTaskActivity retrieves completed task counts for the last N days
|
|
func (r *Repository) GetCompletedTaskActivity(ctx context.Context, workspaceID string, days int) ([]*models.CompletedTaskActivity, error) {
|
|
drv := r.ro.DriverName()
|
|
dateStart := dialect.DateNowMinusDays(drv, "?")
|
|
datePlus := dialect.DatePlusOneDay(drv, "date")
|
|
curDate := dialect.CurrentDate(drv)
|
|
dateOfCompleted := dialect.DateOf(drv, "COALESCE(ts.completed_at, t.archived_at)")
|
|
|
|
query := fmt.Sprintf(`
|
|
WITH RECURSIVE dates(date) AS (
|
|
SELECT %s
|
|
UNION ALL
|
|
SELECT %s FROM dates WHERE date < %s
|
|
)
|
|
SELECT d.date, COALESCE(activity.completed_tasks, 0) as completed_tasks
|
|
FROM dates d
|
|
LEFT JOIN (
|
|
SELECT %s as activity_date, COUNT(DISTINCT t.id) as completed_tasks
|
|
FROM tasks t
|
|
LEFT JOIN workflow_steps ws ON ws.id = t.workflow_step_id
|
|
LEFT JOIN (
|
|
SELECT task_id, MAX(completed_at) as completed_at
|
|
FROM task_sessions WHERE completed_at IS NOT NULL GROUP BY task_id
|
|
) ts ON ts.task_id = t.id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+`
|
|
AND (t.archived_at IS NOT NULL
|
|
OR ws.position = (SELECT MAX(ws2.position) FROM workflow_steps ws2 WHERE ws2.workflow_id = ws.workflow_id))
|
|
AND COALESCE(ts.completed_at, t.archived_at) IS NOT NULL
|
|
GROUP BY %s
|
|
) activity ON activity.activity_date = d.date
|
|
ORDER BY d.date ASC
|
|
`, dateStart, datePlus, curDate, dateOfCompleted, dateOfCompleted)
|
|
|
|
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query), days-1, workspaceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var results []*models.CompletedTaskActivity
|
|
for rows.Next() {
|
|
var activity models.CompletedTaskActivity
|
|
if err := rows.Scan(&activity.Date, &activity.CompletedTasks); err != nil {
|
|
return nil, err
|
|
}
|
|
results = append(results, &activity)
|
|
}
|
|
|
|
return results, rows.Err()
|
|
}
|
|
|
|
// GetRepositoryStats retrieves aggregated statistics for repositories in a workspace
|
|
func (r *Repository) GetRepositoryStats(ctx context.Context, workspaceID string, start *time.Time) ([]*models.RepositoryStats, error) {
|
|
startArg := rangeStartArg(start)
|
|
|
|
query := buildRepositoryStatsQuery(r.ro.DriverName())
|
|
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query),
|
|
startArg, startArg, startArg, startArg,
|
|
startArg, startArg, startArg, startArg,
|
|
workspaceID,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var results []*models.RepositoryStats
|
|
for rows.Next() {
|
|
var stats models.RepositoryStats
|
|
var totalDurationMs float64
|
|
err := rows.Scan(
|
|
&stats.RepositoryID, &stats.RepositoryName,
|
|
&stats.TotalTasks, &stats.CompletedTasks, &stats.InProgressTasks,
|
|
&stats.SessionCount, &stats.TurnCount, &stats.MessageCount,
|
|
&stats.UserMessageCount, &stats.ToolCallCount, &totalDurationMs,
|
|
&stats.TotalCommits, &stats.TotalFilesChanged,
|
|
&stats.TotalInsertions, &stats.TotalDeletions,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stats.TotalDurationMs = int64(totalDurationMs)
|
|
results = append(results, &stats)
|
|
}
|
|
|
|
return results, rows.Err()
|
|
}
|
|
|
|
func buildRepositoryStatsQuery(drv string) string {
|
|
dur := dialect.DurationMs(drv, "turn.completed_at", "turn.started_at")
|
|
return fmt.Sprintf(`
|
|
SELECT
|
|
r.id, r.name,
|
|
COALESCE(task_stats.total_tasks, 0) as total_tasks,
|
|
COALESCE(task_stats.completed_tasks, 0) as completed_tasks,
|
|
COALESCE(task_stats.in_progress_tasks, 0) as in_progress_tasks,
|
|
COALESCE(session_stats.session_count, 0) as session_count,
|
|
COALESCE(session_stats.turn_count, 0) as turn_count,
|
|
COALESCE(session_stats.message_count, 0) as message_count,
|
|
COALESCE(session_stats.user_message_count, 0) as user_message_count,
|
|
COALESCE(session_stats.tool_call_count, 0) as tool_call_count,
|
|
COALESCE(duration_stats.total_duration_ms, 0) as total_duration_ms,
|
|
COALESCE(git_stats.total_commits, 0) as total_commits,
|
|
COALESCE(git_stats.total_files_changed, 0) as total_files_changed,
|
|
COALESCE(git_stats.total_insertions, 0) as total_insertions,
|
|
COALESCE(git_stats.total_deletions, 0) as total_deletions
|
|
FROM repositories r
|
|
LEFT JOIN (
|
|
SELECT tr.repository_id,
|
|
COUNT(DISTINCT t.id) as total_tasks,
|
|
COUNT(DISTINCT CASE WHEN ws.position = (SELECT MAX(ws2.position) FROM workflow_steps ws2 WHERE ws2.workflow_id = ws.workflow_id) THEN t.id END) as completed_tasks,
|
|
COUNT(DISTINCT CASE WHEN t.state = 'IN_PROGRESS' THEN t.id END) as in_progress_tasks
|
|
FROM task_repositories tr
|
|
JOIN tasks t ON t.id = tr.task_id
|
|
LEFT JOIN workflow_steps ws ON ws.id = t.workflow_step_id
|
|
WHERE t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "t.created_at")+`
|
|
GROUP BY tr.repository_id
|
|
) task_stats ON task_stats.repository_id = r.id
|
|
LEFT JOIN (
|
|
SELECT tr.repository_id,
|
|
COUNT(DISTINCT s.id) as session_count,
|
|
COUNT(DISTINCT turn.id) as turn_count,
|
|
COUNT(DISTINCT msg.id) as message_count,
|
|
COUNT(DISTINCT CASE WHEN msg.author_type = 'user' THEN msg.id END) as user_message_count,
|
|
COUNT(DISTINCT CASE WHEN msg.type LIKE 'tool_%%' THEN msg.id END) as tool_call_count
|
|
FROM task_repositories tr
|
|
JOIN tasks t ON t.id = tr.task_id
|
|
JOIN task_sessions s ON s.task_id = tr.task_id
|
|
LEFT JOIN task_session_turns turn ON turn.task_session_id = s.id
|
|
LEFT JOIN task_session_messages msg ON msg.task_session_id = s.id
|
|
WHERE t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
GROUP BY tr.repository_id
|
|
) session_stats ON session_stats.repository_id = r.id
|
|
LEFT JOIN (
|
|
SELECT tr.repository_id,
|
|
COALESCE(SUM(CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END), 0) as total_duration_ms
|
|
FROM task_repositories tr
|
|
JOIN tasks t ON t.id = tr.task_id
|
|
JOIN task_sessions s ON s.task_id = tr.task_id
|
|
LEFT JOIN task_session_turns turn ON turn.task_session_id = s.id
|
|
WHERE t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
GROUP BY tr.repository_id
|
|
) duration_stats ON duration_stats.repository_id = r.id
|
|
LEFT JOIN (
|
|
SELECT s.repository_id,
|
|
COUNT(DISTINCT c.id) as total_commits,
|
|
COALESCE(SUM(c.files_changed), 0) as total_files_changed,
|
|
COALESCE(SUM(c.insertions), 0) as total_insertions,
|
|
COALESCE(SUM(c.deletions), 0) as total_deletions
|
|
FROM task_session_commits c
|
|
JOIN task_sessions s ON s.id = c.session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.is_ephemeral = 0`+andNotAutomationOriginT+` AND s.repository_id != '' AND `+rangeStartPredicate(drv, "c.committed_at")+`
|
|
GROUP BY s.repository_id
|
|
) git_stats ON git_stats.repository_id = r.id
|
|
WHERE r.workspace_id = ? AND r.deleted_at IS NULL
|
|
ORDER BY total_duration_ms DESC, total_tasks DESC, r.name ASC
|
|
`, dur)
|
|
}
|
|
|
|
// GetModelUsage retrieves usage statistics per model.
|
|
//
|
|
// Grouping on the model itself is what keeps two ranges consistent. Grouping on
|
|
// the agent profile did not: a profile's snapshot name and model change every
|
|
// time the user reconfigures it, so the group spans several of them and the
|
|
// engine was free to label it from any row it liked — the same profile then
|
|
// reported a different model per range, and per run.
|
|
//
|
|
// Sessions whose snapshot records no model are skipped rather than collected
|
|
// under a blank label, mirroring how sessions with no agent profile were
|
|
// already left out.
|
|
func (r *Repository) GetModelUsage(ctx context.Context, workspaceID string, limit int, start *time.Time) ([]*models.ModelUsage, error) {
|
|
startArg := rangeStartArg(start)
|
|
|
|
drv := r.ro.DriverName()
|
|
dur := dialect.DurationMs(drv, "turn.completed_at", "turn.started_at")
|
|
jeModel := dialect.JSONExtract(drv, "s.agent_profile_snapshot", "model")
|
|
jeModelName := dialect.JSONExtract(drv, "s.agent_profile_snapshot", "model_name")
|
|
jeLLM := dialect.JSONExtract(drv, "s.agent_profile_snapshot", "llm")
|
|
|
|
query := fmt.Sprintf(`
|
|
WITH scoped AS (
|
|
SELECT
|
|
s.id,
|
|
COALESCE(%s, %s, %s, '') as model
|
|
FROM task_sessions s
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0`+andNotAutomationOriginT+` AND `+rangeStartPredicate(drv, "s.started_at")+`
|
|
)
|
|
SELECT
|
|
scoped.model,
|
|
COUNT(DISTINCT scoped.id) as session_count,
|
|
COUNT(DISTINCT turn.id) as turn_count,
|
|
COALESCE(SUM(CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END), 0) as total_duration_ms
|
|
FROM scoped
|
|
LEFT JOIN task_session_turns turn ON turn.task_session_id = scoped.id
|
|
WHERE scoped.model != ''
|
|
GROUP BY scoped.model
|
|
ORDER BY session_count DESC, turn_count DESC, scoped.model ASC
|
|
LIMIT ?
|
|
`, jeModel, jeModelName, jeLLM, dur)
|
|
|
|
rows, err := r.ro.QueryContext(ctx, r.ro.Rebind(query), workspaceID, startArg, startArg, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var results []*models.ModelUsage
|
|
for rows.Next() {
|
|
var usage models.ModelUsage
|
|
var totalDurationMs float64
|
|
err := rows.Scan(
|
|
&usage.Model, &usage.SessionCount, &usage.TurnCount, &totalDurationMs,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
usage.TotalDurationMs = int64(totalDurationMs)
|
|
results = append(results, &usage)
|
|
}
|
|
|
|
return results, rows.Err()
|
|
}
|
|
|
|
// GetGitStats retrieves aggregated git statistics for a workspace
|
|
func (r *Repository) GetGitStats(ctx context.Context, workspaceID string, start *time.Time) (*models.GitStats, error) {
|
|
startArg := rangeStartArg(start)
|
|
|
|
query := `
|
|
SELECT
|
|
COUNT(DISTINCT c.id) as total_commits,
|
|
COALESCE(SUM(c.files_changed), 0) as total_files_changed,
|
|
COALESCE(SUM(c.insertions), 0) as total_insertions,
|
|
COALESCE(SUM(c.deletions), 0) as total_deletions
|
|
FROM task_session_commits c
|
|
JOIN task_sessions s ON s.id = c.session_id
|
|
JOIN tasks t ON t.id = s.task_id
|
|
WHERE t.workspace_id = ? AND t.is_ephemeral = 0` + andNotAutomationOriginT + ` AND ` + rangeStartPredicate(r.ro.DriverName(), "c.committed_at") + `
|
|
`
|
|
|
|
var stats models.GitStats
|
|
err := r.ro.QueryRowContext(ctx, r.ro.Rebind(query), workspaceID, startArg, startArg).Scan(
|
|
&stats.TotalCommits, &stats.TotalFilesChanged,
|
|
&stats.TotalInsertions, &stats.TotalDeletions,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &stats, nil
|
|
}
|
|
|
|
// defaultSessionCodeStatsLimit bounds ListSessionCodeStats when the caller
|
|
// does not specify one, mirroring GetTaskStats' default page size.
|
|
const defaultSessionCodeStatsLimit = 500
|
|
|
|
// commitCaptureActivatedAtMetaKey mirrors the kandev_meta key
|
|
// task/repository/sqlite.migrateSessionCommitsDedupeAndActivation publishes
|
|
// (same literal string; this package has its own read-only handle onto the
|
|
// same database, and there is no shared cross-package helper for kandev_meta
|
|
// reads — every owning package re-embeds the literal query, matching the
|
|
// existing idiom in internal/persistence and internal/system/database).
|
|
const commitCaptureActivatedAtMetaKey = "commit_capture_activated_at"
|
|
|
|
// ListSessionCodeStats returns, per session, committed LOC (summed from
|
|
// task_session_commits) and PEAK pending-diff LOC (the largest single
|
|
// task_session_git_snapshots snapshot, not the latest — the latest snapshot
|
|
// is usually a clean tree after a commit, merge, or archive). This is the
|
|
// per-session line-of-code aggregation the kandev-plugin-agent-stats plugin
|
|
// used to compute by reading the SQLite file directly (see ADR 0043); the
|
|
// SQL here mirrors that plugin's sessionsQuery.
|
|
//
|
|
// lines_added_committed / lines_deleted_committed are NULL, not 0, for a
|
|
// session with no observed commit rows that started before
|
|
// commit_capture_activated_at (kandev_meta, published by
|
|
// task/repository/sqlite.migrateSessionCommitsDedupeAndActivation): capture
|
|
// wasn't running yet for that session, so zero cannot be told apart from
|
|
// unknown. A session with any observed commit, or one that started after
|
|
// activation, always gets a real sum (activation absent entirely — should
|
|
// not happen once boot has completed successfully — falls through to the
|
|
// pre-existing zero behavior via SQL's three-valued NULL comparison logic).
|
|
// Peak-pending is unrelated to this marker and is always a real int64.
|
|
//
|
|
// Portability: the committed-sum half of this query is plain SQL and works
|
|
// unchanged on both drivers. The peak-pending half must walk each snapshot's
|
|
// `files` JSON object (keyed by file path, see task/models.GitSnapshot.Files)
|
|
// to sum per-file additions/deletions — SQLite does this with json_each,
|
|
// Postgres with jsonb_each on the same object; peakPendingSnapshotSubquery
|
|
// branches on driver to build the equivalent fragment for each. Both paths
|
|
// are covered by SQLite unit tests here; the Postgres path is exercised by
|
|
// the ADR 0027-style env-gated Postgres suite (KANDEV_TEST_POSTGRES_DSN) at
|
|
// the task/repository layer for the underlying schema, not re-verified here
|
|
// against a live Postgres instance — if jsonb_each ever proves not to match
|
|
// SQLite's json_each semantics for this shape, guard the Postgres branch
|
|
// with a clear error instead of returning silently-wrong pending numbers.
|
|
func (r *Repository) ListSessionCodeStats(
|
|
ctx context.Context,
|
|
filter models.SessionCodeStatsFilter,
|
|
) ([]*models.SessionCodeStats, error) {
|
|
driver := r.ro.DriverName()
|
|
where, args := buildSessionCodeStatsFilter(filter)
|
|
// Exclude office config-mode tasks' sessions (internal bookkeeping, not
|
|
// plugin-visible work items) — the same exclusion Sessions().List applies
|
|
// via fetchTasksForWorkspaces' excludeConfig=true, so the Host data API's
|
|
// List and CodeStats reads cover the same session set.
|
|
where += " AND " + dialect.ExcludeConfigModePredicate(driver, "t.metadata")
|
|
// Automation runs are hidden from every human-facing surface by their
|
|
// origin; the Host data API is one, so a plugin must not see through it
|
|
// what the UI deliberately does not show.
|
|
where += andNotAutomationOriginT
|
|
// Compare normalized forms, not the raw text or a naive cast on either
|
|
// side. ts.started_at is a naive TIMESTAMP column (no embedded zone) that
|
|
// is always written as UTC wall-clock time (time.Now().UTC()) — use
|
|
// NaiveUTCTimestampOf, not DateTimeOf, or Postgres reinterprets it in the
|
|
// session's timezone GUC and silently shifts it. activation.value is text
|
|
// formatted via time.RFC3339Nano, which already carries an explicit "Z" —
|
|
// use DateTimeOf, which respects that embedded zone.
|
|
startedAtNormalized := dialect.NaiveUTCTimestampOf(driver, "ts.started_at")
|
|
activationNormalized := dialect.DateTimeOf(driver, "activation.value")
|
|
query := fmt.Sprintf(`
|
|
SELECT
|
|
ts.id AS session_id,
|
|
CASE
|
|
WHEN commit_stats.session_id IS NOT NULL THEN commit_stats.insertions
|
|
WHEN %[1]s < %[2]s THEN NULL
|
|
ELSE 0
|
|
END AS lines_added_committed,
|
|
CASE
|
|
WHEN commit_stats.session_id IS NOT NULL THEN commit_stats.deletions
|
|
WHEN %[1]s < %[2]s THEN NULL
|
|
ELSE 0
|
|
END AS lines_deleted_committed,
|
|
COALESCE(peak_stats.peak_additions, 0) AS lines_added_peak_pending,
|
|
COALESCE(peak_stats.peak_deletions, 0) AS lines_deleted_peak_pending
|
|
FROM task_sessions ts
|
|
JOIN tasks t ON t.id = ts.task_id
|
|
LEFT JOIN (
|
|
SELECT c.session_id,
|
|
SUM(c.insertions) AS insertions,
|
|
SUM(c.deletions) AS deletions
|
|
FROM task_session_commits c
|
|
GROUP BY c.session_id
|
|
) commit_stats ON commit_stats.session_id = ts.id
|
|
LEFT JOIN (%[3]s) peak_stats ON peak_stats.session_id = ts.id
|
|
LEFT JOIN kandev_meta activation ON activation.key = '%[4]s'
|
|
WHERE %[5]s
|
|
ORDER BY ts.started_at ASC, ts.id ASC
|
|
LIMIT ? OFFSET ?
|
|
`, startedAtNormalized, activationNormalized, peakPendingSnapshotSubquery(driver), commitCaptureActivatedAtMetaKey, where)
|
|
|
|
inQuery, inArgs, err := sqlx.In(query, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
inQuery = r.ro.Rebind(inQuery)
|
|
|
|
rows, err := r.ro.QueryContext(ctx, inQuery, inArgs...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
return scanSessionCodeStats(rows)
|
|
}
|
|
|
|
// buildSessionCodeStatsFilter turns a SessionCodeStatsFilter into a WHERE
|
|
// clause (against the ts/t aliases used by ListSessionCodeStats) and its
|
|
// positional args, including the trailing LIMIT/OFFSET values.
|
|
func buildSessionCodeStatsFilter(filter models.SessionCodeStatsFilter) (string, []any) {
|
|
var conds []string
|
|
var args []any
|
|
if len(filter.SessionIDs) > 0 {
|
|
conds = append(conds, "ts.id IN (?)")
|
|
args = append(args, filter.SessionIDs)
|
|
}
|
|
if len(filter.TaskIDs) > 0 {
|
|
conds = append(conds, "ts.task_id IN (?)")
|
|
args = append(args, filter.TaskIDs)
|
|
}
|
|
if len(filter.WorkspaceIDs) > 0 {
|
|
conds = append(conds, "t.workspace_id IN (?)")
|
|
args = append(args, filter.WorkspaceIDs)
|
|
}
|
|
if len(filter.States) > 0 {
|
|
conds = append(conds, "ts.state IN (?)")
|
|
args = append(args, filter.States)
|
|
}
|
|
where := "1 = 1"
|
|
if len(conds) > 0 {
|
|
where = strings.Join(conds, " AND ")
|
|
}
|
|
|
|
limit := filter.Limit
|
|
if limit <= 0 {
|
|
limit = defaultSessionCodeStatsLimit
|
|
}
|
|
offset := filter.Offset
|
|
if offset < 0 {
|
|
offset = 0
|
|
}
|
|
args = append(args, limit, offset)
|
|
|
|
return where, args
|
|
}
|
|
|
|
// scanSessionCodeStats reads all rows of a ListSessionCodeStats query result.
|
|
func scanSessionCodeStats(rows *sql.Rows) ([]*models.SessionCodeStats, error) {
|
|
var results []*models.SessionCodeStats
|
|
for rows.Next() {
|
|
var stat models.SessionCodeStats
|
|
if err := rows.Scan(
|
|
&stat.SessionID,
|
|
&stat.LinesAddedCommitted, &stat.LinesDeletedCommitted,
|
|
&stat.LinesAddedPeakPending, &stat.LinesDeletedPeakPending,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
results = append(results, &stat)
|
|
}
|
|
return results, rows.Err()
|
|
}
|
|
|
|
// peakPendingSnapshotSubquery returns a derived-table SELECT (session_id,
|
|
// peak_additions, peak_deletions) that finds, per session, the MAX single
|
|
// git-snapshot total across task_session_git_snapshots.files. additions and
|
|
// deletions are maximized independently (matching the source plugin), so the
|
|
// reported peak-additions and peak-deletions snapshots need not be the same
|
|
// snapshot.
|
|
func peakPendingSnapshotSubquery(drv string) string {
|
|
if dialect.IsPostgres(drv) {
|
|
return `
|
|
SELECT snap.session_id,
|
|
MAX(snap.additions) AS peak_additions,
|
|
MAX(snap.deletions) AS peak_deletions
|
|
FROM (
|
|
SELECT g.id AS snapshot_id, g.session_id,
|
|
SUM(COALESCE((f.jvalue->>'additions')::numeric, 0)) AS additions,
|
|
SUM(COALESCE((f.jvalue->>'deletions')::numeric, 0)) AS deletions
|
|
FROM task_session_git_snapshots g,
|
|
jsonb_each(g.files::jsonb) AS f(jkey, jvalue)
|
|
WHERE g.session_id IS NOT NULL
|
|
GROUP BY g.id, g.session_id
|
|
) snap
|
|
GROUP BY snap.session_id`
|
|
}
|
|
return `
|
|
SELECT snap.session_id,
|
|
MAX(snap.additions) AS peak_additions,
|
|
MAX(snap.deletions) AS peak_deletions
|
|
FROM (
|
|
SELECT g.id AS snapshot_id, g.session_id,
|
|
SUM(COALESCE(json_extract(f.value, '$.additions'), 0)) AS additions,
|
|
SUM(COALESCE(json_extract(f.value, '$.deletions'), 0)) AS deletions
|
|
FROM task_session_git_snapshots g, json_each(g.files) f
|
|
WHERE g.session_id IS NOT NULL
|
|
GROUP BY g.id, g.session_id
|
|
) snap
|
|
GROUP BY snap.session_id`
|
|
}
|