1044 lines
27 KiB
TypeScript
1044 lines
27 KiB
TypeScript
import * as React from "react";
|
|
import Markdown from "react-markdown";
|
|
import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
|
|
import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
|
|
import type { PipelineState } from "../api/client";
|
|
import { api, ChatWebSocket } from "../api/client";
|
|
import type { Message, ProviderConfig, ToolCall } from "../types";
|
|
import { AgentPanel } from "./AgentPanel";
|
|
import { ChatHeader } from "./ChatHeader";
|
|
import { LozengeFlyProvider } from "./LozengeFlyContext";
|
|
import { StagePanel } from "./StagePanel";
|
|
|
|
const { useCallback, useEffect, useRef, useState } = React;
|
|
|
|
const NARROW_BREAKPOINT = 900;
|
|
|
|
function formatToolActivity(toolName: string): string {
|
|
switch (toolName) {
|
|
case "read_file":
|
|
return "Reading file...";
|
|
case "write_file":
|
|
return "Writing file...";
|
|
case "list_directory":
|
|
return "Listing directory...";
|
|
case "search_files":
|
|
return "Searching files...";
|
|
case "exec_shell":
|
|
return "Executing command...";
|
|
default:
|
|
return `Using ${toolName}...`;
|
|
}
|
|
}
|
|
|
|
interface ChatProps {
|
|
projectPath: string;
|
|
onCloseProject: () => void;
|
|
}
|
|
|
|
export function Chat({ projectPath, onCloseProject }: ChatProps) {
|
|
const [messages, setMessages] = useState<Message[]>([]);
|
|
const [input, setInput] = useState("");
|
|
const [loading, setLoading] = useState(false);
|
|
const [model, setModel] = useState("llama3.1");
|
|
const [enableTools, setEnableTools] = useState(true);
|
|
const [availableModels, setAvailableModels] = useState<string[]>([]);
|
|
const [claudeModels, setClaudeModels] = useState<string[]>([]);
|
|
const [streamingContent, setStreamingContent] = useState("");
|
|
const [showApiKeyDialog, setShowApiKeyDialog] = useState(false);
|
|
const [apiKeyInput, setApiKeyInput] = useState("");
|
|
const [hasAnthropicKey, setHasAnthropicKey] = useState(false);
|
|
const [pipeline, setPipeline] = useState<PipelineState>({
|
|
upcoming: [],
|
|
current: [],
|
|
qa: [],
|
|
merge: [],
|
|
});
|
|
const [claudeSessionId, setClaudeSessionId] = useState<string | null>(null);
|
|
const [activityStatus, setActivityStatus] = useState<string | null>(null);
|
|
const [permissionRequest, setPermissionRequest] = useState<{
|
|
requestId: string;
|
|
toolName: string;
|
|
toolInput: Record<string, unknown>;
|
|
} | null>(null);
|
|
const [isNarrowScreen, setIsNarrowScreen] = useState(
|
|
window.innerWidth < NARROW_BREAKPOINT,
|
|
);
|
|
const [reconciliationActive, setReconciliationActive] = useState(false);
|
|
const [reconciliationEvents, setReconciliationEvents] = useState<
|
|
{ id: string; storyId: string; status: string; message: string }[]
|
|
>([]);
|
|
const reconciliationEventIdRef = useRef(0);
|
|
|
|
const wsRef = useRef<ChatWebSocket | null>(null);
|
|
const messagesEndRef = useRef<HTMLDivElement>(null);
|
|
const inputRef = useRef<HTMLTextAreaElement>(null);
|
|
const scrollContainerRef = useRef<HTMLDivElement>(null);
|
|
const shouldAutoScrollRef = useRef(true);
|
|
const lastScrollTopRef = useRef(0);
|
|
const userScrolledUpRef = useRef(false);
|
|
const pendingMessageRef = useRef<string>("");
|
|
|
|
const estimateTokens = (text: string): number => Math.ceil(text.length / 4);
|
|
|
|
const getContextWindowSize = (modelName: string): number => {
|
|
if (modelName.startsWith("claude-")) return 200000;
|
|
if (modelName.includes("llama3")) return 8192;
|
|
if (modelName.includes("qwen2.5")) return 32768;
|
|
if (modelName.includes("deepseek")) return 16384;
|
|
return 8192;
|
|
};
|
|
|
|
const calculateContextUsage = (): {
|
|
used: number;
|
|
total: number;
|
|
percentage: number;
|
|
} => {
|
|
let totalTokens = 0;
|
|
|
|
totalTokens += 200;
|
|
|
|
for (const msg of messages) {
|
|
totalTokens += estimateTokens(msg.content);
|
|
if (msg.tool_calls) {
|
|
totalTokens += estimateTokens(JSON.stringify(msg.tool_calls));
|
|
}
|
|
}
|
|
|
|
if (streamingContent) {
|
|
totalTokens += estimateTokens(streamingContent);
|
|
}
|
|
|
|
const contextWindow = getContextWindowSize(model);
|
|
const percentage = Math.round((totalTokens / contextWindow) * 100);
|
|
|
|
return {
|
|
used: totalTokens,
|
|
total: contextWindow,
|
|
percentage,
|
|
};
|
|
};
|
|
|
|
const contextUsage = calculateContextUsage();
|
|
|
|
useEffect(() => {
|
|
api
|
|
.getOllamaModels()
|
|
.then(async (models) => {
|
|
if (models.length > 0) {
|
|
const sortedModels = models.sort((a, b) =>
|
|
a.toLowerCase().localeCompare(b.toLowerCase()),
|
|
);
|
|
setAvailableModels(sortedModels);
|
|
|
|
try {
|
|
const savedModel = await api.getModelPreference();
|
|
if (savedModel) {
|
|
setModel(savedModel);
|
|
} else if (sortedModels.length > 0) {
|
|
setModel(sortedModels[0]);
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
})
|
|
.catch((err) => console.error(err));
|
|
|
|
api
|
|
.getAnthropicApiKeyExists()
|
|
.then((exists) => {
|
|
setHasAnthropicKey(exists);
|
|
if (!exists) return;
|
|
return api.getAnthropicModels().then((models) => {
|
|
if (models.length > 0) {
|
|
const sortedModels = models.sort((a, b) =>
|
|
a.toLowerCase().localeCompare(b.toLowerCase()),
|
|
);
|
|
setClaudeModels(sortedModels);
|
|
} else {
|
|
setClaudeModels([]);
|
|
}
|
|
});
|
|
})
|
|
.catch((err) => {
|
|
console.error(err);
|
|
setHasAnthropicKey(false);
|
|
setClaudeModels([]);
|
|
});
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
const ws = new ChatWebSocket();
|
|
wsRef.current = ws;
|
|
|
|
ws.connect({
|
|
onToken: (content) => {
|
|
setStreamingContent((prev: string) => prev + content);
|
|
},
|
|
onUpdate: (history) => {
|
|
setMessages(history);
|
|
setStreamingContent("");
|
|
const last = history[history.length - 1];
|
|
if (last?.role === "assistant" && !last.tool_calls) {
|
|
setLoading(false);
|
|
setActivityStatus(null);
|
|
}
|
|
},
|
|
onSessionId: (sessionId) => {
|
|
setClaudeSessionId(sessionId);
|
|
},
|
|
onError: (message) => {
|
|
console.error("WebSocket error:", message);
|
|
setLoading(false);
|
|
setActivityStatus(null);
|
|
},
|
|
onPipelineState: (state) => {
|
|
setPipeline(state);
|
|
},
|
|
onPermissionRequest: (requestId, toolName, toolInput) => {
|
|
setPermissionRequest({ requestId, toolName, toolInput });
|
|
},
|
|
onActivity: (toolName) => {
|
|
setActivityStatus(formatToolActivity(toolName));
|
|
},
|
|
onReconciliationProgress: (storyId, status, message) => {
|
|
if (status === "done") {
|
|
setReconciliationActive(false);
|
|
} else {
|
|
setReconciliationActive(true);
|
|
setReconciliationEvents((prev) => {
|
|
const id = String(reconciliationEventIdRef.current++);
|
|
const next = [...prev, { id, storyId, status, message }];
|
|
// Keep only the last 8 events to avoid the banner growing too tall.
|
|
return next.slice(-8);
|
|
});
|
|
}
|
|
},
|
|
});
|
|
|
|
return () => {
|
|
ws.close();
|
|
wsRef.current = null;
|
|
};
|
|
}, []);
|
|
|
|
const scrollToBottom = useCallback(() => {
|
|
const element = scrollContainerRef.current;
|
|
if (element) {
|
|
element.scrollTop = element.scrollHeight;
|
|
lastScrollTopRef.current = element.scrollHeight;
|
|
}
|
|
}, []);
|
|
|
|
const handleScroll = () => {
|
|
const element = scrollContainerRef.current;
|
|
if (!element) return;
|
|
|
|
const currentScrollTop = element.scrollTop;
|
|
const isAtBottom =
|
|
element.scrollHeight - element.scrollTop - element.clientHeight < 5;
|
|
|
|
if (currentScrollTop < lastScrollTopRef.current) {
|
|
userScrolledUpRef.current = true;
|
|
shouldAutoScrollRef.current = false;
|
|
}
|
|
|
|
if (isAtBottom) {
|
|
userScrolledUpRef.current = false;
|
|
shouldAutoScrollRef.current = true;
|
|
}
|
|
|
|
lastScrollTopRef.current = currentScrollTop;
|
|
};
|
|
|
|
const autoScrollKey = messages.length + streamingContent.length;
|
|
|
|
useEffect(() => {
|
|
if (
|
|
autoScrollKey >= 0 &&
|
|
shouldAutoScrollRef.current &&
|
|
!userScrolledUpRef.current
|
|
) {
|
|
scrollToBottom();
|
|
}
|
|
}, [autoScrollKey, scrollToBottom]);
|
|
|
|
useEffect(() => {
|
|
inputRef.current?.focus();
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
const handleResize = () =>
|
|
setIsNarrowScreen(window.innerWidth < NARROW_BREAKPOINT);
|
|
window.addEventListener("resize", handleResize);
|
|
return () => window.removeEventListener("resize", handleResize);
|
|
}, []);
|
|
|
|
const cancelGeneration = async () => {
|
|
try {
|
|
wsRef.current?.cancel();
|
|
await api.cancelChat();
|
|
|
|
if (streamingContent) {
|
|
setMessages((prev: Message[]) => [
|
|
...prev,
|
|
{ role: "assistant", content: streamingContent },
|
|
]);
|
|
setStreamingContent("");
|
|
}
|
|
|
|
setLoading(false);
|
|
setActivityStatus(null);
|
|
} catch (e) {
|
|
console.error("Failed to cancel chat:", e);
|
|
}
|
|
};
|
|
|
|
const sendMessage = async (messageOverride?: string) => {
|
|
const messageToSend = messageOverride ?? input;
|
|
if (!messageToSend.trim() || loading) return;
|
|
|
|
const isClaudeCode = model === "claude-code-pty";
|
|
if (!isClaudeCode && model.startsWith("claude-")) {
|
|
const hasKey = await api.getAnthropicApiKeyExists();
|
|
if (!hasKey) {
|
|
pendingMessageRef.current = messageToSend;
|
|
setShowApiKeyDialog(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const userMsg: Message = { role: "user", content: messageToSend };
|
|
const newHistory = [...messages, userMsg];
|
|
|
|
setMessages(newHistory);
|
|
if (!messageOverride || messageOverride === input) {
|
|
setInput("");
|
|
}
|
|
setLoading(true);
|
|
setStreamingContent("");
|
|
setActivityStatus(null);
|
|
|
|
try {
|
|
const provider = isClaudeCode
|
|
? "claude-code"
|
|
: model.startsWith("claude-")
|
|
? "anthropic"
|
|
: "ollama";
|
|
const config: ProviderConfig = {
|
|
provider,
|
|
model,
|
|
base_url: "http://localhost:11434",
|
|
enable_tools: enableTools,
|
|
...(isClaudeCode && claudeSessionId
|
|
? { session_id: claudeSessionId }
|
|
: {}),
|
|
};
|
|
|
|
wsRef.current?.sendChat(newHistory, config);
|
|
} catch (e) {
|
|
console.error("Chat error:", e);
|
|
const errorMessage = String(e);
|
|
if (!errorMessage.includes("Chat cancelled by user")) {
|
|
setMessages((prev: Message[]) => [
|
|
...prev,
|
|
{ role: "assistant", content: `**Error:** ${e}` },
|
|
]);
|
|
}
|
|
setLoading(false);
|
|
}
|
|
};
|
|
|
|
const handleSaveApiKey = async () => {
|
|
if (!apiKeyInput.trim()) return;
|
|
|
|
try {
|
|
await api.setAnthropicApiKey(apiKeyInput);
|
|
setShowApiKeyDialog(false);
|
|
setApiKeyInput("");
|
|
|
|
const pendingMessage = pendingMessageRef.current;
|
|
pendingMessageRef.current = "";
|
|
|
|
if (pendingMessage.trim()) {
|
|
sendMessage(pendingMessage);
|
|
}
|
|
} catch (e) {
|
|
console.error("Failed to save API key:", e);
|
|
alert(`Failed to save API key: ${e}`);
|
|
}
|
|
};
|
|
|
|
const handlePermissionResponse = (approved: boolean) => {
|
|
if (!permissionRequest) return;
|
|
wsRef.current?.sendPermissionResponse(
|
|
permissionRequest.requestId,
|
|
approved,
|
|
);
|
|
setPermissionRequest(null);
|
|
};
|
|
|
|
const clearSession = async () => {
|
|
const confirmed = window.confirm(
|
|
"Are you sure? This will clear all messages and reset the conversation context.",
|
|
);
|
|
|
|
if (confirmed) {
|
|
try {
|
|
await api.cancelChat();
|
|
wsRef.current?.cancel();
|
|
} catch (e) {
|
|
console.error("Failed to cancel chat:", e);
|
|
}
|
|
|
|
setMessages([]);
|
|
setStreamingContent("");
|
|
setLoading(false);
|
|
setActivityStatus(null);
|
|
setClaudeSessionId(null);
|
|
}
|
|
};
|
|
|
|
return (
|
|
<div
|
|
className="chat-container"
|
|
style={{
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
height: "100%",
|
|
backgroundColor: "#171717",
|
|
color: "#ececec",
|
|
}}
|
|
>
|
|
<ChatHeader
|
|
projectPath={projectPath}
|
|
onCloseProject={onCloseProject}
|
|
contextUsage={contextUsage}
|
|
onClearSession={clearSession}
|
|
model={model}
|
|
availableModels={availableModels}
|
|
claudeModels={claudeModels}
|
|
hasAnthropicKey={hasAnthropicKey}
|
|
onModelChange={(newModel) => {
|
|
setModel(newModel);
|
|
api.setModelPreference(newModel).catch(console.error);
|
|
}}
|
|
enableTools={enableTools}
|
|
onToggleTools={setEnableTools}
|
|
/>
|
|
|
|
{/* Two-column content area */}
|
|
<div
|
|
data-testid="chat-content-area"
|
|
style={{
|
|
display: "flex",
|
|
flex: 1,
|
|
minHeight: 0,
|
|
flexDirection: isNarrowScreen ? "column" : "row",
|
|
}}
|
|
>
|
|
{/* Left column: chat messages + input pinned at bottom */}
|
|
<div
|
|
data-testid="chat-left-column"
|
|
style={{
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
flex: "0 0 60%",
|
|
minHeight: 0,
|
|
overflow: "hidden",
|
|
}}
|
|
>
|
|
{/* Scrollable messages area */}
|
|
<div
|
|
ref={scrollContainerRef}
|
|
onScroll={handleScroll}
|
|
style={{
|
|
flex: 1,
|
|
overflowY: "auto",
|
|
padding: "20px 0",
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
gap: "24px",
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
maxWidth: "768px",
|
|
margin: "0 auto",
|
|
width: "100%",
|
|
padding: "0 24px",
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
gap: "24px",
|
|
}}
|
|
>
|
|
{messages.map((msg: Message, idx: number) => (
|
|
<div
|
|
key={`msg-${idx}-${msg.role}-${msg.content.substring(0, 20)}`}
|
|
style={{
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
alignItems: msg.role === "user" ? "flex-end" : "flex-start",
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
maxWidth: "100%",
|
|
padding: msg.role === "user" ? "10px 16px" : "0",
|
|
borderRadius: msg.role === "user" ? "20px" : "0",
|
|
background:
|
|
msg.role === "user"
|
|
? "#2f2f2f"
|
|
: msg.role === "tool"
|
|
? "#222"
|
|
: "transparent",
|
|
color: "#ececec",
|
|
border: msg.role === "tool" ? "1px solid #333" : "none",
|
|
fontFamily: msg.role === "tool" ? "monospace" : "inherit",
|
|
fontSize: msg.role === "tool" ? "0.85em" : "1em",
|
|
fontWeight: "500",
|
|
whiteSpace: msg.role === "tool" ? "pre-wrap" : "normal",
|
|
lineHeight: "1.6",
|
|
}}
|
|
>
|
|
{msg.role === "user" ? (
|
|
msg.content
|
|
) : msg.role === "tool" ? (
|
|
<details style={{ cursor: "pointer" }}>
|
|
<summary
|
|
style={{
|
|
color: "#aaa",
|
|
fontSize: "0.9em",
|
|
marginBottom: "8px",
|
|
listStyle: "none",
|
|
display: "flex",
|
|
alignItems: "center",
|
|
gap: "6px",
|
|
}}
|
|
>
|
|
<span style={{ fontSize: "0.8em" }}>▶</span>
|
|
<span>
|
|
Tool Output
|
|
{msg.tool_call_id && ` (${msg.tool_call_id})`}
|
|
</span>
|
|
</summary>
|
|
<pre
|
|
style={{
|
|
maxHeight: "300px",
|
|
overflow: "auto",
|
|
margin: 0,
|
|
padding: "8px",
|
|
background: "#1a1a1a",
|
|
borderRadius: "4px",
|
|
fontSize: "0.85em",
|
|
whiteSpace: "pre-wrap",
|
|
wordBreak: "break-word",
|
|
}}
|
|
>
|
|
{msg.content}
|
|
</pre>
|
|
</details>
|
|
) : (
|
|
<div className="markdown-body">
|
|
<Markdown
|
|
components={{
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
|
|
code: ({ className, children, ...props }: any) => {
|
|
const match = /language-(\w+)/.exec(
|
|
className || "",
|
|
);
|
|
const isInline = !className;
|
|
return !isInline && match ? (
|
|
<SyntaxHighlighter
|
|
// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
|
|
style={oneDark as any}
|
|
language={match[1]}
|
|
PreTag="div"
|
|
>
|
|
{String(children).replace(/\n$/, "")}
|
|
</SyntaxHighlighter>
|
|
) : (
|
|
<code className={className} {...props}>
|
|
{children}
|
|
</code>
|
|
);
|
|
},
|
|
}}
|
|
>
|
|
{msg.content}
|
|
</Markdown>
|
|
</div>
|
|
)}
|
|
|
|
{msg.tool_calls && (
|
|
<div
|
|
style={{
|
|
marginTop: "12px",
|
|
fontSize: "0.85em",
|
|
color: "#aaa",
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
gap: "8px",
|
|
}}
|
|
>
|
|
{msg.tool_calls.map((tc: ToolCall, i: number) => {
|
|
let argsSummary = "";
|
|
try {
|
|
const args = JSON.parse(tc.function.arguments);
|
|
const firstKey = Object.keys(args)[0];
|
|
if (firstKey && args[firstKey]) {
|
|
argsSummary = String(args[firstKey]);
|
|
if (argsSummary.length > 50) {
|
|
argsSummary = `${argsSummary.substring(0, 47)}...`;
|
|
}
|
|
}
|
|
} catch (_e) {
|
|
// ignore
|
|
}
|
|
|
|
return (
|
|
<div
|
|
key={`tool-${i}-${tc.function.name}`}
|
|
style={{
|
|
display: "flex",
|
|
alignItems: "center",
|
|
gap: "8px",
|
|
fontFamily: "monospace",
|
|
}}
|
|
>
|
|
<span style={{ color: "#888" }}>▶</span>
|
|
<span
|
|
style={{
|
|
background: "#333",
|
|
padding: "2px 6px",
|
|
borderRadius: "4px",
|
|
}}
|
|
>
|
|
{tc.function.name}
|
|
{argsSummary && `(${argsSummary})`}
|
|
</span>
|
|
</div>
|
|
);
|
|
})}
|
|
</div>
|
|
)}
|
|
</div>
|
|
</div>
|
|
))}
|
|
{loading && streamingContent && (
|
|
<div
|
|
style={{
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
alignItems: "flex-start",
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
maxWidth: "85%",
|
|
padding: "16px 20px",
|
|
borderRadius: "12px",
|
|
background: "#262626",
|
|
color: "#fff",
|
|
border: "1px solid #404040",
|
|
fontFamily: "system-ui, -apple-system, sans-serif",
|
|
fontSize: "0.95rem",
|
|
fontWeight: 400,
|
|
whiteSpace: "pre-wrap",
|
|
lineHeight: 1.6,
|
|
}}
|
|
>
|
|
<Markdown
|
|
components={{
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
|
|
code: ({ className, children, ...props }: any) => {
|
|
const match = /language-(\w+)/.exec(className || "");
|
|
const isInline = !className;
|
|
return !isInline && match ? (
|
|
<SyntaxHighlighter
|
|
// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
|
|
style={oneDark as any}
|
|
language={match[1]}
|
|
PreTag="div"
|
|
>
|
|
{String(children).replace(/\n$/, "")}
|
|
</SyntaxHighlighter>
|
|
) : (
|
|
<code className={className} {...props}>
|
|
{children}
|
|
</code>
|
|
);
|
|
},
|
|
}}
|
|
>
|
|
{streamingContent}
|
|
</Markdown>
|
|
</div>
|
|
</div>
|
|
)}
|
|
{loading && !streamingContent && (
|
|
<div
|
|
style={{
|
|
alignSelf: "flex-start",
|
|
color: "#888",
|
|
fontSize: "0.9em",
|
|
marginTop: "10px",
|
|
}}
|
|
>
|
|
<span className="pulse">
|
|
{activityStatus ?? "Thinking..."}
|
|
</span>
|
|
</div>
|
|
)}
|
|
<div ref={messagesEndRef} />
|
|
</div>
|
|
</div>
|
|
|
|
{/* Startup reconciliation progress banner */}
|
|
{reconciliationActive && (
|
|
<div
|
|
data-testid="reconciliation-banner"
|
|
style={{
|
|
padding: "6px 24px",
|
|
background: "#1c2a1c",
|
|
borderTop: "1px solid #2d4a2d",
|
|
fontSize: "0.8em",
|
|
color: "#7ec87e",
|
|
maxHeight: "100px",
|
|
overflowY: "auto",
|
|
flexShrink: 0,
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
fontWeight: 600,
|
|
marginBottom: "2px",
|
|
color: "#a0d4a0",
|
|
}}
|
|
>
|
|
Reconciling startup state...
|
|
</div>
|
|
{reconciliationEvents.map((evt) => (
|
|
<div
|
|
key={evt.id}
|
|
style={{
|
|
color:
|
|
evt.status === "failed"
|
|
? "#d07070"
|
|
: evt.status === "advanced"
|
|
? "#80c880"
|
|
: "#666",
|
|
whiteSpace: "nowrap",
|
|
overflow: "hidden",
|
|
textOverflow: "ellipsis",
|
|
}}
|
|
>
|
|
{evt.storyId ? `[${evt.storyId}] ` : ""}
|
|
{evt.message}
|
|
</div>
|
|
))}
|
|
</div>
|
|
)}
|
|
|
|
{/* Chat input pinned at bottom of left column */}
|
|
<div
|
|
style={{
|
|
padding: "24px",
|
|
background: "#171717",
|
|
display: "flex",
|
|
justifyContent: "center",
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
maxWidth: "768px",
|
|
width: "100%",
|
|
display: "flex",
|
|
gap: "8px",
|
|
alignItems: "center",
|
|
}}
|
|
>
|
|
<textarea
|
|
ref={inputRef}
|
|
value={input}
|
|
onChange={(e) => setInput(e.target.value)}
|
|
onKeyDown={(e) => {
|
|
if (e.key === "Enter" && !e.shiftKey) {
|
|
e.preventDefault();
|
|
sendMessage();
|
|
}
|
|
}}
|
|
placeholder="Send a message..."
|
|
rows={1}
|
|
style={{
|
|
flex: 1,
|
|
padding: "14px 20px",
|
|
borderRadius: "24px",
|
|
border: "1px solid #333",
|
|
outline: "none",
|
|
fontSize: "1rem",
|
|
fontWeight: "500",
|
|
background: "#2f2f2f",
|
|
color: "#ececec",
|
|
boxShadow: "0 2px 6px rgba(0,0,0,0.02)",
|
|
resize: "none",
|
|
overflowY: "auto",
|
|
fontFamily: "inherit",
|
|
}}
|
|
/>
|
|
<button
|
|
type="button"
|
|
onClick={loading ? cancelGeneration : () => sendMessage()}
|
|
disabled={!loading && !input.trim()}
|
|
style={{
|
|
background: "#ececec",
|
|
color: "black",
|
|
border: "none",
|
|
borderRadius: "50%",
|
|
width: "32px",
|
|
height: "32px",
|
|
display: "flex",
|
|
alignItems: "center",
|
|
justifyContent: "center",
|
|
cursor: "pointer",
|
|
opacity: !loading && !input.trim() ? 0.5 : 1,
|
|
flexShrink: 0,
|
|
}}
|
|
>
|
|
{loading ? "■" : "↑"}
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
{/* Right column: panels independently scrollable */}
|
|
<div
|
|
data-testid="chat-right-column"
|
|
style={{
|
|
flex: "0 0 40%",
|
|
overflowY: "auto",
|
|
borderLeft: isNarrowScreen ? "none" : "1px solid #333",
|
|
borderTop: isNarrowScreen ? "1px solid #333" : "none",
|
|
padding: "12px",
|
|
display: "flex",
|
|
flexDirection: "column",
|
|
gap: "12px",
|
|
}}
|
|
>
|
|
<LozengeFlyProvider pipeline={pipeline}>
|
|
<AgentPanel />
|
|
|
|
<StagePanel title="To Merge" items={pipeline.merge} />
|
|
<StagePanel title="QA" items={pipeline.qa} />
|
|
<StagePanel title="Current" items={pipeline.current} />
|
|
<StagePanel title="Upcoming" items={pipeline.upcoming} />
|
|
</LozengeFlyProvider>
|
|
</div>
|
|
</div>
|
|
|
|
{showApiKeyDialog && (
|
|
<div
|
|
style={{
|
|
position: "fixed",
|
|
top: 0,
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
backgroundColor: "rgba(0, 0, 0, 0.7)",
|
|
display: "flex",
|
|
alignItems: "center",
|
|
justifyContent: "center",
|
|
zIndex: 1000,
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
backgroundColor: "#2f2f2f",
|
|
padding: "32px",
|
|
borderRadius: "12px",
|
|
maxWidth: "500px",
|
|
width: "90%",
|
|
border: "1px solid #444",
|
|
}}
|
|
>
|
|
<h2 style={{ marginTop: 0, color: "#ececec" }}>
|
|
Enter Anthropic API Key
|
|
</h2>
|
|
<p
|
|
style={{ color: "#aaa", fontSize: "0.9em", marginBottom: "20px" }}
|
|
>
|
|
To use Claude models, please enter your Anthropic API key. Your
|
|
key will be stored server-side and reused across sessions.
|
|
</p>
|
|
<input
|
|
type="password"
|
|
value={apiKeyInput}
|
|
onChange={(e) => setApiKeyInput(e.target.value)}
|
|
onKeyDown={(e) => e.key === "Enter" && handleSaveApiKey()}
|
|
placeholder="sk-ant-..."
|
|
style={{
|
|
width: "100%",
|
|
padding: "12px",
|
|
borderRadius: "8px",
|
|
border: "1px solid #555",
|
|
backgroundColor: "#1a1a1a",
|
|
color: "#ececec",
|
|
fontSize: "1em",
|
|
marginBottom: "20px",
|
|
outline: "none",
|
|
}}
|
|
/>
|
|
<div
|
|
style={{
|
|
display: "flex",
|
|
gap: "12px",
|
|
justifyContent: "flex-end",
|
|
}}
|
|
>
|
|
<button
|
|
type="button"
|
|
onClick={() => {
|
|
setShowApiKeyDialog(false);
|
|
setApiKeyInput("");
|
|
pendingMessageRef.current = "";
|
|
}}
|
|
style={{
|
|
padding: "10px 20px",
|
|
borderRadius: "8px",
|
|
border: "1px solid #555",
|
|
backgroundColor: "transparent",
|
|
color: "#aaa",
|
|
cursor: "pointer",
|
|
fontSize: "0.9em",
|
|
}}
|
|
>
|
|
Cancel
|
|
</button>
|
|
<button
|
|
type="button"
|
|
onClick={handleSaveApiKey}
|
|
disabled={!apiKeyInput.trim()}
|
|
style={{
|
|
padding: "10px 20px",
|
|
borderRadius: "8px",
|
|
border: "none",
|
|
backgroundColor: apiKeyInput.trim() ? "#ececec" : "#555",
|
|
color: apiKeyInput.trim() ? "#000" : "#888",
|
|
cursor: apiKeyInput.trim() ? "pointer" : "not-allowed",
|
|
fontSize: "0.9em",
|
|
}}
|
|
>
|
|
Save Key
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
)}
|
|
{permissionRequest && (
|
|
<div
|
|
style={{
|
|
position: "fixed",
|
|
top: 0,
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
backgroundColor: "rgba(0, 0, 0, 0.7)",
|
|
display: "flex",
|
|
alignItems: "center",
|
|
justifyContent: "center",
|
|
zIndex: 1000,
|
|
}}
|
|
>
|
|
<div
|
|
style={{
|
|
backgroundColor: "#2f2f2f",
|
|
padding: "32px",
|
|
borderRadius: "12px",
|
|
maxWidth: "520px",
|
|
width: "90%",
|
|
border: "1px solid #444",
|
|
}}
|
|
>
|
|
<h2 style={{ marginTop: 0, color: "#ececec" }}>
|
|
Permission Request
|
|
</h2>
|
|
<p
|
|
style={{
|
|
color: "#aaa",
|
|
fontSize: "0.9em",
|
|
marginBottom: "12px",
|
|
}}
|
|
>
|
|
The agent wants to use the{" "}
|
|
<strong style={{ color: "#ececec" }}>
|
|
{permissionRequest.toolName}
|
|
</strong>{" "}
|
|
tool. Do you approve?
|
|
</p>
|
|
{Object.keys(permissionRequest.toolInput).length > 0 && (
|
|
<pre
|
|
style={{
|
|
background: "#1a1a1a",
|
|
border: "1px solid #333",
|
|
borderRadius: "6px",
|
|
padding: "12px",
|
|
fontSize: "0.8em",
|
|
color: "#ccc",
|
|
overflowX: "auto",
|
|
maxHeight: "200px",
|
|
marginBottom: "20px",
|
|
whiteSpace: "pre-wrap",
|
|
wordBreak: "break-word",
|
|
}}
|
|
>
|
|
{JSON.stringify(permissionRequest.toolInput, null, 2)}
|
|
</pre>
|
|
)}
|
|
<div
|
|
style={{
|
|
display: "flex",
|
|
gap: "12px",
|
|
justifyContent: "flex-end",
|
|
}}
|
|
>
|
|
<button
|
|
type="button"
|
|
onClick={() => handlePermissionResponse(false)}
|
|
style={{
|
|
padding: "10px 20px",
|
|
borderRadius: "8px",
|
|
border: "1px solid #555",
|
|
backgroundColor: "transparent",
|
|
color: "#aaa",
|
|
cursor: "pointer",
|
|
fontSize: "0.9em",
|
|
}}
|
|
>
|
|
Deny
|
|
</button>
|
|
<button
|
|
type="button"
|
|
onClick={() => handlePermissionResponse(true)}
|
|
style={{
|
|
padding: "10px 20px",
|
|
borderRadius: "8px",
|
|
border: "none",
|
|
backgroundColor: "#ececec",
|
|
color: "#000",
|
|
cursor: "pointer",
|
|
fontSize: "0.9em",
|
|
}}
|
|
>
|
|
Approve
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
)}
|
|
</div>
|
|
);
|
|
}
|