groove-dev 0.8.0

package/packages/daemon/src/providers/claude-code.js

@@ -0,0 +1,167 @@
+// GROOVE — Claude Code Provider
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execSync } from 'child_process';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { Provider } from './base.js';
+
+export class ClaudeCodeProvider extends Provider {
+  static name = 'claude-code';
+  static displayName = 'Claude Code';
+  static command = 'claude';
+  static authType = 'subscription';
+  static models = [
+    { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', tier: 'heavy', contextWindow: 1_000_000 },
+    { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', tier: 'medium', contextWindow: 200_000 },
+    { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', tier: 'light', contextWindow: 200_000 },
+  ];
+
+  static isInstalled() {
+    try {
+      execSync('which claude', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static installCommand() {
+    return 'npm i -g @anthropic-ai/claude-code';
+  }
+
+  buildSpawnCommand(agent) {
+    // Claude Code interactive mode:
+    //   claude [options] [prompt]
+    //
+    // GROOVE spawns claude with:
+    //   --dangerously-skip-permissions  (autonomous operation)
+    //   --output-format stream-json     (structured stdout for parsing)
+    //   --verbose                       (richer output for journalist)
+    //
+    // The initial prompt is passed as a positional argument.
+    // GROOVE context is injected via an append-only section in CLAUDE.md.
+
+    const args = ['--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions'];
+
+    if (agent.model) {
+      args.push('--model', agent.model);
+    }
+
+    // Pass the initial prompt as positional arg (includes GROOVE context)
+    const fullPrompt = this.buildFullPrompt(agent);
+    if (fullPrompt) {
+      args.push(fullPrompt);
+    }
+
+    return {
+      command: 'claude',
+      args,
+      env: {},
+    };
+  }
+
+  buildHeadlessCommand(prompt, model) {
+    const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
+    if (model) args.push('--model', model);
+    return { command: 'claude', args, env: {} };
+  }
+
+  buildFullPrompt(agent) {
+    const parts = [];
+
+    // Inject GROOVE context so the agent knows its role and team
+    if (agent.introContext) {
+      parts.push(agent.introContext);
+    }
+
+    // User's actual task prompt
+    if (agent.prompt) {
+      parts.push(`## Your Task\n\n${agent.prompt}`);
+    }
+
+    // Scope awareness
+    if (agent.scope && agent.scope.length > 0) {
+      parts.push(
+        `## Scope Rules\n\nYou MUST only modify files matching these patterns: ${agent.scope.join(', ')}. ` +
+        `Do not touch files outside your scope — other agents own them.`
+      );
+    }
+
+    return parts.join('\n\n');
+  }
+
+  switchModel(agent, newModel) {
+    // Claude Code supports mid-session model switching
+    return true;
+  }
+
+  parseOutput(line) {
+    // Claude Code stream-json outputs one JSON object per line.
+    // Relevant message types:
+    //   { type: "assistant", message: {...}, session_id: "..." }
+    //   { type: "result", result: "...", session_id: "..." }
+    //   { type: "system", message: "..." }
+    const lines = line.split('\n').filter(Boolean);
+    const events = [];
+
+    for (const l of lines) {
+      try {
+        const data = JSON.parse(l);
+
+        if (data.type === 'assistant') {
+          events.push({
+            type: 'activity',
+            subtype: 'assistant',
+            data: data.message?.content || '',
+            tokensUsed: data.message?.usage?.output_tokens || 0,
+            model: data.message?.model,
+          });
+        } else if (data.type === 'result') {
+          events.push({
+            type: 'result',
+            data: data.result,
+            tokensUsed: data.total_cost_usd ? undefined : 0,
+            cost: data.total_cost_usd,
+            duration: data.duration_ms,
+            turns: data.num_turns,
+          });
+        } else if (data.type === 'system' && data.subtype === 'usage') {
+          // Use actual context window size from model metadata, not hardcoded 200K
+          // Opus has 1M, Sonnet/Haiku have 200K — rotation must account for this
+          const totalTokens = (data.usage?.cache_read_input_tokens || 0) + (data.usage?.input_tokens || 0);
+          const modelId = data.model || events.find((e) => e.model)?.model;
+          const modelMeta = ClaudeCodeProvider.models.find((m) => m.id === modelId);
+          const contextWindow = modelMeta?.contextWindow || 200_000;
+          events.push({
+            type: 'usage',
+            contextUsage: totalTokens > 0 ? totalTokens / contextWindow : undefined,
+          });
+        }
+      } catch {
+        // Not JSON — ignore raw text lines in stream-json mode
+      }
+    }
+
+    if (events.length === 0) return null;
+
+    // Merge events: accumulate tokens across all events in this chunk,
+    // but return the most significant event type (usage > result > activity)
+    const merged = events[events.length - 1];
+    let totalTokens = 0;
+    for (const e of events) {
+      if (e.tokensUsed > 0) totalTokens += e.tokensUsed;
+    }
+    if (totalTokens > 0) merged.tokensUsed = totalTokens;
+
+    return merged;
+  }
+
+  injectContext(agent, contextMarkdown) {
+    // For Claude Code, inject context by writing to a .groove/context/<agent>.md file
+    // and referencing it. Claude Code auto-reads CLAUDE.md, so we append there.
+    // But we don't want to pollute the user's CLAUDE.md permanently — we use
+    // the append-only GROOVE section approach.
+    return contextMarkdown;
+  }
+}

package/packages/daemon/src/providers/codex.js

@@ -0,0 +1,68 @@
+// GROOVE — Codex Provider (OpenAI)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execSync } from 'child_process';
+import { Provider } from './base.js';
+
+export class CodexProvider extends Provider {
+  static name = 'codex';
+  static displayName = 'Codex';
+  static command = 'codex';
+  static authType = 'api-key';
+  static envKey = 'OPENAI_API_KEY';
+  static models = [
+    { id: 'o3', name: 'o3', tier: 'heavy' },
+    { id: 'o4-mini', name: 'o4-mini', tier: 'medium' },
+  ];
+
+  static isInstalled() {
+    try {
+      execSync('which codex', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static installCommand() {
+    return 'npm i -g @openai/codex';
+  }
+
+  buildSpawnCommand(agent) {
+    const args = [];
+
+    if (agent.model) args.push('--model', agent.model);
+
+    // Codex uses full-auto approval mode for autonomous operation
+    args.push('--approval-mode', 'full-auto');
+
+    if (agent.prompt) args.push(agent.prompt);
+
+    return {
+      command: 'codex',
+      args,
+      env: agent.apiKey ? { OPENAI_API_KEY: agent.apiKey } : {},
+    };
+  }
+
+  buildHeadlessCommand(prompt, model) {
+    const args = ['exec', prompt];
+    if (model) args.push('--model', model);
+    return { command: 'codex', args, env: {} };
+  }
+
+  switchModel() {
+    return false; // Codex doesn't support mid-session model switch
+  }
+
+  parseOutput(line) {
+    // Codex outputs plain text by default
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+
+    return {
+      type: 'activity',
+      data: trimmed,
+    };
+  }
+}

package/packages/daemon/src/providers/gemini.js

@@ -0,0 +1,62 @@
+// GROOVE — Gemini CLI Provider (Google)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execSync } from 'child_process';
+import { Provider } from './base.js';
+
+export class GeminiProvider extends Provider {
+  static name = 'gemini';
+  static displayName = 'Gemini CLI';
+  static command = 'gemini';
+  static authType = 'api-key';
+  static envKey = 'GEMINI_API_KEY';
+  static models = [
+    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', tier: 'heavy' },
+    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', tier: 'medium' },
+  ];
+
+  static isInstalled() {
+    try {
+      execSync('which gemini', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static installCommand() {
+    return 'npm i -g @anthropic-ai/gemini-cli';
+  }
+
+  buildSpawnCommand(agent) {
+    const args = [];
+
+    if (agent.model) args.push('--model', agent.model);
+    if (agent.prompt) args.push(agent.prompt);
+
+    // Sandbox mode off for full filesystem access
+    args.push('--sandbox', 'false');
+
+    return {
+      command: 'gemini',
+      args,
+      env: agent.apiKey ? { GEMINI_API_KEY: agent.apiKey } : {},
+    };
+  }
+
+  buildHeadlessCommand(prompt, model) {
+    const args = ['-p', prompt];
+    if (model) args.push('--model', model);
+    return { command: 'gemini', args, env: {} };
+  }
+
+  switchModel() {
+    return false; // Gemini CLI doesn't support mid-session switch
+  }
+
+  parseOutput(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    return { type: 'activity', data: trimmed };
+  }
+}

package/packages/daemon/src/providers/index.js

@@ -0,0 +1,38 @@
+// GROOVE — Provider Registry
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { ClaudeCodeProvider } from './claude-code.js';
+import { CodexProvider } from './codex.js';
+import { GeminiProvider } from './gemini.js';
+import { AiderProvider } from './aider.js';
+import { OllamaProvider } from './ollama.js';
+
+const providers = {
+  'claude-code': new ClaudeCodeProvider(),
+  'codex': new CodexProvider(),
+  'gemini': new GeminiProvider(),
+  'aider': new AiderProvider(),
+  'ollama': new OllamaProvider(),
+};
+
+export function getProvider(name) {
+  return providers[name] || null;
+}
+
+export function listProviders() {
+  return Object.entries(providers).map(([key, p]) => ({
+    id: key,
+    name: p.constructor.displayName,
+    installed: p.constructor.isInstalled(),
+    authType: p.constructor.authType,
+    envKey: p.constructor.envKey || null,
+    models: p.constructor.models,
+    installCommand: p.constructor.installCommand(),
+    canHotSwap: p.switchModel ? p.switchModel() : false,
+    hardwareRequirements: p.constructor.hardwareRequirements?.() || null,
+  }));
+}
+
+export function getInstalledProviders() {
+  return listProviders().filter((p) => p.installed);
+}

package/packages/daemon/src/providers/ollama.js

@@ -0,0 +1,94 @@
+// GROOVE — Ollama Provider (Local Models)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execSync } from 'child_process';
+import { Provider } from './base.js';
+
+export class OllamaProvider extends Provider {
+  static name = 'ollama';
+  static displayName = 'Ollama (Local)';
+  static command = 'ollama';
+  static authType = 'local';
+  static models = [
+    { id: 'qwen2.5-coder:32b', name: 'Qwen 2.5 Coder 32B', tier: 'heavy' },
+    { id: 'qwen2.5-coder:7b', name: 'Qwen 2.5 Coder 7B', tier: 'medium' },
+    { id: 'codellama:13b', name: 'Code Llama 13B', tier: 'medium' },
+    { id: 'deepseek-coder-v2:16b', name: 'DeepSeek Coder V2', tier: 'medium' },
+  ];
+
+  static isInstalled() {
+    try {
+      execSync('which ollama', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static installCommand() {
+    return 'curl -fsSL https://ollama.ai/install.sh | sh';
+  }
+
+  static hardwareRequirements() {
+    return {
+      minRAM: 8,
+      recommendedRAM: 16,
+      gpuRecommended: true,
+      note: '7B models need ~8GB RAM, 32B models need ~24GB RAM',
+    };
+  }
+
+  static getInstalledModels() {
+    try {
+      const output = execSync('ollama list', { encoding: 'utf8' });
+      const lines = output.split('\n').slice(1).filter(Boolean);
+      return lines.map((line) => {
+        const parts = line.split(/\s+/);
+        return { name: parts[0], size: parts[1] };
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  buildSpawnCommand(agent) {
+    // Ollama works best via Aider as a frontend
+    // aider --model ollama/<model> gives a full coding experience
+    const model = agent.model || 'qwen2.5-coder:7b';
+
+    const args = [
+      '--model', `ollama/${model}`,
+      '--yes-always',
+      '--no-auto-commits',
+    ];
+
+    if (agent.prompt) {
+      args.push('--message', agent.prompt);
+    }
+
+    return {
+      command: 'aider',
+      args,
+      env: { OLLAMA_API_BASE: 'http://localhost:11434' },
+    };
+  }
+
+  buildHeadlessCommand(prompt, model) {
+    const m = model || 'qwen2.5-coder:7b';
+    return {
+      command: 'ollama',
+      args: ['run', m, prompt],
+      env: {},
+    };
+  }
+
+  switchModel() {
+    return false; // Needs rotation for model switch
+  }
+
+  parseOutput(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    return { type: 'activity', data: trimmed };
+  }
+}

package/packages/daemon/src/registry.js

@@ -0,0 +1,89 @@
+// GROOVE — Agent Registry
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+
+export class Registry extends EventEmitter {
+  constructor(state) {
+    super();
+    this.state = state;
+    this.agents = new Map();
+  }
+
+  add(config) {
+    const agent = {
+      id: randomUUID().slice(0, 8),
+      name: config.name || `${config.role}-${this.agents.size + 1}`,
+      role: config.role,
+      scope: config.scope || [],
+      provider: config.provider || 'claude-code',
+      model: config.model || null,
+      prompt: config.prompt || '',
+      permission: config.permission || 'full',
+      workingDir: config.workingDir || process.cwd(),
+      status: 'starting',
+      pid: null,
+      spawnedAt: new Date().toISOString(),
+      lastActivity: null,
+      tokensUsed: 0,
+      contextUsage: 0,
+    };
+
+    this.agents.set(agent.id, agent);
+    this.emit('change', this.getAll());
+    return agent;
+  }
+
+  get(id) {
+    return this.agents.get(id) || null;
+  }
+
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+
+  update(id, updates) {
+    const agent = this.agents.get(id);
+    if (!agent) return null;
+
+    // Only allow known fields to prevent prototype pollution
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'name', 'routingMode', 'routingReason'];
+    for (const key of Object.keys(updates)) {
+      if (SAFE_FIELDS.includes(key)) {
+        agent[key] = updates[key];
+      }
+    }
+    agent.lastActivity = new Date().toISOString();
+    this.emit('change', this.getAll());
+    return agent;
+  }
+
+  remove(id) {
+    const agent = this.agents.get(id);
+    if (!agent) return false;
+
+    this.agents.delete(id);
+    this.emit('change', this.getAll());
+    return true;
+  }
+
+  findByRole(role) {
+    return this.getAll().filter((a) => a.role === role);
+  }
+
+  findByProvider(provider) {
+    return this.getAll().filter((a) => a.provider === provider);
+  }
+
+  restore(agents) {
+    for (const agent of agents) {
+      agent.status = 'stopped';
+      agent.pid = null;
+      this.agents.set(agent.id, agent);
+    }
+    if (agents.length > 0) {
+      this.emit('change', this.getAll());
+    }
+  }
+}

package/packages/daemon/src/rotator.js

@@ -0,0 +1,185 @@
+// GROOVE — Context Rotation Engine
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { EventEmitter } from 'events';
+
+const DEFAULT_THRESHOLD = 0.75; // 75% context usage triggers rotation
+const CHECK_INTERVAL = 15_000; // Check every 15 seconds
+
+export class Rotator extends EventEmitter {
+  constructor(daemon) {
+    super();
+    this.daemon = daemon;
+    this.interval = null;
+    this.rotationHistory = []; // [{ agentId, agentName, oldTokens, timestamp, brief }]
+    this.rotating = new Set(); // Agent IDs currently being rotated
+    this.enabled = false;
+  }
+
+  start() {
+    if (this.interval) return;
+    this.enabled = true;
+    this.interval = setInterval(() => this.check(), CHECK_INTERVAL);
+    console.log('  Rotator started (auto-rotation enabled)');
+  }
+
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.enabled = false;
+  }
+
+  async check() {
+    const agents = this.daemon.registry.getAll();
+    const running = agents.filter((a) => a.status === 'running');
+
+    for (const agent of running) {
+      if (this.rotating.has(agent.id)) continue;
+
+      const threshold = this.daemon.adaptive
+        ? this.daemon.adaptive.getThreshold(agent.provider, agent.role)
+        : DEFAULT_THRESHOLD;
+
+      if (agent.contextUsage >= threshold) {
+        // Check for natural pause: if agent has been idle for >10s
+        const idleMs = agent.lastActivity
+          ? Date.now() - new Date(agent.lastActivity).getTime()
+          : Infinity;
+
+        if (idleMs > 10_000) {
+          console.log(`  Rotator: ${agent.name} at ${Math.round(agent.contextUsage * 100)}% — rotating`);
+          await this.rotate(agent.id);
+        }
+      }
+    }
+  }
+
+  async rotate(agentId, options = {}) {
+    const { registry, processes, journalist } = this.daemon;
+    const agent = registry.get(agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found`);
+    if (this.rotating.has(agentId)) throw new Error(`Agent ${agentId} is already rotating`);
+
+    this.rotating.add(agentId);
+
+    this.daemon.broadcast({
+      type: 'rotation:start',
+      agentId,
+      agentName: agent.name,
+    });
+
+    try {
+      // 1. Record adaptive session so rotation thresholds learn over time
+      const classifierEvents = this.daemon.classifier.agentWindows[agentId] || [];
+      if (classifierEvents.length > 0) {
+        const signals = this.daemon.adaptive.extractSignals(classifierEvents, agent.scope);
+        this.daemon.adaptive.recordSession(agent.provider, agent.role, signals);
+      }
+
+      // Clear classifier window for the old agent
+      this.daemon.classifier.clearAgent(agentId);
+
+      // 2. Generate handoff brief from Journalist
+      let brief = await journalist.generateHandoffBrief(agent);
+
+      // Append additional prompt if provided (used by instruct/continue endpoints)
+      if (options.additionalPrompt) {
+        brief = brief + '\n\n## User Instruction\n\n' + options.additionalPrompt;
+      }
+
+      // 3. Record rotation history
+      const record = {
+        agentId: agent.id,
+        agentName: agent.name,
+        role: agent.role,
+        provider: agent.provider,
+        oldTokens: agent.tokensUsed,
+        contextUsage: agent.contextUsage,
+        timestamp: new Date().toISOString(),
+      };
+
+      // 4. Kill/clean up the old agent
+      // processes.kill handles both alive and dead agents:
+      // - alive: sends SIGTERM, waits for exit, removes from registry
+      // - dead: just removes from registry and releases locks
+      await processes.kill(agentId);
+
+      // 5. Respawn with handoff brief as the prompt
+      // Preserve auto routing mode so the router re-evaluates on respawn
+      const routingMode = this.daemon.router.getMode(agentId);
+      const respawnModel = routingMode.mode === 'auto' ? 'auto' : agent.model;
+
+      const newAgent = await processes.spawn({
+        role: agent.role,
+        scope: agent.scope,
+        provider: agent.provider,
+        model: respawnModel,
+        prompt: brief,
+        permission: agent.permission || 'full',
+        workingDir: agent.workingDir,
+        name: agent.name, // Keep the same name for continuity
+      });
+
+      // Carry cumulative token stats so the dashboard shows lifetime totals
+      if (agent.tokensUsed > 0) {
+        registry.update(newAgent.id, { tokensUsed: agent.tokensUsed });
+      }
+
+      // Record rotation savings in token tracker
+      this.daemon.tokens.recordRotation(agent.id, agent.tokensUsed);
+      // Each rotation is a cold-start that the Journalist's handoff brief skips
+      this.daemon.tokens.recordColdStartSkipped();
+
+      record.newAgentId = newAgent.id;
+      record.newTokens = 0;
+      this.rotationHistory.push(record);
+
+      // Keep last 100 rotations
+      if (this.rotationHistory.length > 100) {
+        this.rotationHistory = this.rotationHistory.slice(-100);
+      }
+
+      this.daemon.broadcast({
+        type: 'rotation:complete',
+        agentId: newAgent.id,
+        agentName: newAgent.name,
+        oldAgentId: agentId,
+        tokensSaved: agent.tokensUsed,
+      });
+
+      this.emit('rotation', record);
+
+      return newAgent;
+    } catch (err) {
+      this.daemon.broadcast({
+        type: 'rotation:failed',
+        agentId,
+        error: err.message,
+      });
+      throw err;
+    } finally {
+      this.rotating.delete(agentId);
+    }
+  }
+
+  isRotating(agentId) {
+    return this.rotating.has(agentId);
+  }
+
+  getHistory() {
+    return this.rotationHistory;
+  }
+
+  getStats() {
+    const totalRotations = this.rotationHistory.length;
+    const totalTokensSaved = this.rotationHistory.reduce((sum, r) => sum + r.oldTokens, 0);
+    return {
+      enabled: this.enabled,
+      totalRotations,
+      totalTokensSaved,
+      rotating: Array.from(this.rotating),
+    };
+  }
+}