groove-dev 0.27.55 → 0.27.57

package/ai-chat/CHAT_MASTER_PLAN.md

@@ -0,0 +1,184 @@
+# Groove Chat — Master Plan
+
+> The smartest AI chat interface ever built, powered by a full orchestration layer.
+
+## North Star
+
+Groove Chat is a first-class standalone chat experience that lives alongside Teams in the sidebar. It is not a wrapper around a chatbot — it is a command center disguised as a conversation. Every capability Groove has (multi-model routing, Layer 7 memory, MCP integrations, agent orchestration, project context) is accessible from a single chat input bar.
+
+For Groove Network users, this is the primary interface — a decentralized LLM chat that feels as polished and intelligent as any frontier cloud product.
+
+## Why This Matters
+
+Teams are powerful but heavy. Sometimes you just want to ask a question, research something, brainstorm, or get a quick code review. Chat fills that gap. It is the fast path — zero setup, instant AI access, full platform power.
+
+## Architecture
+
+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
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Chat View                                               │
+│ ┌──────────────┬────────────────────────────────────────┐│
+│ │ Conversation │ Chat Area                              ││
+│ │ Sidebar      │ ┌────────────────────────────────────┐ ││
+│ │              │ │ Messages (streaming, markdown,     │ ││
+│ │ [+ New Chat] │ │ code blocks, tool calls)           │ ││
+│ │              │ │                                    │ ││
+│ │ Today        │ │                                    │ ││
+│ │  ▸ Chat 1    │ │                                    │ ││
+│ │  ▸ Chat 2    │ │                                    │ ││
+│ │              │ │                                    │ ││
+│ │ Yesterday    │ │                                    │ ││
+│ │  ▸ Chat 3    │ ├────────────────────────────────────┤ ││
+│ │              │ │ [Model ▾] [Type a message...] [➤]  │ ││
+│ │ Pinned       │ │ [Attach] [Stop]                    │ ││
+│ │  ▸ Chat 4    │ └────────────────────────────────────┘ ││
+│ └──────────────┴────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```
+
+## Phased Rollout
+
+### Phase 1 — Core Chat Experience (NOW)
+
+The foundation. A beautiful, functional chat that works with every provider.
+
+GUI (packages/gui/):
+- ActivityBar: Add MessageCircle icon below Teams
+- New view: src/views/chat.jsx
+- New components: src/components/chat/
+  - chat-view.jsx — Main layout (conversation sidebar + chat area)
+  - conversation-list.jsx — Left sidebar: new chat button, grouped by date, pinned section, search
+  - chat-messages.jsx — Message rendering: full markdown, syntax-highlighted code blocks, streaming cursor
+  - chat-input.jsx — Rich input bar: model picker dropdown, file attachments, stop button
+  - chat-header.jsx — Active conversation header: title, model badge, token count, actions
+  - model-picker.jsx — Provider/model selector: shows all available providers, model tiers, cost indicators
+- App router: Add chat case to ViewRouter in app.jsx
+- Store: Add conversation state to stores/groove.js
+  - conversations: [] — metadata array
+  - activeConversationId: null
+  - conversationMessages: {} — keyed by conversation ID
+  - createConversation(), deleteConversation(), renameConversation()
+  - setActiveConversation(), sendChatMessage()
+
+Daemon (packages/daemon/):
+- New file: src/conversations.js — Conversation manager
+  - CRUD operations with .groove/conversations.json persistence
+  - Auto-title generation (first message summary)
+  - Pin/archive support
+  - Maps conversation ID to agent ID
+- API endpoints in src/api.js:
+  - GET /api/conversations — list all conversations
+  - POST /api/conversations — create new conversation (spawns chat agent)
+  - GET /api/conversations/:id — get conversation with messages
+  - PATCH /api/conversations/:id — rename, pin, archive
+  - DELETE /api/conversations/:id — delete conversation (kills agent)
+  - POST /api/conversations/:id/message — send message (proxies to agent instruct)
+- WebSocket: broadcast conversation events (created, updated, deleted)
+
+Key behaviors:
+- Creating a conversation spawns a chat agent with the selected provider/model
+- Messages route through the existing instruct endpoint
+- Streaming responses arrive via existing agent:output WebSocket events
+- Model can be changed mid-conversation (hot-swap for supported providers, rotation for others)
+- Conversations persist in .groove/conversations.json, messages in localStorage
+- Auto-generated titles from first message content
+
+### Phase 2 — Intelligence Layer
+
+What makes Groove Chat feel smarter than everything else.
+
+- Research Mode: Toggle that enables deep codebase exploration, file reading, multi-step reasoning. Results rendered as structured cards with sources.
+- Project Context: Auto-inject CLAUDE.md + project map. Chat knows your codebase without being told.
+- Thinking/Reasoning Display: Collapsible sections showing the AI's chain of thought (for models that support it).
+- Tool Call Visualization: When AI reads files, searches, or runs commands — show inline activity cards (not raw text).
+- Conversation Search: Full-text search across all conversations.
+- Keyboard Shortcuts: Cmd+Shift+N for new chat, Cmd+[ / ] to navigate conversations.
+
+### Phase 3 — Platform Integration
+
+Leverage the full Groove ecosystem.
+
+- MCP Integrations in Chat: Use installed integrations directly — "summarize my unread emails", "post to Slack", "check GitHub PRs".
+- Escalate to Team: One-click button that takes the chat context and spawns a planner + team to build what was discussed.
+- Agent Awareness: Ask about running agents — "what is frontend-3 working on?" queries the live agent.
+- Approval Gates: Destructive actions in chat go through the same approval system as teams.
+- Slash Commands: /search, /agent <id>, /escalate, /model <name>, /clear
+
+### Phase 4 — Advanced Features
+
+- Multi-Model Comparison: Send one prompt to 2-3 models, see responses side by side. Perfect for research and model evaluation.
+- Canvas/Artifacts: Code, documents, or diagrams generated in chat can be pinned to a side panel. Edit inline, iterate with the AI.
+- Voice Input: Whisper-based voice-to-text for hands-free chat.
+- Conversation Branching: Fork a conversation at any point, explore different directions.
+- Shared Conversations: Export/share conversations with team members via federation.
+
+## File Map
+
+```
+packages/gui/src/
+├── views/
+│   └── chat.jsx                    (NEW — Chat view entry point)
+├── components/
+│   └── chat/
+│       ├── chat-view.jsx           (NEW — Main layout container)
+│       ├── conversation-list.jsx   (NEW — Sidebar conversation list)
+│       ├── chat-messages.jsx       (NEW — Message rendering)
+│       ├── chat-input.jsx          (NEW — Input bar + model picker)
+│       ├── chat-header.jsx         (NEW — Conversation header)
+│       └── model-picker.jsx        (NEW — Provider/model selector)
+├── stores/
+│   └── groove.js                   (MODIFY — Add conversation state)
+├── components/layout/
+│   ├── activity-bar.jsx            (MODIFY — Add Chat icon)
+│   └── app-shell.jsx               (MODIFY — Wire up Chat view)
+└── app.jsx                         (MODIFY — Add Chat to ViewRouter)
+
+packages/daemon/src/
+├── conversations.js                (NEW — Conversation manager)
+└── api.js                          (MODIFY — Add /api/conversations endpoints)
+```
+
+## Design Principles
+
+1. Zero friction — New Chat should be one click or one keystroke away
+2. Model-first — The model picker is prominent, not hidden. Users should always know what they're talking to
+3. Project-aware — Chat knows your codebase. You never have to explain your project
+4. Escalation path — Any chat can become a team. Research flows into action
+5. Provider-agnostic — Works with Claude, Gemini, Ollama, Groove Network, anything with a provider
+6. Beautiful defaults — Full markdown rendering, syntax highlighting, smooth streaming. No raw text dumps
+
+## Groove Network Integration
+
+Chat is the primary interface for Groove Network (decentralized LLM). Key considerations:
+- Groove Network is one-shot (stateless per message) — conversations track history client-side
+- Model picker shows Groove Network models with a "decentralized" badge
+- Cost display shows token savings vs cloud pricing
+- Network status indicator in chat header (connected/latency/node count)
+- Future: streaming support as network protocol evolves

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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) => {