# Project export: Relay This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: Cal Hacks 12.0 - Tagline: Postman AI Agent Automation that transforms vague and slow product requirements into detailed pull requests in 30 seconds - Devpost: https://devpost.com/software/https-youtu-be-dqw4w9wgxcq - GitHub: https://github.com/V-prajit/relay - Result: winner (Postman; [MLH] Best Use of Snowflake API) - Team: 3 GitHub contributor(s) — Prajit Viswanadha (17 commits), SSKYAJI (2 commits), Rabib001 (1 commits) ## Devpost submission (written by the team) ### Inspiration Our project solves a real problem that we, SWE interns to PMs face: vague product requirements and incompatible interpretations. Engineers have to decode and figure out: Clarifying requirements back and forth Searching which files to change Writing acceptance criteria Creating boring boilerplate PRs ### What it does This is how our Agent System works: PM in Slack: "Fix React version issue" Postman AI Agent processes the request Ripgrep finds relevant code files (Settings.tsx, theme.ts) snowflake cortex ai generates PR code (≤30 lines) GitHub PR created automatically Slack notifies team with reasoning trace Dashboard shows history and the current usage of current pr's and of snowflake in general Result: PR + acceptance criteria + impacted files in 30 seconds. Tech Stack | Core Orchestration -Postman AI Agent + Flows | Code Search | Ripgrep API (Node.js/Express) | PR Generation | MIstral Large | PR Creation | GitHub REST API | Notifications | Slack Webhooks + Block Kit | Dashboard | Next.js 16 + Express backend Perfect — here’s your Devpost-ready version (slightly reduced for length, but still polished, professional, and readable for judges). You can paste this directly into the “Accomplishments / Learnings / What’s next” sections of your Devpost submission. 🏆 ### Accomplishments we're proud of Autonomous AI Orchestration: The Postman AI Agent plans and executes the full workflow end-to-end, choosing and invoking Ripgrep, Claude, GitHub, and Slack automatically. Deep Postman Ecosystem Use: Integrated 12+ Postman tools AI Agent Block, Flow Modules, Actions, HTTP blocks, Mock Servers, Monitors, and Analytics. Multi-API Coordination: Combined 4 external APIs with proper error handling, retries, and dynamic branching. Smart Conflict Detection: Scans open PRs, compares overlapping files, and assigns a merge-risk score (0–100%). Transparent Reasoning: Every AI decision, tool call, and prompt is logged in Postman Analytics — complete traceability. Live Slack Integration: /impact → PR created → team notified — all in real time. Next.js Dashboard: Displays PR history, conflict hotspots, and risk metrics in a clean, production-ready UI. 30-Second E2E: From Slack command to GitHub PR creation in under 30 seconds. 💡 ### What we learned AI Agent > Decision Blocks: One AI block replaced 50+ manual logic branches. Prompt Engineering is everything: Multiple iterations made Claude’s PR output concise and reliable. Conflict detection is nuanced: Fuzzy path matching and risk scoring were key. Slack UX matters: Block Kit formatting made AI notifications actionable. Reusable Flow Modules: Each tool (Ripgrep, GitHub, Claude, Slack) can plug into future projects. API resilience: Handling rate limits, retries, and errors across four APIs took careful planning. Local testing hurts: ngrok’s constant URL changes reinforced the need for true cloud deployment. ## README (from the GitHub repository) # Relay (PM Copilot) Relay turns a Slack message describing a feature or bug into a GitHub issue with impacted files and acceptance criteria, using a Postman Flow as the orchestration layer instead of a hand-rolled backend. **Status**: Hackathon project (built October 25-29, 2025 for an MLH hackathon). Not actively maintained since; treat as a reference implementation rather than a running service. ![Relay / PM Copilot high-level diagram](./architecture-diagram.jpg) *Diagram from the original repo. It shows the marketing-level view (PM to Slack to Postman AI Agents to GitHub/Snowflake); the diagrams below in this README show the actual block-level wiring found in the code.* --- ## Problem Turning a one-line feature request into a GitHub issue that an engineer can actually start on takes manual work: someone has to figure out which files are relevant, write acceptance criteria, and decide if it's a new feature or a change to existing code. That triage happens over Slack threads and meetings before any code gets written. ## What it does A `/relay ` Slack command: 1. Gets acknowledged within Slack's 3-second webhook timeout. 2. Triggers a Postman Flow that searches the target repo with ripgrep to find files related to the request. 3. Sends the request text and search results to an LLM step (Postman's AI Agent block, or a Snowflake Cortex-backed backend endpoint, depending on which flow variant is deployed - see [Known limitations](#known-limitations)) to draft a title, description, and acceptance criteria. 4. Posts the result back to Slack, and (per the reusable `create-github-pr-module.json` Flow Module) can create the corresponding GitHub issue/PR. 5. Optionally logs the run to a small analytics service that feeds a Next.js dashboard. ## Status line detail Built by a 3-person team in roughly 5 days. Git history stops October 29, 2025 (`final upload`), and the DigitalOcean deployment referenced in the docs no longer responds (verified while writing this README - see Known limitations). Read this as a snapshot of a hackathon build, not a maintained product. --- ## Architecture ```mermaid flowchart LR PM["PM / requester"] -->|"/relay "| SlackApp["Slack workspace"] SlackApp -->|"slash command webhook"| Action["Postman Action\n(deployed Flow - see note below on\nARCHITECTURE.md's documented design\nvs. the exported flow JSON)"] SlackApp -.->|"Socket Mode, local-dev alternative"| Listener["slack-listener\n(Node, @slack/bolt, no public URL needed)"] Action -->|"immediate ack message\n(response_url, within 3s)"| SlackApp Action -->|"background module"| Ripgrep["Ripgrep API\n(Node/Express wrapping the ripgrep CLI)"] Listener --> Ripgrep Ripgrep -->|"matched files / is_new_feature"| Action Action -->|"generate issue/PR content"| Gen["AI Agent block (Postman)\nor FastAPI backend -> Snowflake Cortex"] Gen --> Action Action -.->|"create issue/PR (Flow Module exists;\nwiring in the exported flow is unconfirmed)"| GitHub["GitHub REST API"] GitHub -.-> Action Action -->|"notification"| SlackApp Action -->|"flow-complete webhook"| DashAPI["dashboard-api\n(Express, JSON-file store)"] DashAPI --> Frontend["Next.js analytics dashboard\n(conflict graph, PR timeline, risk meter)"] Backend["FastAPI backend (optional)\nSnowflake Cortex, GitHub PR creation, ripgrep proxy"] -.->|tunneled via ngrok in local flow variant| Action Backend --> GitHub CI["GitHub Actions\nNewman health-check, every 30 min"] -.->|"probes"| Action ``` **Read this diagram carefully around the GitHub step** - see [Known limitations](#known-limitations) for why it's drawn as uncertain rather than a solid arrow. **A note on Evaluate/Validate/Fork:** `ARCHITECTURE.md` documents the Flow's design as `Request -> Evaluate -> Validate -> Fork`, with the Fork branch returning `202 Accepted` immediately. The committed `postman/flows/relay-command-flow.json` is a simpler linear variant - six blocks (`Webhook Start -> Acknowledge Slack -> RIPGREP API -> Snowflake Cortex -> Send Slack Notification -> Final Response`) with no `Evaluate`, `Validate`, or `Fork` block, and no `202` response anywhere in it. Its "immediate ack" is the `Acknowledge Slack` block, which POSTs a `"Processing..."` message to `{{start.response_url}}` before the rest of the chain runs; the flow's own HTTP response (`Final Response`) is a `200` that depends on the whole chain completing, not a forked early return. Treat the Evaluate/Validate/Fork/202 design below as the documented architecture, not something verified against this exported flow. ### Runtime flow (as implemented in `postman/flows/relay-command-flow.json`) ```mermaid sequenceDiagram participant U as PM (Slack user) participant S as Slack participant F as Postman Flow participant R as Ripgrep API participant B as Backend (Snowflake Cortex) participant D as dashboard-api U->>S: /relay "fix mobile login" S->>F: POST form-encoded webhook F->>S: Acknowledge Slack ("Processing...", must be <3s) F->>B: POST /api/ripgrep/search { query: text } (backend proxy) B->>R: proxied ripgrep search R-->>B: { files: [...], is_new_feature } B-->>F: { files: [...], is_new_feature } F->>B: POST /api/snowflake/generate-pr { feature_request, impacted_files } B-->>F: { pr_title, pr_description, branch_name } F->>S: Block Kit message (title, files impacted, branch, description) F->>F: Final Response (200, depends on the full chain) F->>D: POST /api/webhook/flow-complete (execution record) ``` This sequence is drawn straight from the six blocks in `postman/flows/relay-command-flow.json` (no `Evaluate`/`Validate`/`Fork` - see the note above the previous diagram). Two things worth flagging, both confirmed by reading that flow JSON rather than `ARCHITECTURE.md`: - `ripgrep_search` in the flow calls `{{BACKEND_API_URL}}/api/ripgrep/search`, i.e. it goes through the FastAPI backend's proxy route (`backend/app/routes/ripgrep_proxy.py`), not directly to the Ripgrep API. The proxy exists specifically because ngrok in local development can only tunnel one port. - The flow's Slack notification links to the repo generally (a "View Repo" button), not to a specific issue/PR URL - consistent with this flow variant not calling GitHub directly. --- ## Key technical decisions - **Immediate acknowledgment for Slack's 3-second timeout.** In the exported flow, `Acknowledge Slack` POSTs a `"Processing..."` message to `response_url` before the search/generate/notify chain runs, so Slack sees a response well inside its 3-second window while the rest of the work continues. `ARCHITECTURE.md` documents a more general Fork pattern (a `202 Accepted` branch returned in parallel with up to 60 minutes of background execution) as the intended design; the committed flow JSON implements the ack-then-chain version of that idea rather than a literal Fork block, so treat the Fork/`202` framing as documented design, not verified flow behavior. - **An `Evaluate` block flattens Slack's payload (documented design).** `ARCHITECTURE.md` describes `application/x-www-form-urlencoded` from Slack wrapping every field in a single-element array (`{"text": ["hello"]}`) and a TypeScript `Evaluate` step normalizing this before validation. This block isn't present in the exported `relay-command-flow.json`, so it's documented in `ARCHITECTURE.md` rather than confirmed in the committed flow. - **Two independent entry points.** A deployed Postman Action (public webhook, for the "production" path) and a `slack-listener` Socket Mode app (`@slack/bolt`, no public URL required) exist side by side - useful during development when you don't want to stand up a tunnel. - **Code search first, generation second.** Ripgrep runs before the LLM step so the generation prompt is grounded in files that actually exist in the target repo, and `is_new_feature` short-circuits the "which files" q [README truncated for size] ## Detected evidence (automated analysis) Indexed codebase: 61 recognized source files, 386 KB. - CSS (language) — detected in the code - Express (technology) — detected in the code - FastAPI (technology) — detected in the code - JavaScript (language) — detected in the code - Next.js (technology) — detected in the code - Python (language) — detected in the code - React (technology) — detected in the code - SQL (language) — detected in the code - Tailwind CSS (technology) — detected in the code - TypeScript (language) — detected in the code - Node.js (technology) — claimed on Devpost, not found in the code - AI coding agent: Claude Code — evidence: config files committed to the repository ## Codebase structure (from repository index) ### Files (105 of 105) ``` .claude/settings.local.json .env .env.example .gitattributes .github/workflows/pm-copilot-monitor.yml .gitignore ARCHITECTURE.md backend/.env.example backend/app/__init__.py backend/app/main.py backend/app/models/__init__.py backend/app/models/requests.py backend/app/models/responses.py backend/app/routes/__init__.py backend/app/routes/cortex_showcase.py backend/app/routes/dashboard.py backend/app/routes/github.py backend/app/routes/ripgrep_proxy.py backend/app/routes/snowflake.py backend/app/services/__init__.py backend/app/services/github_service.py backend/app/services/snowflake_service.py backend/app/utils/__init__.py backend/app/utils/memory_guard.py backend/requirements.txt backend/run.py backend/test_github_pr.sh backend/test_phase1.py backend/test_snowflake_integration.py backend/test_snowflake_quick.py backend/test_structure.py dashboard-api/.env.example dashboard-api/package.json dashboard-api/src/index.js dashboard-api/src/routes/analytics.js dashboard-api/src/routes/conflicts.js dashboard-api/src/routes/webhooks.js demo/SNOWFLAKE_SHOWCASE.sql demo/snowflake-pr-generations-table.sql docs/WORKSPACE_URL.txt frontend/.gitignore frontend/app/dashboard/[id]/page.tsx frontend/app/dashboard/page.tsx frontend/app/globals.css frontend/app/layout.tsx frontend/app/page.tsx frontend/components/ConflictGraph.tsx frontend/components/PRTimeline.tsx frontend/components/ReasoningTrace.tsx frontend/components/RiskMeter.tsx frontend/eslint.config.mjs frontend/lib/api.ts frontend/next.config.ts frontend/package.json frontend/postcss.config.mjs frontend/tsconfig.json PM_COPILOT_TEAM_TASKS.txt postman/collections/claude-api.json postman/collections/github-api.json postman/collections/pm-copilot-health-check.json postman/collections/ripgrep-api.json postman/collections/slack-webhooks.json postman/collections/snowflake-generate-pr.json postman/environment.example.json postman/environment.json postman/environments/dev-simple.json postman/environments/dev.json postman/environments/pm-copilot-env.json postman/environments/production.json postman/flows/relay-command-flow.json postman/mcp-server-config.json postman/mock-servers/code-samples.json postman/modules/claude-generate-pr-module.json postman/modules/create-github-pr-module.json postman/modules/get-open-prs-module.json postman/modules/get-pr-files-module.json postman/modules/ripgrep-search-module.json postman/modules/send-slack-notification-module.json quick-restart.sh README.md ripgrep-api/.env ripgrep-api/.env.example ripgrep-api/.gitignore ripgrep-api/package.json ripgrep-api/src/index.js ripgrep-api/src/routes/search.js ripgrep-api/src/services/git.js ripgrep-api/src/services/ripgrep.js ripgrep-api/test-rg.js ROADMAP.md SETUP.md slack-listener/.env.example slack-listener/.gitignore slack-listener/index.js slack-listener/package.json snowflake/cortex_analyst_semantic_model.yaml snowflake/FINAL_RUN_THIS.sql snowflake/fix_commits_table.sql snowflake/populate_data_NO_COMMITS.sql snowflake/populate_perfect_data.sql snowflake/setup_tables.sql start-all.sh stop-all.sh test-dashboard.sh VERIFY_SNOWFLAKE.sql ``` ### Dependencies - backend/requirements.txt: fastapi@==0.104.1, gitpython@==3.1.40, httpx@==0.25.2, PyGithub@==2.1.1, python-dotenv@==1.0.0, snowflake-connector-python@==3.6.0, snowflake-sqlalchemy@==1.5.1, uvicorn[standard]@==0.24.0 - dashboard-api/package.json: cors@^2.8.5, dotenv@^16.3.1, express@^4.18.2, uuid@^9.0.1 - frontend/package.json: @tailwindcss/postcss@^4, @types/node@^20, @types/react@^19, @types/react-dom@^19, eslint@^9, eslint-config-next@16.0.0, next@16.0.0, react@19.2.0, react-dom@19.2.0, tailwindcss@^4, typescript@^5 - ripgrep-api/package.json: @vscode/ripgrep@^1.15.9, cors@^2.8.5, dotenv@^16.3.1, express@^4.18.2, nodemon@^3.0.1, simple-git@^3.25.0 - slack-listener/package.json: @slack/bolt@^3.17.1, axios@^1.6.5, dotenv@^16.4.1, nodemon@^3.0.3 ### Recent commits (newest first) - docs: README and architecture refresh (#29) - final upload - working dashbaord and stuff - fixed the automation - working base stable - Merge adding-json-config-and-devops: Add health monitoring features - Add /docs to .gitignore - Security fix: Remove exposed API keys from .env.example - Merge Snowflake and DeepSeek-OCR integration from rabib branch - Clean up documentation and update environment files - some light - stable nough - Added Snowflake integration modules - Phase 2: Complete CI/CD Pipeline and DevOps Setup - working base postman with slack and github - Merge branch 'backend' - some fixes and basic backend - Add DeepSeek-OCR visual context compression architecture - Update CLAUDE.md - basic Claude.md ## Key source files (fetched from GitHub, selected and truncated for size) ### SETUP.md ```markdown # Relay Setup Guide Complete installation and configuration instructions for deploying Relay from scratch. --- ## Table of Contents 1. [Prerequisites](#prerequisites) 2. [Ripgrep API Setup](#ripgrep-api-setup) 3. [Postman Flow Setup](#postman-flow-setup) 4. [Slack App Configuration](#slack-app-configuration) 5. [Action Deployment](#action-deployment) 6. [Testing](#testing) 7. [Production Deployment](#production-deployment) --- ## Prerequisites ### Required Software - **Node.js**: Version 18 or later - **npm**: Version 9 or later - **Postman Desktop**: Version 11.42.3 or later - **Git**: For cloning repositories - **curl**: For testing API endpoints ### Required Accounts - **GitHub**: Personal account with ability to create repositories - **Slack**: Workspace with admin privileges - **Postman**: Account with Flows access - **DigitalOcean** (optional): For production deployment ### Required Credentials 1. **GitHub Personal Access Token**: - Go to GitHub Settings → Developer settings → Personal access tokens → Tokens (classic) - Click "Generate new token (classic)" - Select scopes: `repo` (full control of private repositories) - Copy token (starts with `ghp_`) 2. **Slack Webhook URL**: - Created during Slack app setup (see below) --- ## Ripgrep API Setup The Ripgrep API provides fast code search functionality. ### 1. Clone Repository ```bash git clone https://github.com/V-prajit/relay.git cd relay/ripgrep-api ``` ### 2. Install Dependencies ```bash npm install ``` ### 3. Configure Environment ```bash cp .env.example .env ``` Edit `.env` file: ```bash # Server Configuration PORT=3001 # GitHub Repository Configuration REPO_OWNER=V-prajit REPO_NAME=postman-api-toolkit # Search Configuration CLONE_DIR=/tmp/ripgrep-repo-cache MAX_SEARCH_RESULTS=50 ALLOWED_ORIGINS=* ``` **Configuration Details**: - `PORT`: Local server port (default 3001, avoid conflicts with other services) - `REPO_OWNER`: GitHub username or organization - `REPO_NAME`: Repository to search - `CLONE_DIR`: Temporary directory for repository clones - `MAX_SEARCH_RESULTS`: Maximum files returned per search - `ALLOWED_ORIGINS`: CORS configuration (use `*` for development, restrict in production) ### 4. Start Development Server ```bash npm run dev ``` Expected output: ``` Ripgrep API listening on port 3001 Repository will be cloned to: /tmp/ripgrep-repo-cache ``` ### 5. Verify Installation ```bash # Health check curl http://localhost:3001/api/health # Expected response: # {"success":true,"status":"healthy","service":"Ripgrep API"} # Test search curl -X POST http://localhost:3001/api/search \ -H "Content-Type: application/json" \ -d '{"query":"import"}' # Expected response: # {"success":true,"data":{"files":[...],"total":5,"is_new_feature":false}} ``` --- ## Postman Flow Setup ### 1. Install Postman Desktop Download from [postman.com/downloads](https://www.postman.com/downloads/) and install. **Minimum version**: 11.42.3 (required for [truncated — 13697 more characters] ``` ### ARCHITECTURE.md ```markdown # Relay Architecture Technical documentation of Relay's system design, data flow, and implementation patterns. --- ## Table of Contents 1. [System Overview](#system-overview) 2. [Component Architecture](#component-architecture) 3. [Postman Flow Structure](#postman-flow-structure) 4. [Data Flow](#data-flow) 5. [Slack Integration](#slack-integration) 6. [Ripgrep API](#ripgrep-api) 7. [GitHub Integration](#github-integration) 8. [Error Handling](#error-handling) 9. [Performance Considerations](#performance-considerations) --- ## System Overview Relay is built on a serverless, event-driven architecture that processes Slack slash commands through a Postman Flow orchestration layer. The system is designed to handle Slack's 3-second webhook timeout requirement while performing potentially long-running operations in the background. ### Key Design Principles - **Asynchronous by default**: Immediate acknowledgment with background processing - **Stateless execution**: Each request is independent and self-contained - **Idempotent operations**: Safe to retry failed requests - **Fail-fast validation**: Catch errors early before expensive operations - **Modular composition**: Reusable Flow Modules for common operations ### Architecture Diagram ``` ┌─────────────┐ │ Slack │ │ /relay cmd │ └──────┬──────┘ │ HTTP POST (form-encoded) │ ┌──────▼─────────────────────────────────────┐ │ Postman Action (Deployed Flow) │ │ │ │ ┌───────┐ ┌──────────┐ ┌──────────┐ │ │ │Request│──▶│ Evaluate │──▶│ Validate │ │ │ └───────┘ └──────────┘ └────┬─────┘ │ │ │ │ │ ┌────▼────┐ │ │ │ Fork │ │ │ └────┬────┘ │ │ ┌──────────────┴──────────────┐ │ │ │ │ ┌──────▼─────┐ ┌─────────▼────────┐ │ │ Response │ │ Module │ │ │ (202 OK) │ │ (Background) │ │ └────────────┘ └──────┬───────────┘ │ │ └──────────────────────────────────────────────┼────────────┘ │ ┌──────────────────────────┼──────────────────┐ │ │ │ ┌──────▼────────┐ ┌──────────▼─────┐ ┌────────▼─────────┐ │ Ripgrep API │ │ GitHub API │ │ Slack Webhook │ │ (Code Search)│ │ (Create Issue) │ │ (Notification) │ └───────────────┘ └─────────────────┘ └──────────────────┘ ``` --- ## Component Architecture ### 1. Postman Flows (Orchestration Layer) Postman Flows serves as the orchestration engine, coordinating between multiple services without requiring a traditio [truncated — 17865 more characters] ``` ### backend/requirements.txt ``` # Core API Framework fastapi==0.104.1 uvicorn[standard]==0.24.0 python-dotenv==1.0.0 gitpython==3.1.40 httpx==0.25.2 PyGithub==2.1.1 # Snowflake Integration snowflake-connector-python==3.6.0 snowflake-sqlalchemy==1.5.1 ``` ### frontend/package.json ``` { "name": "frontend", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev -p 3002", "build": "next build", "start": "next start -p 3002", "lint": "eslint" }, "dependencies": { "react": "19.2.0", "react-dom": "19.2.0", "next": "16.0.0" }, "devDependencies": { "typescript": "^5", "@types/node": "^20", "@types/react": "^19", "@types/react-dom": "^19", "@tailwindcss/postcss": "^4", "tailwindcss": "^4", "eslint": "^9", "eslint-config-next": "16.0.0" } } ``` ### slack-listener/package.json ``` { "name": "pm-copilot-slack-listener", "version": "1.0.0", "description": "Slack Socket Mode listener for PM Copilot - no public URL required!", "main": "index.js", "scripts": { "start": "node index.js", "dev": "nodemon index.js" }, "keywords": [ "slack", "socket-mode", "pm-copilot", "localhost" ], "author": "", "license": "MIT", "dependencies": { "@slack/bolt": "^3.17.1", "axios": "^1.6.5", "dotenv": "^16.4.1" }, "devDependencies": { "nodemon": "^3.0.3" }, "engines": { "node": ">=18.0.0" } } ``` ### dashboard-api/package.json ``` { "name": "pm-copilot-dashboard-api", "version": "1.0.0", "description": "Dashboard API for PM Copilot - stores flow execution data and serves analytics", "main": "src/index.js", "type": "module", "scripts": { "start": "node src/index.js", "dev": "node --watch src/index.js", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [ "postman", "flows", "dashboard", "analytics" ], "author": "", "license": "MIT", "dependencies": { "express": "^4.18.2", "cors": "^2.8.5", "dotenv": "^16.3.1", "uuid": "^9.0.1" }, "devDependencies": {} } ``` ### ripgrep-api/package.json ``` { "name": "ripgrep-api", "version": "1.0.0", "description": "HTTP API wrapper for ripgrep code search", "main": "src/index.js", "type": "module", "scripts": { "dev": "cd .. && node --watch ripgrep-api/src/index.js", "start": "node src/index.js", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [ "ripgrep", "code-search", "api", "pm-copilot" ], "author": "", "license": "MIT", "dependencies": { "@vscode/ripgrep": "^1.15.9", "express": "^4.18.2", "cors": "^2.8.5", "dotenv": "^16.3.1", "simple-git": "^3.25.0" }, "devDependencies": { "nodemon": "^3.0.1" }, "engines": { "node": ">=18.0.0" } } ``` ### slack-listener/index.js ```javascript /** * Slack Socket Mode Listener for PM Copilot * * This app listens for /impact slash commands from Slack using Socket Mode, * which means NO public URL required - works entirely on localhost! * * Flow: Slack → Socket Mode → This app → Local services → GitHub PR → Slack notification */ const { App } = require('@slack/bolt'); const axios = require('axios'); require('dotenv').config(); // Initialize Slack app with Socket Mode const app = new App({ token: process.env.SLACK_BOT_TOKEN, // xoxb-... (from OAuth & Permissions) appToken: process.env.SLACK_APP_TOKEN, // xapp-... (from Basic Information) socketMode: true, // Enable Socket Mode (no public URL needed!) }); // Configuration const RIPGREP_API_URL = process.env.RIPGREP_API_URL || 'http://localhost:3001'; const BACKEND_API_URL = process.env.BACKEND_API_URL || 'http://localhost:8000'; const GITHUB_TOKEN = process.env.GITHUB_TOKEN; const REPO_OWNER = process.env.REPO_OWNER || 'V-prajit'; const REPO_NAME = process.env.REPO_NAME || 'youareabsolutelyright'; const SLACK_CHANNEL = process.env.SLACK_CHANNEL || '#new-channel'; /** * Handle /relay slash command */ app.command('/relay', async ({ command, ack, respond, client }) => { // Acknowledge command immediately (Slack requires response within 3 seconds) await ack({ response_type: 'in_channel', text: `⏳ Processing your request: "${command.text}"` }); const featureRequest = command.text; const userId = command.user_id; const userName = command.user_name; const channelId = command.channel_id; console.log(`\n${'='.repeat(60)}`); console.log(`📨 Received /relay command from @${userName}`); console.log(`Feature request: "${featureRequest}"`); console.log(`${'='.repeat(60)}\n`); try { // Step 1: Search codebase with Ripgrep console.log('🔍 Step 1: Searching codebase with Ripgrep...'); const ripgrepResponse = await axios.post(`${RIPGREP_API_URL}/api/search`, { query: featureRequest, path: './', type: 'all', case_sensitive: false }); const ripgrepData = ripgrepResponse.data.data; const impactedFiles = ripgrepData.files || []; const isNewFeature = ripgrepData.is_new_feature || false; const totalFiles = ripgrepData.total || 0; console.log(` ✅ Found ${totalFiles} file(s)`); console.log(` 📁 Files: ${impactedFiles.slice(0, 5).join(', ')}${totalFiles > 5 ? '...' : ''}`); console.log(` 🆕 New feature: ${isNewFeature}`); // Step 2: Generate PR with Snowflake Cortex console.log('\n🤖 Step 2: Generating PR with Snowflake Cortex...'); const prResponse = await axios.post(`${BACKEND_API_URL}/api/snowflake/generate-pr`, { feature_request: featureRequest, impacted_files: impactedFiles, is_new_feature: isNewFeature, repo_name: `${REPO_OWNER}/${REPO_NAME}` }); const prData = prResponse.data; console.log(` ✅ Generated PR: "${prData.pr_title}"`); console.log(` 🌿 Branch: ${prData.branch_name}`); // Step 3: Create GitHub PR (if you want to auto-create) // For demo, you might skip this and just show the generated content let githubPrUrl = null; if (GITHUB_TOKEN && process.env.AUTO_CREATE_PR === 'true') { console.log('\n📝 Step 3: Creating GitHub PR...'); try { const githubResponse = await axios.post( `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/pulls`, { title: prData.pr_title, body: prData.pr_description, head: prData.branch_name, base: 'main' }, { headers: { 'Authorization': `Bearer ${GITHUB_TOKEN}`, 'Accept': 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28' } } ); githubPrUrl = githubResponse.data.html_url; console.log(` ✅ PR created: ${githubPrUrl}`); } catch (githubError) { console.error(` ⚠️ GitHub PR creation failed: ${githubError.message}`); console.log(' ℹ️ Continuing without GitHub PR (you can create manually)'); } } else { console.log('\n📝 Step 3: Skipping GitHub PR creation (set AUTO_CREATE_PR=true to enable)'); } // Step 4: Send rich notification to Slack console.log('\n💬 Step 4: Sending notification to Slack...'); const blocks = [ { type: 'header', text: { type: 'plain_text', text: `✅ Task Created: ${prData.pr_title}` } }, { type: 'section', text: { type: 'mrkdwn', text: `*Feature Request:* ${featureRequest}\n*Requested by:* <@${userId}> (PM)` } }, { type: 'section', fields: [ { type: 'mrkdwn', text: `*Files Impacted:* ${totalFiles}` }, { type: 'mrkdwn', text: `*Is New Feature:* ${isNewFeature ? 'Yes 🆕' : 'No 🔧'}` } ] }, { type: 'section', text: { type: 'mrkdwn', text: `*Impacted Files:*\n${impactedFiles.slice(0, 5).map(f => `• \`${f}\``).join('\n')}${totalFiles > 5 ? `\n• _...and ${totalFiles - 5} more_` : ''}` } }, { type: 'section', text: { type: 'mrkdwn', text: `*Branch:* \`${prData.branch_name}\`` } } ]; // Add PR description preview if (prData.pr_description) { blocks.push({ type: 'section', text: { type: 'mrkdwn', text: `*PR Description:*\n${prData.pr_description.substring(0, 300)}${prData.pr_description.length > 300 ? '...' : ''}` } }); } // Add action buttons const actionElements = []; if (githubPrUrl) { actionElements.push({ type: 'button', text: { type: 'plain_text', text: 'View PR' [truncated — 3113 more characters] ``` ### frontend/app/layout.tsx ```typescript import type { Metadata } from "next"; import { Geist, Geist_Mono } from "next/font/google"; import "./globals.css"; const geistSans = Geist({ variable: "--font-geist-sans", subsets: ["latin"], }); const geistMono = Geist_Mono({ variable: "--font-geist-mono", subsets: ["latin"], }); export const metadata: Metadata = { title: "Snowflake Cortex Analytics Hub - BugRewind", description: "Showcase of Snowflake Cortex AI features: LLM Functions, Time Travel, Semantic Search, Data Warehousing", }; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` ### backend/app/main.py ```python """ BugRewind API - FastAPI backend for git archaeology and bug analysis This is the main entry point for the FastAPI application. """ import os from pathlib import Path from typing import Dict from contextlib import asynccontextmanager from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from dotenv import load_dotenv # Load environment variables load_dotenv() @asynccontextmanager async def lifespan(app: FastAPI): """ Lifespan event handler for startup and shutdown tasks. Replaces the deprecated @app.on_event("startup") pattern. """ # Startup tasks clone_dir = os.getenv("CLONE_DIR", "/tmp/bugrewind-clones") Path(clone_dir).mkdir(parents=True, exist_ok=True) port = os.getenv("PORT", "8000") print("=" * 60) print("BugRewind API Starting") print("=" * 60) print(f"Clone directory: {clone_dir}") print(f"Server port: {port}") print(f"API documentation: http://localhost:{port}/docs") print(f"Alternative docs: http://localhost:{port}/redoc") print("=" * 60) yield # Server runs here # Shutdown tasks (if needed) print("BugRewind API shutting down") # Initialize FastAPI app with lifespan handler app = FastAPI( title="BugRewind API", version="1.0.0", description="Git archaeology for bug origins - trace bugs back to their source commits", docs_url="/docs", redoc_url="/redoc", lifespan=lifespan, ) # Configure CORS middleware app.add_middleware( CORSMiddleware, allow_origins=["*"], # In production, specify actual origins allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) @app.get("/health") async def health_check() -> Dict[str, str]: """ Health check endpoint to verify the API is running. Returns: dict: Status and version information """ return { "status": "healthy", "version": "1.0.0", "service": "BugRewind API" } # Import and include routers # Snowflake routes try: from app.routes import snowflake app.include_router(snowflake.router, prefix="/api") print("✓ Snowflake routes loaded") except ImportError as e: print(f"⚠ Snowflake routes not loaded: {e}") except Exception as e: print(f"⚠ Error loading Snowflake routes: {e}") # Dashboard routes try: from app.routes import dashboard app.include_router(dashboard.router, prefix="/api") print("✓ Dashboard routes loaded") except ImportError as e: print(f"⚠ Dashboard routes not loaded: {e}") except Exception as e: print(f"⚠ Error loading Dashboard routes: {e}") # Cortex Showcase routes try: from app.routes import cortex_showcase app.include_router(cortex_showcase.router, prefix="/api") print("✓ Cortex Showcase routes loaded") except ImportError as e: print(f"⚠ Cortex Showcase routes not loaded: {e}") except Exception as e: print(f"⚠ Error loading Cortex Showcase routes: {e}") # Ripgrep Proxy routes (for Postman Action via ngrok) try: from app.routes import ripgrep_proxy app.include_router(ripgrep_proxy.router, prefix="/api") print("✓ Ripgrep Proxy routes loaded (Postman can now call /api/ripgrep/search)") except ImportError as e: print(f"⚠ Ripgrep Proxy routes not loaded: {e}") except Exception as e: print(f"⚠ Error loading Ripgrep Proxy routes: {e}") # GitHub routes (for creating PRs and issues) try: from app.routes import github app.include_router(github.router, prefix="/api") print("✓ GitHub routes loaded (PR creation enabled)") except ImportError as e: print(f"⚠ GitHub routes not loaded: {e}") except Exception as e: print(f"⚠ Error loading GitHub routes: {e}") ``` [50 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]