devskill 2.0.2 → 2.0.4

package/README.md

@@ -48,10 +48,17 @@ npx skills add vuluu2k/skills --skill='pinia-options'
 ```
 
 ### Options 3: Interactive CLI
-We've also built an elegant, interactive CLI for advanced management (requires cloning this repo):
+We've also built an elegant, interactive CLI for advanced management:
 
 ```bash
+# Open interactive menu
+npx devskill
+
+# Option 1: Install entire collections of skills
 npx devskill install
+
+# Option 2: Add specific individual skills (use Space to select)
+npx devskill add
 ```
 
 ---

package/README.vn.md

@@ -27,9 +27,17 @@ Bằng cách cung cấp cho AI các tài liệu `SKILL.md` chuyên dụng, bạn
 
 ## 📦 Cài đặt & Bắt đầu nhanh
 
-Quên việc copy thủ công đi. Chúng tôi đã xây dựng một CLI tương tác thanh lịch để đưa kiến thức trực tiếpChạy CLI trong dự án của bạn:
+Quên việc copy thủ công đi. Chúng tôi đã xây dựng một CLI tương tác thanh lịch để đưa kiến thức trực tiếp vào repo của bạn.
+
 ```bash
+# Mở menu tương tác chính
+npx devskill
+
+# Tuỳ chọn 1: Cài đặt toàn bộ một nhóm (collection) skills
 npx devskill install
