Build a Slack Bot That Answers Questions About Your Codebase

mkdir codebase-bot && cd codebase-bot
pnpm init
pnpm add @anthropic-ai/sdk @slack/bolt @supabase/supabase-js openai glob
pnpm add -D typescript @types/node tsx
npx tsc --init

# .env
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...           # for embeddings
SUPABASE_URL=https://xxx.supabase.co
SUPABASE_SERVICE_KEY=eyJ...
SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...        # for Socket Mode
SLACK_SIGNING_SECRET=...
REPO_PATH=/path/to/your/repo

-- supabase/migrations/001_code_chunks.sql
create extension if not exists vector;

create table code_chunks (
  id uuid primary key default gen_random_uuid(),
  file_path text not null,
  chunk_index int not null,
  content text not null,
  embedding vector(1536),
  language text,
  repo text not null,
  indexed_at timestamptz default now(),
  unique(repo, file_path, chunk_index)
);

create index on code_chunks
  using ivfflat (embedding vector_cosine_ops)
  with (lists = 100);

create or replace function match_code_chunks(
  query_embedding vector(1536),
  match_threshold float,
  match_count int,
  target_repo text
)
returns table (
  id uuid,
  file_path text,
  content text,
  similarity float
)
language sql stable
as $$
  select
    id,
    file_path,
    content,
    1 - (embedding <=> query_embedding) as similarity
  from code_chunks
  where
    repo = target_repo
    and 1 - (embedding <=> query_embedding) > match_threshold
  order by embedding <=> query_embedding
  limit match_count;
$$;

// src/indexer.ts
import fs from 'fs'
import path from 'path'
import { glob } from 'glob'
import OpenAI from 'openai'
import { createClient } from '@supabase/supabase-js'

const openai = new OpenAI()
const supabase = createClient(
    process.env.SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_KEY!
)

interface CodeChunk {
    filePath: string
    chunkIndex: number
    content: string
    language: string
}

const LANGUAGE_MAP: Record<string, string> = {
    '.ts': 'typescript',
    '.tsx': 'typescript',
    '.js': 'javascript',
    '.jsx': 'javascript',
    '.py': 'python',
    '.go': 'go',
    '.rs': 'rust',
    '.md': 'markdown',
}

function chunkFile(filePath: string, content: string, maxChunkSize = 1500): CodeChunk[] {
    const ext = path.extname(filePath)
    const language = LANGUAGE_MAP[ext] || 'text'
    const lines = content.split('\n')
    const chunks: CodeChunk[] = []
    let currentChunk = ''
    let chunkIndex = 0

    for (const line of lines) {
        if (currentChunk.length + line.length > maxChunkSize && currentChunk.length > 0) {
            chunks.push({
                filePath,
                chunkIndex,
                content: `// File: ${filePath}\n${currentChunk}`,
                language,
            })
            chunkIndex++
            currentChunk = ''
        }
        currentChunk += line + '\n'
    }

    if (currentChunk.trim()) {
        chunks.push({
            filePath,
            chunkIndex,
            content: `// File: ${filePath}\n${currentChunk}`,
            language,
        })
    }

    return chunks
}

async function getEmbeddings(texts: string[]): Promise<number[][]> {
    const response = await openai.embeddings.create({
        model: 'text-embedding-3-small',
        input: texts,
    })
    return response.data.map((d) => d.embedding)
}

