amcs/internal/mcpserver/server.go

package mcpserver

import (
	"log/slog"
	"net/http"

	"github.com/modelcontextprotocol/go-sdk/mcp"

	"git.warky.dev/wdevs/amcs/internal/config"
	"git.warky.dev/wdevs/amcs/internal/tools"
)

type ToolSet struct {
	Version       *tools.VersionTool
	Capture       *tools.CaptureTool
	Search        *tools.SearchTool
	List          *tools.ListTool
	Stats         *tools.StatsTool
	Get           *tools.GetTool
	Update        *tools.UpdateTool
	Delete        *tools.DeleteTool
	Archive       *tools.ArchiveTool
	Projects      *tools.ProjectsTool
	Context       *tools.ContextTool
	Recall        *tools.RecallTool
	Summarize     *tools.SummarizeTool
	Links         *tools.LinksTool
	Files         *tools.FilesTool
	Backfill      *tools.BackfillTool
	Reparse       *tools.ReparseMetadataTool
	RetryMetadata *tools.RetryMetadataTool
	Household     *tools.HouseholdTool
	Maintenance   *tools.MaintenanceTool
	Calendar      *tools.CalendarTool
	Meals         *tools.MealsTool
	CRM           *tools.CRMTool
	Skills        *tools.SkillsTool
	ChatHistory   *tools.ChatHistoryTool
}

func New(cfg config.MCPConfig, logger *slog.Logger, toolSet ToolSet, onSessionClosed func(string)) (http.Handler, error) {
	server := mcp.NewServer(&mcp.Implementation{
		Name:    cfg.ServerName,
		Version: cfg.Version,
	}, nil)

	for _, register := range []func(*mcp.Server, *slog.Logger, ToolSet) error{
		registerSystemTools,
		registerThoughtTools,
		registerProjectTools,
		registerFileTools,
		registerMaintenanceTools,
		registerHouseholdTools,
		registerCalendarTools,
		registerMealTools,
		registerCRMTools,
		registerSkillTools,
		registerChatHistoryTools,
	} {
		if err := register(server, logger, toolSet); err != nil {
			return nil, err
		}
	}

	opts := &mcp.StreamableHTTPOptions{
		JSONResponse:   true,
		SessionTimeout: cfg.SessionTimeout,
	}
	if onSessionClosed != nil {
		opts.EventStore = newCleanupEventStore(mcp.NewMemoryEventStore(nil), onSessionClosed)
	}

	return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server {
		return server
	}, opts), nil
}

func registerSystemTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_version_info",
		Description: "Return the server build version information, including version, tag name, commit, and build date.",
	}, toolSet.Version.GetInfo); err != nil {
		return err
	}
	return nil
}

func registerThoughtTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "capture_thought",
		Description: "Store a thought with generated embeddings and extracted metadata.",
	}, toolSet.Capture.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_thoughts",
		Description: "Search stored thoughts by semantic similarity.",
	}, toolSet.Search.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_thoughts",
		Description: "List recent thoughts with optional metadata filters.",
	}, toolSet.List.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "thought_stats",
		Description: "Get counts and top metadata buckets across stored thoughts.",
	}, toolSet.Stats.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_thought",
		Description: "Retrieve a full thought by id.",
	}, toolSet.Get.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "update_thought",
		Description: "Update thought content or merge metadata.",
	}, toolSet.Update.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "delete_thought",
		Description: "Hard-delete a thought by id.",
	}, toolSet.Delete.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "archive_thought",
		Description: "Archive a thought so it is hidden from default search and listing.",
	}, toolSet.Archive.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "summarize_thoughts",
		Description: "Summarize a filtered or searched set of thoughts.",
	}, toolSet.Summarize.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "recall_context",
		Description: "Recall semantically relevant and recent context.",
	}, toolSet.Recall.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "link_thoughts",
		Description: "Create a typed relationship between two thoughts.",
	}, toolSet.Links.Link); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "related_thoughts",
		Description: "Retrieve explicit links and semantic neighbors for a thought.",
	}, toolSet.Links.Related); err != nil {
		return err
	}
	return nil
}

func registerProjectTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "create_project",
		Description: "Create a named project container for thoughts.",
	}, toolSet.Projects.Create); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_projects",
		Description: "List projects and their current thought counts.",
	}, toolSet.Projects.List); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "set_active_project",
		Description: "Set the active project for the current MCP session. Requires a stateful MCP client that reuses the same session across calls.",
	}, toolSet.Projects.SetActive); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_active_project",
		Description: "Return the active project for the current MCP session. If your client does not preserve MCP sessions, pass project explicitly to project-scoped tools instead.",
	}, toolSet.Projects.GetActive); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_project_context",
		Description: "Get recent and semantic context for a project. Uses the explicit project when provided, otherwise the active MCP session project.",
	}, toolSet.Context.Handle); err != nil {
		return err
	}
	return nil
}

func registerFileTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	server.AddResourceTemplate(&mcp.ResourceTemplate{
		Name:        "stored_file",
		URITemplate: "amcs://files/{id}",
		Description: "A stored file. Read a file's raw binary content by its id. Use load_file for metadata.",
	}, toolSet.Files.ReadResource)

	if err := addTool(server, logger, &mcp.Tool{
		Name:        "upload_file",
		Description: "Stage a file and get an amcs://files/{id} resource URI. Provide content_path (absolute server-side path, no size limit) or content_base64 (≤10 MB). Optionally link immediately with thought_id/project, or omit them and pass the returned URI to save_file later.",
	}, toolSet.Files.Upload); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "save_file",
		Description: "Store a file and optionally link it to a thought. Supply either content_base64 (≤10 MB) or content_uri (amcs://files/{id} from a prior upload_file or POST /files call). For files larger than 10 MB, use upload_file with content_path first.",
	}, toolSet.Files.Save); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "load_file",
		Description: "Load a previously stored file by id and return its metadata and base64 content.",
	}, toolSet.Files.Load); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_files",
		Description: "List stored files, optionally filtered by thought, project, or kind.",
	}, toolSet.Files.List); err != nil {
		return err
	}
	return nil
}

func registerMaintenanceTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "backfill_embeddings",
		Description: "Generate missing embeddings for stored thoughts using the active embedding model.",
	}, toolSet.Backfill.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "reparse_thought_metadata",
		Description: "Re-extract and normalize metadata for stored thoughts from their content.",
	}, toolSet.Reparse.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "retry_failed_metadata",
		Description: "Retry metadata extraction for thoughts still marked pending or failed.",
	}, toolSet.RetryMetadata.Handle); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_maintenance_task",
		Description: "Create a recurring or one-time home maintenance task.",
	}, toolSet.Maintenance.AddTask); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "log_maintenance",
		Description: "Log completed maintenance work; automatically updates the task's next due date.",
	}, toolSet.Maintenance.LogWork); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_upcoming_maintenance",
		Description: "List maintenance tasks due within the next N days.",
	}, toolSet.Maintenance.GetUpcoming); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_maintenance_history",
		Description: "Search the maintenance log by task name, category, or date range.",
	}, toolSet.Maintenance.SearchHistory); err != nil {
		return err
	}
	return nil
}

func registerHouseholdTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_household_item",
		Description: "Store a household fact (paint color, appliance details, measurement, document, etc.).",
	}, toolSet.Household.AddItem); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_household_items",
		Description: "Search household items by name, category, or location.",
	}, toolSet.Household.SearchItems); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_household_item",
		Description: "Retrieve a household item by id.",
	}, toolSet.Household.GetItem); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_vendor",
		Description: "Add a service provider (plumber, electrician, landscaper, etc.).",
	}, toolSet.Household.AddVendor); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_vendors",
		Description: "List household service vendors, optionally filtered by service type.",
	}, toolSet.Household.ListVendors); err != nil {
		return err
	}
	return nil
}

func registerCalendarTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_family_member",
		Description: "Add a family member to the household.",
	}, toolSet.Calendar.AddMember); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_family_members",
		Description: "List all family members.",
	}, toolSet.Calendar.ListMembers); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_activity",
		Description: "Schedule a one-time or recurring family activity.",
	}, toolSet.Calendar.AddActivity); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_week_schedule",
		Description: "Get all activities scheduled for a given week.",
	}, toolSet.Calendar.GetWeekSchedule); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_activities",
		Description: "Search activities by title, type, or family member.",
	}, toolSet.Calendar.SearchActivities); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_important_date",
		Description: "Track a birthday, anniversary, deadline, or other important date.",
	}, toolSet.Calendar.AddImportantDate); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_upcoming_dates",
		Description: "Get important dates coming up in the next N days.",
	}, toolSet.Calendar.GetUpcomingDates); err != nil {
		return err
	}
	return nil
}

func registerMealTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_recipe",
		Description: "Save a recipe with ingredients and instructions.",
	}, toolSet.Meals.AddRecipe); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_recipes",
		Description: "Search recipes by name, cuisine, tags, or ingredient.",
	}, toolSet.Meals.SearchRecipes); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "update_recipe",
		Description: "Update an existing recipe.",
	}, toolSet.Meals.UpdateRecipe); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "create_meal_plan",
		Description: "Set the meal plan for a week; replaces any existing plan for that week.",
	}, toolSet.Meals.CreateMealPlan); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_meal_plan",
		Description: "Get the meal plan for a given week.",
	}, toolSet.Meals.GetMealPlan); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "generate_shopping_list",
		Description: "Auto-generate a shopping list from the meal plan for a given week.",
	}, toolSet.Meals.GenerateShoppingList); err != nil {
		return err
	}
	return nil
}

func registerCRMTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_professional_contact",
		Description: "Add a professional contact to the CRM.",
	}, toolSet.CRM.AddContact); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "search_contacts",
		Description: "Search professional contacts by name, company, title, notes, or tags.",
	}, toolSet.CRM.SearchContacts); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "log_interaction",
		Description: "Log an interaction with a professional contact.",
	}, toolSet.CRM.LogInteraction); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_contact_history",
		Description: "Get full history (interactions and opportunities) for a contact.",
	}, toolSet.CRM.GetHistory); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "create_opportunity",
		Description: "Create a deal, project, or opportunity linked to a contact.",
	}, toolSet.CRM.CreateOpportunity); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_follow_ups_due",
		Description: "List contacts with a follow-up date due within the next N days.",
	}, toolSet.CRM.GetFollowUpsDue); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "link_thought_to_contact",
		Description: "Append a stored thought to a contact's notes.",
	}, toolSet.CRM.LinkThought); err != nil {
		return err
	}
	return nil
}

func registerSkillTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_skill",
		Description: "Store a reusable agent skill (behavioural instruction or capability prompt).",
	}, toolSet.Skills.AddSkill); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "remove_skill",
		Description: "Delete an agent skill by id.",
	}, toolSet.Skills.RemoveSkill); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_skills",
		Description: "List all agent skills, optionally filtered by tag.",
	}, toolSet.Skills.ListSkills); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_guardrail",
		Description: "Store a reusable agent guardrail (constraint or safety rule).",
	}, toolSet.Skills.AddGuardrail); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "remove_guardrail",
		Description: "Delete an agent guardrail by id.",
	}, toolSet.Skills.RemoveGuardrail); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_guardrails",
		Description: "List all agent guardrails, optionally filtered by tag or severity.",
	}, toolSet.Skills.ListGuardrails); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_project_skill",
		Description: "Link an agent skill to a project. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.AddProjectSkill); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "remove_project_skill",
		Description: "Unlink an agent skill from a project. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.RemoveProjectSkill); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_project_skills",
		Description: "List all skills linked to a project. Call this at the start of a project session to load existing agent behaviour instructions before generating new ones. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.ListProjectSkills); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "add_project_guardrail",
		Description: "Link an agent guardrail to a project. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.AddProjectGuardrail); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "remove_project_guardrail",
		Description: "Unlink an agent guardrail from a project. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.RemoveProjectGuardrail); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_project_guardrails",
		Description: "List all guardrails linked to a project. Call this at the start of a project session to load existing agent constraints before generating new ones. Pass project explicitly when your client does not preserve MCP sessions.",
	}, toolSet.Skills.ListProjectGuardrails); err != nil {
		return err
	}
	return nil
}

func registerChatHistoryTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "save_chat_history",
		Description: "Save a chat session's message history for later retrieval. Stores messages with optional title, summary, channel, agent, and project metadata.",
	}, toolSet.ChatHistory.SaveChatHistory); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "get_chat_history",
		Description: "Retrieve a saved chat history by its UUID or session_id. Returns the full message list.",
	}, toolSet.ChatHistory.GetChatHistory); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "list_chat_histories",
		Description: "List saved chat histories with optional filters: project, channel, agent_id, session_id, or recent days.",
	}, toolSet.ChatHistory.ListChatHistories); err != nil {
		return err
	}
	if err := addTool(server, logger, &mcp.Tool{
		Name:        "delete_chat_history",
		Description: "Permanently delete a saved chat history by id.",
	}, toolSet.ChatHistory.DeleteChatHistory); err != nil {
		return err
	}
	return nil
}