Files
kandev/apps/backend/internal/office/repository/sqlite/tree_holds.go
T
2026-05-16 20:07:57 +01:00

289 lines
8.4 KiB
Go

package sqlite
import (
"context"
"database/sql"
"fmt"
"strings"
"time"
"github.com/google/uuid"
"github.com/kandev/kandev/internal/office/models"
)
func (r *Repository) createTreeHoldTables() error {
_, err := r.db.Exec(`
CREATE TABLE IF NOT EXISTS office_task_tree_holds (
id TEXT PRIMARY KEY,
workspace_id TEXT NOT NULL,
root_task_id TEXT NOT NULL,
mode TEXT NOT NULL,
release_policy TEXT NOT NULL DEFAULT '{"strategy":"manual"}',
released_at DATETIME,
released_by TEXT DEFAULT '',
released_reason TEXT DEFAULT '',
created_at DATETIME NOT NULL,
FOREIGN KEY (root_task_id) REFERENCES tasks(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS office_task_tree_hold_members (
hold_id TEXT NOT NULL,
task_id TEXT NOT NULL,
depth INTEGER NOT NULL,
task_status TEXT NOT NULL DEFAULT '',
skip_reason TEXT NOT NULL DEFAULT '',
PRIMARY KEY (hold_id, task_id),
FOREIGN KEY (hold_id) REFERENCES office_task_tree_holds(id) ON DELETE CASCADE,
FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
);
CREATE INDEX IF NOT EXISTS idx_tree_holds_root_mode ON office_task_tree_holds(root_task_id, mode, released_at);
CREATE INDEX IF NOT EXISTS idx_tree_hold_members_task ON office_task_tree_hold_members(task_id);
`)
return err
}
func (r *Repository) FindSubtree(ctx context.Context, rootTaskID string) ([]models.SubtreeMember, error) {
var members []models.SubtreeMember
err := r.ro.SelectContext(ctx, &members, r.ro.Rebind(`
WITH RECURSIVE subtree(id, depth) AS (
SELECT id, 0 FROM tasks WHERE id = ?
UNION ALL
SELECT t.id, s.depth + 1
FROM tasks t JOIN subtree s ON t.parent_id = s.id
WHERE t.archived_at IS NULL
)
SELECT id, depth FROM subtree ORDER BY depth, id
`), rootTaskID)
if err != nil {
return nil, err
}
if members == nil {
members = []models.SubtreeMember{}
}
return members, nil
}
func (r *Repository) CreateTreeHold(ctx context.Context, hold *models.TreeHold) error {
if hold.ID == "" {
hold.ID = uuid.New().String()
}
if hold.ReleasePolicy == "" {
hold.ReleasePolicy = `{"strategy":"manual"}`
}
hold.CreatedAt = time.Now().UTC()
_, err := r.db.ExecContext(ctx, r.db.Rebind(`
INSERT INTO office_task_tree_holds (
id, workspace_id, root_task_id, mode, release_policy,
released_at, released_by, released_reason, created_at
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
`), hold.ID, hold.WorkspaceID, hold.RootTaskID, hold.Mode, hold.ReleasePolicy,
hold.ReleasedAt, hold.ReleasedBy, hold.ReleasedReason, hold.CreatedAt)
return err
}
func (r *Repository) CreateTreeHoldMembers(
ctx context.Context,
holdID string,
members []models.TreeHoldMember,
) error {
tx, err := r.db.BeginTxx(ctx, nil)
if err != nil {
return err
}
defer func() { _ = tx.Rollback() }()
stmt, err := tx.PreparexContext(ctx, r.db.Rebind(`
INSERT INTO office_task_tree_hold_members (
hold_id, task_id, depth, task_status, skip_reason
) VALUES (?, ?, ?, ?, ?)
`))
if err != nil {
return err
}
defer func() { _ = stmt.Close() }()
for _, m := range members {
if _, err := stmt.ExecContext(ctx, holdID, m.TaskID, m.Depth, m.TaskStatus, m.SkipReason); err != nil {
return err
}
}
return tx.Commit()
}
func (r *Repository) GetActiveHold(ctx context.Context, rootTaskID, mode string) (*models.TreeHold, error) {
var hold models.TreeHold
err := r.ro.QueryRowxContext(ctx, r.ro.Rebind(`
SELECT * FROM office_task_tree_holds
WHERE root_task_id = ? AND mode = ? AND released_at IS NULL
ORDER BY created_at DESC
LIMIT 1
`), rootTaskID, mode).StructScan(&hold)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return &hold, nil
}
func (r *Repository) GetActiveHoldForMember(ctx context.Context, taskID string) (*models.TreeHold, error) {
var hold models.TreeHold
err := r.ro.QueryRowxContext(ctx, r.ro.Rebind(`
SELECT h.* FROM office_task_tree_holds h
JOIN office_task_tree_hold_members m ON m.hold_id = h.id
WHERE m.task_id = ? AND h.released_at IS NULL
ORDER BY h.created_at DESC
LIMIT 1
`), taskID).StructScan(&hold)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return &hold, nil
}
func (r *Repository) ReleaseHold(ctx context.Context, holdID, releasedBy, reason string) error {
_, err := r.db.ExecContext(ctx, r.db.Rebind(`
UPDATE office_task_tree_holds
SET released_at = ?, released_by = ?, released_reason = ?
WHERE id = ? AND released_at IS NULL
`), time.Now().UTC(), releasedBy, reason, holdID)
return err
}
func (r *Repository) ListHoldMembers(ctx context.Context, holdID string) ([]models.TreeHoldMember, error) {
var members []models.TreeHoldMember
err := r.ro.SelectContext(ctx, &members, r.ro.Rebind(`
SELECT * FROM office_task_tree_hold_members
WHERE hold_id = ?
ORDER BY depth, task_id
`), holdID)
if err != nil {
return nil, err
}
if members == nil {
members = []models.TreeHoldMember{}
}
return members, nil
}
func (r *Repository) PreviewSubtree(ctx context.Context, rootTaskID string) ([]*models.TreePreviewTask, error) {
var tasks []*models.TreePreviewTask
err := r.ro.SelectContext(ctx, &tasks, r.ro.Rebind(`
WITH RECURSIVE subtree(id, depth) AS (
SELECT id, 0 FROM tasks WHERE id = ?
UNION ALL
SELECT t.id, s.depth + 1
FROM tasks t JOIN subtree s ON t.parent_id = s.id
WHERE t.archived_at IS NULL
)
SELECT t.id, COALESCE(t.title, '') AS title, COALESCE(t.state, '') AS status, s.depth
FROM subtree s JOIN tasks t ON t.id = s.id
ORDER BY s.depth, t.id
`), rootTaskID)
if err != nil {
return nil, err
}
if tasks == nil {
tasks = []*models.TreePreviewTask{}
}
return tasks, nil
}
func (r *Repository) CountActiveRunsForTasks(ctx context.Context, taskIDs []string) (int, error) {
if len(taskIDs) == 0 {
return 0, nil
}
query, args := taskIDInQuery(`
SELECT COUNT(*) FROM runs
WHERE status IN ('queued', 'claimed')
AND json_extract(payload, '$.task_id') IN (%s)
`, taskIDs)
var count int
err := r.ro.QueryRowxContext(ctx, r.ro.Rebind(query), args...).Scan(&count)
return count, err
}
func (r *Repository) CancelRunsForTasks(ctx context.Context, taskIDs []string, reason string) (int, error) {
if len(taskIDs) == 0 {
return 0, nil
}
query, args := taskIDInQuery(`
UPDATE runs
SET status = 'cancelled', cancel_reason = ?, finished_at = ?
WHERE status IN ('queued', 'claimed')
AND json_extract(payload, '$.task_id') IN (%s)
`, taskIDs)
args = append([]interface{}{reason, time.Now().UTC()}, args...)
res, err := r.db.ExecContext(ctx, r.db.Rebind(query), args...)
if err != nil {
return 0, err
}
rows, _ := res.RowsAffected()
return int(rows), nil
}
func (r *Repository) BulkUpdateTaskState(ctx context.Context, taskIDs []string, state string) error {
if len(taskIDs) == 0 {
return nil
}
query, args := taskIDInQuery(`UPDATE tasks SET state = ?, updated_at = CURRENT_TIMESTAMP WHERE id IN (%s)`, taskIDs)
args = append([]interface{}{state}, args...)
_, err := r.db.ExecContext(ctx, r.db.Rebind(query), args...)
return err
}
func (r *Repository) BulkReleaseTaskCheckout(ctx context.Context, taskIDs []string) error {
if len(taskIDs) == 0 {
return nil
}
query, args := taskIDInQuery(`
UPDATE tasks SET checkout_agent_id = '', checkout_at = NULL, updated_at = CURRENT_TIMESTAMP
WHERE id IN (%s)
`, taskIDs)
_, err := r.db.ExecContext(ctx, r.db.Rebind(query), args...)
return err
}
func (r *Repository) GetSubtreeCostSummary(
ctx context.Context,
rootTaskID string,
) (*models.SubtreeCostSummary, error) {
var summary models.SubtreeCostSummary
err := r.ro.QueryRowxContext(ctx, r.ro.Rebind(`
WITH RECURSIVE subtree(id) AS (
SELECT id FROM tasks WHERE id = ?
UNION ALL
SELECT t.id FROM tasks t JOIN subtree s ON t.parent_id = s.id
WHERE t.archived_at IS NULL
)
SELECT
COUNT(DISTINCT t.id) AS task_count,
COALESCE(SUM(e.cost_subcents), 0) AS cost_subcents,
COALESCE(SUM(e.tokens_in), 0) AS tokens_in,
COALESCE(SUM(e.tokens_cached_in), 0) AS tokens_cached_in,
COALESCE(SUM(e.tokens_out), 0) AS tokens_out
FROM subtree t
LEFT JOIN office_cost_events e ON e.task_id = t.id
`), rootTaskID).StructScan(&summary)
if err != nil {
return nil, err
}
summary.RootTaskID = rootTaskID
summary.IncludeDescendants = true
return &summary, nil
}
func taskIDInQuery(template string, taskIDs []string) (string, []interface{}) {
placeholders := make([]string, len(taskIDs))
args := make([]interface{}, len(taskIDs))
for i, id := range taskIDs {
placeholders[i] = "?"
args[i] = id
}
return fmt.Sprintf(template, strings.Join(placeholders, ",")), args
}