+
+# Tuỳ chọn 2: Thêm các skills đơn lẻ (chọn bằng phím Space)
+npx devskill add
 ```
 
 > **Mẹo:** Bạn cũng có thể cài đặt mọi skill trên toàn hệ thống bằng công cụ chính thức:  

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,6 @@
 {
   "name": "devskill",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "type": "module",
   "bin": {
     "devskill": "bin/devskill.js"

package/scripts/cli.ts

@@ -97,9 +97,9 @@ async function initSubmodules(skipPrompt = false) {
     const shouldRemove = skipPrompt
       ? true
       : await p.confirm({
-          message: 'Remove these extra submodules?',
-          initialValue: true,
-        })
+        message: 'Remove these extra submodules?',
+        initialValue: true,
+      })
 
     if (p.isCancel(shouldRemove)) {
       p.cancel('Cancelled')
@@ -130,14 +130,14 @@ async function initSubmodules(skipPrompt = false) {
   const selected = skipPrompt
     ? newProjects
     : await p.multiselect({
-        message: 'Select projects to initialize',
-        options: newProjects.map(project => ({
-          value: project,
-          label: `${project.name} (${project.type})`,
-          hint: project.url,
-        })),
-        initialValues: newProjects,
-      })
+      message: 'Select projects to initialize',
+      options: newProjects.map(project => ({
+        value: project,
+        label: `${project.name} (${project.type})`,
+        hint: project.url,
+      })),
+      initialValues: newProjects,
+    })
 
   if (p.isCancel(selected)) {
     p.cancel('Cancelled')
@@ -332,9 +332,9 @@ async function cleanup(skipPrompt = false) {
     const shouldRemove = skipPrompt
       ? true
       : await p.confirm({
-          message: 'Remove these extra skills?',
-          initialValue: false,
-        })
+        message: 'Remove these extra skills?',
+        initialValue: false,
+      })
 
     if (p.isCancel(shouldRemove)) {
       p.cancel('Cancelled')
@@ -366,7 +366,7 @@ async function cleanup(skipPrompt = false) {
 
 async function installSkills() {
   const spinner = p.spinner()
-  
+
   const allCollections: Record<string, string[]> = { ...collections }
   for (const [vendorName, config] of Object.entries(vendors)) {
     const vendorConfig = config as VendorConfig
@@ -379,7 +379,7 @@ async function installSkills() {
   }
 
   const selectedCollectionNames = await p.multiselect({
-    message: 'Select collections to install',
+    message: 'Select collections to install (Space to select, Enter to confirm)',
     options: Object.keys(allCollections).map(name => ({
       value: name,
       label: name,
@@ -412,21 +412,45 @@ async function installSkills() {
     return
   }
 
-  const skillsDirName = await p.text({
-    message: 'Name of the skills directory inside target project?',
-    initialValue: 'skills',
-    placeholder: 'skills'
+  const toolChoice = await p.select({
+    message: 'Which AI tool are you installing these skills for?',
+    options: [
+      { value: 'skills', label: 'Generic (skills/)', hint: 'Default skills directory' },
+      { value: '.cursor/skills', label: 'Cursor (.cursor/skills)' },
+      { value: '.windsurf/skills', label: 'Windsurf (.windsurf/skills)' },
+      { value: '.claude/skills', label: 'Claude Desktop (.claude/skills)' },
+      { value: '.claudecode/skills', label: 'Claude Code (.claudecode/skills)' },
+      { value: '.agents/skills', label: 'Antigravity (.agents/skills)' },
+      { value: '.vscode/skills', label: 'VSCode / Copilot (.vscode/skills)' },
+      { value: 'custom', label: 'Custom path...' }
+    ]
   })
 
-  if (p.isCancel(skillsDirName)) {
+  if (p.isCancel(toolChoice)) {
     p.cancel('Cancelled')
     return
   }
 
+  let skillsDirName = toolChoice as string
+
+  if (toolChoice === 'custom') {
+    const customDir = await p.text({
+      message: 'Enter custom skills directory path:',
+      initialValue: 'skills',
+      placeholder: 'skills'
+    })
+
+    if (p.isCancel(customDir)) {
+      p.cancel('Cancelled')
+      return
+    }
+    skillsDirName = customDir as string
+  }
+
   const selectedSkills = Array.from(new Set(
     (selectedCollectionNames as string[]).flatMap(name => allCollections[name])
   ))
-  const targetDir = join(targetProject as string, skillsDirName as string)
+  const targetDir = join(targetProject as string, skillsDirName)
 
   if (!existsSync(targetDir)) {
     mkdirSync(targetDir, { recursive: true })
@@ -446,9 +470,129 @@ async function installSkills() {
     if (existsSync(destPath)) {
       rmSync(destPath, { recursive: true })
     }
-    
+
     mkdirSync(destPath, { recursive: true })
-    
+
+    const files = readdirSync(sourcePath, { recursive: true, withFileTypes: true })
+    for (const file of files) {
+      if (file.isFile()) {
+        const fullPath = join(file.parentPath, file.name)
+        const relativePath = fullPath.replace(sourcePath, '')
+        const dp = join(destPath, relativePath)
+        const dd = dirname(dp)
+        if (!existsSync(dd)) {
+          mkdirSync(dd, { recursive: true })
+        }
+        cpSync(fullPath, dp)
+      }
+    }
+    successCount++;
+  }
+
+  spinner.stop(`Installed ${successCount}/${selectedSkills.length} skills to target project`)
+}
+
+async function installSpecificSkills() {
+  const spinner = p.spinner()
+
+  const allSkills = getExistingSkillNames()
+
+  if (allSkills.length === 0) {
+    p.log.warn('No skills found in skills directory. Try running init or sync first.')
+    return
+  }
+
+  const selectedSkills = await p.multiselect({
+    message: 'Select specific skills to install (Space to select, Enter to confirm)',
+    options: allSkills.map(name => ({
+      value: name,
+      label: name
+    }))
+  })
+
+  if (p.isCancel(selectedSkills)) {
+    p.cancel('Cancelled')
+    return
+  }
+
+  if (selectedSkills.length === 0) {
+    p.log.warn('No skills selected')
+    return
+  }
+
+  const targetProject = await p.text({
+    message: 'Enter target project directory path (relative or absolute)',
+    initialValue: process.cwd(),
+    placeholder: process.cwd(),
+    validate: (value) => {
+      if (!value) return 'Path is required'
+      if (!existsSync(value)) return 'Directory does not exist'
+    }
+  })
+
+  if (p.isCancel(targetProject)) {
+    p.cancel('Cancelled')
+    return
+  }
+
+  const toolChoice = await p.select({
+    message: 'Which AI tool are you installing these skills for?',
+    options: [
+      { value: 'skills', label: 'Generic (skills/)', hint: 'Default skills directory' },
+      { value: '.cursor/skills', label: 'Cursor (.cursor/skills)' },
+      { value: '.windsurf/rules', label: 'Windsurf (.windsurf/rules)' },
+      { value: '.claude/skills', label: 'Claude Desktop (.claude/skills)' },
+      { value: '.claudecode/skills', label: 'Claude Code (.claudecode/skills)' },
+      { value: '.agents/skills', label: 'Antigravity (.agents/skills)' },
+      { value: '.vscode/skills', label: 'VSCode / Copilot (.vscode/skills)' },
+      { value: 'custom', label: 'Custom path...' }
+    ]
+  })
+
+  if (p.isCancel(toolChoice)) {
+    p.cancel('Cancelled')
+    return
+  }
+
+  let skillsDirName = toolChoice as string
+
+  if (toolChoice === 'custom') {
+    const customDir = await p.text({
+      message: 'Enter custom skills directory path:',
+      initialValue: 'skills',
+      placeholder: 'skills'
+    })
+
+    if (p.isCancel(customDir)) {
+      p.cancel('Cancelled')
+      return
+    }
+    skillsDirName = customDir as string
+  }
+
+  const targetDir = join(targetProject as string, skillsDirName)
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true })
+  }
+
+  spinner.start(`Installing ${selectedSkills.length} skills to ${targetDir}...`)
+
+  let successCount = 0;
+  for (const skill of selectedSkills as string[]) {
+    const sourcePath = join(root, 'skills', skill)
+    if (!existsSync(sourcePath)) {
+      p.log.warn(`Skill not found: ${skill}`)
+      continue
+    }
+
+    const destPath = join(targetDir, skill)
+    if (existsSync(destPath)) {
+      rmSync(destPath, { recursive: true })
+    }
+
+    mkdirSync(destPath, { recursive: true })
+
     const files = readdirSync(sourcePath, { recursive: true, withFileTypes: true })
     for (const file of files) {
       if (file.isFile()) {
@@ -502,15 +646,22 @@ async function main() {
   }
 
   if (command === 'install') {
-    p.intro('Skills Manager - Install')
+    p.intro('Skills Manager - Install Groups')
     await installSkills()
     p.outro('Done')
     return
   }
 
+  if (command === 'add') {
+    p.intro('Skills Manager - Add Specific Skills')
+    await installSpecificSkills()
+    p.outro('Done')
+    return
+  }
+
   if (skipPrompt) {
     p.log.error('Command required when using -y flag')
-    p.log.info('Available commands: install, init, sync, check, cleanup')
+    p.log.info('Available commands: install, add, init, sync, check, cleanup')
     process.exit(1)
   }
 
@@ -519,7 +670,8 @@ async function main() {
   const action = await p.select({
     message: 'What would you like to do?',
     options: [
-      { value: 'install', label: 'Install collections', hint: 'Copy skill collections to a local project' },
+      { value: 'install', label: 'Install collections', hint: 'Copy entire skill collections to a local project' },
+      { value: 'add', label: 'Add specific skills', hint: 'Choose individual skills to add to your project' },
       { value: 'sync', label: 'Sync submodules', hint: 'Pull latest and sync Type 2 skills' },
       { value: 'init', label: 'Init submodules', hint: 'Add new submodules from meta.ts' },
       { value: 'check', label: 'Check updates', hint: 'See available updates' },
@@ -536,6 +688,9 @@ async function main() {
     case 'install':
       await installSkills()
       break
+    case 'add':
+      await installSpecificSkills()
+      break
     case 'init':
       await initSubmodules()
       break

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!")
+```