The Open Standard for Generative UI
"use client";
import { DemoCreditsDialog } from "@/components/DemoCreditsDialog";
import { isDemoCreditsErrorPayload } from "@/lib/demo-credits";
import { mergeStatements } from "@openuidev/react-lang";
import { Button } from "@openuidev/react-ui";
import { encode } from "gpt-tokenizer";
import {
Activity,
Check,
CircleDot,
Code2,
Copy,
GitPullRequest,
Hexagon,
Search,
Zap,
type LucideIcon,
} from "lucide-react";
import { useTheme } from "next-themes";
import { Highlight, themes } from "prism-react-renderer";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { ConversationPanel } from "./components/ConversationPanel/ConversationPanel";
import { GitHubConnect } from "./components/GitHubConnect/GitHubConnect";
import { Header } from "./components/Header/Header";
import { PreviewPanel } from "./components/PreviewPanel/PreviewPanel";
import { SavedSidebar } from "./components/SavedSidebar/SavedSidebar";
import {
GITHUB_DEMO_MODEL_LABEL,
GITHUB_STARTERS,
STREAM_RESULT,
type ChatMessage,
type GitHubStarterIconKey,
type Status,
type StreamResult,
type Theme,
type ToolCallEntry,
} from "./constants";
import { clearCache, createGitHubToolProvider, prefetchAndSummarize } from "./github/tools";
import {
deleteSavedDashboard,
getSavedDashboards,
upsertDashboard,
type SavedDashboard,
} from "./saved/store";
// ── Helpers ─────────────────────────────────────────────────────────────────
function extractCodeOnly(response: string): string | null {
const fenceRegex = /```[\w-]*\n([\s\S]*?)```/g;
const blocks: string[] = [];
let match;
while ((match = fenceRegex.exec(response)) !== null) {
blocks.push(match[1].trim());
}
if (blocks.length > 0) return blocks.join("\n");
const unclosedMatch = response.match(/```[\w-]*\n([\s\S]*)$/);
if (unclosedMatch) return unclosedMatch[1].trim() || null;
if (isPureCode(response)) return response;
return null;
}
function extractText(response: string): string {
const withoutFences = response.replace(/```[\w-]*\n[\s\S]*?```/g, "").trim();
const withoutUnclosed = withoutFences.replace(/```[\w-]*\n[\s\S]*$/g, "").trim();
if (withoutUnclosed && isPureCode(withoutUnclosed)) return "";
return withoutUnclosed;
}
function responseHasCode(response: string): boolean {
if (/```[\w-]*\n/.test(response)) return true;
const trimmed = response.trim();
if (/^[a-zA-Z_$][\w$]*\s*=\s*/.test(trimmed)) return true;
return false;
}
function isPureCode(response: string): boolean {
const trimmed = response.trim();
if (/```/.test(trimmed)) return false;
const lines = trimmed.split("\n").filter((l) => l.trim());
if (lines.length === 0) return false;
const stmtPattern = /^[a-zA-Z_$][\w$]*\s*=/;
const stmtCount = lines.filter((l) => stmtPattern.test(l.trim())).length;
return stmtCount / lines.length > 0.7;
}
const STARTER_ICON_MAP: Record<GitHubStarterIconKey, LucideIcon> = {
"commit-activity": Activity,
"pull-requests": GitPullRequest,
"issue-tracking": CircleDot,
"code-reviews": Search,
"language-breakdown": Code2,
"repository-stats": Hexagon,
};
function renderStarterIcon(icon: GitHubStarterIconKey) {
const Icon = STARTER_ICON_MAP[icon];
return <Icon size={16} strokeWidth={2} />;
}
// ── Tool call tracking wrapper ───────────────────────────────────────────
type ToolCallListener = (calls: ToolCallEntry[]) => void;
function wrapToolProvider(
inner: Record<string, (args: Record<string, unknown>) => Promise<unknown>>,
listener: ToolCallListener,
): {
tools: Record<string, (args: Record<string, unknown>) => Promise<unknown>>;
resetCalls: () => void;
} {
let activeCalls: ToolCallEntry[] = [];
const wrapped: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {};
for (const [name, fn] of Object.entries(inner)) {
wrapped[name] = async (args) => {
const entry: ToolCallEntry = { tool: name, status: "pending" };
activeCalls.push(entry);
listener([...activeCalls]);
try {
const data = await fn(args);
entry.status = "done";
listener([...activeCalls]);
return data;
} catch {
entry.status = "error";
listener([...activeCalls]);
return null;
}
};
}
return {
tools: wrapped,
resetCalls: () => {
activeCalls = [];
},
};
}
// ── SSE streaming ────────────────────────────────────────────────────────
async function streamChat(
body: Record<string, unknown>,
onChunk: (text: string) => void,
onDone: () => void,
signal?: AbortSignal,
onFirstChunk?: () => void,
): Promise<StreamResult> {
const res = await fetch("/api/demo/github/stream", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
signal,
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
if (isDemoCreditsErrorPayload((err as { error?: unknown }).error)) {
return STREAM_RESULT.CreditsExhausted;
}
onChunk(
`Error: ${(err as { error?: { message?: string } }).error?.message ?? `Server error ${res.status}`}`,
);
onDone();
return STREAM_RESULT.Done;
}
const reader = res.body!.getReader();
const decoder = new TextDecoder();
let firstChunkFired = false;
while (true) {
const { done, value } = await reader.read();
if (done) break;
const raw = decoder.decode(value, { stream: true });
for (const line of raw.split("\n")) {
const trimmed = line.trim();
if (!trimmed.startsWith("data:")) continue;
const data = trimmed.slice(5).trim();
if (data === "[DONE]") {
onDone();
return STREAM_RESULT.Done;
}
let parsed: {
error?: unknown;
choices?: Array<{ delta?: { content?: string }; finish_reason?: string }>;
};
try {
parsed = JSON.parse(data);
} catch {
// skip malformed chunks
continue;
}
const content = parsed.choices?.[0]?.delta?.content;
if (content) {
if (!firstChunkFired) {
firstChunkFired = true;
onFirstChunk?.();
}
onChunk(content);
}
}
}
onDone();
return STREAM_RESULT.Done;
}
// ── Main Page ────────────────────────────────────────────────────────────
export default function GitHubDemoPage() {
// Theme
const { theme, setTheme, resolvedTheme } = useTheme();
// GitHub connection
const [githubUsername, setGithubUsername] = useState<string | null>(null);
const [toolProvider, setToolProvider] = useState<Record<
string,
(args: Record<string, unknown>) => Promise<unknown>
> | null>(null);
// Dashboard state
const [dashboardCode, setDashboardCode] = useState<string | null>(null);
const [showSource, setShowSource] = useState(false);
const [sourceTab, setSourceTab] = useState<"raw" | "json">("raw");
const [parsedJson, setParsedJson] = useState<string | null>(null);
const [codeCopied, setCodeCopied] = useState(false);
const [savedDashboards, setSavedDashboards] = useState<SavedDashboard[]>([]);
const [activeSavedId, setActiveSavedId] = useState<string | null>(null);
const [convCollapsed, setConvCollapsed] = useState(false);
const activeSavedIdRef = useRef<string | null>(null);
const githubUsernameRef = useRef<string | null>(null);
useEffect(() => {
setSavedDashboards(getSavedDashboards());
}, []);
// Conversation
const [conversation, setConversation] = useState<ChatMessage[]>([]);
const [streamingText, setStreamingText] = useState("");
const [toolCalls, setToolCalls] = useState<ToolCallEntry[]>([]);
const [streamResponseHasCode, setStreamResponseHasCode] = useState(false);
// Streaming
const [status, setStatus] = useState<Status>("idle");
const [startTime, setStartTime] = useState<number | null>(null);
const [elapsed, setElapsed] = useState<number | null>(null);
const [errorMsg, setErrorMsg] = useState("");
const [showGitHubCreditsDialog, setShowGitHubCreditsDialog] = useState(false);
const abortRef = useRef<AbortController | null>(null);
const responseRef = useRef("");
const pendingPromptRef = useRef<string | null>(null);
const isStreaming = status === "streaming";
const hasDashboard = dashboardCode !== null;
const isGitHub = githubUsername !== null;
const isHomeState = !isGitHub && !hasDashboard && conversation.length === 0;
// Token comparison
const rawTokens = useMemo(
() => (dashboardCode ? encode(dashboardCode).length : 0),
[dashboardCode],
);
const jsonTokens = useMemo(() => (parsedJson ? encode(parsedJson).length : 0), [parsedJson]);
const tokenSavingPct =
status === "done" && rawTokens > 0 && jsonTokens > 0 && rawTokens < jsonTokens
? Math.round(((jsonTokens - rawTokens) / jsonTokens) * 100)
: null;
// Theme. next-themes reports undefined theme/resolvedTheme during SSR and the
// first client render, so gate the theme-derived render output behind a mount
// flag. mounted is false on both the server and the first client render, so
// both paint the same fallback (no hydration mismatch on the toggle label or
// the editor/dashboard mode); the real theme is applied after mount.
const [mounted, setMounted] = useState(false);
useEffect(() => setMounted(true), []);
const currentTheme = useMemo<Theme>(() => {
if (!mounted) return "system";
if (theme === "light" || theme === "dark" || theme === "system") {
return theme;
}
return "system";
}, [mounted, theme]);
const resolvedMode = mounted && resolvedTheme === "dark" ? "dark" : "light";
const cycleTheme = () =>
setTheme(currentTheme === "system" ? "light" : currentTheme === "light" ? "dark" : "system");
// Timer
useEffect(() => {
if (!isStreaming || !startTime) return;
const iv = setInterval(() => setElapsed(Date.now() - startTime), 100);
return () => clearInterval(iv);
}, [isStreaming, startTime]);
// ── GitHub connect ───────────────────────────────────────────────────
const rawToolsRef = useRef<Record<
string,
(args: Record<string, unknown>) => Promise<unknown>
> | null>(null);
const resetToolCallsRef = useRef<(() => void) | null>(null);
const handleConnect = useCallback((username: string) => {
const rawTools = createGitHubToolProvider(username);
rawToolsRef.current = rawTools;
const { tools: wrapped, resetCalls } = wrapToolProvider(rawTools, (calls) => {
setToolCalls([...calls]);
});
resetToolCallsRef.current = resetCalls;
githubUsernameRef.current = username;
setGithubUsername(username);
setToolProvider(wrapped);
}, []);
const handleDisconnect = () => {
abortRef.current?.abort();
abortRef.current = null;
clearCache();
githubUsernameRef.current = null;
activeSavedIdRef.current = null;
setGithubUsername(null);
setToolProvider(null);
setDashboardCode(null);
setConversation([]);
setStatus("idle");
setStreamingText("");
setToolCalls([]);
setStreamResponseHasCode(false);
setElapsed(null);
setShowSource(false);
setParsedJson(null);
setErrorMsg("");
setShowGitHubCreditsDialog(false);
setActiveSavedId(null);
};
// ── Send message ─────────────────────────────────────────────────────
const send = useCallback(
async (text: string) => {
if (!text.trim() || isStreaming) return;
const trimmed = text.trim();
setConvCollapsed(false);
setStatus("streaming");
setStartTime(null);
setElapsed(null);
setErrorMsg("");
setShowGitHubCreditsDialog(false);
responseRef.current = "";
setStreamingText("");
setToolCalls([]);
resetToolCallsRef.current?.();
setStreamResponseHasCode(false);
let streamStartTime: number | null = null;
const userMsg: ChatMessage = {
role: "user",
content: trimmed,
hasCode: false,
};
const updated = [...conversation, userMsg];
setConversation(updated);
const existingCode = dashboardCode;
const apiMessages = updated.map((m) => ({ role: m.role, content: m.content }));
const currentTurn = existingCode
? `${trimmed}\n\n<current-dashboard>\n${existingCode}\n</current-dashboard>`
: trimmed;
// Prefetch GitHub data on first message to warm cache + give LLM context
// Use raw (unwrapped) tools to avoid triggering tool-call tracking side effects
let githubContext = "";
if (conversation.length === 0 && rawToolsRef.current) {
try {
githubContext = await prefetchAndSummarize(rawToolsRef.current);
} catch {
// Non-critical — LLM just won't have data context
}
}
const controller = new AbortController();
abortRef.current = controller;
try {
const streamResult = await streamChat(
{
prompt: githubContext ? `${githubContext}\n\n${currentTurn}` : currentTurn,
messages: apiMessages.slice(0, -1),
},
(chunk) => {
responseRef.current += chunk;
const raw = responseRef.current;
setStreamingText(extractText(raw) || "");
setStreamResponseHasCode(responseHasCode(raw));
if (existingCode) {
setDashboardCode(existingCode + "\n" + raw);
} else {
setDashboardCode(raw);
}
},
() => {
setStatus("done");
abortRef.current = null;
setStreamingText("");
setStreamResponseHasCode(false);
if (streamStartTime) setElapsed(Date.now() - streamStartTime);
const raw = responseRef.current;
const hasCode = responseHasCode(raw);
const pureCode = isPureCode(raw);
const text = pureCode ? undefined : extractText(raw) || undefined;
const assistantMsg: ChatMessage = {
role: "assistant",
content: raw,
text,
hasCode,
};
setConversation((prev) => [...prev, assistantMsg]);
if (hasCode) {
const newCode = pureCode ? raw : extractCodeOnly(raw);
if (newCode) {
const merged = existingCode ? mergeStatements(existingCode, newCode) : newCode;
setDashboardCode(merged);
// Auto-save: one entry per session, upserted in place on every
// successful generation/edit. Only real code is persisted, so
// prose/error replies never create or pollute a saved entry.
const username = githubUsernameRef.current;
if (username) {
const firstPrompt = updated.find((m) => m.role === "user")?.content.trim();
const title = firstPrompt ? firstPrompt.slice(0, 60) : `@${username} dashboard`;
const saved = upsertDashboard({
id: activeSavedIdRef.current,
username,
title,
code: merged,
});
activeSavedIdRef.current = saved.id;
setActiveSavedId(saved.id);
setSavedDashboards(getSavedDashboards());
}
}
}
},
controller.signal,
() => {
streamStartTime = Date.now();
setStartTime(streamStartTime);
},
);
if (streamResult === STREAM_RESULT.CreditsExhausted) {
abortRef.current = null;
setStatus("idle");
setStreamResponseHasCode(false);
setShowGitHubCreditsDialog(true);
}
} catch (err: unknown) {
if (err instanceof Error && err.name === "AbortError") {
setStreamResponseHasCode(false);
setStatus("idle");
return;
}
setErrorMsg(err instanceof Error ? err.message : "Unknown error");
setStreamResponseHasCode(false);
setStatus("error");
}
},
[isStreaming, conversation, dashboardCode],
);
// Process pending prompt after GitHub connect
useEffect(() => {
if (githubUsername && toolProvider && pendingPromptRef.current) {
const p = pendingPromptRef.current;
pendingPromptRef.current = null;
send(p);
}
}, [githubUsername, toolProvider, send]);
const handleStop = () => {
abortRef.current?.abort();
setStreamResponseHasCode(false);
setStatus("idle");
};
const handleConnectAndPrompt = useCallback(
(username: string, promptText: string) => {
pendingPromptRef.current = promptText;
handleConnect(username);
},
[handleConnect],
);
// ── Saved dashboards ───────────────────────────────────────────────────
const handleSelectSaved = (d: SavedDashboard) => {
abortRef.current?.abort();
abortRef.current = null;
clearCache();
handleConnect(d.username);
setConversation([]);
setStreamingText("");
setToolCalls([]);
setStreamResponseHasCode(false);
setShowSource(false);
setParsedJson(null);
setErrorMsg("");
setElapsed(null);
setDashboardCode(d.code);
setStatus("done");
activeSavedIdRef.current = d.id;
setActiveSavedId(d.id);
setConvCollapsed(true);
};
const handleDeleteSaved = (id: string) => {
setSavedDashboards(deleteSavedDashboard(id));
if (activeSavedId === id) {
activeSavedIdRef.current = null;
setActiveSavedId(null);
}
};
const handleNewDashboard = () => {
handleDisconnect();
};
// ── Render ─────────────────────────────────────────────────────────────
const showConversation = conversation.length > 0 || isStreaming || hasDashboard;
return (
<div className={`app ${isHomeState ? "app-home" : "app-artifact"}`}>
<h1 className="sr-only">OpenUI GitHub Dashboard Demo</h1>
<Header
theme={currentTheme}
onThemeToggle={cycleTheme}
borderMode={isHomeState ? "scroll" : "always"}
/>
<div className={`app-body ${isHomeState ? "app-body-home" : ""}`}>
{/* Saved dashboards sidebar */}
{savedDashboards.length > 0 && (
<SavedSidebar
dashboards={savedDashboards}
activeId={activeSavedId}
onSelect={handleSelectSaved}
onDelete={handleDeleteSaved}
onNew={handleNewDashboard}
/>
)}
{/* Phase 1: Connect Screen */}
{isHomeState && (
<div className="content-wrapper content-wrapper-home">
<GitHubConnect onConnectAndPrompt={handleConnectAndPrompt} />
</div>
)}
{/* Phase 2: Artifact Layout */}
{(isGitHub || hasDashboard || conversation.length > 0) && (
<div className="artifact-layout">
{/* Left: Dashboard */}
<div className="dashboard-area">
{/* GitHub starters (before first generation) */}
{isGitHub && !hasDashboard && conversation.length === 0 && (
<div className="gh-starters-welcome">
<div className="gh-welcome-text">
<span className="gh-welcome-avatar">
<img
src={`https://github.com/${githubUsername}.png?size=32`}
alt={`${githubUsername} avatar`}
className="gh-welcome-avatar-image"
/>
</span>
Connected as <strong>@{githubUsername}</strong>. What do you want to build?
</div>
<div className="gh-starters-grid gh-starters-grid-compact">
{GITHUB_STARTERS.map((s) => (
<Button
key={s.prompt}
className="gh-starter-card"
variant="tertiary"
size="large"
onClick={() => send(s.prompt)}
disabled={isStreaming}
>
<span className={`gh-starter-icon gh-tone-${s.tone}`}>
{renderStarterIcon(s.icon)}
</span>
<div className="gh-starter-label">{s.label}</div>
<div className="gh-starter-desc">
{s.prompt.length > 60 ? s.prompt.slice(0, 60) + "..." : s.prompt}
</div>
</Button>
))}
</div>
</div>
)}
{/* Meta + source toggle + token comparison */}
{hasDashboard && !isStreaming && (
<div className="dashboard-meta">
<span className="dashboard-model-label">{GITHUB_DEMO_MODEL_LABEL}</span>
{elapsed && (
<span className="dashboard-elapsed">{(elapsed / 1000).toFixed(1)}s</span>
)}
{tokenSavingPct !== null && (
<span className="dashboard-token-saving">
<Zap size={10} />
{tokenSavingPct}% fewer tokens
</span>
)}
<Button
className="dashboard-source-toggle"
variant="tertiary"
size="extra-small"
onClick={() => setShowSource(!showSource)}
>
<Code2 size={12} />
{showSource ? "Hide code" : "View code"}
</Button>
</div>
)}
{/* Source code view with tabs */}
{hasDashboard &&
showSource &&
(() => {
const activeSource =
sourceTab === "raw"
? (dashboardCode ?? "")
: (parsedJson ?? "Waiting for parse...");
const handleCopy = async () => {
await navigator.clipboard.writeText(activeSource);
setCodeCopied(true);
setTimeout(() => setCodeCopied(false), 2000);
};
return (
<div className="dashboard-source-panel">
<div className="dashboard-source-header">
<div className="dashboard-source-tabs">
<button
className={`dashboard-source-tab ${sourceTab === "raw" ? "dashboard-source-tab-active" : ""}`}
onClick={() => {
setSourceTab("raw");
setCodeCopied(false);
}}
>
openui-lang
{rawTokens > 0 && (
<span className="dashboard-source-token-count">
{rawTokens.toLocaleString()}
</span>
)}
</button>
<button
className={`dashboard-source-tab ${sourceTab === "json" ? "dashboard-source-tab-active" : ""}`}
onClick={() => {
setSourceTab("json");
setCodeCopied(false);
}}
>
Parsed JSON
{jsonTokens > 0 && (
<span className="dashboard-source-token-count">
{jsonTokens.toLocaleString()}
</span>
)}
</button>
</div>
<button
className="dashboard-source-copy"
onClick={handleCopy}
title="Copy code"
>
{codeCopied ? <Check size={14} /> : <Copy size={14} />}
</button>
</div>
<div className="dashboard-source">
<Highlight
theme={resolvedMode === "dark" ? themes.oneDark : themes.oneLight}
code={activeSource.trim()}
language={sourceTab === "json" ? "json" : "javascript"}
>
{({ className, style, tokens, getLineProps, getTokenProps }) => (
<pre
className={className}
style={{ ...style, margin: 0, background: "transparent" }}
>
<code>
{tokens.map((line, i) => (
<div key={i} {...getLineProps({ line })}>
{line.map((token, j) => (
<span key={j} {...getTokenProps({ token })} />
))}
</div>
))}
</code>
</pre>
)}
</Highlight>
</div>
</div>
);
})()}
{/* Connected user bar */}
{isGitHub && (hasDashboard || conversation.length > 0) && (
<div className="gh-connected-bar">
<img
src={`https://github.com/${githubUsername}.png?size=32`}
alt={`${githubUsername} avatar`}
className="gh-connected-avatar"
/>
<span>@{githubUsername}</span>
</div>
)}
{/* Live data indicator */}
{hasDashboard && toolCalls.length > 0 && (
<div
className={`dashboard-data-strip ${toolCalls.some((t) => t.status === "pending") ? "dashboard-data-strip-loading" : ""}`}
>
<span className="dashboard-data-label">
{toolCalls.some((t) => t.status === "pending")
? "Fetching live data..."
: "Live data from GitHub"}
</span>
<div className="dashboard-data-chips">
{toolCalls.map((tc, i) => (
<span
key={i}
className={`dashboard-data-chip dashboard-data-chip-${tc.status}`}
>
{tc.status === "done" ? "✓" : tc.status === "error" ? "✗" : "⏳"}{" "}
{tc.tool.replace("get_", "")}
</span>
))}
</div>
</div>
)}
{/* Dashboard renderer */}
{hasDashboard && (
<div className="dashboard-renderer">
<PreviewPanel
code={dashboardCode!}
isStreaming={isStreaming}
onParseResult={(r) => setParsedJson(r ? JSON.stringify(r, null, 2) : null)}
mode={resolvedMode}
toolProvider={toolProvider}
onAction={(event) => {
if (event.type === "continue_conversation") {
const text =
(typeof event.params?.context === "string" ? event.params.context : "") ||
event.humanFriendlyMessage ||
"";
if (text) send(text);
} else if (event.type === "open_url") {
const url = event.params?.["url"] as string | undefined;
if (url) window.open(url, "_blank");
}
}}
/>
</div>
)}
{/* Streaming placeholder */}
{isStreaming && !hasDashboard && (
<div className="dashboard-loading">
<div className="dashboard-loading-text">Generating dashboard...</div>
{elapsed && (
<div className="dashboard-loading-timer">{(elapsed / 1000).toFixed(1)}s</div>
)}
</div>
)}
</div>
{/* Right: Conversation Panel */}
{showConversation && (
<ConversationPanel
messages={conversation}
streamingText={streamingText}
isStreaming={isStreaming}
elapsed={elapsed}
onSend={send}
onStop={handleStop}
hasDashboard={hasDashboard}
responseHasCode={streamResponseHasCode}
collapsed={convCollapsed}
onToggleCollapsed={() => setConvCollapsed((v) => !v)}
/>
)}
</div>
)}
</div>
{/* Error banner */}
{status === "error" && errorMsg && <div className="error-banner">{errorMsg}</div>}
<DemoCreditsDialog
open={showGitHubCreditsDialog}
onClose={() => setShowGitHubCreditsDialog(false)}
/>
</div>
);
}