groove-dev 0.27.55 → 0.27.57

package/node_modules/@groove-dev/gui/src/stores/groove.js

@@ -75,6 +75,13 @@ export const useGrooveStore = create((set, get) => ({
   chatInputs: {},   // Per-agent draft input text — persists across tab switches
   tokenTimeline: {},
 
+  // ── Conversations (Chat view) ────────────────────────────
+  conversations: [],
+  activeConversationId: localStorage.getItem('groove:activeConversationId') || null,
+  conversationMessages: loadJSON('groove:conversationMessages'),
+  sendingMessage: false,
+  streamingConversationId: null,
+
   // ── Approvals ─────────────────────────────────────────────
   pendingApprovals: [],
   resolvedApprovals: [],
@@ -163,6 +170,7 @@ export const useGrooveStore = create((set, get) => ({
         if (isTunneled) get().fetchProjectDir();
       }).catch(() => {});
       get().fetchTeams();
+      get().fetchConversations();
       get().fetchApprovals();
       get().checkMarketplaceAuth();
       get().fetchTunnels();
@@ -342,6 +350,28 @@ export const useGrooveStore = create((set, get) => ({
               set({ chatHistory: history });
               persistJSON('groove:chatHistory', history);
             }
+
+            // Mirror to conversation messages if this agent belongs to a conversation
+            const conv = get().conversations.find((c) => c.agentId === agentId);
+            if (conv) {
+              const convMsgs = { ...get().conversationMessages };
+              if (!convMsgs[conv.id]) convMsgs[conv.id] = [];
+              const convArr = [...convMsgs[conv.id]];
+              const lastConv = convArr[convArr.length - 1];
+              const isRecentConv = lastConv && lastConv.from === 'assistant' && (Date.now() - lastConv.timestamp) < 8000;
+              const isConvDupe = isRecentConv && (lastConv.text === trimmed || lastConv.text.endsWith(trimmed));
+              if (!isConvDupe) {
+                if (isRecentConv) {
+                  const sep = data.subtype === 'assistant' ? '\n\n' : ' ';
+                  convArr[convArr.length - 1] = { ...lastConv, text: lastConv.text + sep + trimmed, timestamp: Date.now() };
+                } else {
+                  convArr.push({ from: 'assistant', text: trimmed, timestamp: Date.now() });
+                }
+                convMsgs[conv.id] = convArr.slice(-200);
+                set({ conversationMessages: convMsgs, streamingConversationId: conv.id });
+                persistJSON('groove:conversationMessages', convMsgs);
+              }
+            }
           }
 
           // Tool calls → activity log (shown in streaming bar, not as chat bubbles)
@@ -379,6 +409,12 @@ export const useGrooveStore = create((set, get) => ({
             });
           }
 
+          // Clear conversation streaming state
+          const exitConv = get().conversations.find((c) => c.agentId === msg.agentId);
+          if (exitConv && get().streamingConversationId === exitConv.id) {
+            set({ sendingMessage: false, streamingConversationId: null });
+          }
+
           // Log crash error to agent chat so user can see what happened
           if (msg.error && msg.agentId) {
             get().addChatMessage(msg.agentId, 'system', `Crashed: ${msg.error}`);
@@ -736,6 +772,76 @@ export const useGrooveStore = create((set, get) => ({
           get().fetchBetaStatus();
           get().fetchNetworkInstallStatus();
           break;
+
+        case 'conversation:created': {
+          const conv = msg.data;
+          if (conv) set((s) => ({ conversations: [conv, ...s.conversations.filter((c) => c.id !== conv.id)] }));
+          break;
+        }
+
+        case 'conversation:updated': {
+          const conv = msg.data;
+          if (conv) set((s) => ({ conversations: s.conversations.map((c) => c.id === conv.id ? { ...c, ...conv } : c) }));
+          break;
+        }
+
+        case 'conversation:deleted': {
+          const id = msg.data?.id || msg.id;
+          if (id) {
+            set((s) => {
+              const conversations = s.conversations.filter((c) => c.id !== id);
+              const conversationMessages = { ...s.conversationMessages };
+              delete conversationMessages[id];
+              const activeConversationId = s.activeConversationId === id ? null : s.activeConversationId;
+              if (activeConversationId !== s.activeConversationId) localStorage.setItem('groove:activeConversationId', '');
+              return { conversations, conversationMessages, activeConversationId };
+            });
+          }
+          break;
+        }
+
+        case 'conversation:chunk': {
+          const { conversationId, text } = msg.data || msg;
+          if (!conversationId || !text) break;
+          set((s) => {
+            const msgs = { ...s.conversationMessages };
+            if (!msgs[conversationId]) msgs[conversationId] = [];
+            const arr = [...msgs[conversationId]];
+            const last = arr[arr.length - 1];
+            if (last && last.from === 'assistant' && (Date.now() - last.timestamp) < 30000) {
+              arr[arr.length - 1] = { ...last, text: last.text + text, timestamp: Date.now() };
+            } else {
+              arr.push({ from: 'assistant', text, timestamp: Date.now() });
+            }
+            msgs[conversationId] = arr.slice(-200);
+            persistJSON('groove:conversationMessages', msgs);
+            return { conversationMessages: msgs, streamingConversationId: conversationId };
+          });
+          break;
+        }
+
+        case 'conversation:complete': {
+          const { conversationId } = msg.data || msg;
+          if (conversationId) {
+            set({ sendingMessage: false, streamingConversationId: null });
+            persistJSON('groove:conversationMessages', get().conversationMessages);
+          }
+          break;
+        }
+
+        case 'conversation:error': {
+          const { conversationId, error } = msg.data || msg;
+          if (conversationId) {
+            set((s) => {
+              const msgs = { ...s.conversationMessages };
+              if (!msgs[conversationId]) msgs[conversationId] = [];
+              msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Error: ${error || 'Unknown error'}`, timestamp: Date.now() }];
+              persistJSON('groove:conversationMessages', msgs);
+              return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
+            });
+          }
+          break;
+        }
       }
     };
 
@@ -1532,6 +1638,120 @@ export const useGrooveStore = create((set, get) => ({
     }
   },
 
+  // ── Conversations (Chat view) ────────────────────────────
+
+  async fetchConversations() {
+    try {
+      const data = await api.get('/conversations');
+      set({ conversations: data.conversations || data || [] });
+    } catch { /* endpoint may not exist yet */ }
+  },
+
+  async createConversation(provider, model, mode = 'api') {
+    try {
+      const conv = await api.post('/conversations', { provider, model, mode });
+      set((s) => ({
+        conversations: [conv, ...s.conversations.filter((c) => c.id !== conv.id)],
+        activeConversationId: conv.id,
+      }));
+      localStorage.setItem('groove:activeConversationId', conv.id);
+      return conv;
+    } catch (err) {
+      get().addToast('error', 'Failed to create conversation', err.message);
+      throw err;
+    }
+  },
+
+  async setConversationMode(id, mode) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { mode });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Mode change failed', err.message);
+    }
+  },
+
+  async stopChatStreaming(conversationId) {
+    try {
+      await api.post(`/conversations/${encodeURIComponent(conversationId)}/stop`);
+      set({ sendingMessage: false, streamingConversationId: null });
+    } catch { /* ignore */ }
+  },
+
+  async deleteConversation(id) {
+    try {
+      await api.delete(`/conversations/${encodeURIComponent(id)}`);
+      set((s) => {
+        const conversations = s.conversations.filter((c) => c.id !== id);
+        const conversationMessages = { ...s.conversationMessages };
+        delete conversationMessages[id];
+        persistJSON('groove:conversationMessages', conversationMessages);
+        const activeConversationId = s.activeConversationId === id
+          ? (conversations[0]?.id || null)
+          : s.activeConversationId;
+        localStorage.setItem('groove:activeConversationId', activeConversationId || '');
+        return { conversations, conversationMessages, activeConversationId };
+      });
+    } catch (err) {
+      get().addToast('error', 'Delete failed', err.message);
+    }
+  },
+
+  async renameConversation(id, title) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { title });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Rename failed', err.message);
+    }
+  },
+
+  async pinConversation(id, pinned) {
+    try {
+      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { pinned });
+      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
+    } catch (err) {
+      get().addToast('error', 'Pin failed', err.message);
+    }
+  },
+
+  setActiveConversation(id) {
+    set({ activeConversationId: id });
+    localStorage.setItem('groove:activeConversationId', id || '');
+  },
+
+  async sendChatMessage(conversationId, message) {
+    const conv = get().conversations.find((c) => c.id === conversationId);
+    if (!conv) return;
+
+    // Add user message to local state immediately
+    set((s) => {
+      const msgs = { ...s.conversationMessages };
+      if (!msgs[conversationId]) msgs[conversationId] = [];
+      msgs[conversationId] = [...msgs[conversationId], { from: 'user', text: message, timestamp: Date.now() }];
+      persistJSON('groove:conversationMessages', msgs);
+      return { conversationMessages: msgs, sendingMessage: true, streamingConversationId: conversationId };
+    });
+
+    try {
+      const body = { message };
+      if (conv.mode === 'api' || !conv.mode) {
+        const history = get().conversationMessages[conversationId] || [];
+        body.history = history.slice(0, -1);
+      }
+      await api.post(`/conversations/${encodeURIComponent(conversationId)}/message`, body);
+    } catch (err) {
+      set((s) => {
+        const msgs = { ...s.conversationMessages };
+        if (!msgs[conversationId]) msgs[conversationId] = [];
+        msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Failed: ${err.message}`, timestamp: Date.now() }];
+        persistJSON('groove:conversationMessages', msgs);
+        return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
+      });
+      get().addToast('error', 'Message failed', err.message);
+    }
+  },
+
   // ── Editor ────────────────────────────────────────────────
 
   async openFile(path) {

package/node_modules/@groove-dev/gui/src/views/chat.jsx

@@ -0,0 +1,6 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+import { ChatView } from '../components/chat/chat-view';
+
+export default function ChatViewEntry() {
+  return <ChatView />;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.55",
+  "version": "0.27.57",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.55",
+  "version": "0.27.57",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.55",
+  "version": "0.27.57",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/api.js

@@ -810,6 +810,175 @@ export function createApi(app, daemon) {
     }
   });
 
+  // --- Conversations ---
+
+  app.get('/api/conversations', (req, res) => {
+    res.json({ conversations: daemon.conversations.list() });
+  });
+
+  app.post('/api/conversations', async (req, res) => {
+    try {
+      const { provider, model, title, mode } = req.body;
+      if (!provider || typeof provider !== 'string') {
+        return res.status(400).json({ error: 'provider is required' });
+      }
+      if (mode && mode !== 'api' && mode !== 'agent') {
+        return res.status(400).json({ error: 'mode must be "api" or "agent"' });
+      }
+      const conversation = await daemon.conversations.create(provider, model, title, mode || 'api');
+      daemon.audit.log('conversation.create', { id: conversation.id, provider, model, mode: conversation.mode });
+      res.status(201).json(conversation);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/conversations/:id', (req, res) => {
+    const conversation = daemon.conversations.get(req.params.id);
+    if (!conversation) return res.status(404).json({ error: 'Conversation not found' });
+    res.json(conversation);
+  });
+
+  app.patch('/api/conversations/:id', async (req, res) => {
+    try {
+      const conv = daemon.conversations.get(req.params.id);
+      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
+      if (req.body.title !== undefined) daemon.conversations.rename(req.params.id, req.body.title);
+      if (req.body.pinned !== undefined) daemon.conversations.pin(req.params.id, req.body.pinned);
+      if (req.body.archived !== undefined) daemon.conversations.archive(req.params.id, req.body.archived);
+      if (req.body.mode !== undefined) {
+        if (req.body.mode !== 'api' && req.body.mode !== 'agent') {
+          return res.status(400).json({ error: 'mode must be "api" or "agent"' });
+        }
+        await daemon.conversations.setMode(req.params.id, req.body.mode);
+      }
+      daemon.audit.log('conversation.update', { id: req.params.id, mode: req.body.mode });
+      res.json(daemon.conversations.get(req.params.id));
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/conversations/:id', async (req, res) => {
+    try {
+      const conv = daemon.conversations.get(req.params.id);
+      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
+      await daemon.conversations.delete(req.params.id);
+      daemon.audit.log('conversation.delete', { id: req.params.id });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/conversations/:id/message', async (req, res) => {
+    try {
+      const { message, history } = req.body;
+      if (!message || typeof message !== 'string' || !message.trim()) {
+        return res.status(400).json({ error: 'message is required' });
+      }
+      const conv = daemon.conversations.get(req.params.id);
+      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
+
+      daemon.conversations.autoTitle(req.params.id, message.trim());
+      daemon.conversations.touchUpdatedAt(req.params.id);
+
+      // API mode — lightweight headless streaming, no agent spawned
+      if (conv.mode === 'api' || !conv.agentId) {
+        await daemon.conversations.sendMessage(req.params.id, message.trim(), history || []);
+        daemon.audit.log('conversation.message', { id: req.params.id, mode: 'api' });
+        return res.json({ status: 'streaming', mode: 'api' });
+      }
+
+      // Agent mode — existing behavior
+      const agent = daemon.registry.get(conv.agentId);
+      if (!agent) return res.status(400).json({ error: 'Agent no longer exists' });
+
+      // Record user feedback for journalist context
+      if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, message.trim());
+
+      // Agent loop path — send message directly to the running loop
+      if (daemon.processes.hasAgentLoop(conv.agentId)) {
+        const sent = await daemon.processes.sendMessage(conv.agentId, message.trim());
+        if (sent) {
+          daemon.audit.log('conversation.message', { id: req.params.id, agentId: conv.agentId });
+          return res.json({ id: conv.agentId, status: 'message_sent' });
+        }
+      }
+
+      // One-shot providers: kill and respawn with the message as prompt
+      const provider = getProvider(agent.provider);
+      if (provider?.constructor?.isOneShot) {
+        const oldConfig = { ...agent };
+        if (daemon.processes.isRunning(conv.agentId)) {
+          await daemon.processes.kill(conv.agentId);
+        }
+        daemon.registry.remove(conv.agentId);
+        daemon.locks.release(conv.agentId);
+
+        const newAgent = await daemon.processes.spawn({
+          role: 'chat',
+          scope: oldConfig.scope,
+          provider: oldConfig.provider,
+          model: oldConfig.model,
+          prompt: message.trim(),
+          permission: oldConfig.permission || 'full',
+          workingDir: oldConfig.workingDir,
+          name: oldConfig.name,
+          teamId: oldConfig.teamId,
+        });
+
+        // Update conversation to point to new agent
+        const convObj = daemon.conversations.conversations.get(req.params.id);
+        if (convObj) {
+          convObj.agentId = newAgent.id;
+          daemon.conversations._save();
+        }
+        daemon.audit.log('conversation.message', { id: req.params.id, agentId: newAgent.id, oneShot: true });
+        return res.json({ id: newAgent.id, status: 'respawned' });
+      }
+
+      // Running CLI agent — queue the message
+      if (daemon.processes.isRunning(conv.agentId)) {
+        daemon.processes.queueMessage(conv.agentId, message.trim());
+        daemon.audit.log('conversation.message', { id: req.params.id, agentId: conv.agentId, queued: true });
+        return res.json({ id: conv.agentId, status: 'message_queued' });
+      }
+
+      // CLI agent — session resume or rotation
+      const SESSION_RESUME_CEILING = 5_000_000;
+      const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
+      const newAgent = resumed
+        ? await daemon.processes.resume(conv.agentId, message.trim())
+        : await daemon.rotator.rotate(conv.agentId, { additionalPrompt: message.trim() });
+
+      // Update conversation to point to new agent if rotated
+      if (newAgent.id !== conv.agentId) {
+        const convObj = daemon.conversations.conversations.get(req.params.id);
+        if (convObj) {
+          convObj.agentId = newAgent.id;
+          daemon.conversations._save();
+        }
+      }
+
+      daemon.audit.log('conversation.message', { id: req.params.id, agentId: newAgent.id, resumed });
+      res.json({ id: newAgent.id, status: resumed ? 'resumed' : 'rotated' });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/conversations/:id/stop', (req, res) => {
+    try {
+      const conv = daemon.conversations.get(req.params.id);
+      if (!conv) return res.status(404).json({ error: 'Conversation not found' });
+      daemon.conversations.stopStreaming(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // --- Approvals ---
 
   app.get('/api/approvals', (req, res) => {