export async function indexRepository(repoPath: string, repoName: string): Promise<number> {
    const files = await glob('**/*.{ts,tsx,js,jsx,py,go,rs,md}', {
        cwd: repoPath,
        ignore: [
            '**/node_modules/**',
            '**/dist/**',
            '**/build/**',
            '**/.next/**',
            '**/coverage/**',
            '**/*.min.*',
            '**/package-lock.json',
            '**/pnpm-lock.yaml',
        ],
    })

    console.log(`Found ${files.length} files to index`)

    // Clear old entries for this repo
    await supabase.from('code_chunks').delete().eq('repo', repoName)

    let totalChunks = 0
    const BATCH_SIZE = 20

    for (let i = 0; i < files.length; i += BATCH_SIZE) {
        const batch = files.slice(i, i + BATCH_SIZE)
        const allChunks: CodeChunk[] = []

        for (const file of batch) {
            const fullPath = path.join(repoPath, file)
            const content = fs.readFileSync(fullPath, 'utf-8')

            // Skip huge files — they're usually generated
            if (content.length > 50_000) {
                console.log(`Skipping ${file} (too large)`)
                continue
            }

            allChunks.push(...chunkFile(file, content))
        }

        if (allChunks.length === 0) continue

        const embeddings = await getEmbeddings(allChunks.map((c) => c.content))

        const rows = allChunks.map((chunk, idx) => ({
            file_path: chunk.filePath,
            chunk_index: chunk.chunkIndex,
            content: chunk.content,
            embedding: embeddings[idx],
            language: chunk.language,
            repo: repoName,
        }))

        const { error } = await supabase.from('code_chunks').upsert(rows, {
            onConflict: 'repo,file_path,chunk_index',
        })

        if (error) {
            console.error(`Failed to insert batch: ${error.message}`)
        }

        totalChunks += allChunks.length
        console.log(`Indexed ${totalChunks} chunks (${i + batch.length}/${files.length} files)`)
    }

    return totalChunks
}

// src/run-indexer.ts
import 'dotenv/config'
import { indexRepository } from './indexer'

const repoPath = process.env.REPO_PATH!
const repoName = repoPath.split('/').pop()!

console.log(`Indexing ${repoName} from ${repoPath}...`)

indexRepository(repoPath, repoName).then((count) => {
    console.log(`Done! Indexed ${count} chunks.`)
    process.exit(0)
})

npx tsx src/run-indexer.ts

// src/query-engine.ts
import Anthropic from '@anthropic-ai/sdk'
import OpenAI from 'openai'
import { createClient } from '@supabase/supabase-js'

const anthropic = new Anthropic()
const openai = new OpenAI()
const supabase = createClient(
    process.env.SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_KEY!
)

interface QueryResult {
    answer: string
    sources: string[]
}

async function findRelevantCode(
    question: string,
    repoName: string,
    maxChunks = 8
): Promise<{ content: string; filePath: string; similarity: number }[]> {
    const embeddingResponse = await openai.embeddings.create({
        model: 'text-embedding-3-small',
        input: question,
    })

    const queryEmbedding = embeddingResponse.data[0].embedding

    const { data, error } = await supabase.rpc('match_code_chunks', {
        query_embedding: queryEmbedding,
        match_threshold: 0.3,
        match_count: maxChunks,
        target_repo: repoName,
    })

    if (error) {
        throw new Error(`Similarity search failed: ${error.message}`)
    }

    return (data || []).map((row: { content: string; file_path: string; similarity: number }) => ({
        content: row.content,
        filePath: row.file_path,
        similarity: row.similarity,
    }))
}

export async function queryCodebase(
    question: string,
    repoName: string
): Promise<QueryResult> {
    const relevantChunks = await findRelevantCode(question, repoName)

    if (relevantChunks.length === 0) {
        return {
            answer: "I couldn't find any relevant code for that question. Try rephrasing, or the code might be in a file type I haven't indexed.",
            sources: [],
        }
    }

    const codeContext = relevantChunks
        .map((chunk, i) => `--- Chunk ${i + 1} (${chunk.filePath}, similarity: ${chunk.similarity.toFixed(3)}) ---\n${chunk.content}`)
        .join('\n\n')

    const response = await anthropic.messages.create({
        model: 'claude-sonnet-4-20250514',
        max_tokens: 1500,
        system: `You are a codebase assistant. You answer questions about a codebase using the provided code snippets as context.

Rules:
- Reference specific file paths when explaining where code lives
- If you're not sure about something, say so — don't make up code that isn't in the context
- Keep answers concise but complete
- Use code blocks with the correct language for any code you reference
- If the question can't be answered from the provided context, say so`,
        messages: [
            {
                role: 'user',
                content: `Question: ${question}\n\nRelevant code from the repository:\n\n${codeContext}`,
            },
        ],
    })

    const answer = response.content[0].type === 'text' ? response.content[0].text : ''
    const sources = [...new Set(relevantChunks.map((c) => c.filePath))]

    return { answer, sources }
}

