refactor(store): replace project and skill models with generated models

* Update project creation and retrieval to use generated models
* Modify skill addition and listing to utilize generated models
* Refactor thought handling to incorporate generated models
* Adjust tool annotations to align with new model structure
* Update API calls in the UI to use new ResolveSpec-based endpoints
* Enhance stats retrieval logic to aggregate thought metadata

internal/app/admin_legacy.go.disabled

@@ -1,4 +1,5 @@
 package app
+// Legacy admin handlers retired in favor of ResolveSpec-backed routes.
 
 import (
 	"encoding/json"
@@ -265,4 +266,3 @@ func parseUUID(w http.ResponseWriter, s string) (uuid.UUID, bool) {
 	}
 	return id, true
 }
-

internal/app/app.go

@@ -227,7 +227,9 @@ func routes(logger *slog.Logger, cfg *config.Config, info buildinfo.Info, db *st
 		mux.Handle(cfg.MCP.SSEPath, authMiddleware(mcpHandlers.SSE))
 		logger.Info("SSE transport enabled", slog.String("sse_path", cfg.MCP.SSEPath))
 	}
-	newAdminHandlers(db, logger).register(mux, authMiddleware)
+	if err := registerResolveSpecAdminRoutes(mux, db, authMiddleware, logger); err != nil {
+		return nil, fmt.Errorf("setup resolvespec admin routes: %w", err)
+	}
 	mux.Handle("/files", authMiddleware(fileHandler(filesTool)))
 	mux.Handle("/files/{id}", authMiddleware(fileHandler(filesTool)))
 	mux.HandleFunc("/.well-known/oauth-authorization-server", oauthMetadataHandler())

internal/app/resolvespec_admin.go

@@ -0,0 +1,128 @@
+package app
+
+import (
+	"fmt"
+	"log/slog"
+	"net/http"
+
+	"github.com/bitechdev/ResolveSpec/pkg/resolvespec"
+	"github.com/uptrace/bunrouter"
+
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
+	"git.warky.dev/wdevs/amcs/internal/store"
+)
+
+func registerResolveSpecAdminRoutes(mux *http.ServeMux, db *store.DB, middleware func(http.Handler) http.Handler, logger *slog.Logger) error {
+	rs := resolvespec.NewHandlerWithBun(db.Bun())
+	registerResolveSpecGuards(rs)
+	for _, model := range resolveSpecModels() {
+		if err := rs.RegisterModel(model.schema, model.entity, model.model); err != nil {
+			return fmt.Errorf("register resolvespec model %s.%s: %w", model.schema, model.entity, err)
+		}
+	}
+
+	rsRouter := bunrouter.New()
+	resolvespec.SetupBunRouterRoutes(rsRouter, rs, nil)
+
+	rsMount := http.StripPrefix("/api/rs", rsRouter)
+	protectedRSMount := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodOptions {
+			rsMount.ServeHTTP(w, r)
+			return
+		}
+		middleware(rsMount).ServeHTTP(w, r)
+	})
+
+	mux.Handle("/api/rs/", protectedRSMount)
+	mux.Handle("/api/rs", http.RedirectHandler("/api/rs/openapi", http.StatusTemporaryRedirect))
+
+	if logger != nil {
+		logger.Info("resolvespec admin api enabled",
+			slog.String("prefix", "/api/rs"),
+			slog.Int("models", len(resolveSpecModels())),
+		)
+	}
+
+	return nil
+}
+
+func registerResolveSpecGuards(rs *resolvespec.Handler) {
+	mutableByEntity := map[string]map[string]struct{}{
+		"projects": {
+			"create": {},
+		},
+		"thoughts": {
+			"update": {},
+			"delete": {},
+		},
+		"agent_skills": {
+			"delete": {},
+		},
+		"agent_guardrails": {
+			"delete": {},
+		},
+	}
+
+	rs.Hooks().Register(resolvespec.BeforeHandle, func(hookCtx *resolvespec.HookContext) error {
+		switch hookCtx.Operation {
+		case "read", "meta":
+			return nil
+		case "create", "update", "delete":
+			allowedOps, ok := mutableByEntity[hookCtx.Entity]
+			if !ok {
+				hookCtx.Abort = true
+				hookCtx.AbortCode = http.StatusForbidden
+				hookCtx.AbortMessage = fmt.Sprintf("operation %q is not allowed for %s.%s", hookCtx.Operation, hookCtx.Schema, hookCtx.Entity)
+				return fmt.Errorf("forbidden operation")
+			}
+			if _, ok := allowedOps[hookCtx.Operation]; !ok {
+				hookCtx.Abort = true
+				hookCtx.AbortCode = http.StatusForbidden
+				hookCtx.AbortMessage = fmt.Sprintf("operation %q is not allowed for %s.%s", hookCtx.Operation, hookCtx.Schema, hookCtx.Entity)
+				return fmt.Errorf("forbidden operation")
+			}
+			return nil
+		default:
+			hookCtx.Abort = true
+			hookCtx.AbortCode = http.StatusBadRequest
+			hookCtx.AbortMessage = fmt.Sprintf("unsupported operation %q", hookCtx.Operation)
+			return fmt.Errorf("unsupported operation")
+		}
+	})
+}
+
+type resolveSpecModel struct {
+	schema string
+	entity string
+	model  any
+}
+
+func resolveSpecModels() []resolveSpecModel {
+	return []resolveSpecModel{
+		{schema: "public", entity: "activities", model: generatedmodels.ModelPublicActivities{}},
+		{schema: "public", entity: "agent_guardrails", model: generatedmodels.ModelPublicAgentGuardrails{}},
+		{schema: "public", entity: "agent_skills", model: generatedmodels.ModelPublicAgentSkills{}},
+		{schema: "public", entity: "chat_histories", model: generatedmodels.ModelPublicChatHistories{}},
+		{schema: "public", entity: "contact_interactions", model: generatedmodels.ModelPublicContactInteractions{}},
+		{schema: "public", entity: "embeddings", model: generatedmodels.ModelPublicEmbeddings{}},
+		{schema: "public", entity: "family_members", model: generatedmodels.ModelPublicFamilyMembers{}},
+		{schema: "public", entity: "household_items", model: generatedmodels.ModelPublicHouseholdItems{}},
+		{schema: "public", entity: "household_vendors", model: generatedmodels.ModelPublicHouseholdVendors{}},
+		{schema: "public", entity: "important_dates", model: generatedmodels.ModelPublicImportantDates{}},
+		{schema: "public", entity: "learnings", model: generatedmodels.ModelPublicLearnings{}},
+		{schema: "public", entity: "maintenance_logs", model: generatedmodels.ModelPublicMaintenanceLogs{}},
+		{schema: "public", entity: "maintenance_tasks", model: generatedmodels.ModelPublicMaintenanceTasks{}},
+		{schema: "public", entity: "meal_plans", model: generatedmodels.ModelPublicMealPlans{}},
+		{schema: "public", entity: "opportunities", model: generatedmodels.ModelPublicOpportunities{}},
+		{schema: "public", entity: "professional_contacts", model: generatedmodels.ModelPublicProfessionalContacts{}},
+		{schema: "public", entity: "project_guardrails", model: generatedmodels.ModelPublicProjectGuardrails{}},
+		{schema: "public", entity: "project_skills", model: generatedmodels.ModelPublicProjectSkills{}},
+		{schema: "public", entity: "projects", model: generatedmodels.ModelPublicProjects{}},
+		{schema: "public", entity: "recipes", model: generatedmodels.ModelPublicRecipes{}},
+		{schema: "public", entity: "shopping_lists", model: generatedmodels.ModelPublicShoppingLists{}},
+		{schema: "public", entity: "stored_files", model: generatedmodels.ModelPublicStoredFiles{}},
+		{schema: "public", entity: "thought_links", model: generatedmodels.ModelPublicThoughtLinks{}},
+		{schema: "public", entity: "thoughts", model: generatedmodels.ModelPublicThoughts{}},
+		{schema: "public", entity: "tool_annotations", model: generatedmodels.ModelPublicToolAnnotations{}},
+	}
+}

internal/app/resolvespec_admin_test.go

@@ -0,0 +1,154 @@
+package app
+
+import (
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.warky.dev/wdevs/amcs/internal/auth"
+	"git.warky.dev/wdevs/amcs/internal/config"
+
+	"github.com/bitechdev/ResolveSpec/pkg/resolvespec"
+)
+
+func TestResolveSpecAuthRequiresValidCredentials(t *testing.T) {
+	keyring, err := auth.NewKeyring([]config.APIKey{{ID: "operator", Value: "secret"}})
+	if err != nil {
+		t.Fatalf("NewKeyring() error = %v", err)
+	}
+
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	protected := auth.Middleware(config.AuthConfig{}, keyring, nil, nil, nil, logger)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/rs/public/projects" {
+			t.Fatalf("path = %q, want /api/rs/public/projects", r.URL.Path)
+		}
+		w.WriteHeader(http.StatusNoContent)
+	}))
+
+	t.Run("missing credentials are rejected", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPost, "/api/rs/public/projects", strings.NewReader(`{"operation":"read"}`))
+		rec := httptest.NewRecorder()
+
+		protected.ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusUnauthorized {
+			t.Fatalf("status = %d, want %d", rec.Code, http.StatusUnauthorized)
+		}
+	})
+
+	t.Run("valid API key is accepted", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodPost, "/api/rs/public/projects", strings.NewReader(`{"operation":"read"}`))
+		req.Header.Set("x-brain-key", "secret")
+		rec := httptest.NewRecorder()
+
+		protected.ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusNoContent {
+			t.Fatalf("status = %d, want %d", rec.Code, http.StatusNoContent)
+		}
+	})
+}
+
+func TestResolveSpecGuardAllowsSupportedMutations(t *testing.T) {
+	rs := resolvespec.NewHandler(nil, nil)
+	registerResolveSpecGuards(rs)
+
+	cases := []struct {
+		name      string
+		entity    string
+		operation string
+	}{
+		{name: "projects create", entity: "projects", operation: "create"},
+		{name: "thoughts update", entity: "thoughts", operation: "update"},
+		{name: "thoughts delete", entity: "thoughts", operation: "delete"},
+		{name: "agent_skills delete", entity: "agent_skills", operation: "delete"},
+		{name: "agent_guardrails delete", entity: "agent_guardrails", operation: "delete"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			hookCtx := &resolvespec.HookContext{
+				Schema:    "public",
+				Entity:    tc.entity,
+				Operation: tc.operation,
+			}
+
+			err := rs.Hooks().Execute(resolvespec.BeforeHandle, hookCtx)
+			if err != nil {
+				t.Fatalf("Execute() error = %v, want nil", err)
+			}
+			if hookCtx.Abort {
+				t.Fatalf("Abort = true, want false (code=%d message=%q)", hookCtx.AbortCode, hookCtx.AbortMessage)
+			}
+		})
+	}
+}
+
+func TestResolveSpecGuardBlocksUnsupportedMutations(t *testing.T) {
+	rs := resolvespec.NewHandler(nil, nil)
+	registerResolveSpecGuards(rs)
+
+	cases := []struct {
+		name          string
+		entity        string
+		operation     string
+		wantCode      int
+		wantMessageIn string
+	}{
+		{
+			name:          "create not allowed on thoughts",
+			entity:        "thoughts",
+			operation:     "create",
+			wantCode:      http.StatusForbidden,
+			wantMessageIn: `operation "create" is not allowed for public.thoughts`,
+		},
+		{
+			name:          "delete not allowed on projects",
+			entity:        "projects",
+			operation:     "delete",
+			wantCode:      http.StatusForbidden,
+			wantMessageIn: `operation "delete" is not allowed for public.projects`,
+		},
+		{
+			name:          "mutations blocked for non-allowlisted entity",
+			entity:        "stored_files",
+			operation:     "delete",
+			wantCode:      http.StatusForbidden,
+			wantMessageIn: `operation "delete" is not allowed for public.stored_files`,
+		},
+		{
+			name:          "unknown operation is rejected",
+			entity:        "projects",
+			operation:     "scan",
+			wantCode:      http.StatusBadRequest,
+			wantMessageIn: `unsupported operation "scan"`,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			hookCtx := &resolvespec.HookContext{
+				Schema:    "public",
+				Entity:    tc.entity,
+				Operation: tc.operation,
+			}
+
+			err := rs.Hooks().Execute(resolvespec.BeforeHandle, hookCtx)
+			if err == nil {
+				t.Fatal("Execute() error = nil, want non-nil")
+			}
+			if !hookCtx.Abort {
+				t.Fatal("Abort = false, want true")
+			}
+			if hookCtx.AbortCode != tc.wantCode {
+				t.Fatalf("AbortCode = %d, want %d", hookCtx.AbortCode, tc.wantCode)
+			}
+			if !strings.Contains(hookCtx.AbortMessage, tc.wantMessageIn) {
+				t.Fatalf("AbortMessage = %q, want substring %q", hookCtx.AbortMessage, tc.wantMessageIn)
+			}
+		})
+	}
+}

internal/generatedmodels/sql_public_activities.go

@@ -0,0 +1,70 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicActivities struct {
+	bun.BaseModel     `bun:"table:public.activities,alias:activities"`
+	ID                resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	ActivityType      resolvespec_common.SqlString    `bun:"activity_type,type:text,nullzero," json:"activity_type"`
+	CreatedAt         resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	DayOfWeek         resolvespec_common.SqlString    `bun:"day_of_week,type:text,nullzero," json:"day_of_week"`
+	EndDate           resolvespec_common.SqlDate      `bun:"end_date,type:date,nullzero," json:"end_date"`
+	EndTime           resolvespec_common.SqlTime      `bun:"end_time,type:time,nullzero," json:"end_time"`
+	FamilyMemberID    resolvespec_common.SqlUUID      `bun:"family_member_id,type:uuid,nullzero," json:"family_member_id"`
+	Location          resolvespec_common.SqlString    `bun:"location,type:text,nullzero," json:"location"`
+	Notes             resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	StartDate         resolvespec_common.SqlDate      `bun:"start_date,type:date,nullzero," json:"start_date"`
+	StartTime         resolvespec_common.SqlTime      `bun:"start_time,type:time,nullzero," json:"start_time"`
+	Title             resolvespec_common.SqlString    `bun:"title,type:text,notnull," json:"title"`
+	RelFamilyMemberID *ModelPublicFamilyMembers       `bun:"rel:has-one,join:family_member_id=id" json:"relfamilymemberid,omitempty"` // Has one ModelPublicFamilyMembers
+}
+
+// TableName returns the table name for ModelPublicActivities
+func (m ModelPublicActivities) TableName() string {
+	return "public.activities"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicActivities
+func (m ModelPublicActivities) TableNameOnly() string {
+	return "activities"
+}
+
+// SchemaName returns the schema name for ModelPublicActivities
+func (m ModelPublicActivities) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicActivities) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicActivities) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicActivities) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicActivities) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicActivities) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicActivities) GetPrefix() string {
+	return "ACT"
+}

internal/generatedmodels/sql_public_agent_guardrails.go

@@ -0,0 +1,66 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicAgentGuardrails struct {
+	bun.BaseModel                         `bun:"table:public.agent_guardrails,alias:agent_guardrails"`
+	ID                                    resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	Content                               resolvespec_common.SqlString    `bun:"content,type:text,notnull," json:"content"`
+	CreatedAt                             resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Description                           resolvespec_common.SqlString    `bun:"description,type:text,default:'',notnull," json:"description"`
+	Name                                  resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Severity                              resolvespec_common.SqlString    `bun:"severity,type:text,default:'medium',notnull," json:"severity"`
+	Tags                                  resolvespec_common.SqlString    `bun:"tags,type:text,nullzero," json:"tags"`
+	UpdatedAt                             resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelGuardrailIDPublicProjectGuardrails []*ModelPublicProjectGuardrails `bun:"rel:has-many,join:id=guardrail_id" json:"relguardrailidpublicprojectguardrails,omitempty"` // Has many ModelPublicProjectGuardrails
+}
+
+// TableName returns the table name for ModelPublicAgentGuardrails
+func (m ModelPublicAgentGuardrails) TableName() string {
+	return "public.agent_guardrails"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicAgentGuardrails
+func (m ModelPublicAgentGuardrails) TableNameOnly() string {
+	return "agent_guardrails"
+}
+
+// SchemaName returns the schema name for ModelPublicAgentGuardrails
+func (m ModelPublicAgentGuardrails) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicAgentGuardrails) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicAgentGuardrails) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicAgentGuardrails) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicAgentGuardrails) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicAgentGuardrails) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicAgentGuardrails) GetPrefix() string {
+	return "AGG"
+}

internal/generatedmodels/sql_public_agent_skills.go

