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/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(),
+	}
+}