// src/bot.ts
import 'dotenv/config'
import { App } from '@slack/bolt'
import { queryCodebase } from './query-engine'

const app = new App({
    token: process.env.SLACK_BOT_TOKEN!,
    appToken: process.env.SLACK_APP_TOKEN!,
    signingSecret: process.env.SLACK_SIGNING_SECRET!,
    socketMode: true,
})

const repoName = process.env.REPO_PATH!.split('/').pop()!

app.event('app_mention', async ({ event, say }) => {
    // Strip the bot mention from the message to get the question
    const question = event.text.replace(/<@[A-Z0-9]+>/g, '').trim()

    if (!question) {
        await say({
            text: 'Ask me anything about the codebase! For example: "Where is the authentication middleware?"',
            thread_ts: event.ts,
        })
        return
    }

    // Post a "thinking" message
    const thinkingMsg = await say({
        text: ':mag: Looking through the codebase...',
        thread_ts: event.ts,
    })

    try {
        const result = await queryCodebase(question, repoName)

        const sourcesText =
            result.sources.length > 0
                ? `\n\n:file_folder: *Sources:* ${result.sources.map((s) => `\`${s}\``).join(', ')}`
                : ''

        await app.client.chat.update({
            channel: event.channel,
            ts: thinkingMsg.ts!,
            text: `${result.answer}${sourcesText}`,
        })
    } catch (error) {
        const errMessage = error instanceof Error ? error.message : 'Unknown error'
        console.error('Query failed:', errMessage)

        await app.client.chat.update({
            channel: event.channel,
            ts: thinkingMsg.ts!,
            text: `:warning: Something went wrong: ${errMessage}`,
        })
    }
})

async function start(): Promise<void> {
    await app.start()
    console.log(`Codebase bot is running! Repo: ${repoName}`)
}

start()

npx tsx src/bot.ts

// src/summarize-file.ts
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

export async function summarizeFile(
    filePath: string,
    content: string
): Promise<string> {
    const response = await anthropic.messages.create({
        model: 'claude-haiku-4-5-20251001',
        max_tokens: 100,
        messages: [
            {
                role: 'user',
                content: `Summarize what this file does in one sentence. File: ${filePath}\n\n${content.slice(0, 3000)}`,
            },
        ],
    })

    return response.content[0].type === 'text' ? response.content[0].text : ''
}

// src/smart-chunker.ts
function chunkByFunctions(content: string, filePath: string): string[] {
    // Match function/class/method declarations
    const boundaries =
        /^(?:export\s+)?(?:async\s+)?(?:function|class|const\s+\w+\s*=\s*(?:async\s*)?\(|interface|type\s+\w+\s*=)/gm
    const chunks: string[] = []
    let lastIndex = 0
    let match: RegExpExecArray | null

    while ((match = boundaries.exec(content)) !== null) {
        if (match.index > lastIndex && match.index - lastIndex > 100) {
            chunks.push(content.slice(lastIndex, match.index))
            lastIndex = match.index
        }
    }

    if (lastIndex < content.length) {
        chunks.push(content.slice(lastIndex))
    }

    return chunks.map((c) => `// File: ${filePath}\n${c}`)
}

# .github/workflows/index-codebase.yml
name: Index Codebase
on:
  push:
    branches: [main]

jobs:
  index:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v2
        with:
          version: 9
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: pnpm install
      - run: npx tsx src/run-indexer.ts
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
          SUPABASE_SERVICE_KEY: ${{ secrets.SUPABASE_SERVICE_KEY }}
          REPO_PATH: ${{ github.workspace }}