feat: mcp server first take

lib/bds/scripting/capabilities.ex

@@ -0,0 +1,110 @@
+defmodule BDS.Scripting.Capabilities do
+  @moduledoc false
+
+  import Ecto.Query
+
+  alias BDS.Metadata
+  alias BDS.PostLinks
+  alias BDS.Posts.Post
+  alias BDS.Repo
+  alias BDS.Tags
+
+  def for_project(project_id) when is_binary(project_id) do
+    metadata = preload_metadata(project_id)
+    posts = preload_posts(project_id)
+    posts_by_id = Map.new(posts, &{&1["id"], &1})
+    posts_by_slug = Map.new(posts, &{&1["slug"], &1})
+    tags = preload_tags(project_id)
+
+    %{
+      meta: %{
+        get_project_metadata: unary(fn -> metadata end)
+      },
+      posts: %{
+        get: unary(fn post_id -> Map.get(posts_by_id, post_id) end),
+        get_by_slug: unary(fn slug -> Map.get(posts_by_slug, slug) end)
+      },
+      tags: %{
+        get_all: unary(fn -> tags end)
+      }
+    }
+  end
+
+  defp preload_metadata(project_id) do
+    {:ok, metadata} = Metadata.get_project_metadata(project_id)
+    sanitize(metadata)
+  end
+
+  defp preload_posts(project_id) do
+    Repo.all(from(post in Post, where: post.project_id == ^project_id))
+    |> Enum.map(&post_payload/1)
+  end
+
+  defp preload_tags(project_id) do
+    project_id
+    |> Tags.list_tags()
+    |> Enum.map(&sanitize/1)
+  end
+
+  defp unary(callback) when is_function(callback, 0) do
+    fn args, state ->
+      _decoded_args = :luerl.decode_list(args, state)
+      :luerl.encode_list([callback.()], state)
+    end
+  end
+
+  defp unary(callback) when is_function(callback, 1) do
+    fn args, state ->
+      decoded_args = :luerl.decode_list(args, state)
+
+      value =
+        case decoded_args do
+          [first | _rest] -> callback.(sanitize(first))
+          [] -> callback.(nil)
+        end
+
+      :luerl.encode_list([value], state)
+    end
+  end
+
+  defp post_payload(%Post{} = post) do
+    post
+    |> sanitize()
+    |> Map.put("backlinks", linked_posts(post.id, :incoming))
+    |> Map.put("links_to", linked_posts(post.id, :outgoing))
+  end
+
+  defp linked_posts(post_id, :incoming) do
+    PostLinks.list_incoming_links(post_id)
+    |> Enum.map(&load_linked_post(&1.source_post_id))
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp linked_posts(post_id, :outgoing) do
+    PostLinks.list_outgoing_links(post_id)
+    |> Enum.map(&load_linked_post(&1.target_post_id))
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp load_linked_post(post_id) do
+    case Repo.get(Post, post_id) do
+      %Post{} = post -> %{"id" => post.id, "title" => post.title, "slug" => post.slug}
+      nil -> nil
+    end
+  end
+
+  defp sanitize(%_struct{} = struct) do
+    struct
+    |> Map.from_struct()
+    |> Map.drop([:__meta__, :post, :project, :media])
+    |> sanitize()
+  end
+
+  defp sanitize(map) when is_map(map) do
+    Map.new(map, fn {key, value} -> {to_string(key), sanitize(value)} end)
+  end
+
+  defp sanitize(list) when is_list(list), do: Enum.map(list, &sanitize/1)
+  defp sanitize(value) when is_atom(value), do: Atom.to_string(value)
+  defp sanitize(value), do: value
+end