@@ -0,0 +1,66 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicAgentSkills struct {
+	bun.BaseModel                    `bun:"table:public.agent_skills,alias:agent_skills"`
+	ID                               resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	Content                          resolvespec_common.SqlString    `bun:"content,type:text,notnull," json:"content"`
+	CreatedAt                        resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Description                      resolvespec_common.SqlString    `bun:"description,type:text,default:'',notnull," json:"description"`
+	Name                             resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Tags                             resolvespec_common.SqlString    `bun:"tags,type:text,nullzero," json:"tags"`
+	UpdatedAt                        resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelRelatedSkillIDPublicLearnings []*ModelPublicLearnings         `bun:"rel:has-many,join:id=related_skill_id" json:"relrelatedskillidpubliclearnings,omitempty"` // Has many ModelPublicLearnings
+	RelSkillIDPublicProjectSkills    []*ModelPublicProjectSkills     `bun:"rel:has-many,join:id=skill_id" json:"relskillidpublicprojectskills,omitempty"`            // Has many ModelPublicProjectSkills
+}
+
+// TableName returns the table name for ModelPublicAgentSkills
+func (m ModelPublicAgentSkills) TableName() string {
+	return "public.agent_skills"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicAgentSkills
+func (m ModelPublicAgentSkills) TableNameOnly() string {
+	return "agent_skills"
+}
+
+// SchemaName returns the schema name for ModelPublicAgentSkills
+func (m ModelPublicAgentSkills) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicAgentSkills) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicAgentSkills) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicAgentSkills) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicAgentSkills) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicAgentSkills) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicAgentSkills) GetPrefix() string {
+	return "ASG"
+}

internal/generatedmodels/sql_public_chat_histories.go

@@ -0,0 +1,69 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicChatHistories struct {
+	bun.BaseModel `bun:"table:public.chat_histories,alias:chat_histories"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	AgentID       resolvespec_common.SqlString    `bun:"agent_id,type:text,nullzero," json:"agent_id"`
+	Channel       resolvespec_common.SqlString    `bun:"channel,type:text,nullzero," json:"channel"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Messages      resolvespec_common.SqlJSONB     `bun:"messages,type:jsonb,default:'[',notnull," json:"messages"`
+	Metadata      resolvespec_common.SqlJSONB     `bun:"metadata,type:jsonb,default:'{}',notnull," json:"metadata"`
+	ProjectID     resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,nullzero," json:"project_id"`
+	SessionID     resolvespec_common.SqlString    `bun:"session_id,type:text,notnull," json:"session_id"`
+	Summary       resolvespec_common.SqlString    `bun:"summary,type:text,nullzero," json:"summary"`
+	Title         resolvespec_common.SqlString    `bun:"title,type:text,nullzero," json:"title"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelProjectID  *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"` // Has one ModelPublicProjects
+}
+
+// TableName returns the table name for ModelPublicChatHistories
+func (m ModelPublicChatHistories) TableName() string {
+	return "public.chat_histories"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicChatHistories
+func (m ModelPublicChatHistories) TableNameOnly() string {
+	return "chat_histories"
+}
+
+// SchemaName returns the schema name for ModelPublicChatHistories
+func (m ModelPublicChatHistories) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicChatHistories) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicChatHistories) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicChatHistories) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicChatHistories) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicChatHistories) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicChatHistories) GetPrefix() string {
+	return "CHH"
+}

internal/generatedmodels/sql_public_contact_interactions.go

@@ -0,0 +1,66 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicContactInteractions struct {
+	bun.BaseModel   `bun:"table:public.contact_interactions,alias:contact_interactions"`
+	ID              resolvespec_common.SqlUUID       `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	ContactID       resolvespec_common.SqlUUID       `bun:"contact_id,type:uuid,notnull," json:"contact_id"`
+	CreatedAt       resolvespec_common.SqlTimeStamp  `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	FollowUpNeeded  bool                             `bun:"follow_up_needed,type:boolean,default:false,notnull," json:"follow_up_needed"`
+	FollowUpNotes   resolvespec_common.SqlString     `bun:"follow_up_notes,type:text,nullzero," json:"follow_up_notes"`
+	InteractionType resolvespec_common.SqlString     `bun:"interaction_type,type:text,notnull," json:"interaction_type"`
+	OccurredAt      resolvespec_common.SqlTimeStamp  `bun:"occurred_at,type:timestamptz,default:now(),notnull," json:"occurred_at"`
+	Summary         resolvespec_common.SqlString     `bun:"summary,type:text,notnull," json:"summary"`
+	RelContactID    *ModelPublicProfessionalContacts `bun:"rel:has-one,join:contact_id=id" json:"relcontactid,omitempty"` // Has one ModelPublicProfessionalContacts
+}
+
+// TableName returns the table name for ModelPublicContactInteractions
+func (m ModelPublicContactInteractions) TableName() string {
+	return "public.contact_interactions"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicContactInteractions
+func (m ModelPublicContactInteractions) TableNameOnly() string {
+	return "contact_interactions"
+}
+
+// SchemaName returns the schema name for ModelPublicContactInteractions
+func (m ModelPublicContactInteractions) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicContactInteractions) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicContactInteractions) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicContactInteractions) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicContactInteractions) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicContactInteractions) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicContactInteractions) GetPrefix() string {
+	return "CIO"
+}

internal/generatedmodels/sql_public_embeddings.go

@@ -0,0 +1,66 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicEmbeddings struct {
+	bun.BaseModel `bun:"table:public.embeddings,alias:embeddings"`
+	ID            resolvespec_common.SqlInt64     `bun:"id,type:bigserial,pk,autoincrement," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),nullzero," json:"created_at"`
+	Dim           resolvespec_common.SqlInt32     `bun:"dim,type:int,notnull," json:"dim"`
+	Embedding     resolvespec_common.SqlString    `bun:"embedding,type:vector,notnull," json:"embedding"`
+	GUID          resolvespec_common.SqlUUID      `bun:"guid,type:uuid,default:gen_random_uuid(),notnull," json:"guid"`
+	Model         resolvespec_common.SqlString    `bun:"model,type:text,notnull,unique:uidx_embeddings_thought_id_model," json:"model"`
+	ThoughtID     resolvespec_common.SqlUUID      `bun:"thought_id,type:uuid,notnull,unique:uidx_embeddings_thought_id_model," json:"thought_id"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),nullzero," json:"updated_at"`
+	RelThoughtID  *ModelPublicThoughts            `bun:"rel:has-one,join:thought_id=guid" json:"relthoughtid,omitempty"` // Has one ModelPublicThoughts
+}
+
+// TableName returns the table name for ModelPublicEmbeddings
+func (m ModelPublicEmbeddings) TableName() string {
+	return "public.embeddings"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicEmbeddings
+func (m ModelPublicEmbeddings) TableNameOnly() string {
+	return "embeddings"
+}
+
+// SchemaName returns the schema name for ModelPublicEmbeddings
+func (m ModelPublicEmbeddings) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicEmbeddings) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicEmbeddings) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicEmbeddings) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicEmbeddings) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicEmbeddings) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicEmbeddings) GetPrefix() string {
+	return "EMB"
+}

internal/generatedmodels/sql_public_family_members.go

@@ -0,0 +1,65 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicFamilyMembers struct {
+	bun.BaseModel                         `bun:"table:public.family_members,alias:family_members"`
+	ID                                    resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	BirthDate                             resolvespec_common.SqlDate      `bun:"birth_date,type:date,nullzero," json:"birth_date"`
+	CreatedAt                             resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Name                                  resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Notes                                 resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	Relationship                          resolvespec_common.SqlString    `bun:"relationship,type:text,nullzero," json:"relationship"`
+	RelFamilyMemberIDPublicActivities     []*ModelPublicActivities        `bun:"rel:has-many,join:id=family_member_id" json:"relfamilymemberidpublicactivities,omitempty"`     // Has many ModelPublicActivities
+	RelFamilyMemberIDPublicImportantDates []*ModelPublicImportantDates    `bun:"rel:has-many,join:id=family_member_id" json:"relfamilymemberidpublicimportantdates,omitempty"` // Has many ModelPublicImportantDates
+}
+
+// TableName returns the table name for ModelPublicFamilyMembers
+func (m ModelPublicFamilyMembers) TableName() string {
+	return "public.family_members"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicFamilyMembers
+func (m ModelPublicFamilyMembers) TableNameOnly() string {
+	return "family_members"
+}
+
+// SchemaName returns the schema name for ModelPublicFamilyMembers
+func (m ModelPublicFamilyMembers) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicFamilyMembers) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicFamilyMembers) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicFamilyMembers) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicFamilyMembers) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicFamilyMembers) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicFamilyMembers) GetPrefix() string {
+	return "FMA"
+}

internal/generatedmodels/sql_public_household_items.go

@@ -0,0 +1,65 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicHouseholdItems struct {
+	bun.BaseModel `bun:"table:public.household_items,alias:household_items"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	Category      resolvespec_common.SqlString    `bun:"category,type:text,nullzero," json:"category"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Details       resolvespec_common.SqlJSONB     `bun:"details,type:jsonb,default:'{}',notnull," json:"details"`
+	Location      resolvespec_common.SqlString    `bun:"location,type:text,nullzero," json:"location"`
+	Name          resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+}
+
+// TableName returns the table name for ModelPublicHouseholdItems
+func (m ModelPublicHouseholdItems) TableName() string {
+	return "public.household_items"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicHouseholdItems
+func (m ModelPublicHouseholdItems) TableNameOnly() string {
+	return "household_items"
+}
+
+// SchemaName returns the schema name for ModelPublicHouseholdItems
+func (m ModelPublicHouseholdItems) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicHouseholdItems) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicHouseholdItems) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicHouseholdItems) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicHouseholdItems) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicHouseholdItems) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicHouseholdItems) GetPrefix() string {
+	return "HIO"
+}

internal/generatedmodels/sql_public_household_vendors.go

@@ -0,0 +1,67 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicHouseholdVendors struct {
+	bun.BaseModel `bun:"table:public.household_vendors,alias:household_vendors"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Email         resolvespec_common.SqlString    `bun:"email,type:text,nullzero," json:"email"`
+	LastUsed      resolvespec_common.SqlDate      `bun:"last_used,type:date,nullzero," json:"last_used"`
+	Name          resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	Phone         resolvespec_common.SqlString    `bun:"phone,type:text,nullzero," json:"phone"`
+	Rating        resolvespec_common.SqlInt32     `bun:"rating,type:int,nullzero," json:"rating"`
+	ServiceType   resolvespec_common.SqlString    `bun:"service_type,type:text,nullzero," json:"service_type"`
+	Website       resolvespec_common.SqlString    `bun:"website,type:text,nullzero," json:"website"`
+}
+
+// TableName returns the table name for ModelPublicHouseholdVendors
+func (m ModelPublicHouseholdVendors) TableName() string {
+	return "public.household_vendors"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicHouseholdVendors
+func (m ModelPublicHouseholdVendors) TableNameOnly() string {
+	return "household_vendors"
+}
+
+// SchemaName returns the schema name for ModelPublicHouseholdVendors
+func (m ModelPublicHouseholdVendors) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicHouseholdVendors) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicHouseholdVendors) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicHouseholdVendors) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicHouseholdVendors) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicHouseholdVendors) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicHouseholdVendors) GetPrefix() string {
+	return "HVO"
+}

internal/generatedmodels/sql_public_important_dates.go

@@ -0,0 +1,66 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicImportantDates struct {
+	bun.BaseModel      `bun:"table:public.important_dates,alias:important_dates"`
+	ID                 resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CreatedAt          resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	DateValue          resolvespec_common.SqlDate      `bun:"date_value,type:date,notnull," json:"date_value"`
+	FamilyMemberID     resolvespec_common.SqlUUID      `bun:"family_member_id,type:uuid,nullzero," json:"family_member_id"`
+	Notes              resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	RecurringYearly    bool                            `bun:"recurring_yearly,type:boolean,default:false,notnull," json:"recurring_yearly"`
+	ReminderDaysBefore resolvespec_common.SqlInt32     `bun:"reminder_days_before,type:int,default:7,notnull," json:"reminder_days_before"`
+	Title              resolvespec_common.SqlString    `bun:"title,type:text,notnull," json:"title"`
+	RelFamilyMemberID  *ModelPublicFamilyMembers       `bun:"rel:has-one,join:family_member_id=id" json:"relfamilymemberid,omitempty"` // Has one ModelPublicFamilyMembers
+}
+
+// TableName returns the table name for ModelPublicImportantDates
+func (m ModelPublicImportantDates) TableName() string {
+	return "public.important_dates"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicImportantDates
+func (m ModelPublicImportantDates) TableNameOnly() string {
+	return "important_dates"
+}
+
+// SchemaName returns the schema name for ModelPublicImportantDates
+func (m ModelPublicImportantDates) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicImportantDates) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicImportantDates) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicImportantDates) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicImportantDates) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicImportantDates) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicImportantDates) GetPrefix() string {
+	return "IDM"
+}

internal/generatedmodels/sql_public_learnings.go

@@ -0,0 +1,83 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicLearnings struct {
+	bun.BaseModel            `bun:"table:public.learnings,alias:learnings"`
+	ID                       resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	ActionRequired           bool                            `bun:"action_required,type:boolean,default:false,notnull," json:"action_required"`
+	Area                     resolvespec_common.SqlString    `bun:"area,type:text,default:'other',notnull," json:"area"`
+	Category                 resolvespec_common.SqlString    `bun:"category,type:text,default:'insight',notnull," json:"category"`
+	Confidence               resolvespec_common.SqlString    `bun:"confidence,type:text,default:'hypothesis',notnull," json:"confidence"`
+	CreatedAt                resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Details                  resolvespec_common.SqlString    `bun:"details,type:text,default:'',notnull," json:"details"`
+	DuplicateOfLearningID    resolvespec_common.SqlUUID      `bun:"duplicate_of_learning_id,type:uuid,nullzero," json:"duplicate_of_learning_id"`
+	Priority                 resolvespec_common.SqlString    `bun:"priority,type:text,default:'medium',notnull," json:"priority"`
+	ProjectID                resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,nullzero," json:"project_id"`
+	RelatedSkillID           resolvespec_common.SqlUUID      `bun:"related_skill_id,type:uuid,nullzero," json:"related_skill_id"`
+	RelatedThoughtID         resolvespec_common.SqlUUID      `bun:"related_thought_id,type:uuid,nullzero," json:"related_thought_id"`
+	ReviewedAt               resolvespec_common.SqlTimeStamp `bun:"reviewed_at,type:timestamptz,nullzero," json:"reviewed_at"`
+	ReviewedBy               resolvespec_common.SqlString    `bun:"reviewed_by,type:text,nullzero," json:"reviewed_by"`
+	SourceRef                resolvespec_common.SqlString    `bun:"source_ref,type:text,nullzero," json:"source_ref"`
+	SourceType               resolvespec_common.SqlString    `bun:"source_type,type:text,nullzero," json:"source_type"`
+	Status                   resolvespec_common.SqlString    `bun:"status,type:text,default:'pending',notnull," json:"status"`
+	Summary                  resolvespec_common.SqlString    `bun:"summary,type:text,notnull," json:"summary"`
+	SupersedesLearningID     resolvespec_common.SqlUUID      `bun:"supersedes_learning_id,type:uuid,nullzero," json:"supersedes_learning_id"`
+	Tags                     resolvespec_common.SqlString    `bun:"tags,type:text,nullzero," json:"tags"`
+	UpdatedAt                resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelDuplicateOfLearningID *ModelPublicLearnings           `bun:"rel:has-one,join:duplicate_of_learning_id=id" json:"relduplicateoflearningid,omitempty"` // Has one ModelPublicLearnings
+	RelProjectID             *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"`                         // Has one ModelPublicProjects
+	RelRelatedSkillID        *ModelPublicAgentSkills         `bun:"rel:has-one,join:related_skill_id=id" json:"relrelatedskillid,omitempty"`                // Has one ModelPublicAgentSkills
+	RelRelatedThoughtID      *ModelPublicThoughts            `bun:"rel:has-one,join:related_thought_id=guid" json:"relrelatedthoughtid,omitempty"`          // Has one ModelPublicThoughts
+	RelSupersedesLearningID  *ModelPublicLearnings           `bun:"rel:has-one,join:supersedes_learning_id=id" json:"relsupersedeslearningid,omitempty"`    // Has one ModelPublicLearnings
+}
+
+// TableName returns the table name for ModelPublicLearnings
+func (m ModelPublicLearnings) TableName() string {
+	return "public.learnings"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicLearnings
+func (m ModelPublicLearnings) TableNameOnly() string {
+	return "learnings"
+}
+
+// SchemaName returns the schema name for ModelPublicLearnings
+func (m ModelPublicLearnings) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicLearnings) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicLearnings) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicLearnings) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicLearnings) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicLearnings) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicLearnings) GetPrefix() string {
+	return "LEA"
+}

