groove-dev 0.8.0

package/packages/cli/src/commands/approve.js

@@ -0,0 +1,50 @@
+// GROOVE CLI — approve/reject commands
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function approvals() {
+  try {
+    const { pending, status } = await apiCall('GET', '/api/approvals');
+
+    if (pending.length === 0) {
+      console.log(chalk.dim('  No pending approvals.'));
+      return;
+    }
+
+    console.log(chalk.bold(`\n  Pending Approvals (${pending.length})\n`));
+    for (const a of pending) {
+      console.log(`  ${chalk.yellow(a.id)}`);
+      console.log(`    Agent: ${a.agentName}`);
+      console.log(`    Action: ${a.action?.description || a.action?.type || 'unknown'}`);
+      console.log(`    Time: ${new Date(a.requestedAt).toLocaleTimeString()}`);
+      console.log('');
+    }
+  } catch {
+    console.error(chalk.red('  Cannot connect to daemon.'));
+    process.exit(1);
+  }
+}
+
+export async function approve(id) {
+  try {
+    const result = await apiCall('POST', `/api/approvals/${id}/approve`);
+    console.log(chalk.green('  Approved:'), result.id);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}
+
+export async function reject(id, options) {
+  try {
+    const result = await apiCall('POST', `/api/approvals/${id}/reject`, {
+      reason: options.reason || '',
+    });
+    console.log(chalk.green('  Rejected:'), result.id);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/config.js

@@ -0,0 +1,35 @@
+// GROOVE CLI — config command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function configShow() {
+  try {
+    const status = await apiCall('GET', '/api/config');
+    console.log(chalk.bold('\n  GROOVE Configuration\n'));
+    for (const [key, value] of Object.entries(status)) {
+      console.log(`  ${chalk.dim(key.padEnd(24))} ${chalk.white(JSON.stringify(value))}`);
+    }
+    console.log('');
+  } catch {
+    console.error(chalk.red('  Cannot connect to daemon.'));
+    process.exit(1);
+  }
+}
+
+export async function configSet(key, value) {
+  try {
+    // Auto-parse numbers and booleans
+    let parsed = value;
+    if (value === 'true') parsed = true;
+    else if (value === 'false') parsed = false;
+    else if (!isNaN(value) && value !== '') parsed = Number(value);
+
+    await apiCall('PATCH', '/api/config', { [key]: parsed });
+    console.log(chalk.green(`  Set ${key} = ${JSON.stringify(parsed)}`));
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/kill.js

@@ -0,0 +1,15 @@
+// GROOVE CLI — kill command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function kill(id) {
+  try {
+    await apiCall('DELETE', `/api/agents/${id}`);
+    console.log(chalk.green('Killed agent:'), id);
+  } catch (err) {
+    console.error(chalk.red('Failed to kill:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/nuke.js

@@ -0,0 +1,19 @@
+// GROOVE CLI — nuke command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function nuke() {
+  try {
+    console.log(chalk.yellow('Nuking all agents...'));
+    await apiCall('DELETE', '/api/agents');
+
+    const status = await apiCall('GET', '/api/status');
+    process.kill(status.pid, 'SIGTERM');
+
+    console.log(chalk.green('All agents killed. Daemon stopped.'));
+  } catch {
+    console.log(chalk.yellow('No running daemon found.'));
+  }
+}

package/packages/cli/src/commands/providers.js

@@ -0,0 +1,40 @@
+// GROOVE CLI — providers command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function providers() {
+  try {
+    const list = await apiCall('GET', '/api/providers');
+
+    console.log(chalk.bold('\n  Available Providers\n'));
+
+    for (const p of list) {
+      const installed = p.installed ? chalk.green('installed') : chalk.red('not installed');
+      const authed = p.authType === 'local' || p.authType === 'subscription'
+        ? ''
+        : p.hasKey ? chalk.green(' (key set)') : chalk.yellow(' (no key)');
+
+      console.log(`  ${chalk.bold(p.name.padEnd(18))} ${installed}${authed}`);
+      console.log(`    Auth: ${p.authType}  Models: ${p.models.map(m => m.name).join(', ')}`);
+      if (!p.installed) {
+        console.log(`    Install: ${chalk.dim(p.installCommand)}`);
+      }
+      console.log('');
+    }
+  } catch {
+    console.error(chalk.red('  Cannot connect to daemon.'));
+    process.exit(1);
+  }
+}
+
+export async function setKey(provider, key) {
+  try {
+    const result = await apiCall('POST', `/api/credentials/${provider}`, { key });
+    console.log(chalk.green(`  Key set for ${provider}:`), result.masked);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/rotate.js

@@ -0,0 +1,16 @@
+// GROOVE CLI — rotate command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function rotate(id) {
+  try {
+    console.log(chalk.yellow(`  Rotating agent ${id}...`));
+    const newAgent = await apiCall('POST', `/api/agents/${id}/rotate`);
+    console.log(chalk.green(`  Rotated.`), `New session: ${chalk.bold(newAgent.name)} (${newAgent.id})`);
+  } catch (err) {
+    console.error(chalk.red('  Rotation failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/spawn.js

@@ -0,0 +1,91 @@
+// GROOVE CLI — spawn command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+import { apiCall } from '../client.js';
+
+const ROLE_PRESETS = {
+  backend:  { scope: ['src/api/**', 'src/server/**', 'src/lib/**', 'src/db/**'] },
+  frontend: { scope: ['src/components/**', 'src/views/**', 'src/pages/**', 'src/styles/**'] },
+  devops:   { scope: ['Dockerfile*', 'docker-compose*', '.github/**', 'infra/**'] },
+  testing:  { scope: ['tests/**', 'test/**', '**/*.test.*', '**/*.spec.*'] },
+  docs:     { scope: ['docs/**', '*.md', 'README*'] },
+  fullstack: { scope: [] },
+};
+
+export async function spawn(options) {
+  // If no role specified, run interactive picker
+  if (!options.role) {
+    return interactiveSpawn();
+  }
+
+  try {
+    const config = {
+      role: options.role,
+      scope: options.scope || ROLE_PRESETS[options.role]?.scope || [],
+      provider: options.provider || 'claude-code',
+      model: options.model || null,
+      prompt: options.prompt || null,
+    };
+
+    const agent = await apiCall('POST', '/api/agents', config);
+
+    console.log('');
+    console.log(chalk.green('  Agent spawned'));
+    console.log(`  Name:     ${chalk.bold(agent.name)}`);
+    console.log(`  ID:       ${chalk.dim(agent.id)}`);
+    console.log(`  Role:     ${agent.role}`);
+    console.log(`  Provider: ${agent.provider}`);
+    console.log(`  Scope:    ${agent.scope.length > 0 ? agent.scope.join(', ') : chalk.dim('unrestricted')}`);
+    if (agent.prompt) {
+      console.log(`  Prompt:   ${agent.prompt.slice(0, 60)}${agent.prompt.length > 60 ? '...' : ''}`);
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red('Failed to spawn:'), err.message);
+    process.exit(1);
+  }
+}
+
+async function interactiveSpawn() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((res) => rl.question(q, res));
+
+  console.log('');
+  console.log(chalk.bold('  GROOVE — Spawn Agent'));
+  console.log('');
+  console.log('  Available roles:');
+  for (const [role, preset] of Object.entries(ROLE_PRESETS)) {
+    const scope = preset.scope.length > 0 ? chalk.dim(preset.scope.join(', ')) : chalk.dim('unrestricted');
+    console.log(`    ${chalk.bold(role.padEnd(12))} ${scope}`);
+  }
+  console.log('');
+
+  const role = await ask('  Role: ');
+  if (!role.trim()) {
+    console.log(chalk.yellow('  Cancelled.'));
+    rl.close();
+    return;
+  }
+
+  const prompt = await ask('  Task prompt (optional): ');
+  rl.close();
+
+  const config = {
+    role: role.trim(),
+    scope: ROLE_PRESETS[role.trim()]?.scope || [],
+    provider: 'claude-code',
+    prompt: prompt.trim() || null,
+  };
+
+  try {
+    const agent = await apiCall('POST', '/api/agents', config);
+    console.log('');
+    console.log(chalk.green(`  Spawned ${chalk.bold(agent.name)}`), chalk.dim(`(${agent.id})`));
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/start.js

@@ -0,0 +1,31 @@
+// GROOVE CLI — start command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { Daemon } from '@groove-dev/daemon';
+import chalk from 'chalk';
+
+export async function start(options) {
+  console.log(chalk.bold('GROOVE') + ' starting daemon...');
+
+  try {
+    const daemon = new Daemon({ port: parseInt(options.port, 10) });
+
+    const shutdown = async () => {
+      console.log('\nShutting down...');
+      // Force exit after 3s if stop hangs
+      const forceTimer = setTimeout(() => process.exit(1), 3000);
+      forceTimer.unref();
+      try { await daemon.stop(); } catch { /* ignore */ }
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    await daemon.start();
+    console.log(chalk.green('Ready.') + ` Open http://localhost:${options.port} for the GUI.`);
+  } catch (err) {
+    console.error(chalk.red('Failed to start:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/status.js

@@ -0,0 +1,38 @@
+// GROOVE CLI — status command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function status() {
+  try {
+    const s = await apiCall('GET', '/api/status');
+    console.log('');
+    console.log(chalk.bold('  GROOVE Daemon'));
+    console.log('');
+    console.log(`  Status:   ${chalk.green('running')}`);
+    console.log(`  PID:      ${s.pid}`);
+    console.log(`  Port:     ${s.port}`);
+    console.log(`  Uptime:   ${formatUptime(s.uptime)}`);
+    console.log(`  Agents:   ${s.agents} total, ${s.running} running`);
+    console.log(`  Project:  ${s.projectDir}`);
+    console.log(`  GUI:      ${chalk.cyan(`http://localhost:${s.port}`)}`);
+    console.log('');
+  } catch {
+    console.log('');
+    console.log(chalk.bold('  GROOVE Daemon'));
+    console.log('');
+    console.log(`  Status:   ${chalk.red('not running')}`);
+    console.log(`  Start:    ${chalk.dim('groove start')}`);
+    console.log('');
+  }
+}
+
+function formatUptime(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  if (h > 0) return `${h}h ${m}m`;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}

package/packages/cli/src/commands/stop.js

@@ -0,0 +1,15 @@
+// GROOVE CLI — stop command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+export async function stop() {
+  try {
+    const status = await apiCall('GET', '/api/status');
+    process.kill(status.pid, 'SIGTERM');
+    console.log(chalk.green('GROOVE daemon stopped.'));
+  } catch {
+    console.log(chalk.yellow('No running daemon found.'));
+  }
+}

package/packages/cli/src/commands/team.js

@@ -0,0 +1,77 @@
+// GROOVE CLI — team commands
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { apiCall } from '../client.js';
+
+export async function teamSave(name) {
+  try {
+    const team = await apiCall('POST', '/api/teams', { name });
+    console.log(chalk.green(`  Saved team "${team.name}"`) + ` (${team.agents.length} agents)`);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}
+
+export async function teamLoad(name) {
+  try {
+    console.log(chalk.yellow(`  Loading team "${name}"...`));
+    const result = await apiCall('POST', `/api/teams/${encodeURIComponent(name)}/load`);
+    console.log(chalk.green(`  Loaded "${name}"`), `— ${result.agents.length} agents spawned`);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}
+
+export async function teamList() {
+  try {
+    const { teams, activeTeam } = await apiCall('GET', '/api/teams');
+    if (teams.length === 0) {
+      console.log(chalk.dim('  No saved teams. Use `groove team save "name"` to create one.'));
+      return;
+    }
+    console.log(chalk.bold(`\n  Saved Teams (${teams.length})\n`));
+    for (const t of teams) {
+      const active = t.name === activeTeam ? chalk.green(' (active)') : '';
+      console.log(`  ${chalk.bold(t.name)}${active}  — ${t.agents} agents — saved ${new Date(t.updatedAt).toLocaleDateString()}`);
+    }
+    console.log('');
+  } catch {
+    console.error(chalk.red('  Cannot connect to daemon.'));
+    process.exit(1);
+  }
+}
+
+export async function teamDelete(name) {
+  try {
+    await apiCall('DELETE', `/api/teams/${encodeURIComponent(name)}`);
+    console.log(chalk.green(`  Deleted team "${name}"`));
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}
+
+export async function teamExport(name) {
+  try {
+    const data = await apiCall('GET', `/api/teams/${encodeURIComponent(name)}/export`);
+    console.log(JSON.stringify(data, null, 2));
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}
+
+export async function teamImport(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const team = await apiCall('POST', '/api/teams/import', JSON.parse(content));
+    console.log(chalk.green(`  Imported team "${team.name}"`), `(${team.agents.length} agents)`);
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/daemon/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@groove-dev/daemon",
+  "version": "0.8.0",
+  "description": "GROOVE daemon — agent orchestration engine",
+  "license": "FSL-1.1-Apache-2.0",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "dev": "node --watch src/index.js",
+    "start": "node src/index.js",
+    "test": "node --test test/*.test.js"
+  },
+  "dependencies": {
+    "ws": "^8.17.0",
+    "express": "^4.21.0",
+    "minimatch": "^10.0.0"
+  }
+}