Public Documentation
Open & Accessible
[truncated — 3250 more characters]
```
### ui/app/chat/page.tsx
```typescript
"use client"
import { useChat } from "ai/react"
import { SplitScreenChat } from "@/components/split-screen-chat"
export default function PublicChatPage() {
const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
api: "/api/public-chat",
initialMessages: [
{
id: "system-1",
role: "system",
content:
"You are LLMAO (Large Language Model Aided Overflow), an AI assistant for public documentation. Provide helpful, accurate responses based on available documentation.",
},
],
// Ensure messages persist properly
keepLastMessageOnError: true,
})
return (
)
}
```
### ui/app/internal/page.tsx
```typescript
"use client"
import type React from "react"
import { useState, useCallback } from "react"
import { useRouter } from "next/navigation"
import { Input } from "@/components/ui/input"
import { Button } from "@/components/ui/button"
import { Card, CardContent } from "@/components/ui/card"
import { useEffect } from "react"
import {
Lock,
Github,
FileText,
ArrowRight,
Eye,
EyeOff,
Brain,
ArrowLeft,
AlertCircle,
CheckCircle,
} from "lucide-react"
import Link from "next/link"
import { ThemeToggle } from "@/components/theme-toggle"
interface Config {
repo: string
conf: string
timestamp: number
}
export default function InternalPage() {
const [repoUrl, setRepoUrl] = useState("")
const [confUrl, setConfUrl] = useState("")
const [assistantMessage, setAssistantMessage] = useState("")
const [isAuthorized, setIsAuthorized] = useState(false)
const [password, setPassword] = useState("")
const [error, setError] = useState("")
const [showPassword, setShowPassword] = useState(false)
const [isLoading, setIsLoading] = useState(false)
const [configError, setConfigError] = useState("")
const [authLoading, setAuthLoading] = useState(true)
const [repoUrlValid, setRepoUrlValid] = useState
(null)
const [confUrlValid, setConfUrlValid] = useState(null)
const router = useRouter()
// URL validation functions
const validateGitHubUrl = useCallback((url: string): boolean => {
if (!url.trim()) return false
try {
const urlObj = new URL(url)
return urlObj.hostname === "github.com" && urlObj.pathname.split("/").length >= 3
} catch {
return false
}
}, [])
const validateConfluenceUrl = useCallback((url: string): boolean => {
if (!url.trim()) return false
try {
const urlObj = new URL(url)
return urlObj.hostname.includes("atlassian.net") || urlObj.pathname.includes("/wiki")
} catch {
return false
}
}, [])
// Real-time URL validation
useEffect(() => {
if (repoUrl) {
setRepoUrlValid(validateGitHubUrl(repoUrl))
} else {
setRepoUrlValid(null)
}
}, [repoUrl, validateGitHubUrl])
useEffect(() => {
if (confUrl) {
setConfUrlValid(validateConfluenceUrl(confUrl))
} else {
setConfUrlValid(null)
}
}, [confUrl, validateConfluenceUrl])
const handleSubmit = useCallback(
async (e: React.FormEvent) => {
e.preventDefault()
e.stopPropagation()
setConfigError("")
// Validate inputs
if (!repoUrl.trim() || !confUrl.trim()) {
setConfigError("Both GitHub repository and Confluence URLs are required")
return
}
if (!validateGitHubUrl(repoUrl)) {
setConfigError("Please enter a valid GitHub repository URL (e.g., https://github.com/username/repository)")
return
}
if (!validateConfluenceUrl(confUrl)) {
setConfigError("Please enter a valid Confluence URL (e.g., https://your-domain.atlassian.net/wiki)")
return
}
setIsLoading(true)
try {
// Send repository data to Python server
console.log("Where are you");
const response = await fetch("http://127.0.0.1:5000/repo", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
repoUrl: repoUrl.trim(),
confUrl: confUrl.trim(),
}),
})
console.log("Works");
const result = await response.json()
if (!response.ok) {
throw new Error(result.details || result.error || "Failed to send repository to Python server")
}
if (result && result.assistantMessageContent) {
console.log("Received assistant message:", result.assistantMessageContent);
// Display or use it in your UI
setAssistantMessage(result.assistantMessageContent);
} else {
console.error("Assistant message missing in response", result);
}
console.log("Successfully sent to Python server:", result)
const config: Config = {
repo: repoUrl.trim(),
conf: confUrl.trim(),
timestamp: Date.now(),
}
// Clear any existing config first
sessionStorage.removeItem("llmao_config")
// Set new config
sessionStorage.setItem("llmao_config", JSON.stringify(config))
// Verify it was saved
const saved = sessionStorage.getItem("llmao_config")
if (!saved) {
throw new Error("Failed to save configuration")
}
// Navigate after a short delay to ensure state is saved
setTimeout(() => {
router.push("/internal/chat")
}, 500)
} catch (error) {
console.error("Error during submission:", error)
const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred"
setConfigError(`Error: ${errorMessage}`)
setIsLoading(false)
}
},
[repoUrl, confUrl, validateGitHubUrl, validateConfluenceUrl, router],
)
const handleLogin = useCallback(
(e: React.FormEvent) => {
e.preventDefault()
e.stopPropagation()
setError("")
setIsLoading(true)
setTimeout(() => {
const adminPassword = process.env.NEXT_PUBLIC_ADMIN_PASSWORD || "admin123"
if (password === adminPassword) {
try {
sessionStorage.setItem("isInternalAuthorized", "true")
sessionStorage.setItem("authTimestamp", Date.now().toString())
setIsAuthorized(true)
setError("")
} catch (error) {
console.error("Failed to set authorization:", error)
setError("Authorization failed. Please try again.")
}
} else {
setError("Invalid password")
}
setIsLoading(false)
}, 800)
},
[password],
)
useEffect(()
[truncated — 13322 more characters]
```
### ui/app/api/public-chat/route.ts
```typescript
// Allow streaming responses up to 30 seconds
export const maxDuration = 30
function textToStream(text: string, chunkDelay = 40) {
const encoder = new TextEncoder()
return new ReadableStream({
start(controller) {
const words = text.split(" ")
let i = 0
const push = () => {
if (i < words.length) {
controller.enqueue(encoder.encode(`0:"${words[i]}${i < words.length - 1 ? " " : ""}"\n`))
i++
setTimeout(push, chunkDelay)
} else {
controller.enqueue(encoder.encode("d:\n"))
controller.close()
}
}
push()
},
})
}
export async function POST(req: Request) {
try {
const { messages } = await req.json()
const latestUserMsg =
[...messages]
.reverse()
.find((m: any) => m.role === "user")
?.content?.trim() ?? ""
if (!latestUserMsg) {
return new Response("No content", { status: 400 })
}
// Use your actual API URL here instead of environment variables
// Replace this with your real API endpoint
const apiURL = "https://your-actual-api-endpoint.com/chat"
const apiKey = "your-actual-api-key" // or leave empty if not needed
// For demo purposes, let's simulate a response instead of calling external API
const simulatedResponse = `Here's information about "${latestUserMsg}" from the public documentation. This is a simulated response that shows how your custom API would integrate. The response demonstrates the streaming typing effect and message persistence that you requested. You can replace this with your actual API logic when ready.`
// Uncomment and modify this section when you have your real API ready:
/*
const upstream = await fetch(apiURL, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
body: JSON.stringify({
query: latestUserMsg,
context: "public-documentation",
}),
})
if (!upstream.ok) {
throw new Error(`API error ${upstream.status}`)
}
const contentType = upstream.headers.get("content-type") || ""
let answer = ""
if (contentType.includes("application/json")) {
const data = await upstream.json()
answer = data.answer ?? data.response ?? data.text ?? "No response"
} else {
answer = await upstream.text()
}
*/
// For now, use the simulated response
const answer = simulatedResponse
return new Response(textToStream(answer), {
headers: {
"Content-Type": "text/plain; charset=utf-8",
"X-Vercel-AI-Data-Stream": "v1",
},
})
} catch (err) {
console.error("Error in public chat:", err)
return new Response(
textToStream(
"I'm sorry, I'm having trouble processing your request. This is a demo response while your custom API is being configured.",
),
{
headers: {
"Content-Type": "text/plain; charset=utf-8",
"X-Vercel-AI-Data-Stream": "v1",
},
status: 500,
},
)
}
}
```
### ui/app/api/internal-chat/route.ts
```typescript
// Allow streaming responses up to 30 seconds
export const maxDuration = 30
function textToStream(text: string, chunkDelay = 30) {
const encoder = new TextEncoder()
return new ReadableStream({
start(controller) {
const words = text.split(" ")
let i = 0
const push = () => {
if (i < words.length) {
controller.enqueue(encoder.encode(`0:"${words[i]}${i < words.length - 1 ? " " : ""}"\n`))
i++
setTimeout(push, chunkDelay)
} else {
controller.enqueue(encoder.encode("d:\n"))
controller.close()
}
}
push()
},
})
}
export async function POST(req: Request) {
try {
const { messages, repo, conf } = await req.json()
const latestUserMsg =
[...messages]
.reverse()
.find((m: any) => m.role === "user")
?.content?.trim() ?? ""
if (!latestUserMsg) {
return new Response("No content", { status: 400 })
}
// Use your actual API URL here instead of environment variables
// Replace this with your real API endpoint
const apiURL = "https://your-actual-api-endpoint.com/chat"
const apiKey = "your-actual-api-key" // or leave empty if not needed
// For demo purposes, let's simulate a response instead of calling external API
const simulatedResponse = `Based on your internal documentation for ${repo} and Confluence at ${conf}, here's what I found regarding: "${latestUserMsg}". This is a simulated response that demonstrates how your custom API integration would work. You can replace this logic with your actual API call.`
// Uncomment and modify this section when you have your real API ready:
/*
const upstream = await fetch(apiURL, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
body: JSON.stringify({
query: latestUserMsg,
context: "internal-documentation",
repository: repo,
confluence: conf,
}),
})
if (!upstream.ok) {
throw new Error(`API error ${upstream.status}`)
}
const contentType = upstream.headers.get("content-type") || ""
let answer = ""
if (contentType.includes("application/json")) {
const data = await upstream.json()
answer = data.answer ?? data.response ?? data.text ?? "No response"
} else {
answer = await upstream.text()
}
*/
// For now, use the simulated response
const answer = simulatedResponse
return new Response(textToStream(answer), {
headers: {
"Content-Type": "text/plain; charset=utf-8",
"X-Vercel-AI-Data-Stream": "v1",
},
})
} catch (err) {
console.error("Error in internal chat:", err)
return new Response(
textToStream(
"I'm sorry, I had trouble processing your request. This is a demo response while your custom API is being configured.",
),
{
headers: {
"Content-Type": "text/plain; charset=utf-8",
"X-Vercel-AI-Data-Stream": "v1",
},
status: 500,
},
)
}
}
```
[70 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]