internal/generatedmodels/sql_public_maintenance_logs.go

@@ -0,0 +1,65 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicMaintenanceLogs struct {
+	bun.BaseModel `bun:"table:public.maintenance_logs,alias:maintenance_logs"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CompletedAt   resolvespec_common.SqlTimeStamp `bun:"completed_at,type:timestamptz,default:now(),notnull," json:"completed_at"`
+	Cost          resolvespec_common.SqlFloat64   `bun:"cost,type:decimal(10,2),nullzero," json:"cost"`
+	NextAction    resolvespec_common.SqlString    `bun:"next_action,type:text,nullzero," json:"next_action"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	PerformedBy   resolvespec_common.SqlString    `bun:"performed_by,type:text,nullzero," json:"performed_by"`
+	TaskID        resolvespec_common.SqlUUID      `bun:"task_id,type:uuid,notnull," json:"task_id"`
+	RelTaskID     *ModelPublicMaintenanceTasks    `bun:"rel:has-one,join:task_id=id" json:"reltaskid,omitempty"` // Has one ModelPublicMaintenanceTasks
+}
+
+// TableName returns the table name for ModelPublicMaintenanceLogs
+func (m ModelPublicMaintenanceLogs) TableName() string {
+	return "public.maintenance_logs"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicMaintenanceLogs
+func (m ModelPublicMaintenanceLogs) TableNameOnly() string {
+	return "maintenance_logs"
+}
+
+// SchemaName returns the schema name for ModelPublicMaintenanceLogs
+func (m ModelPublicMaintenanceLogs) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicMaintenanceLogs) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicMaintenanceLogs) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicMaintenanceLogs) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicMaintenanceLogs) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicMaintenanceLogs) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicMaintenanceLogs) GetPrefix() string {
+	return "MLA"
+}

internal/generatedmodels/sql_public_maintenance_tasks.go

@@ -0,0 +1,68 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicMaintenanceTasks struct {
+	bun.BaseModel                  `bun:"table:public.maintenance_tasks,alias:maintenance_tasks"`
+	ID                             resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	Category                       resolvespec_common.SqlString    `bun:"category,type:text,nullzero," json:"category"`
+	CreatedAt                      resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	FrequencyDays                  resolvespec_common.SqlInt32     `bun:"frequency_days,type:int,nullzero," json:"frequency_days"`
+	LastCompleted                  resolvespec_common.SqlTimeStamp `bun:"last_completed,type:timestamptz,nullzero," json:"last_completed"`
+	Name                           resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	NextDue                        resolvespec_common.SqlTimeStamp `bun:"next_due,type:timestamptz,nullzero," json:"next_due"`
+	Notes                          resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	Priority                       resolvespec_common.SqlString    `bun:"priority,type:text,default:'medium',notnull," json:"priority"`
+	UpdatedAt                      resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelTaskIDPublicMaintenanceLogs []*ModelPublicMaintenanceLogs   `bun:"rel:has-many,join:id=task_id" json:"reltaskidpublicmaintenancelogs,omitempty"` // Has many ModelPublicMaintenanceLogs
+}
+
+// TableName returns the table name for ModelPublicMaintenanceTasks
+func (m ModelPublicMaintenanceTasks) TableName() string {
+	return "public.maintenance_tasks"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicMaintenanceTasks
+func (m ModelPublicMaintenanceTasks) TableNameOnly() string {
+	return "maintenance_tasks"
+}
+
+// SchemaName returns the schema name for ModelPublicMaintenanceTasks
+func (m ModelPublicMaintenanceTasks) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicMaintenanceTasks) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicMaintenanceTasks) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicMaintenanceTasks) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicMaintenanceTasks) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicMaintenanceTasks) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicMaintenanceTasks) GetPrefix() string {
+	return "MTA"
+}

internal/generatedmodels/sql_public_meal_plans.go

@@ -0,0 +1,67 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicMealPlans struct {
+	bun.BaseModel `bun:"table:public.meal_plans,alias:meal_plans"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	CustomMeal    resolvespec_common.SqlString    `bun:"custom_meal,type:text,nullzero," json:"custom_meal"`
+	DayOfWeek     resolvespec_common.SqlString    `bun:"day_of_week,type:text,notnull," json:"day_of_week"`
+	MealType      resolvespec_common.SqlString    `bun:"meal_type,type:text,notnull," json:"meal_type"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	RecipeID      resolvespec_common.SqlUUID      `bun:"recipe_id,type:uuid,nullzero," json:"recipe_id"`
+	Servings      resolvespec_common.SqlInt32     `bun:"servings,type:int,nullzero," json:"servings"`
+	WeekStart     resolvespec_common.SqlDate      `bun:"week_start,type:date,notnull," json:"week_start"`
+	RelRecipeID   *ModelPublicRecipes             `bun:"rel:has-one,join:recipe_id=id" json:"relrecipeid,omitempty"` // Has one ModelPublicRecipes
+}
+
+// TableName returns the table name for ModelPublicMealPlans
+func (m ModelPublicMealPlans) TableName() string {
+	return "public.meal_plans"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicMealPlans
+func (m ModelPublicMealPlans) TableNameOnly() string {
+	return "meal_plans"
+}
+
+// SchemaName returns the schema name for ModelPublicMealPlans
+func (m ModelPublicMealPlans) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicMealPlans) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicMealPlans) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicMealPlans) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicMealPlans) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicMealPlans) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicMealPlans) GetPrefix() string {
+	return "MPE"
+}

internal/generatedmodels/sql_public_opportunities.go

@@ -0,0 +1,68 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicOpportunities struct {
+	bun.BaseModel     `bun:"table:public.opportunities,alias:opportunities"`
+	ID                resolvespec_common.SqlUUID       `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	ContactID         resolvespec_common.SqlUUID       `bun:"contact_id,type:uuid,nullzero," json:"contact_id"`
+	CreatedAt         resolvespec_common.SqlTimeStamp  `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Description       resolvespec_common.SqlString     `bun:"description,type:text,nullzero," json:"description"`
+	ExpectedCloseDate resolvespec_common.SqlDate       `bun:"expected_close_date,type:date,nullzero," json:"expected_close_date"`
+	Notes             resolvespec_common.SqlString     `bun:"notes,type:text,nullzero," json:"notes"`
+	Stage             resolvespec_common.SqlString     `bun:"stage,type:text,default:'identified',notnull," json:"stage"`
+	Title             resolvespec_common.SqlString     `bun:"title,type:text,notnull," json:"title"`
+	UpdatedAt         resolvespec_common.SqlTimeStamp  `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	Value             resolvespec_common.SqlFloat64    `bun:"value,type:decimal(12,2),nullzero," json:"value"`
+	RelContactID      *ModelPublicProfessionalContacts `bun:"rel:has-one,join:contact_id=id" json:"relcontactid,omitempty"` // Has one ModelPublicProfessionalContacts
+}
+
+// TableName returns the table name for ModelPublicOpportunities
+func (m ModelPublicOpportunities) TableName() string {
+	return "public.opportunities"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicOpportunities
+func (m ModelPublicOpportunities) TableNameOnly() string {
+	return "opportunities"
+}
+
+// SchemaName returns the schema name for ModelPublicOpportunities
+func (m ModelPublicOpportunities) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicOpportunities) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicOpportunities) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicOpportunities) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicOpportunities) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicOpportunities) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicOpportunities) GetPrefix() string {
+	return "OPP"
+}

internal/generatedmodels/sql_public_professional_contacts.go

@@ -0,0 +1,73 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicProfessionalContacts struct {
+	bun.BaseModel                         `bun:"table:public.professional_contacts,alias:professional_contacts"`
+	ID                                    resolvespec_common.SqlUUID        `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	Company                               resolvespec_common.SqlString      `bun:"company,type:text,nullzero," json:"company"`
+	CreatedAt                             resolvespec_common.SqlTimeStamp   `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Email                                 resolvespec_common.SqlString      `bun:"email,type:text,nullzero," json:"email"`
+	FollowUpDate                          resolvespec_common.SqlDate        `bun:"follow_up_date,type:date,nullzero," json:"follow_up_date"`
+	HowWeMet                              resolvespec_common.SqlString      `bun:"how_we_met,type:text,nullzero," json:"how_we_met"`
+	LastContacted                         resolvespec_common.SqlTimeStamp   `bun:"last_contacted,type:timestamptz,nullzero," json:"last_contacted"`
+	LinkedinURL                           resolvespec_common.SqlString      `bun:"linkedin_url,type:text,nullzero," json:"linkedin_url"`
+	Name                                  resolvespec_common.SqlString      `bun:"name,type:text,notnull," json:"name"`
+	Notes                                 resolvespec_common.SqlString      `bun:"notes,type:text,nullzero," json:"notes"`
+	Phone                                 resolvespec_common.SqlString      `bun:"phone,type:text,nullzero," json:"phone"`
+	Tags                                  resolvespec_common.SqlString      `bun:"tags,type:text,nullzero," json:"tags"`
+	Title                                 resolvespec_common.SqlString      `bun:"title,type:text,nullzero," json:"title"`
+	UpdatedAt                             resolvespec_common.SqlTimeStamp   `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelContactIDPublicContactInteractions []*ModelPublicContactInteractions `bun:"rel:has-many,join:id=contact_id" json:"relcontactidpubliccontactinteractions,omitempty"` // Has many ModelPublicContactInteractions
+	RelContactIDPublicOpportunities       []*ModelPublicOpportunities       `bun:"rel:has-many,join:id=contact_id" json:"relcontactidpublicopportunities,omitempty"`       // Has many ModelPublicOpportunities
+}
+
+// TableName returns the table name for ModelPublicProfessionalContacts
+func (m ModelPublicProfessionalContacts) TableName() string {
+	return "public.professional_contacts"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicProfessionalContacts
+func (m ModelPublicProfessionalContacts) TableNameOnly() string {
+	return "professional_contacts"
+}
+
+// SchemaName returns the schema name for ModelPublicProfessionalContacts
+func (m ModelPublicProfessionalContacts) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicProfessionalContacts) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicProfessionalContacts) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicProfessionalContacts) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicProfessionalContacts) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicProfessionalContacts) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicProfessionalContacts) GetPrefix() string {
+	return "PCR"
+}

internal/generatedmodels/sql_public_project_guardrails.go

@@ -0,0 +1,63 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicProjectGuardrails struct {
+	bun.BaseModel  `bun:"table:public.project_guardrails,alias:project_guardrails"`
+	ID             resolvespec_common.SqlInt32     `bun:"id,type:serial,pk,autoincrement," json:"id"`
+	CreatedAt      resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	GuardrailID    resolvespec_common.SqlUUID      `bun:"guardrail_id,type:uuid,notnull," json:"guardrail_id"`
+	ProjectID      resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,notnull," json:"project_id"`
+	RelGuardrailID *ModelPublicAgentGuardrails     `bun:"rel:has-one,join:guardrail_id=id" json:"relguardrailid,omitempty"` // Has one ModelPublicAgentGuardrails
+	RelProjectID   *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"`   // Has one ModelPublicProjects
+}
+
+// TableName returns the table name for ModelPublicProjectGuardrails
+func (m ModelPublicProjectGuardrails) TableName() string {
+	return "public.project_guardrails"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicProjectGuardrails
+func (m ModelPublicProjectGuardrails) TableNameOnly() string {
+	return "project_guardrails"
+}
+
+// SchemaName returns the schema name for ModelPublicProjectGuardrails
+func (m ModelPublicProjectGuardrails) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicProjectGuardrails) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicProjectGuardrails) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicProjectGuardrails) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicProjectGuardrails) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicProjectGuardrails) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicProjectGuardrails) GetPrefix() string {
+	return "PGR"
+}

internal/generatedmodels/sql_public_project_skills.go

@@ -0,0 +1,63 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicProjectSkills struct {
+	bun.BaseModel `bun:"table:public.project_skills,alias:project_skills"`
+	ID            resolvespec_common.SqlInt32     `bun:"id,type:serial,pk,autoincrement," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	ProjectID     resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,notnull," json:"project_id"`
+	SkillID       resolvespec_common.SqlUUID      `bun:"skill_id,type:uuid,notnull," json:"skill_id"`
+	RelProjectID  *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"` // Has one ModelPublicProjects
+	RelSkillID    *ModelPublicAgentSkills         `bun:"rel:has-one,join:skill_id=id" json:"relskillid,omitempty"`       // Has one ModelPublicAgentSkills
+}
+
+// TableName returns the table name for ModelPublicProjectSkills
+func (m ModelPublicProjectSkills) TableName() string {
+	return "public.project_skills"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicProjectSkills
+func (m ModelPublicProjectSkills) TableNameOnly() string {
+	return "project_skills"
+}
+
+// SchemaName returns the schema name for ModelPublicProjectSkills
+func (m ModelPublicProjectSkills) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicProjectSkills) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicProjectSkills) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicProjectSkills) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicProjectSkills) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicProjectSkills) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicProjectSkills) GetPrefix() string {
+	return "PSR"
+}

internal/generatedmodels/sql_public_projects.go

@@ -0,0 +1,69 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicProjects struct {
+	bun.BaseModel                       `bun:"table:public.projects,alias:projects"`
+	ID                                  resolvespec_common.SqlInt64     `bun:"id,type:bigserial,pk,autoincrement," json:"id"`
+	CreatedAt                           resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),nullzero," json:"created_at"`
+	Description                         resolvespec_common.SqlString    `bun:"description,type:text,nullzero," json:"description"`
+	GUID                                resolvespec_common.SqlUUID      `bun:"guid,type:uuid,default:gen_random_uuid(),notnull," json:"guid"`
+	LastActiveAt                        resolvespec_common.SqlTimeStamp `bun:"last_active_at,type:timestamptz,default:now(),nullzero," json:"last_active_at"`
+	Name                                resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	RelProjectIDPublicThoughts          []*ModelPublicThoughts          `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpublicthoughts,omitempty"`          // Has many ModelPublicThoughts
+	RelProjectIDPublicStoredFiles       []*ModelPublicStoredFiles       `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpublicstoredfiles,omitempty"`       // Has many ModelPublicStoredFiles
+	RelProjectIDPublicChatHistories     []*ModelPublicChatHistories     `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpublicchathistories,omitempty"`     // Has many ModelPublicChatHistories
+	RelProjectIDPublicLearnings         []*ModelPublicLearnings         `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpubliclearnings,omitempty"`         // Has many ModelPublicLearnings
+	RelProjectIDPublicProjectSkills     []*ModelPublicProjectSkills     `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpublicprojectskills,omitempty"`     // Has many ModelPublicProjectSkills
+	RelProjectIDPublicProjectGuardrails []*ModelPublicProjectGuardrails `bun:"rel:has-many,join:guid=project_id" json:"relprojectidpublicprojectguardrails,omitempty"` // Has many ModelPublicProjectGuardrails
+}
+
+// TableName returns the table name for ModelPublicProjects
+func (m ModelPublicProjects) TableName() string {
+	return "public.projects"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicProjects
+func (m ModelPublicProjects) TableNameOnly() string {
+	return "projects"
+}
+
+// SchemaName returns the schema name for ModelPublicProjects
+func (m ModelPublicProjects) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicProjects) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicProjects) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicProjects) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicProjects) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicProjects) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicProjects) GetPrefix() string {
+	return "PRO"
+}

internal/generatedmodels/sql_public_recipes.go

@@ -0,0 +1,71 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicRecipes struct {
+	bun.BaseModel              `bun:"table:public.recipes,alias:recipes"`
+	ID                         resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CookTimeMinutes            resolvespec_common.SqlInt32     `bun:"cook_time_minutes,type:int,nullzero," json:"cook_time_minutes"`
+	CreatedAt                  resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Cuisine                    resolvespec_common.SqlString    `bun:"cuisine,type:text,nullzero," json:"cuisine"`
+	Ingredients                resolvespec_common.SqlJSONB     `bun:"ingredients,type:jsonb,default:'[',notnull," json:"ingredients"`
+	Instructions               resolvespec_common.SqlJSONB     `bun:"instructions,type:jsonb,default:'[',notnull," json:"instructions"`
+	Name                       resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	Notes                      resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	PrepTimeMinutes            resolvespec_common.SqlInt32     `bun:"prep_time_minutes,type:int,nullzero," json:"prep_time_minutes"`
+	Rating                     resolvespec_common.SqlInt32     `bun:"rating,type:int,nullzero," json:"rating"`
+	Servings                   resolvespec_common.SqlInt32     `bun:"servings,type:int,nullzero," json:"servings"`
+	Tags                       resolvespec_common.SqlString    `bun:"tags,type:text,nullzero," json:"tags"`
+	UpdatedAt                  resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelRecipeIDPublicMealPlans []*ModelPublicMealPlans         `bun:"rel:has-many,join:id=recipe_id" json:"relrecipeidpublicmealplans,omitempty"` // Has many ModelPublicMealPlans
+}
+
+// TableName returns the table name for ModelPublicRecipes
+func (m ModelPublicRecipes) TableName() string {
+	return "public.recipes"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicRecipes
+func (m ModelPublicRecipes) TableNameOnly() string {
+	return "recipes"
+}
+
+// SchemaName returns the schema name for ModelPublicRecipes
+func (m ModelPublicRecipes) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicRecipes) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicRecipes) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicRecipes) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicRecipes) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicRecipes) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicRecipes) GetPrefix() string {
+	return "REC"
+}

