groove-dev 0.26.38 → 0.27.0

package/packages/daemon/src/mcp-manager.js

@@ -0,0 +1,270 @@
+// GROOVE — MCP Manager (Provider-Agnostic Integration Execution)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { spawn as cpSpawn } from 'child_process';
+
+const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_RETRIES = 3;
+
+export class McpManager {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.servers = new Map();
+    this._crashCounts = new Map();
+    this._nextId = 1;
+  }
+
+  async startServer(integrationId) {
+    if (this.servers.has(integrationId)) {
+      const existing = this.servers.get(integrationId);
+      if (existing.proc && !existing.proc.killed) {
+        return existing.tools;
+      }
+      this._cleanup(integrationId);
+    }
+
+    const entry = this.daemon.integrations.registry.find((s) => s.id === integrationId);
+    if (!entry) throw new Error(`Integration not found: ${integrationId}`);
+
+    if (!this.daemon.integrations._isInstalled(integrationId)) {
+      throw new Error(`Integration not installed: ${integrationId}`);
+    }
+
+    if ((this._crashCounts.get(integrationId) || 0) >= MAX_RETRIES) {
+      throw new Error(`Integration ${integrationId} crashed ${MAX_RETRIES} times — not restarting`);
+    }
+
+    const command = entry.command || 'npx';
+    const args = entry.args || ['-y', entry.npmPackage];
+
+    const env = { ...process.env };
+    const spawnEnv = this.daemon.integrations.getSpawnEnv([integrationId]);
+    Object.assign(env, spawnEnv);
+
+    const proc = cpSpawn(command, args, {
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: false,
+    });
+
+    const server = {
+      proc,
+      integrationId,
+      tools: [],
+      pending: new Map(),
+      buffer: '',
+      lastCall: Date.now(),
+      idleTimer: null,
+    };
+
+    this.servers.set(integrationId, server);
+
+    proc.stdout.on('data', (chunk) => {
+      server.buffer += chunk.toString();
+      this._processBuffer(server);
+    });
+
+    proc.stderr.on('data', (chunk) => {
+      console.log(`[Groove:MCP:${integrationId}] stderr: ${chunk.toString().slice(0, 200)}`);
+    });
+
+    proc.on('error', (err) => {
+      console.log(`[Groove:MCP:${integrationId}] Process error: ${err.message}`);
+      this._handleCrash(integrationId);
+    });
+
+    proc.on('exit', (code, signal) => {
+      console.log(`[Groove:MCP:${integrationId}] Process exited: code=${code} signal=${signal}`);
+      if ((code !== 0 && code !== null) || (code === null && signal)) {
+        this._handleCrash(integrationId);
+      }
+    });
+
+    const tools = await this._initialize(server);
+    server.tools = tools;
+    this._crashCounts.delete(integrationId);
+    this._resetIdleTimer(server);
+
+    console.log(`[Groove:MCP:${integrationId}] Started — ${tools.length} tools available`);
+    return tools;
+  }
+
+  stopServer(integrationId) {
+    const server = this.servers.get(integrationId);
+    if (!server) return;
+    this._cleanup(integrationId);
+    console.log(`[Groove:MCP:${integrationId}] Stopped`);
+  }
+
+  async execTool(integrationId, toolName, params) {
+    let server = this.servers.get(integrationId);
+    if (!server || server.proc.killed) {
+      await this.startServer(integrationId);
+      server = this.servers.get(integrationId);
+    }
+    if (!server) throw new Error(`Failed to start MCP server for ${integrationId}`);
+
+    server.lastCall = Date.now();
+    this._resetIdleTimer(server);
+
+    const id = this._nextId++;
+    const msg = {
+      jsonrpc: '2.0',
+      id,
+      method: 'tools/call',
+      params: { name: toolName, arguments: params || {} },
+    };
+
+    const result = await this._sendRequest(server, id, msg);
+
+    if (result.error) {
+      throw new Error(result.error.message || JSON.stringify(result.error));
+    }
+
+    return result.result;
+  }
+
+  async listTools(integrationId) {
+    const server = this.servers.get(integrationId);
+    if (server && !server.proc.killed && server.tools.length > 0) {
+      return server.tools;
+    }
+    return this.startServer(integrationId);
+  }
+
+  stopAll() {
+    for (const integrationId of this.servers.keys()) {
+      this._cleanup(integrationId);
+    }
+    console.log('[Groove:MCP] All servers stopped');
+  }
+
+  _processBuffer(server) {
+    const lines = server.buffer.split('\n');
+    server.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.id !== undefined && server.pending.has(msg.id)) {
+          const { resolve } = server.pending.get(msg.id);
+          server.pending.delete(msg.id);
+          resolve(msg);
+        }
+      } catch {
+        // Not JSON — ignore
+      }
+    }
+  }
+
+  _sendRequest(server, id, msg) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        server.pending.delete(id);
+        reject(new Error(`MCP request timed out (id=${id}, method=${msg.method})`));
+      }, 30_000);
+
+      server.pending.set(id, {
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve(result);
+        },
+      });
+
+      try {
+        server.proc.stdin.write(JSON.stringify(msg) + '\n');
+      } catch (err) {
+        clearTimeout(timeout);
+        server.pending.delete(id);
+        reject(new Error(`Failed to write to MCP server: ${err.message}`));
+      }
+    });
+  }
+
+  async _initialize(server) {
+    const initId = this._nextId++;
+    const initMsg = {
+      jsonrpc: '2.0',
+      id: initId,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'groove', version: '1.0.0' },
+      },
+    };
+
+    const initResp = await this._sendRequest(server, initId, initMsg);
+    if (initResp.error) {
+      throw new Error(initResp.error.message || 'MCP initialize failed');
+    }
+
+    const notif = { jsonrpc: '2.0', method: 'notifications/initialized' };
+    try {
+      server.proc.stdin.write(JSON.stringify(notif) + '\n');
+    } catch {
+      throw new Error('MCP server died during initialization');
+    }
+
+    const listId = this._nextId++;
+    const listMsg = {
+      jsonrpc: '2.0',
+      id: listId,
+      method: 'tools/list',
+      params: {},
+    };
+
+    const listResp = await this._sendRequest(server, listId, listMsg);
+    return listResp.result?.tools || [];
+  }
+
+  _handleCrash(integrationId) {
+    const server = this.servers.get(integrationId);
+    if (!server) return;
+
+    for (const [, { resolve }] of server.pending) {
+      resolve({ error: { message: 'MCP server crashed' } });
+    }
+    server.pending.clear();
+
+    const crashes = (this._crashCounts.get(integrationId) || 0) + 1;
+    this._crashCounts.set(integrationId, crashes);
+
+    if (crashes >= MAX_RETRIES) {
+      console.log(`[Groove:MCP:${integrationId}] Max retries reached (${crashes}/${MAX_RETRIES}) — giving up`);
+    } else {
+      console.log(`[Groove:MCP:${integrationId}] Crash ${crashes}/${MAX_RETRIES} — will restart on next call`);
+    }
+    this._cleanup(integrationId);
+  }
+
+  _resetIdleTimer(server) {
+    if (server.idleTimer) clearTimeout(server.idleTimer);
+    server.idleTimer = setTimeout(() => {
+      console.log(`[Groove:MCP:${server.integrationId}] Idle timeout — stopping`);
+      this.stopServer(server.integrationId);
+    }, IDLE_TIMEOUT_MS);
+  }
+
+  _cleanup(integrationId) {
+    const server = this.servers.get(integrationId);
+    if (!server) return;
+
+    if (server.idleTimer) clearTimeout(server.idleTimer);
+
+    for (const [, { resolve }] of server.pending) {
+      resolve({ error: { message: 'MCP server stopped' } });
+    }
+    server.pending.clear();
+
+    try {
+      if (server.proc && !server.proc.killed) {
+        server.proc.kill('SIGTERM');
+      }
+    } catch { /* ignore */ }
+
+    this.servers.delete(integrationId);
+  }
+}

