@shepai/cli 1.106.3 → 1.106.4-pr327.f3fea88

package/dist/src/presentation/web/hooks/use-chat.js

@@ -0,0 +1,217 @@
+'use client';
+import { useCallback, useReducer, useRef } from 'react';
+export const initialChatState = {
+    messages: [],
+    status: 'idle',
+    error: null,
+    sessionId: null,
+};
+/* ------------------------------------------------------------------ */
+/*  Reducer                                                            */
+/* ------------------------------------------------------------------ */
+export function chatReducer(state, action) {
+    switch (action.type) {
+        case 'add_user_message':
+            return {
+                ...state,
+                messages: [...state.messages, action.message],
+                status: 'sending',
+                error: null,
+            };
+        case 'start_streaming': {
+            const assistantMessage = {
+                id: crypto.randomUUID(),
+                role: 'assistant',
+                content: '',
+                timestamp: new Date(),
+                status: 'streaming',
+            };
+            return {
+                ...state,
+                messages: [...state.messages, assistantMessage],
+                status: 'streaming',
+            };
+        }
+        case 'stream_token': {
+            const msgs = [...state.messages];
+            const last = msgs[msgs.length - 1];
+            if (last?.role === 'assistant') {
+                msgs[msgs.length - 1] = { ...last, content: last.content + action.content };
+            }
+            return { ...state, messages: msgs };
+        }
+        case 'complete_streaming': {
+            const msgs = [...state.messages];
+            const last = msgs[msgs.length - 1];
+            if (last?.role === 'assistant') {
+                msgs[msgs.length - 1] = { ...last, status: 'complete' };
+            }
+            return {
+                ...state,
+                messages: msgs,
+                status: 'idle',
+                sessionId: action.sessionId ?? state.sessionId,
+            };
+        }
+        case 'set_error': {
+            const msgs = [...state.messages];
+            const last = msgs[msgs.length - 1];
+            if (last?.role === 'assistant' && last.status === 'streaming') {
+                msgs[msgs.length - 1] = { ...last, status: 'error' };
+            }
+            return {
+                ...state,
+                messages: msgs,
+                status: 'error',
+                error: action.error,
+            };
+        }
+        case 'clear_messages':
+            return { ...initialChatState };
+        default:
+            return state;
+    }
+}
+/**
+ * Parse SSE-formatted chunks from a ReadableStream.
+ * Yields parsed events as they arrive.
+ */
+export async function* parseSSEStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        // Split on double newline (SSE event boundary)
+        const parts = buffer.split('\n\n');
+        // Last part may be incomplete — keep it in the buffer
+        buffer = parts.pop() ?? '';
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed || trimmed.startsWith(':'))
+                continue; // Skip empty lines and comments (heartbeats)
+            // Extract data lines
+            const dataLines = [];
+            for (const line of trimmed.split('\n')) {
+                if (line.startsWith('data: ')) {
+                    dataLines.push(line.slice(6));
+                }
+            }
+            if (dataLines.length === 0)
+                continue;
+            try {
+                const parsed = JSON.parse(dataLines.join('\n'));
+                yield parsed;
+            }
+            catch {
+                // Non-JSON data — skip
+            }
+        }
+    }
+}
+export function useChat() {
+    const [state, dispatch] = useReducer(chatReducer, initialChatState);
+    const abortControllerRef = useRef(null);
+    const lastUserMessageRef = useRef(null);
+    const streamResponse = useCallback(async (message, sessionId) => {
+        // Cancel any in-flight request
+        abortControllerRef.current?.abort();
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        dispatch({ type: 'start_streaming' });
+        try {
+            const response = await fetch('/api/chat/stream', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message, sessionId }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Request failed');
+                dispatch({ type: 'set_error', error: errorText });
+                return;
+            }
+            if (!response.body) {
+                dispatch({ type: 'set_error', error: 'No response body' });
+                return;
+            }
+            const reader = response.body.getReader();
+            try {
+                for await (const event of parseSSEStream(reader)) {
+                    if (controller.signal.aborted)
+                        break;
+                    switch (event.type) {
+                        case 'progress':
+                            dispatch({ type: 'stream_token', content: event.content });
+                            break;
+                        case 'result':
+                            dispatch({ type: 'complete_streaming', sessionId: event.sessionId });
+                            return;
+                        case 'error':
+                            dispatch({ type: 'set_error', error: event.content });
+                            return;
+                    }
+                }
+                // Stream ended without a result event — treat as complete
+                dispatch({ type: 'complete_streaming' });
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        catch (err) {
+            if (controller.signal.aborted)
+                return;
+            const errorMessage = err instanceof Error ? err.message : 'An unexpected error occurred';
+            dispatch({ type: 'set_error', error: errorMessage });
+        }
+    }, []);
+    const sendMessage = useCallback(async (content) => {
+        const trimmed = content.trim();
+        if (!trimmed)
+            return;
+        if (state.status === 'sending' || state.status === 'streaming')
+            return;
+        lastUserMessageRef.current = trimmed;
+        const userMessage = {
+            id: crypto.randomUUID(),
+            role: 'user',
+            content: trimmed,
+            timestamp: new Date(),
+            status: 'complete',
+        };
+        dispatch({ type: 'add_user_message', message: userMessage });
+        await streamResponse(trimmed, state.sessionId);
+    }, [state.status, state.sessionId, streamResponse]);
+    const retry = useCallback(async () => {
+        const lastMessage = lastUserMessageRef.current;
+        if (!lastMessage)
+            return;
+        // Remove the last assistant message if it errored
+        dispatch({ type: 'clear_messages' });
+        const userMessage = {
+            id: crypto.randomUUID(),
+            role: 'user',
+            content: lastMessage,
+            timestamp: new Date(),
+            status: 'complete',
+        };
+        dispatch({ type: 'add_user_message', message: userMessage });
+        await streamResponse(lastMessage, state.sessionId);
+    }, [state.sessionId, streamResponse]);
+    const clearChat = useCallback(() => {
+        abortControllerRef.current?.abort();
+        lastUserMessageRef.current = null;
+        dispatch({ type: 'clear_messages' });
+    }, []);
+    return {
+        messages: state.messages,
+        status: state.status,
+        error: state.error,
+        sendMessage,
+        retry,
+        clearChat,
+    };
+}

package/dist/src/presentation/web/lib/feature-flags.d.ts

@@ -9,6 +9,7 @@ export interface FeatureFlagsState {
     skills: boolean;
     envDeploy: boolean;
     debug: boolean;
+    chat: boolean;
 }
 export declare function getFeatureFlags(): FeatureFlagsState;
 /**
@@ -19,5 +20,6 @@ export declare const featureFlags: {
     readonly skills: boolean;
     readonly envDeploy: boolean;
     readonly debug: boolean;
+    readonly chat: boolean;
 };
 //# sourceMappingURL=feature-flags.d.ts.map

package/dist/src/presentation/web/lib/feature-flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CAwBnD;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;CAUf,CAAC"}
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/lib/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CA6BnD;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;CAaf,CAAC"}

package/dist/src/presentation/web/lib/feature-flags.js

@@ -18,6 +18,7 @@ export function getFeatureFlags() {
                     skills: flags.skills,
                     envDeploy: flags.envDeploy,
                     debug: flags.debug,
+                    chat: flags.chat,
                 };
             }
         }
@@ -31,6 +32,9 @@ export function getFeatureFlags() {
             ? isEnabled(process.env.NEXT_PUBLIC_FLAG_ENV_DEPLOY)
             : true,
         debug: false,
+        chat: process.env.NEXT_PUBLIC_FLAG_CHAT !== undefined
+            ? isEnabled(process.env.NEXT_PUBLIC_FLAG_CHAT)
+            : true,
     };
 }
 /**
@@ -47,4 +51,7 @@ export const featureFlags = {
     get debug() {
         return getFeatureFlags().debug;
     },
+    get chat() {
+        return getFeatureFlags().chat;
+    },
 };