groove-dev 0.27.55 → 0.27.57

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

@@ -0,0 +1,423 @@
+// GROOVE — Conversation Manager
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+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) {
+    this.daemon = daemon;
+    this.filePath = resolve(daemon.grooveDir, 'conversations.json');
+    this.conversations = new Map();
+    this._load();
+    this._listenForAgentExits();
+  }
+
+  _load() {
+    if (!existsSync(this.filePath)) return;
+    try {
+      const data = JSON.parse(readFileSync(this.filePath, 'utf8'));
+      if (Array.isArray(data)) {
+        for (const conv of data) this.conversations.set(conv.id, conv);
+      }
+    } catch { /* ignore corrupt file */ }
+  }
+
+  _save() {
+    writeFileSync(this.filePath, JSON.stringify([...this.conversations.values()], null, 2));
+  }
+
+  _listenForAgentExits() {
+    this.daemon.registry.on('change', (delta) => {
+      if (!delta?.changed) return;
+      for (const agentId of delta.changed) {
+        const agent = this.daemon.registry.get(agentId);
+        if (!agent) continue;
+        const conv = this._findByAgentId(agentId);
+        if (!conv) continue;
+        if (agent.status === 'completed' || agent.status === 'killed' || agent.status === 'crashed') {
+          conv.agentStatus = agent.status;
+          conv.updatedAt = new Date().toISOString();
+          this._save();
+          this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+        }
+      }
+    });
+  }
+
+  _findByAgentId(agentId) {
+    for (const conv of this.conversations.values()) {
+      if (conv.agentId === agentId) return conv;
+    }
+    return null;
+  }
+
+  async create(provider, model, title, mode = 'api') {
+    const id = randomUUID().slice(0, 12);
+    const now = new Date().toISOString();
+
+    let agentId = null;
+
+    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,
+      provider,
+      model: model || null,
+      mode: mode === 'agent' ? 'agent' : 'api',
+      createdAt: now,
+      updatedAt: now,
+      pinned: false,
+      archived: false,
+    };
+
+    this.conversations.set(id, conversation);
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:created', data: conversation });
+    return conversation;
+  }
+
+  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,
+      agentStatus: agent?.status || conv.agentStatus || 'unknown',
+    };
+  }
+
+  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,
+        agentStatus: agent?.status || conv.agentStatus || 'unknown',
+      };
+    });
+    all.sort((a, b) => {
+      if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+      return new Date(b.updatedAt) - new Date(a.updatedAt);
+    });
+    return all;
+  }
+
+  rename(id, title) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    if (!title || typeof title !== 'string' || !title.trim()) {
+      throw new Error('Title is required');
+    }
+    conv.title = title.trim().slice(0, 200);
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
+  pin(id, pinned) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    conv.pinned = !!pinned;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
+  archive(id, archived) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    conv.archived = !!archived;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
+  async delete(id) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+
+    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 } });
+    return true;
+  }
+
+  touchUpdatedAt(id) {
+    const conv = this.conversations.get(id);
+    if (!conv) return;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+  }
+
+  autoTitle(id, message) {
+    const conv = this.conversations.get(id);
+    if (!conv) return;
+    if (conv.title !== 'New Chat') return;
+    const cleaned = message.trim().replace(/\s+/g, ' ').slice(0, 50);
+    conv.title = cleaned || 'New Chat';
+    conv.updatedAt = new Date().toISOString();
+    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
+          if (json.type === 'result' && json.result) {
+            this.daemon.broadcast({
+              type: 'conversation:chunk',
+              data: { conversationId: id, text: 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 },
+    });
+  }
+}

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

@@ -41,6 +41,7 @@ import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
 import { LlamaServerManager } from './llama-server.js';
 import { RepoImporter } from './repo-import.js';
+import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 import { bindDaemon as bindGrooveNetworkDaemon } from './providers/groove-network.js';
@@ -126,6 +127,7 @@ export class Daemon {
     this.rotator = new Rotator(this);
     this.adaptive = new AdaptiveThresholds(this.grooveDir);
     this.teams = new Teams(this);
+    this.conversations = new ConversationManager(this);
     this.credentials = new CredentialStore(this.grooveDir);
     this.classifier = new TaskClassifier();
     this.router = new ModelRouter(this);