groove-dev 0.27.56 → 0.27.58

package/ai-chat/CHAT_MASTER_PLAN.md

@@ -14,11 +14,31 @@ Teams are powerful but heavy. Sometimes you just want to ask a question, researc
 
 ## Architecture
 
-Chat is a thin layer on top of the existing agent system:
-- Each conversation spawns a lightweight agent with role="chat"
-- Conversations persist metadata (title, model, timestamps, pinned status) separately from agent lifecycle
-- Session resume means returning to a conversation has zero cold-start
-- WebSocket streaming delivers real-time responses
+Chat supports two modes — the user picks which one fits the moment:
+
+### API Mode (default, lightweight)
+- No agent process spawned — each message is a one-shot callHeadless() call
+- Client sends conversation history with each request (context managed client-side)
+- Cheap, fast, casual — like talking to ChatGPT or Claude.ai
+- Uses the journalist's existing callHeadless() infrastructure (works across all providers)
+- Response streamed back via a streaming HTTP response or WebSocket
+- Perfect for: quick questions, brainstorming, research, casual chat
+- Groove Network models are always API mode (inherently one-shot)
+
+### Agent Mode (heavyweight)
+- Spawns a full chat agent with tools, file access, session resume
+- Agent persists between messages — maintains its own context
+- Can read/write files, run commands, search codebase
+- Session resume means zero cold-start when returning
+- More expensive but more powerful
+- Perfect for: code reviews, implementation help, deep analysis
+
+### Mode Switching
+- Toggle in the chat header next to the model picker: "Chat" (API) vs "Agent" (full)
+- Default is API mode — lightweight until you need power
+- Can switch mid-conversation — upgrading to Agent spawns an agent with the conversation history as context
+- Downgrading to API kills the agent, continues with client-side history
+- Conversations persist metadata (title, model, mode, timestamps, pinned status) separately from agent lifecycle
 - Layer 7 memory gives continuity across conversations
 
 ```

package/node_modules/@groove-dev/cli/package.json

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

package/node_modules/@groove-dev/daemon/package.json

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

package/node_modules/@groove-dev/daemon/src/api.js

@@ -818,12 +818,15 @@ export function createApi(app, daemon) {
 
   app.post('/api/conversations', async (req, res) => {
     try {
-      const { provider, model, title } = req.body;
+      const { provider, model, title, mode } = req.body;
       if (!provider || typeof provider !== 'string') {
         return res.status(400).json({ error: 'provider is required' });
       }
-      const conversation = await daemon.conversations.create(provider, model, title);
-      daemon.audit.log('conversation.create', { id: conversation.id, provider, model });
+      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 });
@@ -836,14 +839,20 @@ export function createApi(app, daemon) {
     res.json(conversation);
   });
 
-  app.patch('/api/conversations/:id', (req, res) => {
+  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);
-      daemon.audit.log('conversation.update', { id: req.params.id });
+      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 });
@@ -864,19 +873,27 @@ export function createApi(app, daemon) {
 
   app.post('/api/conversations/:id/message', async (req, res) => {
     try {
-      const { message } = req.body;
+      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' });
 
-      const agent = daemon.registry.get(conv.agentId);
-      if (!agent) return res.status(400).json({ error: 'Agent no longer exists' });
-
       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());
 
@@ -951,6 +968,17 @@ export function createApi(app, daemon) {
     }
   });
 
+  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) => {

package/node_modules/@groove-dev/daemon/src/conversations.js

@@ -4,6 +4,8 @@
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { randomUUID } from 'crypto';
+import { spawn as cpSpawn } from 'child_process';
+import { getProvider, getInstalledProviders } from './providers/index.js';
 
 export class ConversationManager {
   constructor(daemon) {
@@ -53,28 +55,34 @@ export class ConversationManager {
     return null;
   }
 
-  async create(provider, model, title) {
+  async create(provider, model, title, mode = 'api') {
     const id = randomUUID().slice(0, 12);
     const now = new Date().toISOString();
 
-    const defaultTeam = this.daemon.teams.getDefault();
-    const workingDir = defaultTeam?.workingDir || this.daemon.projectDir;
+    let agentId = null;
 
-    const agent = await this.daemon.processes.spawn({
-      role: 'chat',
-      provider,
-      model: model || null,
-      workingDir,
-      teamId: defaultTeam?.id || null,
-      permission: 'full',
-    });
+    if (mode === 'agent') {
+      const defaultTeam = this.daemon.teams.getDefault();
+      const workingDir = defaultTeam?.workingDir || this.daemon.projectDir;
+
+      const agent = await this.daemon.processes.spawn({
+        role: 'chat',
+        provider,
+        model: model || null,
+        workingDir,
+        teamId: defaultTeam?.id || null,
+        permission: 'full',
+      });
+      agentId = agent.id;
+    }
 
     const conversation = {
       id,
       title: title || 'New Chat',
-      agentId: agent.id,
-      provider: agent.provider,
-      model: agent.model,
+      agentId,
+      provider,
+      model: model || null,
+      mode: mode === 'agent' ? 'agent' : 'api',
       createdAt: now,
       updatedAt: now,
       pinned: false,
@@ -90,6 +98,9 @@ export class ConversationManager {
   get(id) {
     const conv = this.conversations.get(id);
     if (!conv) return null;
+    if (conv.mode === 'api' || !conv.agentId) {
+      return { ...conv, agentStatus: conv.agentStatus || null };
+    }
     const agent = this.daemon.registry.get(conv.agentId);
     return {
       ...conv,
@@ -99,6 +110,9 @@ export class ConversationManager {
 
   list() {
     const all = [...this.conversations.values()].map((conv) => {
+      if (conv.mode === 'api' || !conv.agentId) {
+        return { ...conv, agentStatus: conv.agentStatus || null };
+      }
       const agent = this.daemon.registry.get(conv.agentId);
       return {
         ...conv,
@@ -149,14 +163,19 @@ export class ConversationManager {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
 
-    const agent = this.daemon.registry.get(conv.agentId);
-    if (agent && (agent.status === 'running' || agent.status === 'starting')) {
-      try { await this.daemon.processes.kill(conv.agentId); } catch { /* ignore */ }
-    }
-    if (agent) {
-      this.daemon.registry.remove(conv.agentId);
+    if (conv.agentId) {
+      const agent = this.daemon.registry.get(conv.agentId);
+      if (agent && (agent.status === 'running' || agent.status === 'starting')) {
+        try { await this.daemon.processes.kill(conv.agentId); } catch { /* ignore */ }
+      }
+      if (agent) {
+        this.daemon.registry.remove(conv.agentId);
+      }
     }
 
+    // Kill any active API mode streaming process
+    this._killStreamingProcess(id);
+
     this.conversations.delete(id);
     this._save();
     this.daemon.broadcast({ type: 'conversation:deleted', data: { id } });
@@ -180,4 +199,222 @@ export class ConversationManager {
     this._save();
     this.daemon.broadcast({ type: 'conversation:updated', data: conv });
   }
+
+  async setMode(id, mode) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    if (mode !== 'api' && mode !== 'agent') throw new Error('Mode must be "api" or "agent"');
+    if (conv.mode === mode) return conv;
+
+    if (mode === 'agent') {
+      const defaultTeam = this.daemon.teams.getDefault();
+      const workingDir = defaultTeam?.workingDir || this.daemon.projectDir;
+      const agent = await this.daemon.processes.spawn({
+        role: 'chat',
+        provider: conv.provider,
+        model: conv.model || null,
+        workingDir,
+        teamId: defaultTeam?.id || null,
+        permission: 'full',
+      });
+      conv.agentId = agent.id;
+    } else {
+      // Switching to API mode — kill the agent if running
+      this._killStreamingProcess(id);
+      if (conv.agentId) {
+        const agent = this.daemon.registry.get(conv.agentId);
+        if (agent && (agent.status === 'running' || agent.status === 'starting')) {
+          try { await this.daemon.processes.kill(conv.agentId); } catch { /* ignore */ }
+        }
+        if (agent) this.daemon.registry.remove(conv.agentId);
+        conv.agentId = null;
+      }
+    }
+
+    conv.mode = mode;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
+  _buildHistoryPrompt(history, newMessage) {
+    const parts = [];
+    if (history && history.length > 0) {
+      parts.push('Previous conversation:');
+      for (const msg of history) {
+        const role = msg.from === 'user' ? 'User' : 'Assistant';
+        parts.push(`${role}: ${msg.text}`);
+      }
+      parts.push('');
+    }
+    parts.push(`User: ${newMessage}`);
+    return parts.join('\n');
+  }
+
+  _getStreamingProcesses() {
+    if (!this._streamingProcesses) this._streamingProcesses = new Map();
+    return this._streamingProcesses;
+  }
+
+  _killStreamingProcess(conversationId) {
+    const procs = this._getStreamingProcesses();
+    const proc = procs.get(conversationId);
+    if (proc && !proc.killed) {
+      proc.kill();
+    }
+    procs.delete(conversationId);
+  }
+
+  async sendMessage(id, message, history) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    if (conv.mode !== 'api') throw new Error('sendMessage only works in API mode');
+
+    // Kill any previous streaming process for this conversation
+    this._killStreamingProcess(id);
+
+    const prompt = this._buildHistoryPrompt(history, message);
+
+    // Resolve the provider for this conversation
+    let provider = getProvider(conv.provider);
+    let modelId = conv.model;
+
+    if (!provider || !provider.constructor.isInstalled()) {
+      const priority = ['claude-code', 'gemini', 'codex', 'ollama'];
+      const installed = getInstalledProviders();
+      const fallbackId = priority.find((p) => installed.some((i) => i.id === p));
+      if (!fallbackId) throw new Error('No provider available for chat');
+      provider = getProvider(fallbackId);
+      modelId = null;
+    }
+
+    const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
+    const { command, args, env, stdin: stdinData, cwd } = headlessCmd;
+
+    const spawnOpts = {
+      env: { ...process.env, ...env },
+      cwd: cwd || this.daemon.projectDir,
+      stdio: stdinData ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+    };
+
+    const proc = cpSpawn(command, args, spawnOpts);
+    this._getStreamingProcesses().set(id, proc);
+
+    if (stdinData) {
+      proc.stdin.write(stdinData);
+      proc.stdin.end();
+    }
+
+    let fullOutput = '';
+
+    proc.stdout.on('data', (data) => {
+      const text = data.toString();
+      fullOutput += text;
+
+      // Parse provider output for streaming chunks
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // Try to parse as JSON (stream-json format)
+        try {
+          const json = JSON.parse(trimmed);
+
+          // Claude Code stream-json: assistant message content
+          if (json.type === 'assistant' && json.message?.content) {
+            for (const block of json.message.content) {
+              if (block.type === 'text' && block.text) {
+                this.daemon.broadcast({
+                  type: 'conversation:chunk',
+                  data: { conversationId: id, text: block.text },
+                });
+              }
+            }
+            continue;
+          }
+
+          // Claude Code stream-json: content_block_delta
+          if (json.type === 'content_block_delta' && json.delta?.text) {
+            this.daemon.broadcast({
+              type: 'conversation:chunk',
+              data: { conversationId: id, text: json.delta.text },
+            });
+            continue;
+          }
+
+          // Claude Code stream-json: result block — skip broadcasting since
+          // the content was already streamed via assistant/content_block_delta
+          if (json.type === 'result' && json.result) {
+            continue;
+          }
+
+          // Groove Network: token events
+          if (json.type === 'token' && json.text != null) {
+            this.daemon.broadcast({
+              type: 'conversation:chunk',
+              data: { conversationId: id, text: json.text },
+            });
+            continue;
+          }
+
+          // Groove Network: done/complete/result
+          if ((json.type === 'done' || json.type === 'complete' || json.type === 'result') && json.text) {
+            this.daemon.broadcast({
+              type: 'conversation:chunk',
+              data: { conversationId: id, text: json.text },
+            });
+            continue;
+          }
+
+          // Gemini / Codex: content text
+          if (json.content?.[0]?.text) {
+            this.daemon.broadcast({
+              type: 'conversation:chunk',
+              data: { conversationId: id, text: json.content[0].text },
+            });
+            continue;
+          }
+        } catch { /* not JSON — treat as raw text */ }
+
+        // Non-JSON output: broadcast raw text (some providers output plain text)
+        if (!trimmed.startsWith('{')) {
+          this.daemon.broadcast({
+            type: 'conversation:chunk',
+            data: { conversationId: id, text: trimmed },
+          });
+        }
+      }
+    });
+
+    proc.on('error', (err) => {
+      this._getStreamingProcesses().delete(id);
+      this.daemon.broadcast({
+        type: 'conversation:error',
+        data: { conversationId: id, error: err.message },
+      });
+    });
+
+    proc.on('exit', (code) => {
+      this._getStreamingProcesses().delete(id);
+      this.daemon.broadcast({
+        type: 'conversation:complete',
+        data: { conversationId: id, exitCode: code },
+      });
+    });
+
+    const timeout = setTimeout(() => {
+      if (!proc.killed) proc.kill();
+    }, 120_000);
+    proc.on('exit', () => clearTimeout(timeout));
+  }
+
+  stopStreaming(id) {
+    this._killStreamingProcess(id);
+    this.daemon.broadcast({
+      type: 'conversation:complete',
+      data: { conversationId: id, stopped: true },
+    });
+  }
 }