Started skeletoning out broadcasts

Author: D-K-P

claude-agent-github-wiki/.env.example

@@ -6,3 +6,13 @@ TRIGGER_SECRET_KEY=your_secret_key
 # Claude API Key
 # Get from https://console.anthropic.com
 ANTHROPIC_API_KEY=your_anthropic_api_key
+
+# Supabase Configuration
+# Get these from your Supabase project settings
+# https://app.supabase.com/project/_/settings/api
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_PRIVATE_KEY=your_supabase_private_key  # For backend use only - more secure than anon key
+
+# Public Supabase keys for frontend (if needed)
+NEXT_PUBLIC_SUPABASE_URL=your_supabase_project_url
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key

claude-agent-github-wiki/README.md

@@ -1,62 +1,188 @@
-# Repo Wiki Chat
+# GitHub Repository Chat with AI
 
-A Next.js 14 demo application that showcases how to chat with GitHub repositories using AI. Users can paste a GitHub URL, ask questions about the codebase, and see AI's reasoning and tool usage stream live.
+A production-ready Next.js application that enables real-time conversations with GitHub repositories using Claude AI. Built with Trigger.dev for background processing, Supabase for realtime messaging, and Claude Agent SDK for intelligent code analysis.
 
-## Features
+## Architecture Overview
 
-- **Landing Page**: Clean, modern interface with GitHub URL input and example repositories
-- **Chat Interface**: Real-time conversation with AI about repository code
-- **Tool Usage Visualization**: View AI's tool calls (Read, Grep, Bash) with expandable results
-- **Responsive Design**: Works seamlessly across desktop and mobile devices
-- **Mock Data**: Demo includes sample conversations showing typical AI analysis
+This application uses a hybrid architecture combining:
+- **Trigger.dev Realtime Streams v2** for streaming AI responses (main data pipeline)
+- **Supabase Broadcast** for sending questions to the AI (lightweight control plane)
+- **Claude Agent SDK** for repository analysis with tool usage
+- **Build Extensions** for containerized git operations
+
+## Key Features
+
+- **Two-Task System**:
+  - Task 1: Clones repository with git build extension
+  - Task 2: Long-running chat session that maintains repo in memory
+- **No Re-cloning**: Repository stays in memory for entire chat session (up to 60 minutes)
+- **Real-time Streaming**: AI responses stream live via Trigger.dev Streams v2
+- **Tool Usage Visualization**: See Claude using Bash, Grep, Read, and other tools
+- **Session Management**: Unique session IDs link clone and chat operations
 
 ## Tech Stack
 
-- Next.js 14 (App Router)
-- TypeScript
-- Tailwind CSS
-- shadcn/ui components
-- React Markdown for message formatting
+- **Frontend**: Next.js 14 (App Router), TypeScript, Tailwind CSS, shadcn/ui
+- **Backend**: Trigger.dev v4 for task orchestration
+- **AI**: Claude Agent SDK with extended thinking
+- **Realtime**: Trigger.dev Streams v2 + Supabase Broadcast
+- **Build**: Trigger.dev build extensions with apt-get for git
 
 ## Getting Started
 
