API Overview

local vector_db = VectorDB.new({
    db_path = "./data/buidl.db",
    privacy_level = "high"
})

-- Add message to database
vector_db:add_message({
    text = "How do I deploy to production?",
    user = "U1234567890",
    channel = "C1234567890",
    timestamp = "1704067200.123456"
})

-- Search for similar messages
local results = vector_db:search("deployment help", {
    limit = 5,
    channel = "C1234567890"
})

local ai_generator = AIResponseGenerator.new({
    openrouter_client = openrouter,
    conversation_style = "helpful",
    max_context_messages = 8
})

-- Generate response with context
local response = ai_generator:generate_response(
    "How do I fix this error?",
    context_messages
)

local slack_client = SlackSocketMode.new({
    SLACK_APP_TOKEN = config.SLACK_APP_TOKEN,
    SLACK_BOT_TOKEN = config.SLACK_BOT_TOKEN,
    BOT_USER_ID = config.BOT_USER_ID
})

-- Send message to channel
slack_client:send_message("C1234567890", "Hello from Buidl!")

-- Set up event handlers
slack_client:set_vector_db(vector_db)
slack_client:set_ai_generator(ai_generator)

local config_module = require('config')

-- Load configuration from environment and .env file
local config = config_module.load_config()

-- Validate configuration
local is_valid, errors = config_module.validate_config(config)

-- Get default configuration
local defaults = config_module.get_defaults()

{
  -- Required
  SLACK_BOT_TOKEN = "string",
  OPENROUTER_API_KEY = "string",
  
  -- Socket Mode
  SLACK_APP_TOKEN = "string",
  BOT_USER_ID = "string",
  
  -- Optional
  PRIVACY_LEVEL = "high|medium|low",
  AI_ENABLED = "boolean",
  PORT = "number",
  DB_PATH = "string"
}

local CustomEmbeddings = {}

function CustomEmbeddings.new(config)
  local self = setmetatable({}, CustomEmbeddings)
  self.config = config
  return self
end

function CustomEmbeddings:generate_embedding(text)
  -- Custom embedding logic
  return embedding_vector
end

-- Register with vector database
vector_db:set_embeddings_provider(CustomEmbeddings.new(config))

local CustomAI = {}

function CustomAI.new(config)
  local self = setmetatable({}, CustomAI)
  self.config = config
  return self
end

function CustomAI:generate_response(prompt, context)
  -- Custom AI logic
  return response_text
end

-- Use with response generator
local ai_generator = AIResponseGenerator.new({
  ai_provider = CustomAI.new(config)
})

local CustomActions = {}

function CustomActions:handle_action(action_type, parameters)
  if action_type == "deploy" then
    -- Custom deployment logic
    return self:deploy(parameters)
  end
  
  return nil -- Not handled
end

-- Register action handler
ai_generator:register_action_handler(CustomActions.new())

-- Connection opened
function on_open()
  print("WebSocket connected")
end

-- Message received
function on_message(message)
  local data = json.decode(message)
  -- Handle Slack event
end

-- Connection closed
function on_close(code, reason)
  print("WebSocket closed:", reason)
end

-- Error occurred
function on_error(error)
  print("WebSocket error:", error)
end

-- Configuration errors
ConfigurationError = {
  missing_required = "Required configuration missing",
  invalid_format = "Invalid configuration format",
  validation_failed = "Configuration validation failed"
}

-- Connection errors
ConnectionError = {
  slack_auth_failed = "Slack authentication failed",
  websocket_failed = "WebSocket connection failed",
  api_request_failed = "API request failed"
}

-- Processing errors
ProcessingError = {
  embedding_failed = "Embedding generation failed",
  ai_request_failed = "AI request failed",
  database_error = "Database operation failed"
}

-- Standard error format
{
  error = true,
  type = "configuration_error",
  message = "SLACK_BOT_TOKEN is required",
  code = "missing_required",
  timestamp = "2025-07-12T13:45:30Z"
}

local RateLimiter = {}

function RateLimiter.new(requests_per_minute)
  local self = setmetatable({}, RateLimiter)
  self.limit = requests_per_minute
  self.requests = {}
  return self
end

function RateLimiter:check_limit(key)
  local now = os.time()
  local window_start = now - 60
  
  -- Clean old requests
  self.requests[key] = self.requests[key] or {}
  local filtered = {}
  for _, timestamp in ipairs(self.requests[key]) do
    if timestamp > window_start then
      table.insert(filtered, timestamp)
    end
  end
  self.requests[key] = filtered
  
  -- Check limit
  if #self.requests[key] >= self.limit then
    return false, "Rate limit exceeded"
  end
  
  -- Record request
  table.insert(self.requests[key], now)
  return true
end