groove-dev 0.8.0

package/packages/daemon/src/credentials.js

@@ -0,0 +1,121 @@
+// GROOVE — Credential Storage (AES-256-GCM encrypted)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, writeFileSync, existsSync, chmodSync } from 'fs';
+import { resolve } from 'path';
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'crypto';
+import { hostname, homedir } from 'os';
+
+const ALGORITHM = 'aes-256-gcm';
+const SALT_PREFIX = 'groove-v1';
+
+export class CredentialStore {
+  constructor(grooveDir) {
+    this.path = resolve(grooveDir, 'credentials.json');
+    this.data = {};
+    this.encryptionKey = this.deriveKey();
+    this.load();
+  }
+
+  // Derive encryption key from machine-specific data
+  // Not unbreakable, but much better than base64 — credentials file is
+  // meaningless if copied to another machine or read without this process.
+  deriveKey() {
+    const machineId = `${SALT_PREFIX}:${homedir()}:${hostname()}`;
+    return scryptSync(machineId, 'groove-credential-salt', 32);
+  }
+
+  load() {
+    if (existsSync(this.path)) {
+      try {
+        this.data = JSON.parse(readFileSync(this.path, 'utf8'));
+      } catch {
+        this.data = {};
+      }
+    }
+  }
+
+  save() {
+    writeFileSync(this.path, JSON.stringify(this.data, null, 2));
+    try { chmodSync(this.path, 0o600); } catch { /* Windows */ }
+  }
+
+  setKey(provider, key) {
+    if (!provider || typeof provider !== 'string') throw new Error('Provider required');
+    if (!key || typeof key !== 'string') throw new Error('Key required');
+
+    this.data[provider] = {
+      key: this.encrypt(key),
+      setAt: new Date().toISOString(),
+    };
+    this.save();
+  }
+
+  getKey(provider) {
+    const entry = this.data[provider];
+    if (!entry) return null;
+    try {
+      return this.decrypt(entry.key);
+    } catch {
+      // Key was encrypted with different machine key, or corrupted
+      return null;
+    }
+  }
+
+  deleteKey(provider) {
+    delete this.data[provider];
+    this.save();
+  }
+
+  listProviders() {
+    return Object.entries(this.data).map(([provider, entry]) => {
+      const key = this.getKey(provider);
+      return {
+        provider,
+        setAt: entry.setAt,
+        masked: key ? this.mask(key) : '(unable to decrypt)',
+      };
+    });
+  }
+
+  hasKey(provider) {
+    return !!this.data[provider];
+  }
+
+  getEnvForProvider(provider, providerInfo) {
+    const key = this.getKey(provider);
+    if (!key || !providerInfo?.envKey) return {};
+    return { [providerInfo.envKey]: key };
+  }
+
+  encrypt(text) {
+    const iv = randomBytes(16);
+    const cipher = createCipheriv(ALGORITHM, this.encryptionKey, iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag();
+    // Format: iv:authTag:ciphertext
+    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+  }
+
+  decrypt(encoded) {
+    const parts = encoded.split(':');
+    if (parts.length !== 3) {
+      // Legacy base64 format — migrate on read
+      return Buffer.from(encoded, 'base64').toString('utf8');
+    }
+    const [ivHex, authTagHex, ciphertext] = parts;
+    const iv = Buffer.from(ivHex, 'hex');
+    const authTag = Buffer.from(authTagHex, 'hex');
+    const decipher = createDecipheriv(ALGORITHM, this.encryptionKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  }
+
+  mask(key) {
+    if (!key || key.length < 8) return '****';
+    return key.slice(0, 4) + '...' + key.slice(-4);
+  }
+}

package/packages/daemon/src/firstrun.js

@@ -0,0 +1,93 @@
+// GROOVE — First-Run Detection & Setup
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { listProviders } from './providers/index.js';
+
+const DEFAULT_CONFIG = {
+  version: '0.1.0',
+  port: 31415,
+  journalistInterval: 120,
+  rotationThreshold: 0.75,
+  autoRotation: true,
+  qcThreshold: 4,
+  maxAgents: 10,
+  defaultProvider: 'claude-code',
+};
+
+export function isFirstRun(grooveDir) {
+  return !existsSync(resolve(grooveDir, 'config.json'));
+}
+
+// Show welcome banner on every startup
+export function printWelcome(port) {
+  const providers = listProviders();
+  const installed = providers.filter((p) => p.installed);
+  const notInstalled = providers.filter((p) => !p.installed);
+
+  console.log('');
+  console.log('  ┌─────────────────────────────────────┐');
+  console.log('  │        Welcome to GROOVE            │');
+  console.log('  │  Agent orchestration for AI coding  │');
+  console.log('  └─────────────────────────────────────┘');
+  console.log('');
+
+  if (installed.length > 0) {
+    console.log(`  Providers (${installed.length} ready):`);
+    for (const p of installed) {
+      console.log(`    ✓ ${p.name}`);
+    }
+  } else {
+    console.log('  No AI providers detected.');
+    console.log('  Install at least one:  npm i -g @anthropic-ai/claude-code');
+  }
+
+  if (notInstalled.length > 0) {
+    console.log('');
+    console.log('  Available to install:');
+    for (const p of notInstalled) {
+      console.log(`    · ${p.name.padEnd(18)} ${p.installCommand}`);
+    }
+  }
+
+  console.log('');
+  console.log(`  GUI:   http://localhost:${port}`);
+  console.log('  Docs:  https://docs.groovedev.ai');
+  console.log('  GitHub: https://github.com/grooveai-dev/groove');
+  console.log('');
+}
+
+export function runFirstTimeSetup(grooveDir) {
+  // Write default config
+  const config = { ...DEFAULT_CONFIG };
+
+  // Auto-detect best default provider
+  const providers = listProviders();
+  const installed = providers.filter((p) => p.installed);
+  if (installed.length > 0) {
+    const preferred = ['claude-code', 'codex', 'gemini', 'aider', 'ollama'];
+    const best = preferred.find((id) => installed.some((p) => p.id === id));
+    if (best) config.defaultProvider = best;
+  }
+
+  writeFileSync(resolve(grooveDir, 'config.json'), JSON.stringify(config, null, 2));
+
+  return config;
+}
+
+export function loadConfig(grooveDir) {
+  const configPath = resolve(grooveDir, 'config.json');
+  if (!existsSync(configPath)) return { ...DEFAULT_CONFIG };
+
+  try {
+    const saved = JSON.parse(readFileSync(configPath, 'utf8'));
+    return { ...DEFAULT_CONFIG, ...saved };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(grooveDir, config) {
+  writeFileSync(resolve(grooveDir, 'config.json'), JSON.stringify(config, null, 2));
+}

package/packages/daemon/src/index.js

@@ -0,0 +1,208 @@
+// GROOVE Daemon — Entry Point
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { createServer } from 'http';
+import { resolve } from 'path';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { Registry } from './registry.js';
+import { createApi } from './api.js';
+import { ProcessManager } from './process.js';
+import { StateManager } from './state.js';
+import { Introducer } from './introducer.js';
+import { LockManager } from './lockmanager.js';
+import { Supervisor } from './supervisor.js';
+import { Journalist } from './journalist.js';
+import { TokenTracker } from './tokentracker.js';
+import { Rotator } from './rotator.js';
+import { AdaptiveThresholds } from './adaptive.js';
+import { Teams } from './teams.js';
+import { CredentialStore } from './credentials.js';
+import { TaskClassifier } from './classifier.js';
+import { ModelRouter } from './router.js';
+import { ProjectManager } from './pm.js';
+import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
+
+const DEFAULT_PORT = 31415;
+
+export { loadConfig, saveConfig } from './firstrun.js';
+
+export class Daemon {
+  constructor(options = {}) {
+    this.port = options.port !== undefined ? options.port : (parseInt(process.env.GROOVE_PORT, 10) || DEFAULT_PORT);
+    this.projectDir = options.projectDir || process.cwd();
+    this.grooveDir = options.grooveDir || resolve(this.projectDir, '.groove');
+    this.pidFile = resolve(this.grooveDir, 'daemon.pid');
+
+    // Ensure .groove directories exist
+    mkdirSync(resolve(this.grooveDir, 'logs'), { recursive: true });
+    mkdirSync(resolve(this.grooveDir, 'context'), { recursive: true });
+
+    // Initialize coordination file for agent knock protocol
+    const coordPath = resolve(this.grooveDir, 'coordination.md');
+    if (!existsSync(coordPath)) {
+      writeFileSync(coordPath, '# GROOVE Coordination\n\n*Agents write their intent here before shared/destructive actions.*\n\n<!-- No active operations -->\n');
+    }
+
+    // First-run detection
+    if (isFirstRun(this.grooveDir)) {
+      this.config = runFirstTimeSetup(this.grooveDir);
+    } else {
+      this.config = loadConfig(this.grooveDir);
+    }
+
+    // Initialize core components
+    this.state = new StateManager(this.grooveDir);
+    this.registry = new Registry(this.state);
+    this.locks = new LockManager(this.grooveDir);
+    this.tokens = new TokenTracker(this.grooveDir);
+    this.processes = new ProcessManager(this);
+    this.introducer = new Introducer(this);
+    this.supervisor = new Supervisor(this);
+    this.journalist = new Journalist(this);
+    this.rotator = new Rotator(this);
+    this.adaptive = new AdaptiveThresholds(this.grooveDir);
+    this.teams = new Teams(this);
+    this.credentials = new CredentialStore(this.grooveDir);
+    this.classifier = new TaskClassifier();
+    this.router = new ModelRouter(this);
+    this.pm = new ProjectManager(this);
+
+    // HTTP + WebSocket server
+    this.app = express();
+    this.server = createServer(this.app);
+    this.wss = new WebSocketServer({
+      server: this.server,
+      maxPayload: 1024 * 1024, // 1MB max message
+      verifyClient: ({ req }) => {
+        const origin = req.headers.origin;
+        // Allow: no origin (CLI/native clients), localhost origins
+        if (!origin) return true;
+        const allowed = [
+          `http://localhost:${this.port}`,
+          `http://127.0.0.1:${this.port}`,
+          'http://localhost:3142',
+        ];
+        return allowed.includes(origin);
+      },
+    });
+
+    // Wire up API routes
+    createApi(this.app, this);
+
+    // Broadcast registry changes over WebSocket
+    this.registry.on('change', () => {
+      this.broadcast({ type: 'state', data: this.registry.getAll() });
+    });
+
+    // Send full state to new WebSocket clients
+    this.wss.on('connection', (ws) => {
+      ws.send(JSON.stringify({
+        type: 'state',
+        data: this.registry.getAll(),
+      }));
+    });
+
+    // Auto-update AGENTS_REGISTRY.md and CLAUDE.md GROOVE section on changes
+    this.registry.on('change', () => {
+      this.introducer.writeRegistryFile(this.projectDir);
+      this.introducer.injectGrooveSection(this.projectDir);
+      this.teams.onAgentChange();
+      this.supervisor.checkQcThreshold();
+    });
+  }
+
+  broadcast(message) {
+    const payload = JSON.stringify(message);
+    for (const client of this.wss.clients) {
+      if (client.readyState === 1) {
+        client.send(payload);
+      }
+    }
+  }
+
+  async start() {
+    // Check for existing daemon
+    if (existsSync(this.pidFile)) {
+      const existingPid = parseInt(readFileSync(this.pidFile, 'utf8'), 10);
+      try {
+        process.kill(existingPid, 0); // Signal 0 = check if alive
+        console.error(`GROOVE daemon already running (PID ${existingPid})`);
+        process.exit(1);
+      } catch {
+        // PID file is stale — previous daemon crashed
+        unlinkSync(this.pidFile);
+      }
+    }
+
+    // Restore persisted state
+    this.state.load();
+    this.registry.restore(this.state.get('agents') || []);
+
+    return new Promise((resolvePromise) => {
+      this.server.listen(this.port, '127.0.0.1', () => {
+        writeFileSync(this.pidFile, String(process.pid));
+
+        printWelcome(this.port);
+
+        // Start background services
+        this.journalist.start();
+        this.rotator.start();
+
+        resolvePromise(this);
+      });
+    });
+  }
+
+  async stop() {
+    // Persist state before shutdown
+    this.state.set('agents', this.registry.getAll());
+    this.state.save();
+
+    // Stop background services
+    this.journalist.stop();
+    this.rotator.stop();
+
+    // Kill all agent processes
+    await this.processes.killAll();
+
+    // Clean up PID file
+    if (existsSync(this.pidFile)) {
+      unlinkSync(this.pidFile);
+    }
+
+    // Clean up generated files
+    const registryPath = resolve(this.projectDir, 'AGENTS_REGISTRY.md');
+    if (existsSync(registryPath)) {
+      unlinkSync(registryPath);
+    }
+    this.introducer.removeGrooveSection(this.projectDir);
+
+    // Close server
+    return new Promise((resolvePromise) => {
+      this.wss.close(() => {
+        this.server.close(() => {
+          console.log('GROOVE daemon stopped.');
+          resolvePromise();
+        });
+      });
+    });
+  }
+}
+
+// Start daemon if run directly
+const isDirectRun = process.argv[1] && import.meta.url === `file://${process.argv[1]}`;
+if (isDirectRun) {
+  const daemon = new Daemon();
+
+  const shutdown = async () => {
+    await daemon.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  daemon.start();
+}

package/packages/daemon/src/introducer.js

@@ -0,0 +1,238 @@
+// GROOVE — Introduction Protocol
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { escapeMd } from './validate.js';
+
+const GROOVE_SECTION_START = '<!-- GROOVE:START -->';
+const GROOVE_SECTION_END = '<!-- GROOVE:END -->';
+
+export class Introducer {
+  constructor(daemon) {
+    this.daemon = daemon;
+  }
+
+  generateContext(newAgent, options = {}) {
+    const { taskNegotiation } = options;
+    const agents = this.daemon.registry.getAll();
+    // Include ALL agents (running + completed) so new agents know what the team did
+    const others = agents.filter((a) => a.id !== newAgent.id &&
+      (a.status === 'running' || a.status === 'starting' || a.status === 'completed'));
+
+    const lines = [
+      `# GROOVE Agent Context`,
+      ``,
+      `You are **${newAgent.name}** (role: ${newAgent.role}), managed by GROOVE.`,
+    ];
+
+    if (newAgent.scope && newAgent.scope.length > 0) {
+      lines.push(`Your file scope: \`${newAgent.scope.join('`, `')}\``);
+    } else {
+      lines.push(`You have no file scope restrictions.`);
+    }
+
+    lines.push('');
+
+    if (others.length === 0) {
+      lines.push('You are the only agent on this project right now.');
+    } else {
+      lines.push(`## Team (${others.length} other agent${others.length > 1 ? 's' : ''})`);
+      lines.push('');
+
+      // Collect all files created by teammates for the project files section
+      const allTeamFiles = [];
+
+      for (const other of others) {
+        const scope = other.scope?.length > 0 ? other.scope.join(', ') : 'unrestricted';
+        lines.push(`- **${other.name}** (${other.role}) — scope: ${scope} — ${other.status}`);
+
+        // Get files this agent created/modified
+        const files = this.daemon.journalist?.getAgentFiles(other) || [];
+        if (files.length > 0) {
+          const shown = files.slice(0, 15);
+          lines.push(`  Files: ${shown.join(', ')}${files.length > 15 ? ` (+${files.length - 15} more)` : ''}`);
+          for (const f of files) {
+            allTeamFiles.push({ file: f, agent: other.name, role: other.role });
+          }
+        }
+
+        // For completed agents, include their final result summary
+        if (other.status === 'completed') {
+          const result = this.daemon.journalist?.getAgentResult(other) || '';
+          if (result) {
+            lines.push(`  Result: ${result.slice(0, 500)}`);
+          }
+        }
+      }
+
+      lines.push('');
+      lines.push(`## Coordination Rules`);
+      lines.push('');
+      lines.push(`- Stay within your file scope. Do NOT modify files owned by other agents.`);
+      lines.push(`- If you need changes outside your scope, document what you need — GROOVE will coordinate.`);
+      lines.push(`- Check AGENTS_REGISTRY.md for the latest team state.`);
+
+      // Project files section — tell the new agent what exists and what to read
+      if (allTeamFiles.length > 0) {
+        lines.push('');
+        lines.push(`## Project Files`);
+        lines.push('');
+        lines.push(`Your team has created the following files. **Read relevant ones before starting work** to understand what's been built and planned:`);
+        lines.push('');
+
+        // Group by agent for clarity
+        const byAgent = {};
+        for (const { file, agent, role } of allTeamFiles) {
+          const key = `${agent} (${role})`;
+          if (!byAgent[key]) byAgent[key] = [];
+          byAgent[key].push(file);
+        }
+        for (const [agent, files] of Object.entries(byAgent)) {
+          lines.push(`**${agent}:**`);
+          for (const f of files.slice(0, 20)) {
+            lines.push(`- ${f}`);
+          }
+        }
+      }
+    }
+
+    // Task negotiation — when a duplicate role joins, include the work division
+    if (taskNegotiation) {
+      lines.push('');
+      lines.push(`## Task Assignment`);
+      lines.push('');
+      lines.push(`A task coordinator has analyzed the current team's work and assigned your focus area:`);
+      lines.push('');
+      lines.push(taskNegotiation);
+      lines.push('');
+      lines.push(`**Follow this assignment.** Focus on your assigned tasks and do NOT modify files that other same-role agents are actively working on.`);
+    }
+
+    // Knock protocol — coordination for destructive/shared actions
+    const running = others.filter((a) => a.status === 'running' || a.status === 'starting');
+    if (running.length > 0) {
+      lines.push('');
+      lines.push(`## Coordination Protocol`);
+      lines.push('');
+      lines.push(`Before performing shared/destructive actions (restart server, npm install/build, modify package.json, modify shared config), coordinate with your team:`);
+      lines.push(`1. Read \`.groove/coordination.md\` to check for active operations`);
+      lines.push(`2. Write your intent to \`.groove/coordination.md\` (e.g., "backend-1: restarting server")`);
+      lines.push(`3. Proceed only if no conflicting operations are active`);
+      lines.push(`4. Clear your entry from \`.groove/coordination.md\` when done`);
+    }
+
+    // Memory containment — prevent agents from reading/writing auto-memory
+    // which can contain stale context from unrelated sessions in the same dir
+    lines.push('');
+    lines.push(`## Memory Policy`);
+    lines.push('');
+    lines.push(`Ignore auto-memory. Do NOT read or write MEMORY.md or any files in the auto-memory directory.`);
+    lines.push(`GROOVE provides all your project context through handoff briefs, AGENTS_REGISTRY.md, and GROOVE_PROJECT_MAP.md.`);
+    lines.push(`Do NOT save memories — your state is managed by GROOVE's rotation and handoff system.`);
+
+    // Add reference to project map if it exists
+    const mapPath = resolve(this.daemon.projectDir, 'GROOVE_PROJECT_MAP.md');
+    if (existsSync(mapPath)) {
+      lines.push('');
+      lines.push(`Read GROOVE_PROJECT_MAP.md for current project context from The Journalist.`);
+    }
+
+    return lines.join('\n');
+  }
+
+  writeRegistryFile(projectDir) {
+    const agents = this.daemon.registry.getAll();
+
+    if (agents.length === 0) {
+      // Clean up if no agents
+      const regPath = resolve(projectDir, 'AGENTS_REGISTRY.md');
+      if (existsSync(regPath)) {
+        writeFileSync(regPath, '');
+      }
+      return;
+    }
+
+    const lines = [
+      `# AGENTS REGISTRY`,
+      ``,
+      `*Auto-generated by GROOVE. Do not edit manually.*`,
+      ``,
+      `| ID | Name | Role | Provider | Scope | Status |`,
+      `|----|------|------|----------|-------|--------|`,
+    ];
+
+    for (const a of agents) {
+      const scope = a.scope?.length > 0 ? `\`${a.scope.join('`, `')}\`` : '-';
+      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${scope} | ${escapeMd(a.status)} |`);
+    }
+
+    lines.push('');
+    lines.push(`*Updated: ${new Date().toISOString()}*`);
+
+    writeFileSync(resolve(projectDir, 'AGENTS_REGISTRY.md'), lines.join('\n'));
+  }
+
+  injectGrooveSection(projectDir) {
+    // Inject a GROOVE section into the project's CLAUDE.md.
+    // This section is delimited by markers so we can update it without
+    // clobbering the user's content.
+    const claudeMdPath = resolve(projectDir, 'CLAUDE.md');
+    const agents = this.daemon.registry.getAll();
+    const running = agents.filter((a) => a.status === 'running');
+
+    const grooveContent = [
+      GROOVE_SECTION_START,
+      '',
+      '## GROOVE Orchestration (auto-injected)',
+      '',
+      `Active agents: ${running.length}`,
+      '',
+      running.length > 0 ? '| Name | Role | Scope |' : '',
+      running.length > 0 ? '|------|------|-------|' : '',
+      ...running.map((a) => `| ${a.name} | ${a.role} | ${a.scope?.join(', ') || '-'} |`),
+      '',
+      `See AGENTS_REGISTRY.md for full agent state.`,
+      '',
+      `**Memory policy:** Ignore auto-memory. Do not read or write MEMORY.md. GROOVE manages all context.`,
+      '',
+      GROOVE_SECTION_END,
+    ].filter(Boolean).join('\n');
+
+    if (!existsSync(claudeMdPath)) {
+      return; // Don't create CLAUDE.md — it's the user's file
+    }
+
+    let content = readFileSync(claudeMdPath, 'utf8');
+
+    const startIdx = content.indexOf(GROOVE_SECTION_START);
+    const endIdx = content.indexOf(GROOVE_SECTION_END);
+
+    if (startIdx !== -1 && endIdx !== -1) {
+      // Replace existing GROOVE section
+      content = content.slice(0, startIdx) + grooveContent + content.slice(endIdx + GROOVE_SECTION_END.length);
+    } else {
+      // Append GROOVE section
+      content = content.trimEnd() + '\n\n' + grooveContent + '\n';
+    }
+
+    writeFileSync(claudeMdPath, content);
+  }
+
+  removeGrooveSection(projectDir) {
+    const claudeMdPath = resolve(projectDir, 'CLAUDE.md');
+    if (!existsSync(claudeMdPath)) return;
+
+    let content = readFileSync(claudeMdPath, 'utf8');
+    const startIdx = content.indexOf(GROOVE_SECTION_START);
+    const endIdx = content.indexOf(GROOVE_SECTION_END);
+
+    if (startIdx !== -1 && endIdx !== -1) {
+      // Remove the GROOVE section and any surrounding blank lines
+      const before = content.slice(0, startIdx).replace(/\n+$/, '');
+      const after = content.slice(endIdx + GROOVE_SECTION_END.length).replace(/^\n+/, '');
+      content = before + (after ? '\n\n' + after : '') + '\n';
+      writeFileSync(claudeMdPath, content);
+    }
+  }
+}