internal/generatedmodels/sql_public_shopping_lists.go

@@ -0,0 +1,63 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicShoppingLists struct {
+	bun.BaseModel `bun:"table:public.shopping_lists,alias:shopping_lists"`
+	ID            resolvespec_common.SqlUUID      `bun:"id,type:uuid,pk,default:gen_random_uuid()," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Items         resolvespec_common.SqlJSONB     `bun:"items,type:jsonb,default:'[',notnull," json:"items"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,nullzero," json:"notes"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	WeekStart     resolvespec_common.SqlDate      `bun:"week_start,type:date,notnull," json:"week_start"`
+}
+
+// TableName returns the table name for ModelPublicShoppingLists
+func (m ModelPublicShoppingLists) TableName() string {
+	return "public.shopping_lists"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicShoppingLists
+func (m ModelPublicShoppingLists) TableNameOnly() string {
+	return "shopping_lists"
+}
+
+// SchemaName returns the schema name for ModelPublicShoppingLists
+func (m ModelPublicShoppingLists) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicShoppingLists) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicShoppingLists) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicShoppingLists) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicShoppingLists) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicShoppingLists) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicShoppingLists) GetPrefix() string {
+	return "SLH"
+}

internal/generatedmodels/sql_public_stored_files.go

@@ -0,0 +1,72 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicStoredFiles struct {
+	bun.BaseModel `bun:"table:public.stored_files,alias:stored_files"`
+	ID            resolvespec_common.SqlInt64     `bun:"id,type:bigserial,pk,autoincrement," json:"id"`
+	Content       []byte                          `bun:"content,type:bytea,notnull," json:"content"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Encoding      resolvespec_common.SqlString    `bun:"encoding,type:text,default:'base64',notnull," json:"encoding"`
+	GUID          resolvespec_common.SqlUUID      `bun:"guid,type:uuid,default:gen_random_uuid(),notnull," json:"guid"`
+	Kind          resolvespec_common.SqlString    `bun:"kind,type:text,default:'file',notnull," json:"kind"`
+	MediaType     resolvespec_common.SqlString    `bun:"media_type,type:text,notnull," json:"media_type"`
+	Name          resolvespec_common.SqlString    `bun:"name,type:text,notnull," json:"name"`
+	ProjectID     resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,nullzero," json:"project_id"`
+	Sha256        resolvespec_common.SqlString    `bun:"sha256,type:text,notnull," json:"sha256"`
+	SizeBytes     int64                           `bun:"size_bytes,type:bigint,notnull," json:"size_bytes"`
+	ThoughtID     resolvespec_common.SqlUUID      `bun:"thought_id,type:uuid,nullzero," json:"thought_id"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+	RelProjectID  *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"` // Has one ModelPublicProjects
+	RelThoughtID  *ModelPublicThoughts            `bun:"rel:has-one,join:thought_id=guid" json:"relthoughtid,omitempty"` // Has one ModelPublicThoughts
+}
+
+// TableName returns the table name for ModelPublicStoredFiles
+func (m ModelPublicStoredFiles) TableName() string {
+	return "public.stored_files"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicStoredFiles
+func (m ModelPublicStoredFiles) TableNameOnly() string {
+	return "stored_files"
+}
+
+// SchemaName returns the schema name for ModelPublicStoredFiles
+func (m ModelPublicStoredFiles) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicStoredFiles) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicStoredFiles) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicStoredFiles) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicStoredFiles) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicStoredFiles) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicStoredFiles) GetPrefix() string {
+	return "SFT"
+}

internal/generatedmodels/sql_public_thought_links.go

@@ -0,0 +1,64 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicThoughtLinks struct {
+	bun.BaseModel `bun:"table:public.thought_links,alias:thought_links"`
+	ID            resolvespec_common.SqlInt32     `bun:"id,type:serial,pk,autoincrement," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),nullzero," json:"created_at"`
+	FromID        int64                           `bun:"from_id,type:bigint,notnull," json:"from_id"`
+	Relation      resolvespec_common.SqlString    `bun:"relation,type:text,notnull," json:"relation"`
+	ToID          int64                           `bun:"to_id,type:bigint,notnull," json:"to_id"`
+	RelFromID     *ModelPublicThoughts            `bun:"rel:has-one,join:from_id=id" json:"relfromid,omitempty"` // Has one ModelPublicThoughts
+	RelToID       *ModelPublicThoughts            `bun:"rel:has-one,join:to_id=id" json:"reltoid,omitempty"`     // Has one ModelPublicThoughts
+}
+
+// TableName returns the table name for ModelPublicThoughtLinks
+func (m ModelPublicThoughtLinks) TableName() string {
+	return "public.thought_links"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicThoughtLinks
+func (m ModelPublicThoughtLinks) TableNameOnly() string {
+	return "thought_links"
+}
+
+// SchemaName returns the schema name for ModelPublicThoughtLinks
+func (m ModelPublicThoughtLinks) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicThoughtLinks) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicThoughtLinks) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicThoughtLinks) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicThoughtLinks) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicThoughtLinks) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicThoughtLinks) GetPrefix() string {
+	return "TLH"
+}

internal/generatedmodels/sql_public_thoughts.go

@@ -0,0 +1,71 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicThoughts struct {
+	bun.BaseModel                      `bun:"table:public.thoughts,alias:thoughts"`
+	ID                                 resolvespec_common.SqlInt64     `bun:"id,type:bigserial,pk,autoincrement," json:"id"`
+	ArchivedAt                         resolvespec_common.SqlTimeStamp `bun:"archived_at,type:timestamptz,nullzero," json:"archived_at"`
+	Content                            resolvespec_common.SqlString    `bun:"content,type:text,notnull," json:"content"`
+	CreatedAt                          resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),nullzero," json:"created_at"`
+	GUID                               resolvespec_common.SqlUUID      `bun:"guid,type:uuid,default:gen_random_uuid(),notnull," json:"guid"`
+	Metadata                           resolvespec_common.SqlJSONB     `bun:"metadata,type:jsonb,default:'{}::jsonb',nullzero," json:"metadata"`
+	ProjectID                          resolvespec_common.SqlUUID      `bun:"project_id,type:uuid,nullzero," json:"project_id"`
+	UpdatedAt                          resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),nullzero," json:"updated_at"`
+	RelProjectID                       *ModelPublicProjects            `bun:"rel:has-one,join:project_id=guid" json:"relprojectid,omitempty"`                                // Has one ModelPublicProjects
+	RelFromIDPublicThoughtLinks        []*ModelPublicThoughtLinks      `bun:"rel:has-many,join:id=from_id" json:"relfromidpublicthoughtlinks,omitempty"`                     // Has many ModelPublicThoughtLinks
+	RelToIDPublicThoughtLinks          []*ModelPublicThoughtLinks      `bun:"rel:has-many,join:id=to_id" json:"reltoidpublicthoughtlinks,omitempty"`                         // Has many ModelPublicThoughtLinks
+	RelThoughtIDPublicEmbeddings       []*ModelPublicEmbeddings        `bun:"rel:has-many,join:guid=thought_id" json:"relthoughtidpublicembeddings,omitempty"`               // Has many ModelPublicEmbeddings
+	RelThoughtIDPublicStoredFiles      []*ModelPublicStoredFiles       `bun:"rel:has-many,join:guid=thought_id" json:"relthoughtidpublicstoredfiles,omitempty"`              // Has many ModelPublicStoredFiles
+	RelRelatedThoughtIDPublicLearnings []*ModelPublicLearnings         `bun:"rel:has-many,join:guid=related_thought_id" json:"relrelatedthoughtidpubliclearnings,omitempty"` // Has many ModelPublicLearnings
+}
+
+// TableName returns the table name for ModelPublicThoughts
+func (m ModelPublicThoughts) TableName() string {
+	return "public.thoughts"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicThoughts
+func (m ModelPublicThoughts) TableNameOnly() string {
+	return "thoughts"
+}
+
+// SchemaName returns the schema name for ModelPublicThoughts
+func (m ModelPublicThoughts) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicThoughts) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicThoughts) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicThoughts) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicThoughts) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicThoughts) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicThoughts) GetPrefix() string {
+	return "THO"
+}

internal/generatedmodels/sql_public_tool_annotations.go

@@ -0,0 +1,62 @@
+// Code generated by relspecgo. DO NOT EDIT.
+package generatedmodels
+
+import (
+	"fmt"
+	resolvespec_common "github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/uptrace/bun"
+)
+
+type ModelPublicToolAnnotations struct {
+	bun.BaseModel `bun:"table:public.tool_annotations,alias:tool_annotations"`
+	ID            resolvespec_common.SqlInt64     `bun:"id,type:bigserial,pk,autoincrement," json:"id"`
+	CreatedAt     resolvespec_common.SqlTimeStamp `bun:"created_at,type:timestamptz,default:now(),notnull," json:"created_at"`
+	Notes         resolvespec_common.SqlString    `bun:"notes,type:text,default:'',notnull," json:"notes"`
+	ToolName      resolvespec_common.SqlString    `bun:"tool_name,type:text,notnull," json:"tool_name"`
+	UpdatedAt     resolvespec_common.SqlTimeStamp `bun:"updated_at,type:timestamptz,default:now(),notnull," json:"updated_at"`
+}
+
+// TableName returns the table name for ModelPublicToolAnnotations
+func (m ModelPublicToolAnnotations) TableName() string {
+	return "public.tool_annotations"
+}
+
+// TableNameOnly returns the table name without schema for ModelPublicToolAnnotations
+func (m ModelPublicToolAnnotations) TableNameOnly() string {
+	return "tool_annotations"
+}
+
+// SchemaName returns the schema name for ModelPublicToolAnnotations
+func (m ModelPublicToolAnnotations) SchemaName() string {
+	return "public"
+}
+
+// GetID returns the primary key value
+func (m ModelPublicToolAnnotations) GetID() int64 {
+	return m.ID.Int64()
+}
+
+// GetIDStr returns the primary key as a string
+func (m ModelPublicToolAnnotations) GetIDStr() string {
+	return fmt.Sprintf("%v", m.ID)
+}
+
+// SetID sets the primary key value
+func (m ModelPublicToolAnnotations) SetID(newid int64) {
+	m.UpdateID(newid)
+}
+
+// UpdateID updates the primary key value
+func (m *ModelPublicToolAnnotations) UpdateID(newid int64) {
+	m.ID.FromString(fmt.Sprintf("%d", newid))
+}
+
+// GetIDName returns the name of the primary key column
+func (m ModelPublicToolAnnotations) GetIDName() string {
+	return "id"
+}
+
+// GetPrefix returns the table prefix
+func (m ModelPublicToolAnnotations) GetPrefix() string {
+	return "TAO"
+}

internal/store/calendar.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -19,9 +20,12 @@ func (db *DB) AddFamilyMember(ctx context.Context, m ext.FamilyMember) (ext.Fami
 	`, m.Name, nullStr(m.Relationship), m.BirthDate, nullStr(m.Notes))
 
 	created := m
-	if err := row.Scan(&created.ID, &created.CreatedAt); err != nil {
+	var model generatedmodels.ModelPublicFamilyMembers
+	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 		return ext.FamilyMember{}, fmt.Errorf("insert family member: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
 	return created, nil
 }
 
@@ -34,14 +38,11 @@ func (db *DB) ListFamilyMembers(ctx context.Context) ([]ext.FamilyMember, error)
 
 	var members []ext.FamilyMember
 	for rows.Next() {
-		var m ext.FamilyMember
-		var relationship, notes *string
-		if err := rows.Scan(&m.ID, &m.Name, &relationship, &m.BirthDate, &notes, &m.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicFamilyMembers
+		if err := rows.Scan(&model.ID, &model.Name, &model.Relationship, &model.BirthDate, &model.Notes, &model.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan family member: %w", err)
 		}
-		m.Relationship = strVal(relationship)
-		m.Notes = strVal(notes)
-		members = append(members, m)
+		members = append(members, familyMemberFromModel(model))
 	}
 	return members, rows.Err()
 }
@@ -56,9 +57,12 @@ func (db *DB) AddActivity(ctx context.Context, a ext.Activity) (ext.Activity, er
 		nullStr(a.Location), nullStr(a.Notes))
 
 	created := a
-	if err := row.Scan(&created.ID, &created.CreatedAt); err != nil {
+	var model generatedmodels.ModelPublicActivities
+	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 		return ext.Activity{}, fmt.Errorf("insert activity: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
 	return created, nil
 }
 
@@ -129,9 +133,12 @@ func (db *DB) AddImportantDate(ctx context.Context, d ext.ImportantDate) (ext.Im
 	`, d.FamilyMemberID, d.Title, d.DateValue, d.RecurringYearly, d.ReminderDaysBefore, nullStr(d.Notes))
 
 	created := d
