devskill 2.0.3 → 2.0.5

package/landing/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "landing",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.3.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "framer-motion": "^12.38.0",
+    "lucide-react": "^1.0.1",
+    "next": "^16.2.1",
+    "next-intl": "^4.8.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "shadcn": "^4.1.0",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.2.2",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.1",
+    "tailwindcss": "^4.2.2",
+    "typescript": "^5"
+  }
+}

package/landing/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/landing/public/file.svg

@@ -0,0 +1 @@
+<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>

package/landing/public/globe.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>

package/landing/public/next.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>

package/landing/public/vercel.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>

package/landing/public/window.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>

package/landing/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/meta.ts

@@ -118,6 +118,10 @@ export const collections: Record<string, string[]> = {
   'builderx_api': [
     'builderx_api-schemas',
     'builderx_api-controllers',
-    'builderx_api-contexts'
+    'builderx_api-contexts',
+    'builderx_api-kafka',
+    'builderx_api-redis',
+    'builderx_api-rabbitmq',
+    'builderx_api-mongodb',
   ]
 }

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "devskill",
-  "version": "2.0.3",
+  "version": "2.0.5",
+  "description": "Equip Cursor, Windsurf, Cline, Antigravity, Claude Code, Codex, GitHub Copilot and other AI Agents with expert programming superpowers via a single interactive prompt.",
+  "homepage": "https://vskill.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vuluu2k/skills.git"
+  },
   "type": "module",
   "bin": {
     "devskill": "bin/devskill.js"

package/skills/builderx_api-kafka/SKILL.md

@@ -0,0 +1,175 @@
+---
+description: Patterns for using Kafka (:brod), creating producers, consumers, and offset management in BuilderX API
+---
+
+# BuilderX API Kafka Skill
+
+The `builderx_api` project uses the `:brod` Erlang package for interacting with Kafka. The central coordination module is `Kafka` (`lib/kafka/kafka.ex`), which starts the `:brod` client and registers producers and consumers under its supervisor.
+
+## 1. Creating a New Consumer
+
+When you need to consume data from a new Kafka topic, follow the pattern established in `Kafka.QuestConsumer`. You need a GenServer that subscribes to `:brod` and relies on Redis to manage consumer offsets.
+
+### Example Structure (`lib/kafka/my_new_consumer.ex`):
+
+```elixir
+defmodule Kafka.MyNewConsumer do
+  use GenServer
+  import Record, only: [defrecord: 2, extract: 2]
+
+  alias BuilderxApi.{Tools}
+
+  @topic "my.new.kafka.topic"
+  @prefetch_count 5
+
+  defmodule State do
+    @enforce_keys [:consumer_pid, :partition]
+    defstruct consumer_pid: nil, partition: nil
+  end
+
+  defmodule KafkaMessage do
+    @enforce_keys [:offset, :key, :value, :ts]
+    defstruct offset: nil, key: nil, value: nil, ts: nil
+  end
+
+  defrecord :kafka_message, extract(:kafka_message, from_lib: "brod/include/brod.hrl")
+  defrecord :kafka_message_set, extract(:kafka_message_set, from_lib: "brod/include/brod.hrl")
+  defrecord :kafka_fetch_error, extract(:kafka_fetch_error, from_lib: "brod/include/brod.hrl")
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts)
+  end
+
+  def init({client_id, partition}) do
+    consumer_config = [
+      prefetch_count: @prefetch_count,
+      max_bytes: @prefetch_count * 1024, # 1KB
+      max_wait_time: 0
+    ]
+
+    :ok = :brod.start_consumer(client_id, @topic, consumer_config)
+
+    {:ok, consumer_pid} = :brod.subscribe(client_id, self(), @topic, partition, consumer_config)
+
+    # Trigger the first fetch manually from Redis offset 
+    Process.send(self(), {:fetch_message}, [])
+
+    {:ok, %State{consumer_pid: consumer_pid, partition: partition}}
+  end
+
+  # Receive fetched messages
+  def handle_info(
+    {consumer_pid, kafka_message_set(messages: msgs)},
+    %State{consumer_pid: consumer_pid, partition: partition} = state
+  ) do
+    msgs = Enum.map(msgs, &kafka_message_to_struct(&1))
+
+    Enum.each(msgs, fn msg -> 
+      # Decode and process your message here
+      try do
+        parsed = Jason.decode!(msg.value)
+        # process parsed data...
+      rescue _ -> nil
+      end
+    end)
+
+    # Acknowledge messages and update Redis offset
+    for msg <- msgs do
+      key = "kafka_topic:#{@topic}:#{partition}"
+      Redis.PubSub.set(key, msg.offset)
+      :brod.consume_ack(consumer_pid, msg.offset)
+    end
+
+    {:noreply, state}
+  end
+
+  # Handle fetch errors
+  def handle_info({_pid, kafka_fetch_error()} = error, state) do
+    Logger.error("KAFKA: my_consumer fetch error #{inspect(error)}")
+    {:noreply, state}
+  end
+
+  # Fetch initially using the offset saved in Redis
+  def handle_info({:fetch_message}, %State{partition: partition} = state) do
+    host = System.get_env("KAFKA1_HOST")
+    port = System.get_env("KAFKA1_PORT") |> String.to_integer()
+    bootstrapEndpoints = [{host, port}]
+
+    key = "kafka_topic:#{@topic}:#{partition}"
+    {:ok, offset} = Redis.PubSub.get(key)
+    offset = Tools.to_int(offset)
+
+    with {:ok, batch} <- :brod.fetch(bootstrapEndpoints, @topic, partition, offset, %{}) do
+      {latest_offset, msgs} = batch
+
+      Enum.each(msgs, fn msg ->
+        msg = kafka_message_to_struct(msg)
+        # Often we just resend the message, or process it immediately.
+        # This behaves as a synchronization mechanism on start.
+      end)
+
+      Redis.PubSub.set(key, latest_offset)
+    end
+
+    {:noreply, state}
+  end
+
+  defp kafka_message_to_struct(kafka_message(offset: offset, key: key, value: value, ts: ts)) do
+    %KafkaMessage{
+      offset: offset,
+      key: key,
+      value: value,
+      ts: DateTime.from_unix!(ts, :millisecond)
+    }
+  end
+end
+```
+
+## 2. Registering the Consumer
+
+Consumer registration is done in `lib/kafka/kafka.ex` based on the hostname, to support distinct consumer groups and parallel partition processing.
+
+1. Ensure the `:brod` client has the client_id `:kafka_client`.
+2. Find the correct worker hostname conditions (e.g., `publish-consumer-01`, `publish-consumer-02`). 
+3. Note how the *second argument* often denotes the Kafka **partition** index. For `publish-consumer-01`, it's usually `0`; for `publish-consumer-02`, it's `1`, etc.
+   
+```elixir
+      "publish-consumer-01" ->
+        [
+          {KafkaProducer, {:kafka_client}},
+          {Kafka.QuestConsumer, {:kafka_client, 0}},
+          {Kafka.MyNewConsumer, {:kafka_client, 0}}  # <--- Add your consumer for partition 0
+        ]
+
+      "publish-consumer-02" ->
+        [
+          {KafkaProducer, {:kafka_client}},
+          {Kafka.QuestConsumer, {:kafka_client, 1}},
+          {Kafka.MyNewConsumer, {:kafka_client, 1}}  # <--- Add your consumer for partition 1
+        ]
+```
+
+## 3. Publishing Messages
+
+All topics you wish to publish to must be registered in `@topics` in `lib/kafka/kafka_producer.ex`.
+
+In `lib/kafka/kafka_producer.ex`:
+```elixir
+  @topics [
+    "store.cache.agg_products",
+    "store.queuing.questdb",
+    "my.new.kafka.topic"  # <--- Register new topic
+  ]
+```
+
+To publish a message, use `KafkaProducer.publish/4`:
+
+```elixir
+topic = "my.new.kafka.topic"
+partition = 0  # Generally, you need to manage partition distribution (e.g., hash the key)
+key = "your_message_key"
+message = Jason.encode!(%{hello: "world"})
+
+# Send synchronously
+:ok = KafkaProducer.publish(topic, partition, key, message)
+```

package/skills/builderx_api-mongodb/SKILL.md

@@ -0,0 +1,93 @@
+---
+description: Patterns for using MongoDB driver and dynamic collections in BuilderX API
+---
+
+# BuilderX API MongoDB Skill
+
+The `builderx_api` project integrates MongoDB via the `mongodb_driver` alongside its primary Postgres (Citus) database. This is used extensively for the *Dynamic Database Collections* feature in `BuilderxApi.DBCollections.DBCollections` (`lib/builderx_api/db_collections/db_collections.ex`).
+
+In this pattern, metadata about the data models (schema) is stored in Postgres (`DBCollection`), but the actual records are physically stored in MongoDB (`MongoRepo`) using a single `records` table separated by `table_name` and `site_id`.
+
+## 1. Interacting with MongoDB Collections
+
+You should generally not interact with `MongoRepo` directly unless you are inside the `builderx_api/db_collections/...` scope. 
+
+Instead, use `DBCollections`:
+
+### Checking if a record exists
+```elixir
+filters = %{"slug" => "my-record"}
+
+# conn must have assigns for customer, account, or is_check_record_creator as required
+DBCollections.exists_record(table_name, filters, db_collection_struct, conn)
+# => {:ok, true | false}
+```
+
+### Querying records
+Retrieves customized results based on dynamic schemas.
+
+```elixir
+select = %{"id" => 1, "name" => 1}
+filters = %{"status" => "active"}
+limit = 10
+skip = 0
+sort = %{"inserted_at" => -1} # Use 1 for ASC, -1 for DESC
+populate = [] # Populate relations if any references are configured
+params = %{"site_id" => "site_uuid"}
+
+DBCollections.query_record(
+  table_name,
+  select,
+  filters,
+  sort,
+  limit,
+  skip,
+  populate,
+  params,
+  conn
+)
+# => List of normalized maps
+```
+
+### Inserting records
+```elixir
+# attrs is a list of map: [%{"field_name" => "name", "field_value" => "Record 1"}]
+# Note that we use a custom key format for dynamic mapping.
+
+{:ok, inserted_record} = DBCollections.insert_record(table_name, attrs, params, conn)
+```
+
+## 2. Using `MongoRepo` directly
+
+The `BuilderxApi.MongoRepo` is an abstraction over `:mongo` (the `mongodb_driver` pool). 
+For some administrative actions, it is called directly:
+
+```elixir
+alias BuilderxApi.MongoRepo
+
+table = "records"
+
+# Find
+records = MongoRepo.find(table, %{"site_id" => site_id, "table_name" => "users"})
+
+# Find one
+record = MongoRepo.find_one(table, %{"_id" => id})
+
+# Update Many
+MongoRepo.update_many(
+  table,
+  %{"site_id" => site_id, "table_name" => "users"},
+  %{"$unset" => %{"webcmscol_removed_field" => ""}}
+)
+
+# Insert Many
+MongoRepo.insert_many(table, list_of_maps)
+
+# Delete Many
+MongoRepo.delete_many(table, %{"site_id" => site_id, "table_name" => "users"})
+```
+
+### Important Patterns
+- `webcmscol_`: The system prepends `webcmscol_` to column names stored in MongoDB to prevent clashes with system variables like `_id`, `site_id`, `table_name`. You will see operations map/unmap this prefix (`DBUtils.sanitize_column_name/1`).
+- **Caching Counts**: Because counting documents in Mongo can slowly become a bottleneck, the total document count per site collection is cached in Redis: `db_collection_records::{site_id}`.
+- All MongoDB records share the `records` collection but are differentiated by standard root fields: `"site_id"` and `"table_name"`.

package/skills/builderx_api-rabbitmq/SKILL.md

@@ -0,0 +1,169 @@
+---
+description: Patterns for using RabbitMQ (AMQP), creating consumers/workers, and publishing messages in BuilderX API
+---
+
+# BuilderX API RabbitMQ Skill
+
+The `builderx_api` project uses the `amqp` package for interacting with RabbitMQ. All RabbitMQ operations orbit around the central `Rabbit` (`lib/rabbit/rabbit.ex`) module, which handles connection pooling, establishing connection channels automatically, and distributing work to supervisors. 
+
+## 1. Creating a New Consumer (Worker)
+
+When you need to create a new background worker to consume events from RabbitMQ, you should structure it following the existing consumer patterns (e.g., `OrderConsumer`, `IndexingConsumer`). This includes subscribing to a queue, setting prefetch count, configuring dead letter queues for errors, and optionally configuring wait queues for retry logic.
+
+### Example Structure (`lib/rabbit/my_new_consumer.ex`):
+
+```elixir
+defmodule Rabbit.MyNewConsumer do
+  require Logger
+  use GenServer
+  use AMQP
+
+  alias BuilderxApi.Tools
+  alias Rabbit
+  alias Worker.MainWorker
+
+  @queue_base   "my_new_queue_name"
+  @storecake_v2_exchange "storecake_v2_ex"
+  @storecake_v2_exchange_deadletter "storecake_v2_ex_deadletter"
+  @sync_queue_error "my_new_queue_error"
+  @prefetch_count 20
+
+  # Client API
+  def start_link() do
+    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+  end
+
+  def child_spec(_args) do
+    %{
+      id: __MODULE__,
+      start: {__MODULE__, :start_link, []}
+    }
+  end
+
+  def channel_available(chan) do
+    GenServer.cast(__MODULE__, {:channel_available, chan})
+  end
+
+  def consumer_tag() do
+    {:ok, hostname} = :inet.gethostname()
+    "#{hostname}-my-new-consumer"
+  end
+
+  # Server Callbacks
+  def init(:ok) do
+    # Request a channel once the gen server is initialized
+    Rabbit.request_channel(__MODULE__)
+    {:ok, nil}
+  end
+
+  def publish(payload) do
+    GenServer.cast(__MODULE__, {:publish, payload})
+  end
+
+  def handle_cast({:publish, payload}, channel) do
+    # When publishing directly through this consumer's channel
+    message = Jason.decode!(payload)
+    queue = get_queue(message)
+
+    AMQP.Basic.publish(channel, @storecake_v2_exchange, queue, payload, persistent: true)
+
+    {:noreply, channel}
+  end
+
+  def handle_cast({:channel_available, channel}, _state) do
+    Logger.info("CHANNEL_AVAILABLE FOR MY NEW CONSUMER")
+
+    Basic.qos(channel, prefetch_count: @prefetch_count)
+
+    Queue.declare(channel, @queue_base,
+      durable: true,
+      arguments: [
+        {"x-dead-letter-exchange", :longstr, @storecake_v2_exchange_deadletter},
+        {"x-dead-letter-routing-key", :longstr, @sync_queue_error}
+      ]
+    )
+
+    # Note: If implementing retries with delayed messages, declare wait queues here 
+    # and bind them as in OrderConsumer.ex.
+    
+    Queue.bind(channel, @queue_base, @storecake_v2_exchange, routing_key: @queue_base)
+    Queue.bind(channel, @sync_queue_error, @storecake_v2_exchange, routing_key: @sync_queue_error)
+
+    {:ok, _consumer_tag} = Basic.consume(channel, @queue_base, self(), consumer_tag: consumer_tag())
+
+    {:noreply, channel}
+  end
+
+  # Basic AMQP handlers...
+  def handle_info({:basic_consume_ok, %{consumer_tag: _consumer_tag}}, chan), do: {:noreply, chan}
+  def handle_info({:basic_cancel, %{consumer_tag: _consumer_tag}}, chan), do: {:stop, :normal, chan}
+  def handle_info({:basic_cancel_ok, %{consumer_tag: _consumer_tag}}, chan), do: {:noreply, chan}
+
+  def handle_info({:basic_deliver, payload, %{delivery_tag: tag, redelivered: redelivered}}, chan) do
+    spawn(fn -> consume(chan, tag, redelivered, payload) end)
+    {:noreply, chan}
+  end
+
+  def consume(chan, tag, _redelivered, payload) do
+    try do
+      # Pass data to your worker implementation
+      MainWorker.assign(Jason.decode!(payload))
+    rescue
+      e -> on_error(payload, e, __STACKTRACE__)
+    after
+      AMQP.Basic.ack(chan, tag)
+    end
+  end
+
+  def on_error(message, exception, stacktrace \\ []) do
+    Logger.error("Error consuming message: #{inspect(exception)}")
+    # Trigger retry logic if applicable using RabbitMq delayed messages
+  end
+
+  def get_queue(_payload) do
+     @queue_base
+  end
+end
+```
+
+## 2. Registering the Worker
+
+After creating the worker, **you MUST register it in the `Rabbit` supervisor** (`lib/rabbit/rabbit.ex`), otherwise it will not start and not consume any queues.
+
+Open `lib/rabbit/rabbit.ex` and:
+
+1. Alias your new consumer at the top:
+   ```elixir
+   alias Rabbit.{
+     ProductConsumer,
+     OrderConsumer,
+     # ...
+     MyNewConsumer
+   }
+   ```
+2. In the `init(:ok)` function, append it to the `children` list for the specific worker hostnames (e.g., `store-worker-01`, `store-worker-02`). 
+
+   ```elixir
+     "store-worker-01" ->
+       [
+         {ProductConsumer, []},
+         {OrderConsumer, []},
+         # ... existing consumers ...
+         {MyNewConsumer, []}  # <------ Add here
+       ]
+   ```
+
+## 3. Publishing Messages
+
+To publish a message from any location in the application without needing a specific consumer channel or `handle_cast` call, use the general `Rabbit.publish_message/2` helper provided in `Rabbit`:
+
+```elixir
+message_payload = %WorkerMessage{
+  action: "sync_something_new", 
+  turn: 0, 
+  data: %{id: 123, status: "pending"}
+}
+
+# The queue name should match a binding routing key in your consumer setup
+Rabbit.publish_message(message_payload, "my_new_queue_name")
+```

package/skills/builderx_api-redis/SKILL.md

@@ -0,0 +1,93 @@
+---
+description: Patterns for using Redis caching, PubSub, and Poolboy in BuilderX API
+---
+
+# BuilderX API Redis Skill
+
+The `builderx_api` project uses the `redix` library combined with Erlang's `:poolboy` for connection pooling. Standard usages revolve entirely around the `Redis.PubSub` module (`lib/redis/redis_pubsub.ex`).
+
+## 1. General Redis Commands
+
+The `Redis.PubSub` module exposes wrapper functions for common Redis operations. Under the hood, they use `Redix.command/2` within a `:poolboy.transaction/2` call targeting the `:redis_poolex` pool.
+
+### Keys and Strings
+```elixir
+# GET a key
+{:ok, value} = Redis.PubSub.get("my_key")
+
+# SET a key
+{:ok, "OK"} = Redis.PubSub.set("my_key", "value")
+
+# SET a key with expiration (in seconds)
+{:ok, "OK"} = Redis.PubSub.set("my_key", "value", 3600)
+
+# Delete keys
+{:ok, deleted_count} = Redis.PubSub.del("my_key")
+{:ok, deleted_count} = Redis.PubSub.del(["key1", "key2"])
+
+# Expire an existing key
+{:ok, 1} = Redis.PubSub.expire("my_key", 60)
+```
+
+### Counters
+```elixir
+# Increment by 1
+{:ok, new_val} = Redis.PubSub.incr("visits")
+
+# Increment by N
+{:ok, new_val} = Redis.PubSub.incr("visits", 5)
+```
+
+### Hash Maps
+```elixir
+# Increment a field inside a hash
+{:ok, new_val} = Redis.PubSub.hincrby("user:123", "login_count", 1)
+
+# Get a field from a hash
+{:ok, value} = Redis.PubSub.hget("user:123", "name")
+
+# Get entire hash
+{:ok, list_of_pairs} = Redis.PubSub.hgetall("user:123")
+```
+
+### Sets
+```elixir
+# Add to Set
+{:ok, added_count} = Redis.PubSub.sadd("my_set", "item1")
+{:ok, added_count} = Redis.PubSub.sadd("my_set", ["item2", "item3"])
+
+# Remove from Set
+{:ok, removed_count} = Redis.PubSub.srem("my_set", "item1")
+{:ok, removed_count} = Redis.PubSub.srem("my_set", ["item2", "item3"])
+
+# Get all members
+{:ok, members} = Redis.PubSub.smembers("my_set")
+```
+
+## 2. Transactions
+
+You can execute Redis commands transactionally via `MULTI` and `EXEC` using the wrappers:
+
+```elixir
+Redis.PubSub.transaction() # Sends MULTI
+Redis.PubSub.set("key1", "val1")
+Redis.PubSub.set("key2", "val2")
+Redis.PubSub.commit() # Sends EXEC
+```
+
+*Note: Since these execute under standard HTTP pools without locking the connection strictly contextually in the Redix API wrappers mapped here, be cautious when using Redis transactions via standard global pool dispatch; ensure your pipeline design handles concurrency correctly.*
+
+## 3. PubSub Features
+
+Through `:redis_pubsub` pool, builderx_api can support pub-sub channels.
+
+```elixir
+# To subscribe the current process to a channel
+Redis.PubSub.subscribe("chat_room_1", self())
+
+# To unsubscribe
+Redis.PubSub.unsubscribe("chat_room_1", self())
+
+# To publish to a channel
+{:ok, subscribers_received} = Redis.PubSub.publish("chat_room_1", "Hello World!")
+```