-Install dependencies:
+### Prerequisites
+
+1. Create accounts and get API keys:
+   - [Trigger.dev](https://cloud.trigger.dev) - Project ref and secret key
+   - [Anthropic](https://console.anthropic.com) - Claude API key
+   - [Supabase](https://app.supabase.com) - Project URL and anon key
+
+### Environment Setup
+
+1. Copy the example environment file:
+```bash
+cp .env.example .env.local
+```
+
+2. Add your API keys to `.env.local`:
+```env
+# Trigger.dev
+TRIGGER_PROJECT_REF=your_project_ref
+TRIGGER_SECRET_KEY=your_secret_key
+
+# Claude API
+ANTHROPIC_API_KEY=your_anthropic_api_key
+
+# Supabase
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_ANON_KEY=your_supabase_anon_key
+NEXT_PUBLIC_SUPABASE_URL=your_supabase_project_url
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key
+```
+
+### Installation
 
 ```bash
 npm install
 ```
 
-Run the development server:
+### Development
+
+Run both the Next.js app and Trigger.dev dev server:
 
 ```bash
+# Terminal 1: Next.js
 npm run dev
+
+# Terminal 2: Trigger.dev
+npx trigger.dev@latest dev
+```
+
+Open [http://localhost:3000](http://localhost:3000)
+
+### Deployment
+
+Deploy to Trigger.dev:
+```bash
+npx trigger.dev@latest deploy
+```
+
+Deploy Next.js to Vercel:
+```bash
+vercel deploy
+```
+
+## How It Works
+
+### Flow Diagram
+
+```
+User enters GitHub URL
+    ↓
+Task 1: clone-repo (with git build extension)
+    ↓
+Returns { tempDir, sessionId, repoName }
+    ↓
+Task 2: repo-chat-session (long-running, 60 min timeout)
+    ↓
+Subscribes to Supabase channel for questions
+    ↓
+User sends questions → Supabase → Task 2
+    ↓
+Claude analyzes repo with tools
+    ↓
+Responses stream via Trigger.dev Streams v2 → Frontend
 ```
 
-Open [http://localhost:3000](http://localhost:3000) in your browser.
+### Key Components
+
+1. **Build Extension** (`trigger.config.ts`):
+   - Installs git via apt-get in container
+   - Enables shallow cloning without local git dependency
+
+2. **Clone Task** (`trigger/clone-repo.ts`):
+   - Performs shallow clone (`--depth=1`)
+   - Generates unique session ID
+   - Returns temp directory path
+
+3. **Chat Session Task** (`trigger/repo-chat-session.ts`):
+   - Maintains repo in memory for 60 minutes
+   - Listens for questions via Supabase Broadcast
+   - Streams responses via Trigger.dev Streams v2
+   - Cleans up temp directory on exit
+
+4. **Frontend** (`app/chat/[runId]/page.tsx`):
+   - Sends questions via Supabase
+   - Receives responses via Trigger.dev Streams
+   - Displays tool usage and AI reasoning
 
 ## Project Structure
 
 ```
 app/
-  ├── page.tsx              # Landing page with repo input
-  ├── chat/[runId]/         # Chat interface
-  └── globals.css           # Global styles
+├── page.tsx                    # Landing page
+├── chat/[runId]/page.tsx      # Chat interface
+└── api/
+    ├── analyze-repo/           # Triggers both tasks
+    └── chat/                   # Sends questions via Supabase
+
+trigger/
+├── clone-repo.ts              # Task 1: Git clone
+├── repo-chat-session.ts       # Task 2: Long-running chat
+└── agent-stream.ts            # Shared stream definition
 
 components/
-  ├── chat/
-  │   ├── user-message.tsx  # User message bubble
-  │   ├── ai-message.tsx    # AI response bubble with markdown
-  │   └── tool-card.tsx     # Tool call visualization
-  └── ui/                   # shadcn/ui components
+├── chat/
+│   ├── user-message.tsx      # User message display
+│   ├── ai-message.tsx        # AI response with markdown
+│   └── tool-card.tsx         # Tool usage visualization
+└── ui/                        # shadcn/ui components
 ```
 
-## Usage
+## Advanced Features
+
+- **60-minute sessions**: Extended timeout for complex analysis
+- **Abort handling**: Graceful cleanup on cancellation
+- **Error recovery**: Fallback to Trigger.dev streams if Supabase fails
+- **Progress tracking**: Real-time status updates
+- **Tool visualization**: Collapsible tool results over 50 lines
+
+## Limitations
+
+- Public repositories only (no auth for private repos)
+- Maximum session duration: 60 minutes
+- Shallow clone only (no full git history)
+- One active question at a time per session
+
+## Development Notes
 
-1. Visit the landing page
-2. Enter a GitHub repository URL or click one of the example repos
-3. Ask questions about the repository's code, features, or architecture
-4. Watch as the AI analyzes the codebase and provides insights
+This demo showcases:
+- Trigger.dev Realtime Streams v2 for data streaming
+- Build extensions for containerized dependencies
+- Hybrid architecture pattern (control + data plane separation)
+- Long-running task management
+- Claude Agent SDK integration
 
-## Note
+## License
 
-This is a demo application with mock data. In a production implementation, it would integrate with an actual AI service and GitHub API to provide real repository analysis.
+MIT

claude-agent-github-wiki/app/api/analyze-repo/route.ts

@@ -1,5 +1,6 @@
-import { tasks } from "@trigger.dev/sdk/v3";
+import { tasks, runs } from "@trigger.dev/sdk/v3";
 import { cloneRepo } from "@/trigger/clone-repo";
+import { repoChatSession } from "@/trigger/repo-chat-session";
 import { NextRequest, NextResponse } from "next/server";
 
 export async function POST(request: NextRequest) {
@@ -24,14 +25,61 @@ export async function POST(request: NextRequest) {
     }
 
     // Trigger the clone task
-    const handle = await tasks.trigger<typeof cloneRepo>(
+    const cloneHandle = await tasks.trigger<typeof cloneRepo>(
       "clone-repo",
       { githubUrl }
     );
 
-    // Return the run ID to track clone progress
+    // Wait for clone to complete using pollForCompletion
+    let cloneResult;
+    let attempts = 0;
+    const maxAttempts = 60; // 60 seconds timeout
+
+    while (attempts < maxAttempts) {
+      const run = await runs.retrieve<typeof cloneRepo>(cloneHandle.id);
+
+      if (run.status === "COMPLETED" && run.output) {
+        cloneResult = { ok: true, output: run.output };
+        break;
+      } else if (run.status === "FAILED") {
+        return NextResponse.json(
+          { error: "Failed to clone repository" },
+          { status: 500 }
+        );
+      }
+
+      // Wait 1 second before next check
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      attempts++;
+    }
+
+    if (!cloneResult) {
+      return NextResponse.json(
+        { error: "Clone operation timed out" },
+        { status: 500 }
+      );
+    }
+
+    // Immediately trigger chat session with the cloned repo
+    const chatHandle = await tasks.trigger<typeof repoChatSession>(
+      "repo-chat-session",
+      {
+        tempDir: cloneResult.output.tempDir,
+        sessionId: cloneResult.output.sessionId,
+        repoName: cloneResult.output.repoName,
+      }
+    );
+
+    // Get public access token from handle (auto-generated, expires in 15 min)
+    const accessToken = chatHandle.publicAccessToken;
+
+    // Return session details
     return NextResponse.json({
-      cloneRunId: handle.id,
+      sessionId: cloneResult.output.sessionId,
+      chatRunId: chatHandle.id,
+      accessToken,
+      repoName: cloneResult.output.repoName,
+      cloneRunId: cloneHandle.id, // Keep for backward compatibility
     });
 
   } catch (error: any) {