-	if err := row.Scan(&created.ID, &created.CreatedAt); err != nil {
+	var model generatedmodels.ModelPublicImportantDates
+	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 		return ext.ImportantDate{}, fmt.Errorf("insert important date: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
 	return created, nil
 }
 
@@ -164,17 +171,13 @@ func (db *DB) GetUpcomingDates(ctx context.Context, daysAhead int) ([]ext.Import
 
 	var dates []ext.ImportantDate
 	for rows.Next() {
-		var d ext.ImportantDate
-		var memberID *uuid.UUID
-		var memberName, notes *string
-		if err := rows.Scan(&d.ID, &memberID, &memberName, &d.Title, &d.DateValue,
-			&d.RecurringYearly, &d.ReminderDaysBefore, &notes, &d.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicImportantDates
+		var memberName *string
+		if err := rows.Scan(&model.ID, &model.FamilyMemberID, &memberName, &model.Title, &model.DateValue,
+			&model.RecurringYearly, &model.ReminderDaysBefore, &model.Notes, &model.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan important date: %w", err)
 		}
-		d.FamilyMemberID = memberID
-		d.MemberName = strVal(memberName)
-		d.Notes = strVal(notes)
-		dates = append(dates, d)
+		dates = append(dates, importantDateFromModel(model, strVal(memberName)))
 	}
 	return dates, rows.Err()
 }
@@ -188,23 +191,16 @@ func scanActivities(rows interface {
 	defer rows.Close()
 	var activities []ext.Activity
 	for rows.Next() {
-		var a ext.Activity
-		var memberName, activityType, dayOfWeek, startTime, endTime, location, notes *string
+		var model generatedmodels.ModelPublicActivities
+		var memberName *string
 		if err := rows.Scan(
-			&a.ID, &a.FamilyMemberID, &memberName, &a.Title, &activityType,
-			&dayOfWeek, &startTime, &endTime,
-			&a.StartDate, &a.EndDate, &location, &notes, &a.CreatedAt,
+			&model.ID, &model.FamilyMemberID, &memberName, &model.Title, &model.ActivityType,
+			&model.DayOfWeek, &model.StartTime, &model.EndTime,
+			&model.StartDate, &model.EndDate, &model.Location, &model.Notes, &model.CreatedAt,
 		); err != nil {
 			return nil, fmt.Errorf("scan activity: %w", err)
 		}
-		a.MemberName = strVal(memberName)
-		a.ActivityType = strVal(activityType)
-		a.DayOfWeek = strVal(dayOfWeek)
-		a.StartTime = strVal(startTime)
-		a.EndTime = strVal(endTime)
-		a.Location = strVal(location)
-		a.Notes = strVal(notes)
-		activities = append(activities, a)
+		activities = append(activities, activityFromModel(model, strVal(memberName)))
 	}
 	return activities, rows.Err()
 }

internal/store/chat_histories.go

@@ -10,6 +10,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -34,9 +35,13 @@ func (db *DB) SaveChatHistory(ctx context.Context, h ext.ChatHistory) (ext.ChatH
 	)
 
 	created := h
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicChatHistories
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.ChatHistory{}, fmt.Errorf("insert chat history: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -157,26 +162,33 @@ type rowScanner interface {
 }
 
 func scanChatHistory(row rowScanner) (ext.ChatHistory, error) {
-	var h ext.ChatHistory
-	var title, channel, agentID, summary *string
-	var messagesJSON, metaJSON []byte
-
+	var model generatedmodels.ModelPublicChatHistories
 	if err := row.Scan(
-		&h.ID, &h.SessionID, &title, &channel, &agentID, &h.ProjectID,
-		&messagesJSON, &summary, &metaJSON, &h.CreatedAt, &h.UpdatedAt,
+		&model.ID, &model.SessionID, &model.Title, &model.Channel, &model.AgentID, &model.ProjectID,
+		&model.Messages, &model.Summary, &model.Metadata, &model.CreatedAt, &model.UpdatedAt,
 	); err != nil {
 		return ext.ChatHistory{}, err
 	}
 
-	h.Title = strVal(title)
-	h.Channel = strVal(channel)
-	h.AgentID = strVal(agentID)
-	h.Summary = strVal(summary)
+	h := ext.ChatHistory{
+		ID:        model.ID.UUID(),
+		SessionID: model.SessionID.String(),
+		Title:     model.Title.String(),
+		Channel:   model.Channel.String(),
+		AgentID:   model.AgentID.String(),
+		Summary:   model.Summary.String(),
+		CreatedAt: model.CreatedAt.Time(),
+		UpdatedAt: model.UpdatedAt.Time(),
+	}
+	if model.ProjectID.Valid {
+		id := model.ProjectID.UUID()
+		h.ProjectID = &id
+	}
 
-	if err := json.Unmarshal(messagesJSON, &h.Messages); err != nil {
+	if err := json.Unmarshal(model.Messages, &h.Messages); err != nil {
 		return ext.ChatHistory{}, fmt.Errorf("unmarshal messages: %w", err)
 	}
-	if err := json.Unmarshal(metaJSON, &h.Metadata); err != nil {
+	if err := json.Unmarshal(model.Metadata, &h.Metadata); err != nil {
 		return ext.ChatHistory{}, fmt.Errorf("unmarshal metadata: %w", err)
 	}
 	if h.Messages == nil {

internal/store/crm.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -24,9 +25,13 @@ func (db *DB) AddProfessionalContact(ctx context.Context, c ext.ProfessionalCont
 		nullStr(c.LinkedInURL), nullStr(c.HowWeMet), c.Tags, nullStr(c.Notes), c.FollowUpDate)
 
 	created := c
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicProfessionalContacts
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.ProfessionalContact{}, fmt.Errorf("insert contact: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -45,7 +50,7 @@ func (db *DB) SearchContacts(ctx context.Context, query string, tags []string) (
 		conditions = append(conditions, fmt.Sprintf("tags @> $%d", len(args)))
 	}
 
-	q := `select id, name, company, title, email, phone, linkedin_url, how_we_met, tags, notes, last_contacted, follow_up_date, created_at, updated_at from professional_contacts`
+	q := `select id, name, company, title, email, phone, linkedin_url, how_we_met, tags::text[], notes, last_contacted, follow_up_date, created_at, updated_at from professional_contacts`
 	if len(conditions) > 0 {
 		q += " where " + strings.Join(conditions, " and ")
 	}
@@ -62,27 +67,18 @@ func (db *DB) SearchContacts(ctx context.Context, query string, tags []string) (
 
 func (db *DB) GetContact(ctx context.Context, id uuid.UUID) (ext.ProfessionalContact, error) {
 	row := db.pool.QueryRow(ctx, `
-		select id, name, company, title, email, phone, linkedin_url, how_we_met, tags, notes, last_contacted, follow_up_date, created_at, updated_at
+		select id, name, company, title, email, phone, linkedin_url, how_we_met, tags::text[], notes, last_contacted, follow_up_date, created_at, updated_at
 		from professional_contacts where id = $1
 	`, id)
 
-	var c ext.ProfessionalContact
-	var company, title, email, phone, linkedInURL, howWeMet, notes *string
-	if err := row.Scan(&c.ID, &c.Name, &company, &title, &email, &phone,
-		&linkedInURL, &howWeMet, &c.Tags, &notes, &c.LastContacted, &c.FollowUpDate,
-		&c.CreatedAt, &c.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicProfessionalContacts
+	var tags []string
+	if err := row.Scan(&model.ID, &model.Name, &model.Company, &model.Title, &model.Email, &model.Phone,
+		&model.LinkedinURL, &model.HowWeMet, &tags, &model.Notes, &model.LastContacted, &model.FollowUpDate,
+		&model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.ProfessionalContact{}, fmt.Errorf("get contact: %w", err)
 	}
-	c.Company = strVal(company)
-	c.Title = strVal(title)
-	c.Email = strVal(email)
-	c.Phone = strVal(phone)
-	c.LinkedInURL = strVal(linkedInURL)
-	c.HowWeMet = strVal(howWeMet)
-	c.Notes = strVal(notes)
-	if c.Tags == nil {
-		c.Tags = []string{}
-	}
+	c := professionalContactFromModel(model, tags)
 	return c, nil
 }
 
@@ -101,9 +97,12 @@ func (db *DB) LogInteraction(ctx context.Context, interaction ext.ContactInterac
 
 	created := interaction
 	created.OccurredAt = occurredAt
-	if err := row.Scan(&created.ID, &created.CreatedAt); err != nil {
+	var model generatedmodels.ModelPublicContactInteractions
+	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 		return ext.ContactInteraction{}, fmt.Errorf("insert interaction: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
 	return created, nil
 }
 
@@ -124,14 +123,12 @@ func (db *DB) GetContactHistory(ctx context.Context, contactID uuid.UUID) (ext.C
 
 	var interactions []ext.ContactInteraction
 	for rows.Next() {
-		var i ext.ContactInteraction
-		var followUpNotes *string
-		if err := rows.Scan(&i.ID, &i.ContactID, &i.InteractionType, &i.OccurredAt, &i.Summary,
-			&i.FollowUpNeeded, &followUpNotes, &i.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicContactInteractions
+		if err := rows.Scan(&model.ID, &model.ContactID, &model.InteractionType, &model.OccurredAt, &model.Summary,
+			&model.FollowUpNeeded, &model.FollowUpNotes, &model.CreatedAt); err != nil {
 			return ext.ContactHistory{}, fmt.Errorf("scan interaction: %w", err)
 		}
-		i.FollowUpNotes = strVal(followUpNotes)
-		interactions = append(interactions, i)
+		interactions = append(interactions, contactInteractionFromModel(model))
 	}
 	if err := rows.Err(); err != nil {
 		return ext.ContactHistory{}, err
@@ -148,15 +145,12 @@ func (db *DB) GetContactHistory(ctx context.Context, contactID uuid.UUID) (ext.C
 
 	var opportunities []ext.Opportunity
 	for oppRows.Next() {
-		var o ext.Opportunity
-		var description, notes *string
-		if err := oppRows.Scan(&o.ID, &o.ContactID, &o.Title, &description, &o.Stage, &o.Value,
-			&o.ExpectedCloseDate, &notes, &o.CreatedAt, &o.UpdatedAt); err != nil {
+		var model generatedmodels.ModelPublicOpportunities
+		if err := oppRows.Scan(&model.ID, &model.ContactID, &model.Title, &model.Description, &model.Stage, &model.Value,
+			&model.ExpectedCloseDate, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
 			return ext.ContactHistory{}, fmt.Errorf("scan opportunity: %w", err)
 		}
-		o.Description = strVal(description)
-		o.Notes = strVal(notes)
-		opportunities = append(opportunities, o)
+		opportunities = append(opportunities, opportunityFromModel(model))
 	}
 	if err := oppRows.Err(); err != nil {
 		return ext.ContactHistory{}, err
@@ -177,9 +171,13 @@ func (db *DB) CreateOpportunity(ctx context.Context, o ext.Opportunity) (ext.Opp
 	`, o.ContactID, o.Title, nullStr(o.Description), o.Stage, o.Value, o.ExpectedCloseDate, nullStr(o.Notes))
 
 	created := o
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicOpportunities
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.Opportunity{}, fmt.Errorf("insert opportunity: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -190,7 +188,7 @@ func (db *DB) GetFollowUpsDue(ctx context.Context, daysAhead int) ([]ext.Profess
 	cutoff := time.Now().AddDate(0, 0, daysAhead)
 
 	rows, err := db.pool.Query(ctx, `
-		select id, name, company, title, email, phone, linkedin_url, how_we_met, tags, notes, last_contacted, follow_up_date, created_at, updated_at
+		select id, name, company, title, email, phone, linkedin_url, how_we_met, tags::text[], notes, last_contacted, follow_up_date, created_at, updated_at
 		from professional_contacts
 		where follow_up_date <= $1
 		order by follow_up_date asc
@@ -224,24 +222,14 @@ func scanContacts(rows interface {
 	defer rows.Close()
 	var contacts []ext.ProfessionalContact
 	for rows.Next() {
-		var c ext.ProfessionalContact
-		var company, title, email, phone, linkedInURL, howWeMet, notes *string
-		if err := rows.Scan(&c.ID, &c.Name, &company, &title, &email, &phone,
-			&linkedInURL, &howWeMet, &c.Tags, &notes, &c.LastContacted, &c.FollowUpDate,
-			&c.CreatedAt, &c.UpdatedAt); err != nil {
+		var model generatedmodels.ModelPublicProfessionalContacts
+		var tags []string
+		if err := rows.Scan(&model.ID, &model.Name, &model.Company, &model.Title, &model.Email, &model.Phone,
+			&model.LinkedinURL, &model.HowWeMet, &tags, &model.Notes, &model.LastContacted, &model.FollowUpDate,
+			&model.CreatedAt, &model.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("scan contact: %w", err)
 		}
-		c.Company = strVal(company)
-		c.Title = strVal(title)
-		c.Email = strVal(email)
-		c.Phone = strVal(phone)
-		c.LinkedInURL = strVal(linkedInURL)
-		c.HowWeMet = strVal(howWeMet)
-		c.Notes = strVal(notes)
-		if c.Tags == nil {
-			c.Tags = []string{}
-		}
-		contacts = append(contacts, c)
+		contacts = append(contacts, professionalContactFromModel(model, tags))
 	}
 	return contacts, rows.Err()
 }

internal/store/db.go

@@ -2,18 +2,23 @@ package store
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"time"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	pgxvec "github.com/pgvector/pgvector-go/pgx"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/dialect/pgdialect"
+	"github.com/uptrace/bun/driver/pgdriver"
 
 	"git.warky.dev/wdevs/amcs/internal/config"
 )
 
 type DB struct {
 	pool *pgxpool.Pool
+	bun  *bun.DB
 }
 
 func New(ctx context.Context, cfg config.DatabaseConfig) (*DB, error) {
@@ -35,8 +40,20 @@ func New(ctx context.Context, cfg config.DatabaseConfig) (*DB, error) {
 		return nil, fmt.Errorf("create database pool: %w", err)
 	}
 
-	db := &DB{pool: pool}
+	bunSQLDB := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(cfg.URL)))
+	bunSQLDB.SetMaxOpenConns(int(cfg.MaxConns))
+	bunSQLDB.SetMaxIdleConns(int(cfg.MinConns))
+	bunSQLDB.SetConnMaxLifetime(cfg.MaxConnLifetime)
+	bunSQLDB.SetConnMaxIdleTime(cfg.MaxConnIdleTime)
+
+	db := &DB{
+		pool: pool,
+		bun:  bun.NewDB(bunSQLDB, pgdialect.New()),
+	}
 	if err := db.Ping(ctx); err != nil {
+		if db.bun != nil {
+			_ = db.bun.Close()
+		}
 		pool.Close()
 		return nil, err
 	}
@@ -45,11 +62,16 @@ func New(ctx context.Context, cfg config.DatabaseConfig) (*DB, error) {
 }
 
 func (db *DB) Close() {
-	if db == nil || db.pool == nil {
+	if db == nil {
 		return
 	}
 
-	db.pool.Close()
+	if db.bun != nil {
+		_ = db.bun.Close()
+	}
+	if db.pool != nil {
+		db.pool.Close()
+	}
 }
 
 func (db *DB) Ping(ctx context.Context) error {
@@ -102,3 +124,10 @@ func (db *DB) VerifyRequirements(ctx context.Context) error {
 
 	return nil
 }
+
+func (db *DB) Bun() *bun.DB {
+	if db == nil {
+		return nil
+	}
+	return db.bun
+}

internal/store/files.go

@@ -9,6 +9,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	thoughttypes "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -19,24 +20,24 @@ func (db *DB) InsertStoredFile(ctx context.Context, file thoughttypes.StoredFile
 		returning guid, thought_id, project_id, name, media_type, kind, encoding, size_bytes, sha256, created_at, updated_at
 	`, file.ThoughtID, file.ProjectID, file.Name, file.MediaType, file.Kind, file.Encoding, file.SizeBytes, file.SHA256, file.Content)
 
-	var created thoughttypes.StoredFile
+	var model generatedmodels.ModelPublicStoredFiles
 	if err := row.Scan(
-		&created.ID,
-		&created.ThoughtID,
-		&created.ProjectID,
-		&created.Name,
-		&created.MediaType,
-		&created.Kind,
-		&created.Encoding,
-		&created.SizeBytes,
-		&created.SHA256,
-		&created.CreatedAt,
-		&created.UpdatedAt,
+		&model.GUID,
+		&model.ThoughtID,
+		&model.ProjectID,
+		&model.Name,
+		&model.MediaType,
+		&model.Kind,
+		&model.Encoding,
+		&model.SizeBytes,
+		&model.Sha256,
+		&model.CreatedAt,
+		&model.UpdatedAt,
 	); err != nil {
 		return thoughttypes.StoredFile{}, fmt.Errorf("insert stored file: %w", err)
 	}
 
-	return created, nil
+	return storedFileFromModel(model), nil
 }
 
 func (db *DB) GetStoredFile(ctx context.Context, id uuid.UUID) (thoughttypes.StoredFile, error) {
@@ -46,20 +47,20 @@ func (db *DB) GetStoredFile(ctx context.Context, id uuid.UUID) (thoughttypes.Sto
 		where guid = $1
 	`, id)
 
-	var file thoughttypes.StoredFile
+	var model generatedmodels.ModelPublicStoredFiles
 	if err := row.Scan(
-		&file.ID,
-		&file.ThoughtID,
-		&file.ProjectID,
-		&file.Name,
-		&file.MediaType,
-		&file.Kind,
-		&file.Encoding,
-		&file.SizeBytes,
-		&file.SHA256,
-		&file.Content,
-		&file.CreatedAt,
-		&file.UpdatedAt,
+		&model.GUID,
+		&model.ThoughtID,
+		&model.ProjectID,
+		&model.Name,
+		&model.MediaType,
+		&model.Kind,
+		&model.Encoding,
+		&model.SizeBytes,
+		&model.Sha256,
+		&model.Content,
+		&model.CreatedAt,
+		&model.UpdatedAt,
 	); err != nil {
 		if err == pgx.ErrNoRows {
 			return thoughttypes.StoredFile{}, err
@@ -67,7 +68,7 @@ func (db *DB) GetStoredFile(ctx context.Context, id uuid.UUID) (thoughttypes.Sto
 		return thoughttypes.StoredFile{}, fmt.Errorf("get stored file: %w", err)
 	}
 
-	return file, nil
+	return storedFileFromModel(model), nil
 }
 
 func (db *DB) ListStoredFiles(ctx context.Context, filter thoughttypes.StoredFileFilter) ([]thoughttypes.StoredFile, error) {
@@ -106,23 +107,23 @@ func (db *DB) ListStoredFiles(ctx context.Context, filter thoughttypes.StoredFil
 
 	files := make([]thoughttypes.StoredFile, 0, filter.Limit)
 	for rows.Next() {
-		var file thoughttypes.StoredFile
+		var model generatedmodels.ModelPublicStoredFiles
 		if err := rows.Scan(
-			&file.ID,
-			&file.ThoughtID,
-			&file.ProjectID,
-			&file.Name,
-			&file.MediaType,
-			&file.Kind,
-			&file.Encoding,
-			&file.SizeBytes,
-			&file.SHA256,
-			&file.CreatedAt,
-			&file.UpdatedAt,
+			&model.GUID,
+			&model.ThoughtID,
+			&model.ProjectID,
+			&model.Name,
+			&model.MediaType,
+			&model.Kind,
+			&model.Encoding,
+			&model.SizeBytes,
+			&model.Sha256,
+			&model.CreatedAt,
+			&model.UpdatedAt,
 		); err != nil {
 			return nil, fmt.Errorf("scan stored file: %w", err)
 		}
-		files = append(files, file)
+		files = append(files, storedFileFromModel(model))
 	}
 	if err := rows.Err(); err != nil {
 		return nil, fmt.Errorf("iterate stored files: %w", err)

internal/store/household.go

@@ -5,10 +5,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
-	"time"
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -25,9 +25,13 @@ func (db *DB) AddHouseholdItem(ctx context.Context, item ext.HouseholdItem) (ext
 	`, item.Name, nullStr(item.Category), nullStr(item.Location), details, nullStr(item.Notes))
 
 	created := item
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicHouseholdItems
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.HouseholdItem{}, fmt.Errorf("insert household item: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -62,19 +66,11 @@ func (db *DB) SearchHouseholdItems(ctx context.Context, query, category, locatio
 
 	var items []ext.HouseholdItem
 	for rows.Next() {
-		var item ext.HouseholdItem
-		var detailsBytes []byte
-		var category, location, notes *string
-		if err := rows.Scan(&item.ID, &item.Name, &category, &location, &detailsBytes, &notes, &item.CreatedAt, &item.UpdatedAt); err != nil {
+		var model generatedmodels.ModelPublicHouseholdItems
+		if err := rows.Scan(&model.ID, &model.Name, &model.Category, &model.Location, &model.Details, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("scan household item: %w", err)
 		}
-		item.Category = strVal(category)
-		item.Location = strVal(location)
-		item.Notes = strVal(notes)
-		if err := json.Unmarshal(detailsBytes, &item.Details); err != nil {
-			item.Details = map[string]any{}
-		}
-		items = append(items, item)
+		items = append(items, householdItemFromModel(model))
 	}
 	return items, rows.Err()
 }
@@ -85,19 +81,11 @@ func (db *DB) GetHouseholdItem(ctx context.Context, id uuid.UUID) (ext.Household
 		from household_items where id = $1
 	`, id)
 
-	var item ext.HouseholdItem
-	var detailsBytes []byte
-	var category, location, notes *string
-	if err := row.Scan(&item.ID, &item.Name, &category, &location, &detailsBytes, &notes, &item.CreatedAt, &item.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicHouseholdItems
+	if err := row.Scan(&model.ID, &model.Name, &model.Category, &model.Location, &model.Details, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.HouseholdItem{}, fmt.Errorf("get household item: %w", err)
 	}
-	item.Category = strVal(category)
-	item.Location = strVal(location)
-	item.Notes = strVal(notes)
-	if err := json.Unmarshal(detailsBytes, &item.Details); err != nil {
-		item.Details = map[string]any{}
-	}
-	return item, nil
+	return householdItemFromModel(model), nil
 }
 
 func (db *DB) AddVendor(ctx context.Context, v ext.HouseholdVendor) (ext.HouseholdVendor, error) {
@@ -109,9 +97,12 @@ func (db *DB) AddVendor(ctx context.Context, v ext.HouseholdVendor) (ext.Househo
 		nullStr(v.Website), nullStr(v.Notes), v.Rating, v.LastUsed)
 
 	created := v
-	if err := row.Scan(&created.ID, &created.CreatedAt); err != nil {
+	var model generatedmodels.ModelPublicHouseholdVendors
+	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 		return ext.HouseholdVendor{}, fmt.Errorf("insert vendor: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
 	return created, nil
 }
 
@@ -132,19 +123,11 @@ func (db *DB) ListVendors(ctx context.Context, serviceType string) ([]ext.Househ
 
 	var vendors []ext.HouseholdVendor
 	for rows.Next() {
-		var v ext.HouseholdVendor
-		var serviceType, phone, email, website, notes *string
-		var lastUsed *time.Time
-		if err := rows.Scan(&v.ID, &v.Name, &serviceType, &phone, &email, &website, &notes, &v.Rating, &lastUsed, &v.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicHouseholdVendors
+		if err := rows.Scan(&model.ID, &model.Name, &model.ServiceType, &model.Phone, &model.Email, &model.Website, &model.Notes, &model.Rating, &model.LastUsed, &model.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan vendor: %w", err)
 		}
-		v.ServiceType = strVal(serviceType)
-		v.Phone = strVal(phone)
-		v.Email = strVal(email)
-		v.Website = strVal(website)
-		v.Notes = strVal(notes)
-		v.LastUsed = lastUsed
-		vendors = append(vendors, v)
+		vendors = append(vendors, householdVendorFromModel(model))
 	}
 	return vendors, rows.Err()
 }

internal/store/learnings.go

@@ -5,9 +5,9 @@ import (
 	"fmt"
 	"strings"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgtype"
 
 	thoughttypes "git.warky.dev/wdevs/amcs/internal/types"
 )
@@ -48,9 +48,13 @@ func (db *DB) CreateLearning(ctx context.Context, learning thoughttypes.Learning
 	)
 
 	created := learning
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicLearnings
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return thoughttypes.Learning{}, fmt.Errorf("create learning: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -59,7 +63,7 @@ func (db *DB) GetLearning(ctx context.Context, id uuid.UUID) (thoughttypes.Learn
 		select id, summary, details, category, area, status, priority, confidence,
 		       action_required, source_type, source_ref, project_id, related_thought_id,
 		       related_skill_id, reviewed_by, reviewed_at, duplicate_of_learning_id,
-		       supersedes_learning_id, tags, created_at, updated_at
+		       supersedes_learning_id, tags::text[], created_at, updated_at
 		from learnings
 		where id = $1
 	`, id)
@@ -111,7 +115,7 @@ func (db *DB) ListLearnings(ctx context.Context, filter thoughttypes.LearningFil
 		select id, summary, details, category, area, status, priority, confidence,
 		       action_required, source_type, source_ref, project_id, related_thought_id,
 		       related_skill_id, reviewed_by, reviewed_at, duplicate_of_learning_id,
-		       supersedes_learning_id, tags, created_at, updated_at
+		       supersedes_learning_id, tags::text[], created_at, updated_at
 		from learnings
 	`
 	if len(conditions) > 0 {
@@ -148,51 +152,40 @@ type learningScanner interface {
 }
 
 func scanLearning(row learningScanner) (thoughttypes.Learning, error) {
-	var learning thoughttypes.Learning
-	var sourceType pgtype.Text
-	var sourceRef pgtype.Text
-	var reviewedBy pgtype.Text
+	var model generatedmodels.ModelPublicLearnings
 	var tags []string
 
 	err := row.Scan(
-		&learning.ID,
-		&learning.Summary,
-		&learning.Details,
-		&learning.Category,
-		&learning.Area,
-		&learning.Status,
-		&learning.Priority,
-		&learning.Confidence,
-		&learning.ActionRequired,
-		&sourceType,
-		&sourceRef,
-		&learning.ProjectID,
-		&learning.RelatedThoughtID,
-		&learning.RelatedSkillID,
-		&reviewedBy,
-		&learning.ReviewedAt,
-		&learning.DuplicateOfLearningID,
-		&learning.SupersedesLearningID,
+		&model.ID,
+		&model.Summary,
+		&model.Details,
+		&model.Category,
+		&model.Area,
+		&model.Status,
+		&model.Priority,
+		&model.Confidence,
+		&model.ActionRequired,
+		&model.SourceType,
+		&model.SourceRef,
+		&model.ProjectID,
+		&model.RelatedThoughtID,
+		&model.RelatedSkillID,
+		&model.ReviewedBy,
+		&model.ReviewedAt,
+		&model.DuplicateOfLearningID,
+		&model.SupersedesLearningID,
 		&tags,
-		&learning.CreatedAt,
-		&learning.UpdatedAt,
+		&model.CreatedAt,
+		&model.UpdatedAt,
 	)
 	if err != nil {
 		return thoughttypes.Learning{}, err
 	}
 
-	learning.SourceType = sourceType.String
-	learning.SourceRef = sourceRef.String
-	if reviewedBy.Valid {
-		value := reviewedBy.String
-		learning.ReviewedBy = &value
-	}
 	if tags == nil {
-		learning.Tags = []string{}
-	} else {
-		learning.Tags = tags
+		tags = []string{}
 	}
-	return learning, nil
+	return learningFromModel(model, tags), nil
 }
 
 func nullableText(value string) *string {

internal/store/links.go

@@ -2,11 +2,11 @@ package store
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	thoughttypes "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -44,24 +44,26 @@ func (db *DB) LinkedThoughts(ctx context.Context, thoughtID uuid.UUID) ([]though
 	links := make([]thoughttypes.LinkedThought, 0)
 	for rows.Next() {
 		var linked thoughttypes.LinkedThought
-		var metadataBytes []byte
+		var model generatedmodels.ModelPublicThoughts
 		if err := rows.Scan(
-			&linked.Thought.ID,
-			&linked.Thought.Content,
-			&metadataBytes,
-			&linked.Thought.ProjectID,
-			&linked.Thought.ArchivedAt,
-			&linked.Thought.CreatedAt,
-			&linked.Thought.UpdatedAt,
+			&model.GUID,
+			&model.Content,
+			&model.Metadata,
+			&model.ProjectID,
+			&model.ArchivedAt,
+			&model.CreatedAt,
+			&model.UpdatedAt,
 			&linked.Relation,
 			&linked.Direction,
 			&linked.CreatedAt,
 		); err != nil {
 			return nil, fmt.Errorf("scan linked thought: %w", err)
 		}
-		if err := json.Unmarshal(metadataBytes, &linked.Thought.Metadata); err != nil {
-			return nil, fmt.Errorf("decode linked thought metadata: %w", err)
+		thought, err := thoughtFromModel(model)
+		if err != nil {
+			return nil, fmt.Errorf("map linked thought: %w", err)
 		}
+		linked.Thought = thought
 		links = append(links, linked)
 	}
 	if err := rows.Err(); err != nil {

internal/store/maintenance.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -17,9 +18,13 @@ func (db *DB) AddMaintenanceTask(ctx context.Context, t ext.MaintenanceTask) (ex
 	`, t.Name, nullStr(t.Category), t.FrequencyDays, t.NextDue, t.Priority, nullStr(t.Notes))
 
 	created := t
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicMaintenanceTasks
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.MaintenanceTask{}, fmt.Errorf("insert maintenance task: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -37,9 +42,11 @@ func (db *DB) LogMaintenance(ctx context.Context, log ext.MaintenanceLog) (ext.M
 
 	created := log
 	created.CompletedAt = completedAt
-	if err := row.Scan(&created.ID); err != nil {
+	var model generatedmodels.ModelPublicMaintenanceLogs
+	if err := row.Scan(&model.ID); err != nil {
 		return ext.MaintenanceLog{}, fmt.Errorf("insert maintenance log: %w", err)
 	}
+	created.ID = model.ID.UUID()
 	return created, nil
 }
 
@@ -60,7 +67,15 @@ func (db *DB) GetUpcomingMaintenance(ctx context.Context, daysAhead int) ([]ext.
 	}
 	defer rows.Close()
 
-	return scanMaintenanceTasks(rows)
+	tasks := make([]ext.MaintenanceTask, 0)
+	for rows.Next() {
+		var model generatedmodels.ModelPublicMaintenanceTasks
+		if err := rows.Scan(&model.ID, &model.Name, &model.Category, &model.FrequencyDays, &model.LastCompleted, &model.NextDue, &model.Priority, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("scan maintenance task: %w", err)
+		}
+		tasks = append(tasks, maintenanceTaskFromModel(model))
+	}
+	return tasks, rows.Err()
 }
 
 func (db *DB) SearchMaintenanceHistory(ctx context.Context, query, category string, start, end *time.Time) ([]ext.MaintenanceLogWithTask, error) {
@@ -103,40 +118,20 @@ func (db *DB) SearchMaintenanceHistory(ctx context.Context, query, category stri
 
 	var logs []ext.MaintenanceLogWithTask
 	for rows.Next() {
-		var l ext.MaintenanceLogWithTask
-		var performedBy, notes, nextAction, taskCategory *string
+		var model generatedmodels.ModelPublicMaintenanceLogs
+		var taskName, taskCategory string
 		if err := rows.Scan(
-			&l.ID, &l.TaskID, &l.CompletedAt, &performedBy, &l.Cost, &notes, &nextAction,
-			&l.TaskName, &taskCategory,
+			&model.ID, &model.TaskID, &model.CompletedAt, &model.PerformedBy, &model.Cost, &model.Notes, &model.NextAction,
+			&taskName, &taskCategory,
 		); err != nil {
 			return nil, fmt.Errorf("scan maintenance log: %w", err)
 		}
-		l.PerformedBy = strVal(performedBy)
-		l.Notes = strVal(notes)
-		l.NextAction = strVal(nextAction)
-		l.TaskCategory = strVal(taskCategory)
+		l := ext.MaintenanceLogWithTask{
+			MaintenanceLog: maintenanceLogFromModel(model),
+			TaskName:       taskName,
+			TaskCategory:   taskCategory,
+		}
 		logs = append(logs, l)
 	}
 	return logs, rows.Err()
 }
-
-func scanMaintenanceTasks(rows interface {
-	Next() bool
-	Scan(...any) error
-	Err() error
-	Close()
-}) ([]ext.MaintenanceTask, error) {
-	defer rows.Close()
-	var tasks []ext.MaintenanceTask
-	for rows.Next() {
-		var t ext.MaintenanceTask
-		var category, notes *string
-		if err := rows.Scan(&t.ID, &t.Name, &category, &t.FrequencyDays, &t.LastCompleted, &t.NextDue, &t.Priority, &notes, &t.CreatedAt, &t.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("scan maintenance task: %w", err)
-		}
-		t.Category = strVal(category)
-		t.Notes = strVal(notes)
-		tasks = append(tasks, t)
-	}
-	return tasks, rows.Err()
-}

internal/store/meals.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -33,9 +34,13 @@ func (db *DB) AddRecipe(ctx context.Context, r ext.Recipe) (ext.Recipe, error) {
 		ingredients, instructions, r.Tags, r.Rating, nullStr(r.Notes))
 
 	created := r
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicRecipes
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.Recipe{}, fmt.Errorf("insert recipe: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -60,7 +65,7 @@ func (db *DB) SearchRecipes(ctx context.Context, query, cuisine string, tags []s
 		conditions = append(conditions, fmt.Sprintf("ingredients::text ILIKE $%d", len(args)))
 	}
 
-	q := `select id, name, cuisine, prep_time_minutes, cook_time_minutes, servings, ingredients, instructions, tags, rating, notes, created_at, updated_at from recipes`
+	q := `select id, name, cuisine, prep_time_minutes, cook_time_minutes, servings, ingredients, instructions, tags::text[], rating, notes, created_at, updated_at from recipes`
 	if len(conditions) > 0 {
 		q += " where " + strings.Join(conditions, " and ")
 	}
@@ -85,29 +90,20 @@ func (db *DB) SearchRecipes(ctx context.Context, query, cuisine string, tags []s
 
 func (db *DB) GetRecipe(ctx context.Context, id uuid.UUID) (ext.Recipe, error) {
 	row := db.pool.QueryRow(ctx, `
-		select id, name, cuisine, prep_time_minutes, cook_time_minutes, servings, ingredients, instructions, tags, rating, notes, created_at, updated_at
+		select id, name, cuisine, prep_time_minutes, cook_time_minutes, servings, ingredients, instructions, tags::text[], rating, notes, created_at, updated_at
 		from recipes where id = $1
 	`, id)
 
-	var r ext.Recipe
-	var cuisine, notes *string
-	var ingredientsBytes, instructionsBytes []byte
-	if err := row.Scan(&r.ID, &r.Name, &cuisine, &r.PrepTimeMinutes, &r.CookTimeMinutes, &r.Servings,
-		&ingredientsBytes, &instructionsBytes, &r.Tags, &r.Rating, &notes, &r.CreatedAt, &r.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicRecipes
+	var tags []string
+	if err := row.Scan(&model.ID, &model.Name, &model.Cuisine, &model.PrepTimeMinutes, &model.CookTimeMinutes, &model.Servings,
+		&model.Ingredients, &model.Instructions, &tags, &model.Rating, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.Recipe{}, fmt.Errorf("get recipe: %w", err)
 	}
-	r.Cuisine = strVal(cuisine)
-	r.Notes = strVal(notes)
-	if r.Tags == nil {
-		r.Tags = []string{}
+	if tags == nil {
+		tags = []string{}
 	}
-	if err := json.Unmarshal(ingredientsBytes, &r.Ingredients); err != nil {
-		r.Ingredients = []ext.Ingredient{}
-	}
-	if err := json.Unmarshal(instructionsBytes, &r.Instructions); err != nil {
-		r.Instructions = []string{}
-	}
-	return r, nil
+	return recipeFromModel(model, tags), nil
 }
 
 func (db *DB) UpdateRecipe(ctx context.Context, id uuid.UUID, r ext.Recipe) (ext.Recipe, error) {
@@ -159,9 +155,12 @@ func (db *DB) CreateMealPlan(ctx context.Context, weekStart time.Time, entries [
 			Servings:   e.Servings,
 			Notes:      e.Notes,
 		}
-		if err := row.Scan(&entry.ID, &entry.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicMealPlans
+		if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
 			return nil, fmt.Errorf("insert meal plan entry: %w", err)
 		}
+		entry.ID = model.ID.UUID()
+		entry.CreatedAt = model.CreatedAt.Time()
 		results = append(results, entry)
 	}
 	return results, nil
@@ -191,15 +190,12 @@ func (db *DB) GetMealPlan(ctx context.Context, weekStart time.Time) ([]ext.MealP
 
 	var entries []ext.MealPlanEntry
 	for rows.Next() {
-		var e ext.MealPlanEntry
-		var recipeName, customMeal, notes *string
-		if err := rows.Scan(&e.ID, &e.WeekStart, &e.DayOfWeek, &e.MealType, &e.RecipeID, &recipeName, &customMeal, &e.Servings, &notes, &e.CreatedAt); err != nil {
+		var model generatedmodels.ModelPublicMealPlans
+		var recipeName *string
+		if err := rows.Scan(&model.ID, &model.WeekStart, &model.DayOfWeek, &model.MealType, &model.RecipeID, &recipeName, &model.CustomMeal, &model.Servings, &model.Notes, &model.CreatedAt); err != nil {
 			return nil, fmt.Errorf("scan meal plan entry: %w", err)
 		}
-		e.RecipeName = strVal(recipeName)
-		e.CustomMeal = strVal(customMeal)
-		e.Notes = strVal(notes)
-		entries = append(entries, e)
+		entries = append(entries, mealPlanEntryFromModel(model, strVal(recipeName)))
 	}
 	return entries, rows.Err()
 }
@@ -259,31 +255,26 @@ func (db *DB) GenerateShoppingList(ctx context.Context, weekStart time.Time) (ex
 		returning id, created_at, updated_at
 	`, weekStart, itemsJSON)
 
+	var model generatedmodels.ModelPublicShoppingLists
 	list := ext.ShoppingList{WeekStart: weekStart, Items: items}
-	if err := row.Scan(&list.ID, &list.CreatedAt, &list.UpdatedAt); err != nil {
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.ShoppingList{}, fmt.Errorf("upsert shopping list: %w", err)
 	}
+	list.ID = model.ID.UUID()
+	list.CreatedAt = model.CreatedAt.Time()
+	list.UpdatedAt = model.UpdatedAt.Time()
 	return list, nil
 }
 
 func scanRecipeRow(rows interface{ Scan(...any) error }) (ext.Recipe, error) {
-	var r ext.Recipe
-	var cuisine, notes *string
-	var ingredientsBytes, instructionsBytes []byte
-	if err := rows.Scan(&r.ID, &r.Name, &cuisine, &r.PrepTimeMinutes, &r.CookTimeMinutes, &r.Servings,
-		&ingredientsBytes, &instructionsBytes, &r.Tags, &r.Rating, &notes, &r.CreatedAt, &r.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicRecipes
+	var tags []string
+	if err := rows.Scan(&model.ID, &model.Name, &model.Cuisine, &model.PrepTimeMinutes, &model.CookTimeMinutes, &model.Servings,
+		&model.Ingredients, &model.Instructions, &tags, &model.Rating, &model.Notes, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.Recipe{}, fmt.Errorf("scan recipe: %w", err)
 	}
-	r.Cuisine = strVal(cuisine)
-	r.Notes = strVal(notes)
-	if r.Tags == nil {
-		r.Tags = []string{}
+	if tags == nil {
+		tags = []string{}
 	}
-	if err := json.Unmarshal(ingredientsBytes, &r.Ingredients); err != nil {
-		r.Ingredients = []ext.Ingredient{}
-	}
-	if err := json.Unmarshal(instructionsBytes, &r.Instructions); err != nil {
-		r.Instructions = []string{}
-	}
-	return r, nil
+	return recipeFromModel(model, tags), nil
 }

internal/store/model_adapters.go

@@ -0,0 +1,487 @@
+package store
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
+	ext "git.warky.dev/wdevs/amcs/internal/types"
+)
+
+func projectFromModel(m generatedmodels.ModelPublicProjects) ext.Project {
+	return ext.Project{
+		ID:           m.GUID.UUID(),
+		Name:         m.Name.String(),
+		Description:  m.Description.String(),
+		CreatedAt:    m.CreatedAt.Time(),
+		LastActiveAt: m.LastActiveAt.Time(),
+	}
+}
+
+func thoughtFromModel(m generatedmodels.ModelPublicThoughts) (ext.Thought, error) {
+	var metadata ext.ThoughtMetadata
+	if len(m.Metadata) > 0 {
+		if err := json.Unmarshal(m.Metadata, &metadata); err != nil {
+			return ext.Thought{}, fmt.Errorf("decode thought metadata: %w", err)
+		}
+	}
+
+	var projectID *uuid.UUID
+	if m.ProjectID.Valid {
+		id := m.ProjectID.UUID()
+		projectID = &id
+	}
+
+	var archivedAt *time.Time
+	if m.ArchivedAt.Valid {
+		t := m.ArchivedAt.Time()
+		archivedAt = &t
+	}
+
+	return ext.Thought{
+		ID:         m.GUID.UUID(),
+		Content:    m.Content.String(),
+		Metadata:   metadata,
+		ProjectID:  projectID,
+		ArchivedAt: archivedAt,
+		CreatedAt:  m.CreatedAt.Time(),
+		UpdatedAt:  m.UpdatedAt.Time(),
+	}, nil
+}
+
+func storedFileFromModel(m generatedmodels.ModelPublicStoredFiles) ext.StoredFile {
+	var thoughtID *uuid.UUID
+	if m.ThoughtID.Valid {
+		id := m.ThoughtID.UUID()
+		thoughtID = &id
+	}
+
+	var projectID *uuid.UUID
+	if m.ProjectID.Valid {
+		id := m.ProjectID.UUID()
+		projectID = &id
+	}
+
+	return ext.StoredFile{
+		ID:        m.GUID.UUID(),
+		ThoughtID: thoughtID,
+		ProjectID: projectID,
+		Name:      m.Name.String(),
+		MediaType: m.MediaType.String(),
+		Kind:      m.Kind.String(),
+		Encoding:  m.Encoding.String(),
+		SizeBytes: m.SizeBytes,
+		SHA256:    m.Sha256.String(),
+		Content:   m.Content,
+		CreatedAt: m.CreatedAt.Time(),
+		UpdatedAt: m.UpdatedAt.Time(),
+	}
+}
+
+func maintenanceTaskFromModel(m generatedmodels.ModelPublicMaintenanceTasks) ext.MaintenanceTask {
+	var frequencyDays *int
+	if m.FrequencyDays.Valid {
+		n := int(m.FrequencyDays.Int64())
+		frequencyDays = &n
+	}
+
+	var lastCompleted *time.Time
+	if m.LastCompleted.Valid {
+		t := m.LastCompleted.Time()
+		lastCompleted = &t
+	}
+
+	var nextDue *time.Time
+	if m.NextDue.Valid {
+		t := m.NextDue.Time()
+		nextDue = &t
+	}
+
+	return ext.MaintenanceTask{
+		ID:            m.ID.UUID(),
+		Name:          m.Name.String(),
+		Category:      m.Category.String(),
+		FrequencyDays: frequencyDays,
+		LastCompleted: lastCompleted,
+		NextDue:       nextDue,
+		Priority:      m.Priority.String(),
+		Notes:         m.Notes.String(),
+		CreatedAt:     m.CreatedAt.Time(),
+		UpdatedAt:     m.UpdatedAt.Time(),
+	}
+}
+
+func maintenanceLogFromModel(m generatedmodels.ModelPublicMaintenanceLogs) ext.MaintenanceLog {
+	var cost *float64
+	if m.Cost.Valid {
+		v := m.Cost.Float64()
+		cost = &v
+	}
+
+	return ext.MaintenanceLog{
+		ID:          m.ID.UUID(),
+		TaskID:      m.TaskID.UUID(),
+		CompletedAt: m.CompletedAt.Time(),
+		PerformedBy: m.PerformedBy.String(),
+		Cost:        cost,
+		Notes:       m.Notes.String(),
+		NextAction:  m.NextAction.String(),
+	}
+}
+
+func householdItemFromModel(m generatedmodels.ModelPublicHouseholdItems) ext.HouseholdItem {
+	details := map[string]any{}
+	if len(m.Details) > 0 {
+		if err := json.Unmarshal(m.Details, &details); err != nil {
+			details = map[string]any{}
+		}
+	}
+
+	return ext.HouseholdItem{
+		ID:        m.ID.UUID(),
+		Name:      m.Name.String(),
+		Category:  m.Category.String(),
+		Location:  m.Location.String(),
+		Details:   details,
+		Notes:     m.Notes.String(),
+		CreatedAt: m.CreatedAt.Time(),
+		UpdatedAt: m.UpdatedAt.Time(),
+	}
+}
+
+func householdVendorFromModel(m generatedmodels.ModelPublicHouseholdVendors) ext.HouseholdVendor {
+	var rating *int
+	if m.Rating.Valid {
+		v := int(m.Rating.Int64())
+		rating = &v
+	}
+
+	var lastUsed *time.Time
+	if m.LastUsed.Valid {
+		t := m.LastUsed.Time()
+		lastUsed = &t
+	}
+
+	return ext.HouseholdVendor{
+		ID:          m.ID.UUID(),
+		Name:        m.Name.String(),
+		ServiceType: m.ServiceType.String(),
+		Phone:       m.Phone.String(),
+		Email:       m.Email.String(),
+		Website:     m.Website.String(),
+		Notes:       m.Notes.String(),
+		Rating:      rating,
+		LastUsed:    lastUsed,
+		CreatedAt:   m.CreatedAt.Time(),
+	}
+}
+
+func familyMemberFromModel(m generatedmodels.ModelPublicFamilyMembers) ext.FamilyMember {
+	var birthDate *time.Time
+	if m.BirthDate.Valid {
+		t := m.BirthDate.Time()
+		birthDate = &t
+	}
+
+	return ext.FamilyMember{
+		ID:           m.ID.UUID(),
+		Name:         m.Name.String(),
+		Relationship: m.Relationship.String(),
+		BirthDate:    birthDate,
+		Notes:        m.Notes.String(),
+		CreatedAt:    m.CreatedAt.Time(),
+	}
+}
+
+func activityFromModel(m generatedmodels.ModelPublicActivities, memberName string) ext.Activity {
+	var familyMemberID *uuid.UUID
+	if m.FamilyMemberID.Valid {
+		id := m.FamilyMemberID.UUID()
+		familyMemberID = &id
+	}
+
+	var startDate *time.Time
+	if m.StartDate.Valid {
+		t := m.StartDate.Time()
+		startDate = &t
+	}
+
+	var endDate *time.Time
+	if m.EndDate.Valid {
+		t := m.EndDate.Time()
+		endDate = &t
+	}
+
+	return ext.Activity{
+		ID:             m.ID.UUID(),
+		FamilyMemberID: familyMemberID,
+		MemberName:     memberName,
+		Title:          m.Title.String(),
+		ActivityType:   m.ActivityType.String(),
+		DayOfWeek:      m.DayOfWeek.String(),
+		StartTime:      m.StartTime.String(),
+		EndTime:        m.EndTime.String(),
+		StartDate:      startDate,
+		EndDate:        endDate,
+		Location:       m.Location.String(),
+		Notes:          m.Notes.String(),
+		CreatedAt:      m.CreatedAt.Time(),
+	}
+}
+
+func importantDateFromModel(m generatedmodels.ModelPublicImportantDates, memberName string) ext.ImportantDate {
+	var familyMemberID *uuid.UUID
+	if m.FamilyMemberID.Valid {
+		id := m.FamilyMemberID.UUID()
+		familyMemberID = &id
+	}
+
+	return ext.ImportantDate{
+		ID:                 m.ID.UUID(),
+		FamilyMemberID:     familyMemberID,
+		MemberName:         memberName,
+		Title:              m.Title.String(),
+		DateValue:          m.DateValue.Time(),
+		RecurringYearly:    m.RecurringYearly,
+		ReminderDaysBefore: int(m.ReminderDaysBefore.Int64()),
+		Notes:              m.Notes.String(),
+		CreatedAt:          m.CreatedAt.Time(),
+	}
+}
+
+func professionalContactFromModel(m generatedmodels.ModelPublicProfessionalContacts, tags []string) ext.ProfessionalContact {
+	var lastContacted *time.Time
+	if m.LastContacted.Valid {
+		t := m.LastContacted.Time()
+		lastContacted = &t
+	}
+
+	var followUpDate *time.Time
+	if m.FollowUpDate.Valid {
+		t := m.FollowUpDate.Time()
+		followUpDate = &t
+	}
+
+	return ext.ProfessionalContact{
+		ID:            m.ID.UUID(),
+		Name:          m.Name.String(),
+		Company:       m.Company.String(),
+		Title:         m.Title.String(),
+		Email:         m.Email.String(),
+		Phone:         m.Phone.String(),
+		LinkedInURL:   m.LinkedinURL.String(),
+		HowWeMet:      m.HowWeMet.String(),
+		Tags:          tags,
+		Notes:         m.Notes.String(),
+		LastContacted: lastContacted,
+		FollowUpDate:  followUpDate,
+		CreatedAt:     m.CreatedAt.Time(),
+		UpdatedAt:     m.UpdatedAt.Time(),
+	}
+}
+
+func contactInteractionFromModel(m generatedmodels.ModelPublicContactInteractions) ext.ContactInteraction {
+	return ext.ContactInteraction{
+		ID:              m.ID.UUID(),
+		ContactID:       m.ContactID.UUID(),
+		InteractionType: m.InteractionType.String(),
+		OccurredAt:      m.OccurredAt.Time(),
+		Summary:         m.Summary.String(),
+		FollowUpNeeded:  m.FollowUpNeeded,
+		FollowUpNotes:   m.FollowUpNotes.String(),
+		CreatedAt:       m.CreatedAt.Time(),
+	}
+}
+
+func opportunityFromModel(m generatedmodels.ModelPublicOpportunities) ext.Opportunity {
+	var contactID *uuid.UUID
+	if m.ContactID.Valid {
+		id := m.ContactID.UUID()
+		contactID = &id
+	}
+
+	var value *float64
+	if m.Value.Valid {
+		v := m.Value.Float64()
+		value = &v
+	}
+
+	var expectedCloseDate *time.Time
+	if m.ExpectedCloseDate.Valid {
+		t := m.ExpectedCloseDate.Time()
+		expectedCloseDate = &t
+	}
+
+	return ext.Opportunity{
+		ID:                m.ID.UUID(),
+		ContactID:         contactID,
+		Title:             m.Title.String(),
+		Description:       m.Description.String(),
+		Stage:             m.Stage.String(),
+		Value:             value,
+		ExpectedCloseDate: expectedCloseDate,
+		Notes:             m.Notes.String(),
+		CreatedAt:         m.CreatedAt.Time(),
+		UpdatedAt:         m.UpdatedAt.Time(),
+	}
+}
+
+func recipeFromModel(m generatedmodels.ModelPublicRecipes, tags []string) ext.Recipe {
+	var prepTimeMinutes *int
+	if m.PrepTimeMinutes.Valid {
+		v := int(m.PrepTimeMinutes.Int64())
+		prepTimeMinutes = &v
+	}
+
+	var cookTimeMinutes *int
+	if m.CookTimeMinutes.Valid {
+		v := int(m.CookTimeMinutes.Int64())
+		cookTimeMinutes = &v
+	}
+
+	var servings *int
+	if m.Servings.Valid {
+		v := int(m.Servings.Int64())
+		servings = &v
+	}
+
+	var rating *int
+	if m.Rating.Valid {
+		v := int(m.Rating.Int64())
+		rating = &v
+	}
+
+	recipe := ext.Recipe{
+		ID:              m.ID.UUID(),
+		Name:            m.Name.String(),
+		Cuisine:         m.Cuisine.String(),
+		PrepTimeMinutes: prepTimeMinutes,
+		CookTimeMinutes: cookTimeMinutes,
+		Servings:        servings,
+		Tags:            tags,
+		Rating:          rating,
+		Notes:           m.Notes.String(),
+		CreatedAt:       m.CreatedAt.Time(),
+		UpdatedAt:       m.UpdatedAt.Time(),
+	}
+
+	if err := json.Unmarshal(m.Ingredients, &recipe.Ingredients); err != nil {
+		recipe.Ingredients = []ext.Ingredient{}
+	}
+	if err := json.Unmarshal(m.Instructions, &recipe.Instructions); err != nil {
+		recipe.Instructions = []string{}
+	}
+	return recipe
+}
+
+func mealPlanEntryFromModel(m generatedmodels.ModelPublicMealPlans, recipeName string) ext.MealPlanEntry {
+	var recipeID *uuid.UUID
+	if m.RecipeID.Valid {
+		id := m.RecipeID.UUID()
+		recipeID = &id
+	}
+
+	var servings *int
+	if m.Servings.Valid {
+		v := int(m.Servings.Int64())
+		servings = &v
+	}
+
+	return ext.MealPlanEntry{
+		ID:         m.ID.UUID(),
+		WeekStart:  m.WeekStart.Time(),
+		DayOfWeek:  m.DayOfWeek.String(),
+		MealType:   m.MealType.String(),
+		RecipeID:   recipeID,
+		RecipeName: recipeName,
+		CustomMeal: m.CustomMeal.String(),
+		Servings:   servings,
+		Notes:      m.Notes.String(),
+		CreatedAt:  m.CreatedAt.Time(),
+	}
+}
+
+func shoppingListFromModel(m generatedmodels.ModelPublicShoppingLists) ext.ShoppingList {
+	list := ext.ShoppingList{
+		ID:        m.ID.UUID(),
+		WeekStart: m.WeekStart.Time(),
+		Notes:     m.Notes.String(),
+		CreatedAt: m.CreatedAt.Time(),
+		UpdatedAt: m.UpdatedAt.Time(),
+	}
+	if err := json.Unmarshal(m.Items, &list.Items); err != nil {
+		list.Items = []ext.ShoppingItem{}
+	}
+	return list
+}
+
+func learningFromModel(m generatedmodels.ModelPublicLearnings, tags []string) ext.Learning {
+	var projectID *uuid.UUID
+	if m.ProjectID.Valid {
+		id := m.ProjectID.UUID()
+		projectID = &id
+	}
+
+	var relatedThoughtID *uuid.UUID
+	if m.RelatedThoughtID.Valid {
+		id := m.RelatedThoughtID.UUID()
+		relatedThoughtID = &id
+	}
+
+	var relatedSkillID *uuid.UUID
+	if m.RelatedSkillID.Valid {
+		id := m.RelatedSkillID.UUID()
+		relatedSkillID = &id
+	}
+
+	var duplicateOfLearningID *uuid.UUID
+	if m.DuplicateOfLearningID.Valid {
+		id := m.DuplicateOfLearningID.UUID()
+		duplicateOfLearningID = &id
+	}
+
+	var supersedesLearningID *uuid.UUID
+	if m.SupersedesLearningID.Valid {
+		id := m.SupersedesLearningID.UUID()
+		supersedesLearningID = &id
+	}
+
+	var reviewedBy *string
+	if m.ReviewedBy.Valid {
+		value := m.ReviewedBy.String()
+		reviewedBy = &value
+	}
+
+	var reviewedAt *time.Time
+	if m.ReviewedAt.Valid {
+		t := m.ReviewedAt.Time()
+		reviewedAt = &t
+	}
+
+	return ext.Learning{
+		ID:                    m.ID.UUID(),
+		Summary:               m.Summary.String(),
+		Details:               m.Details.String(),
+		Category:              m.Category.String(),
+		Area:                  m.Area.String(),
+		Status:                ext.LearningStatus(m.Status.String()),
+		Priority:              ext.LearningPriority(m.Priority.String()),
+		Confidence:            ext.LearningEvidenceLevel(m.Confidence.String()),
+		ActionRequired:        m.ActionRequired,
+		SourceType:            m.SourceType.String(),
+		SourceRef:             m.SourceRef.String(),
+		ProjectID:             projectID,
+		RelatedThoughtID:      relatedThoughtID,
+		RelatedSkillID:        relatedSkillID,
+		ReviewedBy:            reviewedBy,
+		ReviewedAt:            reviewedAt,
+		DuplicateOfLearningID: duplicateOfLearningID,
+		SupersedesLearningID:  supersedesLearningID,
+		Tags:                  tags,
+		CreatedAt:             m.CreatedAt.Time(),
+		UpdatedAt:             m.UpdatedAt.Time(),
+	}
+}

internal/store/projects.go

@@ -8,6 +8,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	thoughttypes "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -18,11 +19,11 @@ func (db *DB) CreateProject(ctx context.Context, name, description string) (thou
 		returning guid, name, description, created_at, last_active_at
 	`, name, description)
 
-	var project thoughttypes.Project
-	if err := row.Scan(&project.ID, &project.Name, &project.Description, &project.CreatedAt, &project.LastActiveAt); err != nil {
+	var model generatedmodels.ModelPublicProjects
+	if err := row.Scan(&model.GUID, &model.Name, &model.Description, &model.CreatedAt, &model.LastActiveAt); err != nil {
 		return thoughttypes.Project{}, fmt.Errorf("create project: %w", err)
 	}
-	return project, nil
+	return projectFromModel(model), nil
 }
 
 func (db *DB) GetProject(ctx context.Context, nameOrID string) (thoughttypes.Project, error) {
@@ -62,14 +63,14 @@ func (db *DB) getProjectByName(ctx context.Context, name string) (thoughttypes.P
 }
 
 func scanProject(row pgx.Row) (thoughttypes.Project, error) {
-	var project thoughttypes.Project
-	if err := row.Scan(&project.ID, &project.Name, &project.Description, &project.CreatedAt, &project.LastActiveAt); err != nil {
+	var model generatedmodels.ModelPublicProjects
+	if err := row.Scan(&model.GUID, &model.Name, &model.Description, &model.CreatedAt, &model.LastActiveAt); err != nil {
 		if err == pgx.ErrNoRows {
 			return thoughttypes.Project{}, err
 		}
 		return thoughttypes.Project{}, fmt.Errorf("get project: %w", err)
 	}
-	return project, nil
+	return projectFromModel(model), nil
 }
 
 func (db *DB) ListProjects(ctx context.Context) ([]thoughttypes.ProjectSummary, error) {
@@ -87,11 +88,15 @@ func (db *DB) ListProjects(ctx context.Context) ([]thoughttypes.ProjectSummary,
 
 	projects := make([]thoughttypes.ProjectSummary, 0)
 	for rows.Next() {
-		var project thoughttypes.ProjectSummary
-		if err := rows.Scan(&project.ID, &project.Name, &project.Description, &project.CreatedAt, &project.LastActiveAt, &project.ThoughtCount); err != nil {
+		var model generatedmodels.ModelPublicProjects
+		var thoughtCount int
+		if err := rows.Scan(&model.GUID, &model.Name, &model.Description, &model.CreatedAt, &model.LastActiveAt, &thoughtCount); err != nil {
 			return nil, fmt.Errorf("scan project summary: %w", err)
 		}
-		projects = append(projects, project)
+		projects = append(projects, thoughttypes.ProjectSummary{
+			Project:      projectFromModel(model),
+			ThoughtCount: thoughtCount,
+		})
 	}
 	if err := rows.Err(); err != nil {
 		return nil, fmt.Errorf("iterate projects: %w", err)

internal/store/skills.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	ext "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -23,9 +24,13 @@ func (db *DB) AddSkill(ctx context.Context, skill ext.AgentSkill) (ext.AgentSkil
 	`, skill.Name, skill.Description, skill.Content, skill.Tags)
 
 	created := skill
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicAgentSkills
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.AgentSkill{}, fmt.Errorf("insert agent skill: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -41,7 +46,7 @@ func (db *DB) RemoveSkill(ctx context.Context, id uuid.UUID) error {
 }
 
 func (db *DB) ListSkills(ctx context.Context, tag string) ([]ext.AgentSkill, error) {
-	q := `select id, name, description, content, tags, created_at, updated_at from agent_skills`
+	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)
@@ -57,12 +62,20 @@ func (db *DB) ListSkills(ctx context.Context, tag string) ([]ext.AgentSkill, err
 
 	var skills []ext.AgentSkill
 	for rows.Next() {
-		var s ext.AgentSkill
-		var desc *string
-		if err := rows.Scan(&s.ID, &s.Name, &desc, &s.Content, &s.Tags, &s.CreatedAt, &s.UpdatedAt); err != nil {
+		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.Description = strVal(desc)
+		s := ext.AgentSkill{
+			ID:          model.ID.UUID(),
+			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{}
 		}
@@ -73,16 +86,24 @@ func (db *DB) ListSkills(ctx context.Context, tag string) ([]ext.AgentSkill, err
 
 func (db *DB) GetSkill(ctx context.Context, id uuid.UUID) (ext.AgentSkill, error) {
 	row := db.pool.QueryRow(ctx, `
-		select id, name, description, content, tags, created_at, updated_at
+		select id, name, description, content, tags::text[], created_at, updated_at
 		from agent_skills where id = $1
 	`, id)
 
-	var s ext.AgentSkill
-	var desc *string
-	if err := row.Scan(&s.ID, &s.Name, &desc, &s.Content, &s.Tags, &s.CreatedAt, &s.UpdatedAt); err != nil {
+	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.Description = strVal(desc)
+	s := ext.AgentSkill{
+		ID:          model.ID.UUID(),
+		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{}
 	}
@@ -105,9 +126,13 @@ func (db *DB) AddGuardrail(ctx context.Context, g ext.AgentGuardrail) (ext.Agent
 	`, g.Name, g.Description, g.Content, g.Severity, g.Tags)
 
 	created := g
-	if err := row.Scan(&created.ID, &created.CreatedAt, &created.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicAgentGuardrails
+	if err := row.Scan(&model.ID, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		return ext.AgentGuardrail{}, fmt.Errorf("insert agent guardrail: %w", err)
 	}
+	created.ID = model.ID.UUID()
+	created.CreatedAt = model.CreatedAt.Time()
+	created.UpdatedAt = model.UpdatedAt.Time()
 	return created, nil
 }
 
@@ -135,7 +160,7 @@ func (db *DB) ListGuardrails(ctx context.Context, tag, severity string) ([]ext.A
 		conditions = append(conditions, fmt.Sprintf("severity = $%d", len(args)))
 	}
 
-	q := `select id, name, description, content, severity, tags, created_at, updated_at from agent_guardrails`
+	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 ")
 	}
@@ -149,12 +174,21 @@ func (db *DB) ListGuardrails(ctx context.Context, tag, severity string) ([]ext.A
 
 	var guardrails []ext.AgentGuardrail
 	for rows.Next() {
-		var g ext.AgentGuardrail
-		var desc *string
-		if err := rows.Scan(&g.ID, &g.Name, &desc, &g.Content, &g.Severity, &g.Tags, &g.CreatedAt, &g.UpdatedAt); err != nil {
+		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.Description = strVal(desc)
+		g := ext.AgentGuardrail{
+			ID:          model.ID.UUID(),
+			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{}
 		}
@@ -165,16 +199,25 @@ func (db *DB) ListGuardrails(ctx context.Context, tag, severity string) ([]ext.A
 
 func (db *DB) GetGuardrail(ctx context.Context, id uuid.UUID) (ext.AgentGuardrail, error) {
 	row := db.pool.QueryRow(ctx, `
-		select id, name, description, content, severity, tags, created_at, updated_at
+		select id, name, description, content, severity, tags::text[], created_at, updated_at
 		from agent_guardrails where id = $1
 	`, id)
 
-	var g ext.AgentGuardrail
-	var desc *string
-	if err := row.Scan(&g.ID, &g.Name, &desc, &g.Content, &g.Severity, &g.Tags, &g.CreatedAt, &g.UpdatedAt); err != nil {
+	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.Description = strVal(desc)
+	g := ext.AgentGuardrail{
+		ID:          model.ID.UUID(),
+		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{}
 	}
@@ -210,7 +253,7 @@ func (db *DB) RemoveProjectSkill(ctx context.Context, projectID, skillID uuid.UU
 
 func (db *DB) ListProjectSkills(ctx context.Context, projectID uuid.UUID) ([]ext.AgentSkill, error) {
 	rows, err := db.pool.Query(ctx, `
-		select s.id, s.name, s.description, s.content, s.tags, s.created_at, s.updated_at
+		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
@@ -223,12 +266,20 @@ func (db *DB) ListProjectSkills(ctx context.Context, projectID uuid.UUID) ([]ext
 
 	var skills []ext.AgentSkill
 	for rows.Next() {
-		var s ext.AgentSkill
-		var desc *string
-		if err := rows.Scan(&s.ID, &s.Name, &desc, &s.Content, &s.Tags, &s.CreatedAt, &s.UpdatedAt); err != nil {
+		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.Description = strVal(desc)
+		s := ext.AgentSkill{
+			ID:          model.ID.UUID(),
+			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{}
 		}
@@ -266,7 +317,7 @@ func (db *DB) RemoveProjectGuardrail(ctx context.Context, projectID, guardrailID
 
 func (db *DB) ListProjectGuardrails(ctx context.Context, projectID uuid.UUID) ([]ext.AgentGuardrail, error) {
 	rows, err := db.pool.Query(ctx, `
-		select g.id, g.name, g.description, g.content, g.severity, g.tags, g.created_at, g.updated_at
+		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
@@ -279,12 +330,21 @@ func (db *DB) ListProjectGuardrails(ctx context.Context, projectID uuid.UUID) ([
 
 	var guardrails []ext.AgentGuardrail
 	for rows.Next() {
-		var g ext.AgentGuardrail
-		var desc *string
-		if err := rows.Scan(&g.ID, &g.Name, &desc, &g.Content, &g.Severity, &g.Tags, &g.CreatedAt, &g.UpdatedAt); err != nil {
+		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.Description = strVal(desc)
+		g := ext.AgentGuardrail{
+			ID:          model.ID.UUID(),
+			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{}
 		}

internal/store/thoughts.go

@@ -12,6 +12,7 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/pgvector/pgvector-go"
 
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 	thoughttypes "git.warky.dev/wdevs/amcs/internal/types"
 )
 
@@ -149,13 +150,13 @@ func (db *DB) ListThoughts(ctx context.Context, filter thoughttypes.ListFilter)
 
 	thoughts := make([]thoughttypes.Thought, 0, filter.Limit)
 	for rows.Next() {
-		var thought thoughttypes.Thought
-		var metadataBytes []byte
-		if err := rows.Scan(&thought.ID, &thought.Content, &metadataBytes, &thought.ProjectID, &thought.ArchivedAt, &thought.CreatedAt, &thought.UpdatedAt); err != nil {
+		var model generatedmodels.ModelPublicThoughts
+		if err := rows.Scan(&model.GUID, &model.Content, &model.Metadata, &model.ProjectID, &model.ArchivedAt, &model.CreatedAt, &model.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("scan listed thought: %w", err)
 		}
-		if err := json.Unmarshal(metadataBytes, &thought.Metadata); err != nil {
-			return nil, fmt.Errorf("decode listed metadata: %w", err)
+		thought, err := thoughtFromModel(model)
+		if err != nil {
+			return nil, fmt.Errorf("map listed thought: %w", err)
 		}
 		thoughts = append(thoughts, thought)
 	}
@@ -222,17 +223,17 @@ func (db *DB) GetThought(ctx context.Context, id uuid.UUID) (thoughttypes.Though
 		where guid = $1
 	`, id)
 
-	var thought thoughttypes.Thought
-	var metadataBytes []byte
-	if err := row.Scan(&thought.ID, &thought.Content, &metadataBytes, &thought.ProjectID, &thought.ArchivedAt, &thought.CreatedAt, &thought.UpdatedAt); err != nil {
+	var model generatedmodels.ModelPublicThoughts
+	if err := row.Scan(&model.GUID, &model.Content, &model.Metadata, &model.ProjectID, &model.ArchivedAt, &model.CreatedAt, &model.UpdatedAt); err != nil {
 		if err == pgx.ErrNoRows {
 			return thoughttypes.Thought{}, err
 		}
 		return thoughttypes.Thought{}, fmt.Errorf("get thought: %w", err)
 	}
 
-	if err := json.Unmarshal(metadataBytes, &thought.Metadata); err != nil {
-		return thoughttypes.Thought{}, fmt.Errorf("decode thought metadata: %w", err)
+	thought, err := thoughtFromModel(model)
+	if err != nil {
+		return thoughttypes.Thought{}, fmt.Errorf("map thought: %w", err)
 	}
 
 	return thought, nil

internal/store/tool_annotations.go

@@ -3,6 +3,8 @@ package store
 import (
 	"context"
 	"fmt"
+
+	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
 )
 
 func (db *DB) UpsertToolAnnotation(ctx context.Context, toolName, notes string) error {
@@ -28,11 +30,11 @@ func (db *DB) GetToolAnnotations(ctx context.Context) (map[string]string, error)
 
 	annotations := make(map[string]string)
 	for rows.Next() {
-		var toolName, notes string
-		if err := rows.Scan(&toolName, &notes); err != nil {
+		var model generatedmodels.ModelPublicToolAnnotations
+		if err := rows.Scan(&model.ToolName, &model.Notes); err != nil {
 			return nil, fmt.Errorf("scan tool annotation: %w", err)
 		}
-		annotations[toolName] = notes
+		annotations[model.ToolName.String()] = model.Notes.String()
 	}
 	return annotations, rows.Err()
 }