groove-dev 0.8.0 → 0.8.1

package/node_modules/@groove-dev/cli/bin/groove.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+// GROOVE CLI — Entry Point
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { program } from 'commander';
+import { start } from '../src/commands/start.js';
+import { stop } from '../src/commands/stop.js';
+import { spawn } from '../src/commands/spawn.js';
+import { kill } from '../src/commands/kill.js';
+import { agents } from '../src/commands/agents.js';
+import { status } from '../src/commands/status.js';
+import { nuke } from '../src/commands/nuke.js';
+import { rotate } from '../src/commands/rotate.js';
+import { teamSave, teamLoad, teamList, teamDelete, teamExport, teamImport } from '../src/commands/team.js';
+import { approvals, approve, reject } from '../src/commands/approve.js';
+import { providers, setKey } from '../src/commands/providers.js';
+import { configShow, configSet } from '../src/commands/config.js';
+
+program
+  .name('groove')
+  .description('Agent orchestration layer for AI coding tools')
+  .version('0.4.0');
+
+program
+  .command('start')
+  .description('Start the GROOVE daemon')
+  .option('-p, --port <port>', 'Port to run on', '31415')
+  .action(start);
+
+program
+  .command('stop')
+  .description('Stop the GROOVE daemon')
+  .action(stop);
+
+program
+  .command('spawn')
+  .description('Spawn a new AI agent')
+  .option('-r, --role <role>', 'Agent role (e.g., backend, frontend, devops)')
+  .option('-s, --scope <patterns...>', 'File scope patterns')
+  .option('-p, --provider <provider>', 'AI provider', 'claude-code')
+  .option('-m, --model <model>', 'Model to use')
+  .option('--prompt <prompt>', 'Initial prompt for the agent')
+  .action(spawn);
+
+program
+  .command('kill <id>')
+  .description('Kill a running agent')
+  .action(kill);
+
+program
+  .command('agents')
+  .description('List all agents')
+  .action(agents);
+
+program
+  .command('status')
+  .description('Show daemon status')
+  .action(status);
+
+program
+  .command('nuke')
+  .description('Kill all agents and stop the daemon')
+  .action(nuke);
+
+program
+  .command('rotate <id>')
+  .description('Rotate an agent (kill + respawn with fresh context)')
+  .action(rotate);
+
+// Teams
+const team = program.command('team').description('Manage saved agent teams');
+team.command('save <name>').description('Save current agents as a team').action(teamSave);
+team.command('load <name>').description('Load and spawn a saved team').action(teamLoad);
+team.command('list').description('List saved teams').action(teamList);
+team.command('delete <name>').description('Delete a saved team').action(teamDelete);
+team.command('export <name>').description('Export team as JSON').action(teamExport);
+team.command('import <file>').description('Import team from JSON file').action(teamImport);
+
+// Approvals
+program.command('approvals').description('List pending approvals').action(approvals);
+program.command('approve <id>').description('Approve a pending request').action(approve);
+program
+  .command('reject <id>')
+  .description('Reject a pending request')
+  .option('--reason <reason>', 'Rejection reason')
+  .action(reject);
+
+// Providers
+program.command('providers').description('List available AI providers').action(providers);
+program.command('set-key <provider> <key>').description('Set API key for a provider').action(setKey);
+
+// Config
+const config = program.command('config').description('View and modify configuration');
+config.command('show').description('Show current configuration').action(configShow);
+config.command('set <key> <value>').description('Set a configuration value').action(configSet);
+
+program.parse();

package/node_modules/@groove-dev/cli/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@groove-dev/cli",
+  "version": "0.8.1",
+  "description": "GROOVE CLI — manage AI coding agents from your terminal",
+  "license": "FSL-1.1-Apache-2.0",
+  "type": "module",
+  "bin": {
+    "groove": "./bin/groove.js"
+  },
+  "dependencies": {
+    "@groove-dev/daemon": "*",
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  }
+}

package/node_modules/@groove-dev/cli/src/client.js

@@ -0,0 +1,25 @@
+// GROOVE CLI — HTTP client for daemon communication
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+const BASE_URL = process.env.GROOVE_URL || 'http://localhost:31415';
+
+export async function apiCall(method, path, body) {
+  const url = `${BASE_URL}${path}`;
+  const options = {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+  };
+
+  if (body) {
+    options.body = JSON.stringify(body);
+  }
+
+  const res = await fetch(url, options);
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    throw new Error(err.error || `HTTP ${res.status}`);
+  }
+
+  return res.json();
+}

package/node_modules/@groove-dev/cli/src/commands/agents.js

@@ -0,0 +1,38 @@
+// GROOVE CLI — agents command
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+const STATUS_COLORS = {
+  running: 'green',
+  starting: 'yellow',
+  stopped: 'gray',
+  crashed: 'red',
+  completed: 'cyan',
+};
+
+export async function agents() {
+  try {
+    const list = await apiCall('GET', '/api/agents');
+
+    if (list.length === 0) {
+      console.log(chalk.dim('No agents running. Use `groove spawn` to start one.'));
+      return;
+    }
+
+    console.log(chalk.bold(`\n  GROOVE Agents (${list.length})\n`));
+
+    for (const a of list) {
+      const color = STATUS_COLORS[a.status] || 'white';
+      const statusBadge = chalk[color](`[${a.status}]`);
+      console.log(`  ${chalk.bold(a.name)} ${statusBadge}  ${chalk.dim(a.id)}`);
+      console.log(`    Role: ${a.role}  Provider: ${a.provider}  Scope: ${a.scope.join(', ') || '-'}`);
+      console.log(`    Tokens: ${a.tokensUsed}  Context: ${Math.round(a.contextUsage * 100)}%`);
+      console.log();
+    }
+  } catch {
+    console.error(chalk.red('Cannot connect to daemon. Is it running? Try: groove start'));
+    process.exit(1);
+  }
+}

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/daemon/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@groove-dev/daemon",
+  "version": "0.8.1",
+  "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"
+  }
+}