implement blip tags, on atproto. create app level concepts for them as well

elixir_blonk/lib/elixir_blonk/atproto/client.ex

···
   @vibe_member_nsid "com.blonk.vibeMember"
   @groove_nsid "com.blonk.groove"
   @comment_nsid "com.blonk.comment"
+  @tag_nsid "com.blonk.tag"
+  @blip_tag_nsid "com.blonk.blipTag"
 
   # Configuration
   @service Application.compile_env(:elixir_blonk, :atproto_service, "https://bsky.social")
···
       %{"replies" => replies} when is_list(replies) -> length(replies)
       _ -> 0
     end
+  end
+
+  @doc """
+  Creates a tag record in ATProto.
+  """
+  def create_tag(client, tag) do
+    record = %{
+      "$type" => @tag_nsid,
+      name: tag.name,
+      description: tag.description,
+      author: tag.author_did,
+      createdAt: DateTime.to_iso8601(tag.indexed_at || DateTime.utc_now())
+    }
+    |> compact_record()
+
+    create_record(client, @tag_nsid, record)
+  end
+
+  @doc """
+  Creates a blip-tag association record in ATProto.
+  """
+  def create_blip_tag(client, blip_tag) do
+    # Get the blip and tag records
+    blip = ElixirBlonk.Blips.get_blip!(blip_tag.blip_id)
+    tag = ElixirBlonk.Tags.get_tag!(blip_tag.tag_id)
+
+    record = %{
+      "$type" => @blip_tag_nsid,
+      blip: %{
+        uri: blip.uri,
+        cid: blip.cid
+      },
+      tag: %{
+        uri: tag.uri,
+        cid: tag.cid
+      },
+      author: blip_tag.author_did,
+      createdAt: DateTime.to_iso8601(DateTime.utc_now())
+    }
+    |> compact_record()
+
+    create_record(client, @blip_tag_nsid, record)
   end
 end

elixir_blonk/lib/elixir_blonk/blip_tags.ex

···
+defmodule ElixirBlonk.BlipTags do
+  @moduledoc """
+  The BlipTags context for managing blip-tag associations.
+  """
+
+  import Ecto.Query, warn: false
+  require Logger
+  alias ElixirBlonk.Repo
+
+  alias ElixirBlonk.BlipTags.BlipTag
+  alias ElixirBlonk.{Blips, Tags}
+
+  @doc """
+  Associates a tag with a blip.
+  """
+  def create_blip_tag(blip_id, tag_id, author_did) do
+    attrs = %{
+      blip_id: blip_id,
+      tag_id: tag_id,
+      author_did: author_did
+    }
+
+    # First create in local database
+    with {:ok, blip_tag} <- %BlipTag{}
+                            |> BlipTag.changeset(attrs)
+                            |> Repo.insert() do
+      
+      # Increment tag usage count
+      tag = Tags.get_tag!(tag_id)
+      Tags.increment_usage_count(tag)
+      
+      # Then try to create in ATProto if enabled
+      if Application.get_env(:elixir_blonk, :atproto_enabled, true) do
+        Task.Supervisor.start_child(ElixirBlonk.TaskSupervisor, fn ->
+          create_blip_tag_in_atproto(blip_tag)
+        end)
+      end
+      
+      {:ok, blip_tag}
+    end
+  end
+
+  @doc """
+  Removes a tag association from a blip.
+  """
+  def delete_blip_tag(blip_id, tag_id) do
+    blip_tag = 
+      BlipTag
+      |> where([bt], bt.blip_id == ^blip_id and bt.tag_id == ^tag_id)
+      |> Repo.one()
+
+    if blip_tag do
+      # Decrement tag usage count
+      tag = Tags.get_tag!(tag_id)
+      if tag.usage_count > 0 do
+        Tags.update_tag(tag, %{usage_count: tag.usage_count - 1})
+      end
+      
+      Repo.delete(blip_tag)
+    else
+      {:error, :not_found}
+    end
+  end
+
+  @doc """
+  Gets all tags for a blip.
+  """
+  def get_tags_for_blip(blip_id) do
+    BlipTag
+    |> where([bt], bt.blip_id == ^blip_id)
+    |> join(:inner, [bt], t in assoc(bt, :tag))
+    |> select([bt, t], t)
+    |> Repo.all()
+  end
+
+  @doc """
+  Gets all blips for a tag.
+  """
+  def get_blips_for_tag(tag_id) do
+    BlipTag
+    |> where([bt], bt.tag_id == ^tag_id)
+    |> join(:inner, [bt], b in assoc(bt, :blip))
+    |> select([bt, b], b)
+    |> preload([bt, b], b: :vibe)
+    |> Repo.all()
+  end
+
+  @doc """
+  Associates multiple tags with a blip by tag names.
+  Creates tags if they don't exist.
+  """
+  def associate_tags_with_blip(blip_id, tag_names, author_did) when is_list(tag_names) do
+    Enum.each(tag_names, fn tag_name ->
+      # Find or create the tag
+      {:ok, tag} = Tags.find_or_create_tag(tag_name, author_did)
+      
+      # Associate with blip (ignore if already exists)
+      case create_blip_tag(blip_id, tag.id, author_did) do
+        {:ok, _} -> :ok
+        {:error, _} -> :ok  # Likely already exists
+      end
+    end)
+  end
+
+  @doc """
+  Removes all tag associations for a blip.
+  """
+  def remove_all_tags_from_blip(blip_id) do
+    blip_tags = 
+      BlipTag
+      |> where([bt], bt.blip_id == ^blip_id)
+      |> Repo.all()
+
+    # Decrement usage counts for all associated tags
+    Enum.each(blip_tags, fn blip_tag ->
+      tag = Tags.get_tag!(blip_tag.tag_id)
+      if tag.usage_count > 0 do
+        Tags.update_tag(tag, %{usage_count: tag.usage_count - 1})
+      end
+    end)
+
+    # Delete all associations
+    BlipTag
+    |> where([bt], bt.blip_id == ^blip_id)
+    |> Repo.delete_all()
+  end
+
+  # Private functions
+
+  defp create_blip_tag_in_atproto(blip_tag) do
+    with {:ok, client} <- ElixirBlonk.ATProto.SessionManager.get_client(),
+         {:ok, %{uri: uri, cid: cid}} <- ElixirBlonk.ATProto.Client.create_blip_tag(client, blip_tag) do
+      
+      # Update local record with ATProto URI and CID
+      blip_tag
+      |> BlipTag.changeset(%{uri: uri, cid: cid})
+      |> Repo.update()
+      
+      Logger.info("Created blip-tag association in ATProto: #{uri}")
+    else
+      {:error, reason} ->
+        Logger.error("Failed to create blip-tag association in ATProto: #{inspect(reason)}")
+    end
+  end
+end

