create-pyric 0.1.0-alpha.13 → 0.1.0-alpha.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pyric",
-  "version": "0.1.0-alpha.13",
+  "version": "0.1.0-alpha.15",
   "license": "Apache-2.0",
   "homepage": "https://pyric.dev",
   "repository": {

package/templates/chat/src/services/presence-service.ts

@@ -1,4 +1,4 @@
-import { onValue, ref, serverTimestamp, set } from 'firebase/database';
+import { onDisconnect, onValue, ref, serverTimestamp, set } from 'firebase/database';
 import { auth, rtdb } from '../firebase/app';
 import { asUserId, type AuthUser, type PresenceEntry, type PresenceRecord, ServiceError } from '../firebase/types';
 import { requireUid } from './firestore-helpers';
@@ -24,19 +24,15 @@ export class PresenceService {
    * `/presence/{uid}` the first time a user comes online, which is what
    * fires the `onPresenceOnline` Cloud Function.
    *
-   * In a production build we also register a real `onDisconnect` so the node
-   * flips to offline when the socket drops. `onDisconnect` is not part of the
-   * sandbox's Realtime Database surface yet (RTDB support is incomplete), so
-   * under `vite dev` we rely on the explicit `goOffline` writes below.
+   * Register `onDisconnect` before publishing the online state so production
+   * and the local sandbox both flip the node to offline on a clean lifecycle
+   * boundary. The explicit `goOffline` method remains the user-driven path.
    */
   async goOnline(user: AuthUser): Promise<void> {
     const uid = requireUid(user.uid);
     try {
       const reference = presenceRef(uid);
-      if (import.meta.env.PROD) {
-        const { onDisconnect } = await import('firebase/database');
-        await onDisconnect(reference).set({ state: 'offline', displayName: user.displayName, at: serverTimestamp() });
-      }
+      await onDisconnect(reference).set({ state: 'offline', displayName: user.displayName, at: serverTimestamp() });
       await set(reference, { state: 'online', displayName: user.displayName, at: serverTimestamp() });
     } catch (error) {
       throw mapRtdbError(error);

package/templates/chat/src/ui/chat/chat-page.tsx

@@ -13,8 +13,7 @@ import type { ChatPageServices, UiConversation, UiMessage, UiNotification, UiPre
 import type { ChatMode } from '../../chat-mode';
 import { MarkdownMessage } from './markdown-message';
 import { storePreviewComponent } from './preview-component-state';
-
-const starterMessages: UiMessage[] = [{ id: 'welcome', role: 'assistant', text: 'Good morning. What would you like to work through?', status: 'complete' }];
+import { reconcileMessages, starterMessages } from './message-reconciliation';
 
 const initials = (user: UiUser | null): string =>
   (user?.displayName ?? user?.email ?? 'You').split(' ').map((part) => part[0]).join('').slice(0, 2).toUpperCase();
@@ -27,11 +26,6 @@ const modeOptions: Array<{ id: ChatMode; label: string; description: string; pla
   { id: 'plan', label: 'Plan', description: 'Make it actionable', placeholder: 'Turn an idea into a plan…' },
   { id: 'refine', label: 'Refine', description: 'Pressure-test a direction', placeholder: 'Pressure-test a direction…' },
 ];
-const chronological = (items: UiMessage[]): UiMessage[] => [...items].sort((a, b) => {
-  if (!a.createdAt || !b.createdAt) return 0;
-  return a.createdAt.getTime() - b.createdAt.getTime();
-});
-
 const conversationIdFromUrl = (): string | null => new URLSearchParams(window.location.search).get('conversation');
 
 const writeConversationUrl = (conversationId: string | null, replace = false): void => {
@@ -41,65 +35,6 @@ const writeConversationUrl = (conversationId: string | null, replace = false): v
   window.history[replace ? 'replaceState' : 'pushState']({}, '', `${url.pathname}${url.search}${url.hash}`);
 };
 
-const reconcileMessages = (serverMessages: UiMessage[], currentMessages: UiMessage[]): UiMessage[] => {
-  const seenServerMessages = new Set<string>();
-  const server = chronological(serverMessages).filter((message) => {
-    if (!message.clientMessageId) return true;
-    const key = `${message.role}:${message.clientMessageId}`;
-    if (seenServerMessages.has(key)) return false;
-    seenServerMessages.add(key);
-    return true;
-  });
-  const serverClientIds = new Set(server.map((message) => message.clientMessageId).filter(Boolean));
-  const localAssistants = currentMessages.filter((message) => message.role === 'assistant' && message.id !== 'welcome');
-  const persistedAssistantIds = new Set(server.filter((message) => message.role === 'assistant').map((message) => message.clientMessageId).filter(Boolean));
-  const linkedAssistants = new Set<string>();
-  const result: UiMessage[] = [];
-
-  const addReply = (message: UiMessage) => {
-    for (const assistant of localAssistants) {
-      if (assistant.replyToClientMessageId === message.clientMessageId && !persistedAssistantIds.has(assistant.id)) {
-        result.push(assistant);
-        linkedAssistants.add(assistant.id);
-      }
-    }
-  };
-
-  for (const message of server) {
-    result.push(message);
-    if (message.role === 'user') addReply(message);
-  }
-
-  for (const message of currentMessages) {
-    if (message.role === 'user' && message.clientMessageId && !serverClientIds.has(message.clientMessageId)) {
-      result.push(message);
-      addReply(message);
-    }
-  }
-
-  result.push(...localAssistants.filter((message) => !linkedAssistants.has(message.id) && !message.replyToClientMessageId));
-
-  const turnKey = (message: UiMessage): string => {
-    if (message.role === 'assistant') {
-      if (message.replyToClientMessageId) return message.replyToClientMessageId;
-      if (message.clientMessageId?.startsWith('assistant-')) return message.clientMessageId.slice('assistant-'.length);
-    }
-    return message.clientMessageId ?? message.id;
-  };
-  const turnOrder = new Map<string, number>();
-  result.forEach((message, index) => {
-    const key = turnKey(message);
-    if (!turnOrder.has(key)) turnOrder.set(key, index);
-  });
-  return result.length ? [...result].sort((a, b) => {
-    const orderDifference = (turnOrder.get(turnKey(a)) ?? 0) - (turnOrder.get(turnKey(b)) ?? 0);
-    if (orderDifference !== 0) return orderDifference;
-    if (a.role === 'user' && b.role !== 'user') return -1;
-    if (a.role !== 'user' && b.role === 'user') return 1;
-    return 0;
-  }) : starterMessages;
-};
-
 function CopyMessageButton({ text }: { text: string }) {
   const [copied, setCopied] = useState(false);
 

package/templates/chat/src/ui/chat/message-reconciliation.ts

@@ -0,0 +1,81 @@
+import type { UiMessage } from './chat-types';
+
+export const starterMessages: UiMessage[] = [{
+  id: 'welcome',
+  role: 'assistant',
+  text: 'Good morning. What would you like to work through?',
+  status: 'complete',
+}];
+
+const chronological = (items: UiMessage[]): UiMessage[] => [...items].sort((a, b) => {
+  if (!a.createdAt || !b.createdAt) return 0;
+  return a.createdAt.getTime() - b.createdAt.getTime();
+});
+
+export const reconcileMessages = (
+  serverMessages: UiMessage[],
+  currentMessages: UiMessage[],
+): UiMessage[] => {
+  const seenServerMessages = new Set<string>();
+  const server = chronological(serverMessages).filter((message) => {
+    if (!message.clientMessageId) return true;
+    const key = `${message.role}:${message.clientMessageId}`;
+    if (seenServerMessages.has(key)) return false;
+    seenServerMessages.add(key);
+    return true;
+  });
+  const serverIds = new Set(server.map((message) => message.id));
+  const serverClientIds = new Set(server.map((message) => message.clientMessageId).filter(Boolean));
+  const localAssistants = currentMessages.filter((message) => message.role === 'assistant' && message.id !== 'welcome');
+  const persistedAssistantIds = new Set(server.filter((message) => message.role === 'assistant').map((message) => message.clientMessageId).filter(Boolean));
+  const linkedAssistants = new Set<string>();
+  const result: UiMessage[] = [];
+
+  const addReply = (message: UiMessage) => {
+    for (const assistant of localAssistants) {
+      if (assistant.replyToClientMessageId === message.clientMessageId && !persistedAssistantIds.has(assistant.id)) {
+        result.push(assistant);
+        linkedAssistants.add(assistant.id);
+      }
+    }
+  };
+
+  for (const message of server) {
+    result.push(message);
+    if (message.role === 'user') addReply(message);
+  }
+
+  for (const message of currentMessages) {
+    if (message.role === 'user' && message.clientMessageId && !serverClientIds.has(message.clientMessageId)) {
+      result.push(message);
+      addReply(message);
+    }
+  }
+
+  // React state contains both optimistic assistants and the previous listener
+  // result. Keep only assistants that are genuinely absent from this snapshot.
+  result.push(...localAssistants.filter((message) =>
+    !serverIds.has(message.id)
+    && !linkedAssistants.has(message.id)
+    && !message.replyToClientMessageId));
+
+  const turnKey = (message: UiMessage): string => {
+    if (message.role === 'assistant') {
+      if (message.replyToClientMessageId) return message.replyToClientMessageId;
+      if (message.clientMessageId?.startsWith('assistant-')) return message.clientMessageId.slice('assistant-'.length);
+    }
+    return message.clientMessageId ?? message.id;
+  };
+  const turnOrder = new Map<string, number>();
+  result.forEach((message, index) => {
+    const key = turnKey(message);
+    if (!turnOrder.has(key)) turnOrder.set(key, index);
+  });
+  return result.length ? [...result].sort((a, b) => {
+    const orderDifference = (turnOrder.get(turnKey(a)) ?? 0) - (turnOrder.get(turnKey(b)) ?? 0);
+    if (orderDifference !== 0) return orderDifference;
+    if (a.role === 'user' && b.role !== 'user') return -1;
+    if (a.role !== 'user' && b.role === 'user') return 1;
+    return 0;
+  }) : starterMessages;
+};

package/templates/chat/test/message-reconciliation.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { reconcileMessages } from '../src/ui/chat/message-reconciliation.ts';
+import type { UiMessage } from '../src/ui/chat/chat-types.ts';
+
+test('does not duplicate a persisted assistant when Firestore publishes again', () => {
+  const persistedAssistant: UiMessage = {
+    id: 'OK6MzPx25jG9GY9FwRA3',
+    role: 'assistant',
+    text: 'Persisted reply',
+    status: 'complete',
+    clientMessageId: 'assistant-client-message-1',
+  };
+
+  const firstSnapshot = reconcileMessages([persistedAssistant], []);
+  const secondSnapshot = reconcileMessages([persistedAssistant], firstSnapshot);
+
+  assert.deepEqual(secondSnapshot.map((message) => message.id), ['OK6MzPx25jG9GY9FwRA3']);
+});
+
+test('keeps a streaming assistant until its persisted replacement arrives', () => {
+  const user: UiMessage = {
+    id: 'server-user-1',
+    role: 'user',
+    text: 'Hello',
+    status: 'complete',
+    clientMessageId: 'client-message-1',
+  };
+  const streamingAssistant: UiMessage = {
+    id: 'assistant-client-message-1',
+    role: 'assistant',
+    text: 'Streaming',
+    status: 'streaming',
+    replyToClientMessageId: 'client-message-1',
+  };
+
+  const whileStreaming = reconcileMessages([user], [user, streamingAssistant]);
+  assert.deepEqual(whileStreaming.map((message) => message.id), [
+    'server-user-1',
+    'assistant-client-message-1',
+  ]);
+
+  const persistedAssistant: UiMessage = {
+    id: 'server-assistant-1',
+    role: 'assistant',
+    text: 'Complete',
+    status: 'complete',
+    clientMessageId: 'assistant-client-message-1',
+  };
+  const afterPersistence = reconcileMessages(
+    [user, persistedAssistant],
+    whileStreaming,
+  );
+  assert.deepEqual(afterPersistence.map((message) => message.id), [
+    'server-user-1',
+    'server-assistant-1',
+  ]);
+});