Hein
91239bcf4b
Some checks failed
CI / build-and-test (push) Failing after -31m12s
All internal entity lookups now use bigserial primary keys (int64) while GUIDs are retained for external/public identification. Updated store functions (TouchProject, UpdateThoughtMetadata, AddThoughtAttachment) to query by id instead of guid, added GetThoughtByID, changed semanticSearch and all tool helpers to use *int64 project IDs, and updated retry/backfill workers to use int64 thought IDs throughout.
355 lines
11 KiB
Go
355 lines
11 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"git.warky.dev/wdevs/amcs/internal/generatedmodels"
|
|
ext "git.warky.dev/wdevs/amcs/internal/types"
|
|
)
|
|
|
|
// Agent Skills
|
|
|
|
func (db *DB) AddSkill(ctx context.Context, skill ext.AgentSkill) (ext.AgentSkill, error) {
|
|
if skill.Tags == nil {
|
|
skill.Tags = []string{}
|
|
}
|
|
row := db.pool.QueryRow(ctx, `
|
|
insert into agent_skills (name, description, content, tags)
|
|
values ($1, $2, $3, $4)
|
|
returning id, guid, created_at, updated_at
|
|
`, skill.Name, skill.Description, skill.Content, skill.Tags)
|
|
|
|
created := skill
|
|
var model generatedmodels.ModelPublicAgentSkills
|
|
if err := row.Scan(&model.ID, &model.GUID, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return ext.AgentSkill{}, fmt.Errorf("insert agent skill: %w", err)
|
|
}
|
|
created.ID = model.ID.Int64()
|
|
created.GUID = model.GUID.UUID()
|
|
created.CreatedAt = model.CreatedAt.Time()
|
|
created.UpdatedAt = model.UpdatedAt.Time()
|
|
return created, nil
|
|
}
|
|
|
|
func (db *DB) RemoveSkill(ctx context.Context, id int64) error {
|
|
tag, err := db.pool.Exec(ctx, `delete from agent_skills where id = $1`, id)
|
|
if err != nil {
|
|
return fmt.Errorf("delete agent skill: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("skill not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) ListSkills(ctx context.Context, tag string) ([]ext.AgentSkill, error) {
|
|
q := `select id, name, description, content, tags::text[], created_at, updated_at from agent_skills`
|
|
args := []any{}
|
|
if t := strings.TrimSpace(tag); t != "" {
|
|
args = append(args, t)
|
|
q += fmt.Sprintf(" where $%d = any(tags)", len(args))
|
|
}
|
|
q += " order by name"
|
|
|
|
rows, err := db.pool.Query(ctx, q, args...)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list agent skills: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var skills []ext.AgentSkill
|
|
for rows.Next() {
|
|
var model generatedmodels.ModelPublicAgentSkills
|
|
var tags []string
|
|
if err := rows.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return nil, fmt.Errorf("scan agent skill: %w", err)
|
|
}
|
|
s := ext.AgentSkill{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if s.Tags == nil {
|
|
s.Tags = []string{}
|
|
}
|
|
skills = append(skills, s)
|
|
}
|
|
return skills, rows.Err()
|
|
}
|
|
|
|
func (db *DB) GetSkill(ctx context.Context, id int64) (ext.AgentSkill, error) {
|
|
row := db.pool.QueryRow(ctx, `
|
|
select id, name, description, content, tags::text[], created_at, updated_at
|
|
from agent_skills where id = $1
|
|
`, id)
|
|
|
|
var model generatedmodels.ModelPublicAgentSkills
|
|
var tags []string
|
|
if err := row.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return ext.AgentSkill{}, fmt.Errorf("get agent skill: %w", err)
|
|
}
|
|
s := ext.AgentSkill{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if s.Tags == nil {
|
|
s.Tags = []string{}
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// Agent Guardrails
|
|
|
|
func (db *DB) AddGuardrail(ctx context.Context, g ext.AgentGuardrail) (ext.AgentGuardrail, error) {
|
|
if g.Tags == nil {
|
|
g.Tags = []string{}
|
|
}
|
|
if g.Severity == "" {
|
|
g.Severity = "medium"
|
|
}
|
|
row := db.pool.QueryRow(ctx, `
|
|
insert into agent_guardrails (name, description, content, severity, tags)
|
|
values ($1, $2, $3, $4, $5)
|
|
returning id, guid, created_at, updated_at
|
|
`, g.Name, g.Description, g.Content, g.Severity, g.Tags)
|
|
|
|
created := g
|
|
var model generatedmodels.ModelPublicAgentGuardrails
|
|
if err := row.Scan(&model.ID, &model.GUID, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return ext.AgentGuardrail{}, fmt.Errorf("insert agent guardrail: %w", err)
|
|
}
|
|
created.ID = model.ID.Int64()
|
|
created.GUID = model.GUID.UUID()
|
|
created.CreatedAt = model.CreatedAt.Time()
|
|
created.UpdatedAt = model.UpdatedAt.Time()
|
|
return created, nil
|
|
}
|
|
|
|
func (db *DB) RemoveGuardrail(ctx context.Context, id int64) error {
|
|
tag, err := db.pool.Exec(ctx, `delete from agent_guardrails where id = $1`, id)
|
|
if err != nil {
|
|
return fmt.Errorf("delete agent guardrail: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("guardrail not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) ListGuardrails(ctx context.Context, tag, severity string) ([]ext.AgentGuardrail, error) {
|
|
args := []any{}
|
|
conditions := []string{}
|
|
|
|
if t := strings.TrimSpace(tag); t != "" {
|
|
args = append(args, t)
|
|
conditions = append(conditions, fmt.Sprintf("$%d = any(tags)", len(args)))
|
|
}
|
|
if s := strings.TrimSpace(severity); s != "" {
|
|
args = append(args, s)
|
|
conditions = append(conditions, fmt.Sprintf("severity = $%d", len(args)))
|
|
}
|
|
|
|
q := `select id, name, description, content, severity, tags::text[], created_at, updated_at from agent_guardrails`
|
|
if len(conditions) > 0 {
|
|
q += " where " + strings.Join(conditions, " and ")
|
|
}
|
|
q += " order by name"
|
|
|
|
rows, err := db.pool.Query(ctx, q, args...)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list agent guardrails: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var guardrails []ext.AgentGuardrail
|
|
for rows.Next() {
|
|
var model generatedmodels.ModelPublicAgentGuardrails
|
|
var tags []string
|
|
if err := rows.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &model.Severity, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return nil, fmt.Errorf("scan agent guardrail: %w", err)
|
|
}
|
|
g := ext.AgentGuardrail{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Severity: model.Severity.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if g.Tags == nil {
|
|
g.Tags = []string{}
|
|
}
|
|
guardrails = append(guardrails, g)
|
|
}
|
|
return guardrails, rows.Err()
|
|
}
|
|
|
|
func (db *DB) GetGuardrail(ctx context.Context, id int64) (ext.AgentGuardrail, error) {
|
|
row := db.pool.QueryRow(ctx, `
|
|
select id, name, description, content, severity, tags::text[], created_at, updated_at
|
|
from agent_guardrails where id = $1
|
|
`, id)
|
|
|
|
var model generatedmodels.ModelPublicAgentGuardrails
|
|
var tags []string
|
|
if err := row.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &model.Severity, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return ext.AgentGuardrail{}, fmt.Errorf("get agent guardrail: %w", err)
|
|
}
|
|
g := ext.AgentGuardrail{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Severity: model.Severity.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if g.Tags == nil {
|
|
g.Tags = []string{}
|
|
}
|
|
return g, nil
|
|
}
|
|
|
|
// Project Skills
|
|
|
|
func (db *DB) AddProjectSkill(ctx context.Context, projectID, skillID int64) error {
|
|
_, err := db.pool.Exec(ctx, `
|
|
insert into project_skills (project_id, skill_id)
|
|
values ($1, $2)
|
|
on conflict do nothing
|
|
`, projectID, skillID)
|
|
if err != nil {
|
|
return fmt.Errorf("add project skill: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) RemoveProjectSkill(ctx context.Context, projectID, skillID int64) error {
|
|
tag, err := db.pool.Exec(ctx, `
|
|
delete from project_skills where project_id = $1 and skill_id = $2
|
|
`, projectID, skillID)
|
|
if err != nil {
|
|
return fmt.Errorf("remove project skill: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("project skill link not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) ListProjectSkills(ctx context.Context, projectID int64) ([]ext.AgentSkill, error) {
|
|
rows, err := db.pool.Query(ctx, `
|
|
select s.id, s.name, s.description, s.content, s.tags::text[], s.created_at, s.updated_at
|
|
from agent_skills s
|
|
join project_skills ps on ps.skill_id = s.id
|
|
where ps.project_id = $1
|
|
order by s.name
|
|
`, projectID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list project skills: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var skills []ext.AgentSkill
|
|
for rows.Next() {
|
|
var model generatedmodels.ModelPublicAgentSkills
|
|
var tags []string
|
|
if err := rows.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return nil, fmt.Errorf("scan project skill: %w", err)
|
|
}
|
|
s := ext.AgentSkill{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if s.Tags == nil {
|
|
s.Tags = []string{}
|
|
}
|
|
skills = append(skills, s)
|
|
}
|
|
return skills, rows.Err()
|
|
}
|
|
|
|
// Project Guardrails
|
|
|
|
func (db *DB) AddProjectGuardrail(ctx context.Context, projectID, guardrailID int64) error {
|
|
_, err := db.pool.Exec(ctx, `
|
|
insert into project_guardrails (project_id, guardrail_id)
|
|
values ($1, $2)
|
|
on conflict do nothing
|
|
`, projectID, guardrailID)
|
|
if err != nil {
|
|
return fmt.Errorf("add project guardrail: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) RemoveProjectGuardrail(ctx context.Context, projectID, guardrailID int64) error {
|
|
tag, err := db.pool.Exec(ctx, `
|
|
delete from project_guardrails where project_id = $1 and guardrail_id = $2
|
|
`, projectID, guardrailID)
|
|
if err != nil {
|
|
return fmt.Errorf("remove project guardrail: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("project guardrail link not found")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (db *DB) ListProjectGuardrails(ctx context.Context, projectID int64) ([]ext.AgentGuardrail, error) {
|
|
rows, err := db.pool.Query(ctx, `
|
|
select g.id, g.name, g.description, g.content, g.severity, g.tags::text[], g.created_at, g.updated_at
|
|
from agent_guardrails g
|
|
join project_guardrails pg on pg.guardrail_id = g.id
|
|
where pg.project_id = $1
|
|
order by g.name
|
|
`, projectID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list project guardrails: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var guardrails []ext.AgentGuardrail
|
|
for rows.Next() {
|
|
var model generatedmodels.ModelPublicAgentGuardrails
|
|
var tags []string
|
|
if err := rows.Scan(&model.ID, &model.Name, &model.Description, &model.Content, &model.Severity, &tags, &model.CreatedAt, &model.UpdatedAt); err != nil {
|
|
return nil, fmt.Errorf("scan project guardrail: %w", err)
|
|
}
|
|
g := ext.AgentGuardrail{
|
|
ID: model.ID.Int64(),
|
|
Name: model.Name.String(),
|
|
Description: model.Description.String(),
|
|
Content: model.Content.String(),
|
|
Severity: model.Severity.String(),
|
|
Tags: tags,
|
|
CreatedAt: model.CreatedAt.Time(),
|
|
UpdatedAt: model.UpdatedAt.Time(),
|
|
}
|
|
if g.Tags == nil {
|
|
g.Tags = []string{}
|
|
}
|
|
guardrails = append(guardrails, g)
|
|
}
|
|
return guardrails, rows.Err()
|
|
}
|