elixir_blonk/lib/elixir_blonk/blip_tags/blip_tag.ex

···
+defmodule ElixirBlonk.BlipTags.BlipTag do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
+  schema "blip_tags" do
+    field :uri, :string
+    field :cid, :string
+    field :author_did, :string
+
+    belongs_to :blip, ElixirBlonk.Blips.Blip
+    belongs_to :tag, ElixirBlonk.Tags.Tag
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(blip_tag, attrs) do
+    blip_tag
+    |> cast(attrs, [:uri, :cid, :author_did, :blip_id, :tag_id])
+    |> validate_required([:author_did, :blip_id, :tag_id])
+    |> unique_constraint(:uri)
+    |> unique_constraint([:blip_id, :tag_id], message: "tag already associated with this blip")
+  end
+end

elixir_blonk/lib/elixir_blonk/tags.ex

···
+defmodule ElixirBlonk.Tags do
+  @moduledoc """
+  The Tags context for managing tag records in ATProto.
+  """
+
+  import Ecto.Query, warn: false
+  require Logger
+  alias ElixirBlonk.Repo
+
+  alias ElixirBlonk.Tags.Tag
+
+  @doc """
+  Returns the list of tags.
+  """
+  def list_tags do
+    Tag
+    |> order_by([t], desc: t.usage_count)
+    |> Repo.all()
+  end
+
+  @doc """
+  Returns the list of tags by author.
+  """
+  def list_tags_by_author(author_did) do
+    Tag
+    |> where([t], t.author_did == ^author_did)
+    |> order_by([t], desc: t.usage_count)
+    |> Repo.all()
+  end
+
+  @doc """
+  Gets a single tag by ID.
+  """
+  def get_tag!(id), do: Repo.get!(Tag, id)
+
+  @doc """
+  Gets a tag by name and author.
+  """
+  def get_tag_by_name_and_author(name, author_did) do
+    Tag
+    |> where([t], t.name == ^name and t.author_did == ^author_did)
+    |> Repo.one()
+  end
+
+  @doc """
+  Gets a tag by URI.
+  """
+  def get_tag_by_uri(uri) do
+    Repo.get_by(Tag, uri: uri)
+  end
+
+  @doc """
+  Searches for tags by name.
+  """
+  def search_tags(query) do
+    search_term = "%#{query}%"
+    
+    Tag
+    |> where([t], ilike(t.name, ^search_term) or ilike(t.description, ^search_term))
+    |> order_by([t], desc: t.usage_count)
+    |> Repo.all()
+  end
+
+  @doc """
+  Creates a tag.
+  """
+  def create_tag(attrs \\ %{}) do
+    # First create in local database
+    with {:ok, tag} <- %Tag{}
+                       |> Tag.changeset(attrs)
+                       |> Repo.insert() do
+      
+      # Then try to create in ATProto if enabled
+      if Application.get_env(:elixir_blonk, :atproto_enabled, true) do
+        Task.Supervisor.start_child(ElixirBlonk.TaskSupervisor, fn ->
+          create_tag_in_atproto(tag)
+        end)
+      end
+      
+      {:ok, tag}
+    end
+  end
+
+  @doc """
+  Finds or creates a tag by name and author.
+  """
+  def find_or_create_tag(name, author_did, description \\ nil) do
+    case get_tag_by_name_and_author(name, author_did) do
+      nil ->
+        create_tag(%{
+          name: name,
+          author_did: author_did,
+          description: description,
+          indexed_at: DateTime.utc_now()
+        })
+      
+      existing_tag ->
+        {:ok, existing_tag}
+    end
+  end
+
+  @doc """
+  Updates a tag.
+  """
+  def update_tag(%Tag{} = tag, attrs) do
+    tag
+    |> Tag.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Increments the usage count for a tag.
+  """
+  def increment_usage_count(%Tag{} = tag) do
+    update_tag(tag, %{usage_count: tag.usage_count + 1})
+  end
+
+  @doc """
+  Deletes a tag.
+  """
+  def delete_tag(%Tag{} = tag) do
+    Repo.delete(tag)
+  end
+
+  @doc """
+  Gets the most popular tags.
+  """
+  def get_popular_tags(limit \\ 20) do
+    Tag
+    |> where([t], t.usage_count > 0)
+    |> order_by([t], desc: t.usage_count)
+    |> limit(^limit)
+    |> Repo.all()
+  end
+
+  # Private functions
+
+  defp create_tag_in_atproto(tag) do
+    with {:ok, client} <- ElixirBlonk.ATProto.SessionManager.get_client(),
+         {:ok, %{uri: uri, cid: cid}} <- ElixirBlonk.ATProto.Client.create_tag(client, tag) do
+      
+      # Update local record with ATProto URI and CID
+      update_tag(tag, %{uri: uri, cid: cid})
+      Logger.info("Created tag in ATProto: #{uri}")
+    else
+      {:error, reason} ->
+        Logger.error("Failed to create tag in ATProto: #{inspect(reason)}")
+    end
+  end
+end

elixir_blonk/lib/elixir_blonk/tags/tag.ex

···
+defmodule ElixirBlonk.Tags.Tag do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
+  schema "tags" do
+    field :uri, :string
+    field :cid, :string
+    field :name, :string
+    field :description, :string
+    field :author_did, :string
+    field :usage_count, :integer, default: 0
+    field :indexed_at, :utc_datetime
+
+    many_to_many :blips, ElixirBlonk.Blips.Blip, join_through: "blip_tags"
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(tag, attrs) do
+    tag
+    |> cast(attrs, [:uri, :cid, :name, :description, :author_did, :usage_count, :indexed_at])
+    |> validate_required([:name, :author_did])
+    |> validate_length(:name, min: 1, max: 50)
+    |> validate_length(:description, max: 280)
+    |> validate_format(:name, ~r/^[a-zA-Z0-9_]+$/, message: "can only contain letters, numbers, and underscores")
+    |> unique_constraint(:uri)
+    |> unique_constraint([:name, :author_did], message: "tag name already exists for this author")
+  end
+end

elixir_blonk/priv/repo/migrations/20250620043347_create_tags.exs

···
+defmodule ElixirBlonk.Repo.Migrations.CreateTags do
+  use Ecto.Migration
+
+  def change do
+    create table(:tags, primary_key: false) do
+      add :id, :binary_id, primary_key: true
+      add :uri, :string
+      add :cid, :string
+      add :name, :string, null: false
+      add :description, :string
+      add :author_did, :string, null: false
+      add :usage_count, :integer, default: 0
+      add :indexed_at, :utc_datetime
+
+      timestamps(type: :utc_datetime)
+    end
+
+    create unique_index(:tags, [:uri])
+    create unique_index(:tags, [:name, :author_did])
+    create index(:tags, [:author_did])
+    create index(:tags, [:usage_count])
+    create index(:tags, [:name])
+  end
+end

elixir_blonk/priv/repo/migrations/20250620043400_create_blip_tags.exs

···
+defmodule ElixirBlonk.Repo.Migrations.CreateBlipTags do
+  use Ecto.Migration
+
+  def change do
+    create table(:blip_tags, primary_key: false) do
+      add :id, :binary_id, primary_key: true
+      add :uri, :string
+      add :cid, :string
+      add :author_did, :string, null: false
+      add :blip_id, references(:blips, on_delete: :delete_all, type: :binary_id), null: false
+      add :tag_id, references(:tags, on_delete: :delete_all, type: :binary_id), null: false
+
+      timestamps(type: :utc_datetime)
+    end
+
+    create unique_index(:blip_tags, [:uri])
+    create unique_index(:blip_tags, [:blip_id, :tag_id])
+    create index(:blip_tags, [:blip_id])
+    create index(:blip_tags, [:tag_id])
+    create index(:blip_tags, [:author_did])
+  end
+end