package/packages/daemon/src/memory.js

@@ -0,0 +1,370 @@
+// GROOVE — Persistent Agent Memory (Layer 7)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Four file types, all in .groove/memory/:
+//   - project-constraints.md    Discovered project rules, do-not-touch, required patterns
+//   - handoff-chain/<role>.md   Cumulative rotation briefs (newest first, last 10 kept)
+//   - agent-discoveries.jsonl   Error→fix pairs (only successes stored)
+//   - agent-specializations.json Per-agent and per-project-role quality profiles
+//
+// Read by the introducer on every spawn so agent #50 knows what agent #1 learned.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, appendFileSync, statSync } from 'fs';
+import { resolve } from 'path';
+import { createHash } from 'crypto';
+
+const MAX_CONSTRAINTS = 50;
+const MAX_HANDOFF_ROTATIONS = 10;
+const MAX_DISCOVERIES = 1000;
+const HANDOFF_BRIEF_MAX_CHARS = 4000;
+
+function hashText(text) {
+  return createHash('sha1').update(text.trim().toLowerCase()).digest('hex').slice(0, 12);
+}
+
+function safeName(role) {
+  return (role || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40);
+}
+
+function truncate(text, max) {
+  if (!text || text.length <= max) return text || '';
+  return text.slice(0, max - 3) + '...';
+}
+
+export class MemoryStore {
+  constructor(grooveDir) {
+    this.memDir = resolve(grooveDir, 'memory');
+    this.constraintsPath = resolve(this.memDir, 'project-constraints.md');
+    this.handoffDir = resolve(this.memDir, 'handoff-chain');
+    this.discoveriesPath = resolve(this.memDir, 'agent-discoveries.jsonl');
+    this.specializationsPath = resolve(this.memDir, 'agent-specializations.json');
+    this._ensureDirs();
+  }
+
+  _ensureDirs() {
+    try {
+      mkdirSync(this.memDir, { recursive: true });
+      mkdirSync(this.handoffDir, { recursive: true });
+    } catch { /* best-effort */ }
+  }
+
+  // --- Project Constraints ---
+
+  listConstraints() {
+    if (!existsSync(this.constraintsPath)) return [];
+    try {
+      const content = readFileSync(this.constraintsPath, 'utf8');
+      const constraints = [];
+      const blocks = content.split(/\n(?=- )/); // each constraint starts with "- "
+      for (const block of blocks) {
+        const m = block.match(/^- \[([a-f0-9]+)\] \*([^*]+)\* (.+)$/s);
+        if (m) {
+          constraints.push({
+            hash: m[1],
+            category: m[2].trim(),
+            text: m[3].trim(),
+          });
+        }
+      }
+      return constraints;
+    } catch {
+      return [];
+    }
+  }
+
+  addConstraint({ text, category = 'general' }) {
+    if (!text || typeof text !== 'string') return { added: false, error: 'text required' };
+    const trimmed = text.trim();
+    if (trimmed.length < 3) return { added: false, error: 'text too short' };
+    if (trimmed.length > 500) return { added: false, error: 'text too long (max 500 chars)' };
+
+    const hash = hashText(trimmed);
+    const existing = this.listConstraints();
+    if (existing.some((c) => c.hash === hash)) {
+      return { added: false, hash, reason: 'duplicate' };
+    }
+
+    existing.push({ hash, category, text: trimmed });
+    // Keep most recent MAX_CONSTRAINTS
+    const pruned = existing.slice(-MAX_CONSTRAINTS);
+    this._writeConstraints(pruned);
+    return { added: true, hash };
+  }
+
+  removeConstraint(hash) {
+    const existing = this.listConstraints();
+    const filtered = existing.filter((c) => c.hash !== hash);
+    if (filtered.length === existing.length) return false;
+    this._writeConstraints(filtered);
+    return true;
+  }
+
+  _writeConstraints(constraints) {
+    const lines = [
+      '# Project Constraints',
+      `*Auto-managed by GROOVE memory (Layer 7). Last updated: ${new Date().toISOString()}*`,
+      '',
+    ];
+    for (const c of constraints) {
+      lines.push(`- [${c.hash}] *${c.category}* ${c.text}`);
+    }
+    lines.push('');
+    try {
+      writeFileSync(this.constraintsPath, lines.join('\n'));
+    } catch { /* best-effort */ }
+  }
+
+  getConstraintsMarkdown(maxChars = 4000) {
+    const constraints = this.listConstraints();
+    if (constraints.length === 0) return '';
+    const byCategory = {};
+    for (const c of constraints) {
+      byCategory[c.category] = byCategory[c.category] || [];
+      byCategory[c.category].push(c.text);
+    }
+    const lines = [];
+    for (const [cat, items] of Object.entries(byCategory)) {
+      lines.push(`**${cat}:**`);
+      for (const item of items) lines.push(`- ${item}`);
+      lines.push('');
+    }
+    return truncate(lines.join('\n').trim(), maxChars);
+  }
+
+  // --- Handoff Chain ---
+
+  _chainPath(role) {
+    return resolve(this.handoffDir, `${safeName(role)}.md`);
+  }
+
+  getHandoffChain(role) {
+    const path = this._chainPath(role);
+    if (!existsSync(path)) return [];
+    try {
+      const content = readFileSync(path, 'utf8');
+      const entries = [];
+      // Parse entries — each starts with "## Rotation N —"
+      // Body includes the header + all content up to (but not including) the
+      // trailing --- separator and the next entry.
+      const blocks = content.split(/\n(?=## Rotation )/);
+      for (const block of blocks) {
+        const headerMatch = block.match(/^## Rotation (\d+) —/);
+        if (!headerMatch) continue;
+        const body = block.replace(/\n---\s*$/, '').trim();
+        entries.push({
+          rotationN: parseInt(headerMatch[1], 10),
+          body,
+        });
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+
+  appendHandoffBrief(role, entry) {
+    if (!role || !entry) return false;
+    const chain = this.getHandoffChain(role);
+    const nextN = (chain[0]?.rotationN || 0) + 1;
+
+    const block = [
+      `## Rotation ${nextN} — ${entry.timestamp || new Date().toISOString()} (${entry.agentId || '?'} → ${entry.newAgentId || '?'})`,
+      `**Reason:** ${entry.reason || 'unknown'}`,
+      entry.oldTokens != null ? `**Tokens carried:** ${entry.oldTokens.toLocaleString()}` : '',
+      entry.contextUsage != null ? `**Context at rotation:** ${Math.round(entry.contextUsage * 100)}%` : '',
+      '',
+      '**Brief summary:**',
+      truncate(entry.brief || '(no brief)', HANDOFF_BRIEF_MAX_CHARS),
+      '',
+    ].filter(Boolean).join('\n');
+
+    // Prepend new entry (newest first), keep last N
+    const newChain = [{ rotationN: nextN, body: block }, ...chain].slice(0, MAX_HANDOFF_ROTATIONS);
+
+    const lines = [
+      `# ${role[0].toUpperCase() + role.slice(1)} Handoff Chain`,
+      `*Cumulative rotation briefs. Newest first. Last ${MAX_HANDOFF_ROTATIONS} kept.*`,
+      '',
+    ];
+    for (const e of newChain) {
+      lines.push(e.body || '');
+      lines.push('---');
+      lines.push('');
+    }
+
+    try {
+      writeFileSync(this._chainPath(role), lines.join('\n'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000) {
+    const chain = this.getHandoffChain(role);
+    if (chain.length === 0) return '';
+    const recent = chain.slice(0, count);
+    const out = recent.map((e) => e.body || '').join('\n\n---\n\n');
+    return truncate(out, maxChars);
+  }
+
+  listHandoffRoles() {
+    if (!existsSync(this.handoffDir)) return [];
+    try {
+      return readdirSync(this.handoffDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => f.replace(/\.md$/, ''));
+    } catch {
+      return [];
+    }
+  }
+
+  // --- Discoveries (error → fix pairs) ---
+
+  addDiscovery({ agentId, role, trigger, fix, outcome = 'success' }) {
+    if (!trigger || !fix) return { added: false, error: 'trigger and fix required' };
+    if (outcome !== 'success') return { added: false, reason: 'only successes stored' };
+
+    const entry = {
+      ts: new Date().toISOString(),
+      agentId: agentId || null,
+      role: role || 'unknown',
+      trigger: truncate(String(trigger).trim(), 300),
+      fix: truncate(String(fix).trim(), 500),
+      outcome,
+    };
+
+    // Dedup: same trigger+fix = skip
+    const existing = this.listDiscoveries({ limit: 200 });
+    const key = hashText(entry.trigger + '||' + entry.fix);
+    if (existing.some((d) => hashText(d.trigger + '||' + d.fix) === key)) {
+      return { added: false, reason: 'duplicate' };
+    }
+
+    try {
+      appendFileSync(this.discoveriesPath, JSON.stringify(entry) + '\n');
+      this._pruneDiscoveries();
+      return { added: true };
+    } catch (err) {
+      return { added: false, error: err.message };
+    }
+  }
+
+  listDiscoveries({ role, limit = 100 } = {}) {
+    if (!existsSync(this.discoveriesPath)) return [];
+    try {
+      const lines = readFileSync(this.discoveriesPath, 'utf8').split('\n').filter(Boolean);
+      const entries = [];
+      for (const line of lines) {
+        try {
+          const e = JSON.parse(line);
+          if (!role || e.role === role) entries.push(e);
+        } catch { /* skip malformed */ }
+      }
+      return entries.slice(-limit).reverse(); // newest first
+    } catch {
+      return [];
+    }
+  }
+
+  _pruneDiscoveries() {
+    if (!existsSync(this.discoveriesPath)) return;
+    try {
+      const stat = statSync(this.discoveriesPath);
+      // Only prune on larger files to avoid thrashing
+      if (stat.size < 50_000) return;
+      const lines = readFileSync(this.discoveriesPath, 'utf8').split('\n').filter(Boolean);
+      if (lines.length <= MAX_DISCOVERIES) return;
+      const kept = lines.slice(-MAX_DISCOVERIES);
+      writeFileSync(this.discoveriesPath, kept.join('\n') + '\n');
+    } catch { /* best-effort */ }
+  }
+
+  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000) {
+    const entries = this.listDiscoveries({ role, limit });
+    if (entries.length === 0) return '';
+    const lines = entries.map((d) => `- When \`${d.trigger}\` → fix: ${d.fix}`);
+    return truncate(lines.join('\n'), maxChars);
+  }
+
+  // --- Specializations ---
+
+  _loadSpecializations() {
+    if (!existsSync(this.specializationsPath)) {
+      return { perAgent: {}, perProjectRole: {} };
+    }
+    try {
+      const data = JSON.parse(readFileSync(this.specializationsPath, 'utf8'));
+      return {
+        perAgent: data.perAgent || {},
+        perProjectRole: data.perProjectRole || {},
+      };
+    } catch {
+      return { perAgent: {}, perProjectRole: {} };
+    }
+  }
+
+  _saveSpecializations(data) {
+    try {
+      writeFileSync(this.specializationsPath, JSON.stringify(data, null, 2));
+    } catch { /* best-effort */ }
+  }
+
+  updateSpecialization(agentId, { role, qualityScore, filesTouched, signals, threshold }) {
+    if (!agentId) return false;
+    const data = this._loadSpecializations();
+
+    const agentEntry = data.perAgent[agentId] || {
+      role: role || 'unknown',
+      sessionCount: 0,
+      avgQualityScore: 0,
+      qualityTotal: 0,
+      fileTouches: {},
+      signatureErrors: [],
+    };
+    agentEntry.sessionCount += 1;
+    if (typeof qualityScore === 'number') {
+      agentEntry.qualityTotal += qualityScore;
+      agentEntry.avgQualityScore = Math.round(agentEntry.qualityTotal / agentEntry.sessionCount);
+    }
+    if (Array.isArray(filesTouched)) {
+      for (const f of filesTouched) {
+        agentEntry.fileTouches[f] = (agentEntry.fileTouches[f] || 0) + 1;
+      }
+    }
+    if (role) agentEntry.role = role;
+    if (threshold != null) agentEntry.preferredThreshold = threshold;
+    data.perAgent[agentId] = agentEntry;
+
+    if (role) {
+      const roleEntry = data.perProjectRole[role] || {
+        sessionCount: 0,
+        avgQualityScore: 0,
+        qualityTotal: 0,
+        topFileChurn: {},
+      };
+      roleEntry.sessionCount += 1;
+      if (typeof qualityScore === 'number') {
+        roleEntry.qualityTotal += qualityScore;
+        roleEntry.avgQualityScore = Math.round(roleEntry.qualityTotal / roleEntry.sessionCount);
+      }
+      if (Array.isArray(filesTouched)) {
+        for (const f of filesTouched) {
+          roleEntry.topFileChurn[f] = (roleEntry.topFileChurn[f] || 0) + 1;
+        }
+      }
+      data.perProjectRole[role] = roleEntry;
+    }
+
+    this._saveSpecializations(data);
+    return true;
+  }
+
+  getSpecialization(agentId) {
+    return this._loadSpecializations().perAgent[agentId] || null;
+  }
+
+  getAllSpecializations() {
+    return this._loadSpecializations();
+  }
+}

package/packages/daemon/src/pm.js

@@ -54,7 +54,7 @@ Review: Is this within scope? Conflicts with other agents? Aligns with project?
 Respond in ONE line: APPROVED: <reason> or REJECTED: <reason>`;
 
     try {
-      const result = await this.daemon.journalist.callHeadless(prompt);
+      const result = await this.daemon.journalist.callHeadless(prompt, { trackAs: '__pm__' });
       const text = (result || '').trim();
       const approved = !text.toUpperCase().startsWith('REJECTED');
       const reason = text.replace(/^(APPROVED|REJECTED):?\s*/i, '').trim();