groove-dev 0.8.0 → 0.8.2

package/node_modules/@groove-dev/daemon/src/router.js

@@ -0,0 +1,132 @@
+// GROOVE — Adaptive Model Router
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { getProvider } from './providers/index.js';
+
+// Routing modes per agent
+const MODES = {
+  FIXED: 'fixed',     // User-selected model, no changes
+  AUTO: 'auto',       // GROOVE picks the model based on task tier
+  AUTO_FLOOR: 'auto-floor', // Auto, but never below a floor model
+};
+
+// Role-based tier hints for new agents with no classifier data yet
+const ROLE_HINTS = {
+  planner:   'heavy',    // Planning is foundational — needs deep reasoning
+  docs:      'light',
+  testing:   'medium',
+  backend:   'medium',
+  frontend:  'medium',
+  devops:    'medium',
+  fullstack: 'heavy',
+};
+
+export class ModelRouter {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.profilesPath = resolve(daemon.grooveDir, 'routing-profiles.json');
+    this.agentModes = {}; // agentId -> { mode, fixedModel, floorModel }
+    this.costLog = []; // [{ agentId, model, tokens, tier, timestamp }]
+    this.profiles = {};
+    this.loadProfiles();
+  }
+
+  loadProfiles() {
+    if (existsSync(this.profilesPath)) {
+      try {
+        this.profiles = JSON.parse(readFileSync(this.profilesPath, 'utf8'));
+      } catch {
+        this.profiles = {};
+      }
+    }
+  }
+
+  saveProfiles() {
+    writeFileSync(this.profilesPath, JSON.stringify(this.profiles, null, 2));
+  }
+
+  // Set routing mode for an agent
+  setMode(agentId, mode, options = {}) {
+    this.agentModes[agentId] = {
+      mode: mode || MODES.FIXED,
+      fixedModel: options.fixedModel || null,
+      floorModel: options.floorModel || null,
+    };
+  }
+
+  getMode(agentId) {
+    return this.agentModes[agentId] || { mode: MODES.FIXED, fixedModel: null, floorModel: null };
+  }
+
+  // Get the recommended model for an agent based on current task
+  recommend(agentId) {
+    const config = this.getMode(agentId);
+    const agent = this.daemon.registry.get(agentId);
+    if (!agent) return null;
+
+    const provider = getProvider(agent.provider);
+    if (!provider) return null;
+    const models = provider.constructor.models;
+
+    // Fixed mode — just return the locked model
+    if (config.mode === MODES.FIXED) {
+      const model = config.fixedModel
+        ? models.find((m) => m.id === config.fixedModel) || models[0]
+        : models[0];
+      return { model, mode: MODES.FIXED, reason: 'Fixed model' };
+    }
+
+    // Auto mode — use classifier
+    const classifier = this.daemon.classifier;
+    if (!classifier) {
+      return { model: models[0], mode: config.mode, reason: 'No classifier available' };
+    }
+
+    // Use role-based hint when classifier has no activity data yet
+    const hasData = classifier.agentWindows[agentId]?.length > 0;
+    if (!hasData && agent.role && ROLE_HINTS[agent.role]) {
+      const hintTier = ROLE_HINTS[agent.role];
+      const match = models.find((m) => m.tier === hintTier) || models[0];
+      return { model: match, mode: config.mode, reason: `Role hint: ${agent.role} → ${hintTier}` };
+    }
+
+    const rec = classifier.getRecommendation(agentId, models);
+
+    // Auto-with-floor — ensure we don't go below floor
+    if (config.mode === MODES.AUTO_FLOOR && config.floorModel) {
+      const floorIdx = models.findIndex((m) => m.id === config.floorModel);
+      const recIdx = models.findIndex((m) => m.id === rec.model.id);
+
+      // Higher index = cheaper model. If rec is cheaper than floor, use floor.
+      if (floorIdx >= 0 && recIdx > floorIdx) {
+        const floor = models[floorIdx];
+        return { model: floor, mode: MODES.AUTO_FLOOR, reason: `Floor: ${floor.name}` };
+      }
+    }
+
+    return { model: rec.model, mode: config.mode, reason: rec.reason };
+  }
+
+  // Record a routing decision for cost tracking
+  recordUsage(agentId, modelId, tokens, tier) {
+    this.costLog.push({
+      agentId,
+      model: modelId,
+      tokens,
+      tier,
+      timestamp: new Date().toISOString(),
+    });
+    // Keep last 1000 entries
+    if (this.costLog.length > 1000) this.costLog = this.costLog.slice(-1000);
+  }
+
+  getStatus() {
+    return {
+      agentModes: this.agentModes,
+      costLogSize: this.costLog.length,
+      modes: MODES,
+    };
+  }
+}

package/node_modules/@groove-dev/daemon/src/state.js

@@ -0,0 +1,34 @@
+// GROOVE — State Persistence
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+export class StateManager {
+  constructor(grooveDir) {
+    this.path = resolve(grooveDir, 'state.json');
+    this.data = {};
+  }
+
+  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));
+  }
+
+  get(key) {
+    return this.data[key];
+  }
+
+  set(key, value) {
+    this.data[key] = value;
+  }
+}

package/node_modules/@groove-dev/daemon/src/supervisor.js

@@ -0,0 +1,178 @@
+// GROOVE — QC Supervisor + Approval System
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+const QC_AUTO_SPAWN_THRESHOLD = 4; // Auto-spawn QC when this many agents running
+
+export class Supervisor {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.pendingApprovals = new Map();
+    this.resolvedApprovals = [];
+    this.counter = 0;
+    this.qcActive = false;
+    this.conflicts = [];
+  }
+
+  // --- Approval System ---
+
+  requestApproval(agentId, action) {
+    const id = `approval-${Date.now()}-${++this.counter}`;
+    const agent = this.daemon.registry?.get(agentId);
+
+    const approval = {
+      id,
+      agentId,
+      agentName: agent?.name || agentId,
+      action,
+      status: 'pending',
+      requestedAt: new Date().toISOString(),
+    };
+
+    this.pendingApprovals.set(id, approval);
+    this.daemon.broadcast({ type: 'approval:request', data: approval });
+    return approval;
+  }
+
+  approve(approvalId) {
+    const approval = this.pendingApprovals.get(approvalId);
+    if (!approval) return null;
+
+    approval.status = 'approved';
+    approval.resolvedAt = new Date().toISOString();
+    this.pendingApprovals.delete(approvalId);
+    this.resolvedApprovals.push(approval);
+    if (this.resolvedApprovals.length > 200) this.resolvedApprovals = this.resolvedApprovals.slice(-200);
+
+    this.daemon.broadcast({ type: 'approval:resolved', data: approval });
+    return approval;
+  }
+
+  reject(approvalId, reason) {
+    const approval = this.pendingApprovals.get(approvalId);
+    if (!approval) return null;
+
+    approval.status = 'rejected';
+    approval.reason = reason || '';
+    approval.resolvedAt = new Date().toISOString();
+    this.pendingApprovals.delete(approvalId);
+    this.resolvedApprovals.push(approval);
+    if (this.resolvedApprovals.length > 200) this.resolvedApprovals = this.resolvedApprovals.slice(-200);
+
+    this.daemon.broadcast({ type: 'approval:resolved', data: approval });
+    return approval;
+  }
+
+  getPending() {
+    return Array.from(this.pendingApprovals.values());
+  }
+
+  getResolved() {
+    return this.resolvedApprovals;
+  }
+
+  getApproval(id) {
+    return this.pendingApprovals.get(id) || this.resolvedApprovals.find((a) => a.id === id) || null;
+  }
+
+  // --- Conflict Detection ---
+
+  recordConflict(agentId, filePath, ownerId) {
+    const agent = this.daemon.registry?.get(agentId);
+    const owner = this.daemon.registry?.get(ownerId);
+
+    const conflict = {
+      timestamp: new Date().toISOString(),
+      agentId,
+      agentName: agent?.name || agentId,
+      filePath,
+      ownerId,
+      ownerName: owner?.name || ownerId,
+    };
+
+    this.conflicts.push(conflict);
+    if (this.conflicts.length > 200) this.conflicts = this.conflicts.slice(-200);
+
+    // Track in token savings
+    this.daemon.tokens?.recordConflictPrevented();
+
+    // Create an approval for the out-of-scope access
+    this.requestApproval(agentId, {
+      type: 'scope_violation',
+      description: `${agent?.name || agentId} tried to modify ${filePath} (owned by ${owner?.name || ownerId})`,
+      filePath,
+      ownerId,
+    });
+
+    // Update GROOVE_CONFLICTS.md
+    this.writeConflictsFile();
+
+    this.daemon.broadcast({
+      type: 'conflict:detected',
+      data: conflict,
+    });
+
+    return conflict;
+  }
+
+  getConflicts() {
+    return this.conflicts;
+  }
+
+  writeConflictsFile() {
+    if (!this.daemon.projectDir) return;
+    if (this.conflicts.length === 0) return;
+
+    const lines = [
+      `# GROOVE Conflicts Log`,
+      ``,
+      `*Auto-generated by QC Supervisor.*`,
+      ``,
+      `| Time | Agent | Attempted File | Owner | Status |`,
+      `|------|-------|---------------|-------|--------|`,
+    ];
+
+    for (const c of this.conflicts.slice(-50)) {
+      const time = new Date(c.timestamp).toLocaleTimeString();
+      lines.push(`| ${time} | ${c.agentName} | ${c.filePath} | ${c.ownerName} | blocked |`);
+    }
+
+    writeFileSync(resolve(this.daemon.projectDir, 'GROOVE_CONFLICTS.md'), lines.join('\n'));
+  }
+
+  // --- QC Auto-spawn ---
+
+  checkQcThreshold() {
+    if (this.qcActive) return false;
+
+    const running = this.daemon.registry?.getAll().filter(
+      (a) => a.status === 'running' && a.role !== 'qc'
+    ) || [];
+
+    if (running.length >= QC_AUTO_SPAWN_THRESHOLD) {
+      this.qcActive = true;
+      this.daemon.broadcast({
+        type: 'qc:activated',
+        agentCount: running.length,
+      });
+      return true;
+    }
+
+    return false;
+  }
+
+  isQcActive() {
+    return this.qcActive;
+  }
+
+  getStatus() {
+    return {
+      qcActive: this.qcActive,
+      pendingApprovals: this.getPending().length,
+      resolvedApprovals: this.resolvedApprovals.length,
+      conflicts: this.conflicts.length,
+    };
+  }
+}

package/node_modules/@groove-dev/daemon/src/teams.js

@@ -0,0 +1,203 @@
+// GROOVE — Teams (Saved Agent Configurations)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { validateTeamName, sanitizeForFilename, validateAgentConfig } from './validate.js';
+
+export class Teams {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.teamsDir = resolve(daemon.grooveDir, 'teams');
+    this.activeTeam = null; // Name of the currently active team
+    this.autoSave = false;
+
+    mkdirSync(this.teamsDir, { recursive: true });
+  }
+
+  // Save current agents as a team
+  save(name) {
+    validateTeamName(name);
+
+    const agents = this.daemon.registry.getAll();
+    if (agents.length === 0) throw new Error('No agents to save');
+
+    const team = {
+      name,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      agents: agents.map((a) => ({
+        role: a.role,
+        scope: a.scope,
+        provider: a.provider,
+        model: a.model,
+        prompt: a.prompt,
+        name: a.name,
+      })),
+    };
+
+    const path = resolve(this.teamsDir, `${this.sanitizeName(name)}.json`);
+    writeFileSync(path, JSON.stringify(team, null, 2));
+
+    this.activeTeam = name;
+    this.autoSave = true;
+
+    return team;
+  }
+
+  // Load a team — spawns all agents from config
+  async load(name) {
+    const team = this.get(name);
+    if (!team) throw new Error(`Team "${name}" not found`);
+
+    // Kill all running agents first
+    await this.daemon.processes.killAll();
+
+    // Clear registry of old entries
+    const old = this.daemon.registry.getAll();
+    for (const a of old) this.daemon.registry.remove(a.id);
+
+    // Spawn all agents from team config
+    const spawned = [];
+    for (const config of team.agents) {
+      try {
+        const agent = await this.daemon.processes.spawn(config);
+        spawned.push(agent);
+      } catch (err) {
+        console.error(`  Failed to spawn ${config.name || config.role}:`, err.message);
+      }
+    }
+
+    this.activeTeam = name;
+    this.autoSave = true;
+
+    this.daemon.broadcast({
+      type: 'team:loaded',
+      name,
+      agentCount: spawned.length,
+    });
+
+    return { name, agents: spawned };
+  }
+
+  // Get a team definition by name
+  get(name) {
+    const path = resolve(this.teamsDir, `${this.sanitizeName(name)}.json`);
+    if (!existsSync(path)) return null;
+    try {
+      return JSON.parse(readFileSync(path, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  // List all saved teams
+  list() {
+    if (!existsSync(this.teamsDir)) return [];
+
+    return readdirSync(this.teamsDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => {
+        try {
+          const data = JSON.parse(readFileSync(resolve(this.teamsDir, f), 'utf8'));
+          return {
+            name: data.name,
+            agents: data.agents?.length || 0,
+            createdAt: data.createdAt,
+            updatedAt: data.updatedAt,
+          };
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  }
+
+  // Delete a team
+  delete(name) {
+    const path = resolve(this.teamsDir, `${this.sanitizeName(name)}.json`);
+    if (!existsSync(path)) throw new Error(`Team "${name}" not found`);
+    unlinkSync(path);
+    if (this.activeTeam === name) {
+      this.activeTeam = null;
+      this.autoSave = false;
+    }
+    return true;
+  }
+
+  // Export team as portable JSON string
+  export(name) {
+    const team = this.get(name);
+    if (!team) throw new Error(`Team "${name}" not found`);
+    return JSON.stringify(team, null, 2);
+  }
+
+  // Import team from JSON string
+  import(jsonStr) {
+    let team;
+    try {
+      team = JSON.parse(jsonStr);
+    } catch {
+      throw new Error('Invalid JSON');
+    }
+
+    if (!team.name || !Array.isArray(team.agents)) {
+      throw new Error('Invalid team format: needs "name" and "agents" array');
+    }
+
+    validateTeamName(team.name);
+
+    if (team.agents.length > 20) {
+      throw new Error('Too many agents in team (max 20)');
+    }
+
+    // Validate each agent config
+    for (const a of team.agents) {
+      validateAgentConfig(a);
+    }
+
+    team.updatedAt = new Date().toISOString();
+    const path = resolve(this.teamsDir, `${this.sanitizeName(team.name)}.json`);
+    writeFileSync(path, JSON.stringify(team, null, 2));
+
+    return team;
+  }
+
+  // Auto-save: called when agents change while a team is active
+  onAgentChange() {
+    if (!this.activeTeam || !this.autoSave) return;
+
+    const agents = this.daemon.registry.getAll().filter(
+      (a) => a.status === 'running' || a.status === 'starting'
+    );
+
+    if (agents.length === 0) return;
+
+    const path = resolve(this.teamsDir, `${this.sanitizeName(this.activeTeam)}.json`);
+    if (!existsSync(path)) return;
+
+    try {
+      const team = JSON.parse(readFileSync(path, 'utf8'));
+      team.updatedAt = new Date().toISOString();
+      team.agents = agents.map((a) => ({
+        role: a.role,
+        scope: a.scope,
+        provider: a.provider,
+        model: a.model,
+        prompt: a.prompt,
+        name: a.name,
+      }));
+      writeFileSync(path, JSON.stringify(team, null, 2));
+    } catch {
+      // Non-critical — don't break the flow
+    }
+  }
+
+  getActiveTeam() {
+    return this.activeTeam;
+  }
+
+  sanitizeName(name) {
+    return sanitizeForFilename(name);
+  }
+}

package/node_modules/@groove-dev/daemon/src/terminal/base.js

@@ -0,0 +1,27 @@
+// GROOVE — Base Terminal Adapter
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export class TerminalAdapter {
+  static name = 'base';
+  static displayName = 'Base Terminal';
+
+  static isAvailable() {
+    return false;
+  }
+
+  createPane(options) {
+    throw new Error('Terminal adapter must implement createPane()');
+  }
+
+  closePane(paneId) {
+    throw new Error('Terminal adapter must implement closePane()');
+  }
+
+  sendKeys(paneId, keys) {
+    throw new Error('Terminal adapter must implement sendKeys()');
+  }
+
+  notify(message) {
+    // Default: no-op
+  }
+}

package/node_modules/@groove-dev/daemon/src/terminal/generic.js

@@ -0,0 +1,27 @@
+// GROOVE — Generic Terminal Adapter (fallback)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { TerminalAdapter } from './base.js';
+
+export class GenericTerminal extends TerminalAdapter {
+  static name = 'generic';
+  static displayName = 'Generic Terminal';
+
+  static isAvailable() {
+    return true; // Always available as fallback
+  }
+
+  createPane(options) {
+    // In generic mode, agents run as background processes
+    // managed directly by the ProcessManager
+    return { type: 'background', id: options.agentId };
+  }
+
+  closePane(paneId) {
+    // Process cleanup handled by ProcessManager
+  }
+
+  sendKeys(paneId, keys) {
+    // Not supported in generic mode
+  }
+}

package/node_modules/@groove-dev/daemon/src/terminal/tmux.js

@@ -0,0 +1,64 @@
+// GROOVE — tmux Terminal Adapter
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { execFileSync } from 'child_process';
+import { TerminalAdapter } from './base.js';
+
+export class TmuxTerminal extends TerminalAdapter {
+  static name = 'tmux';
+  static displayName = 'tmux';
+
+  static isAvailable() {
+    try {
+      execFileSync('which', ['tmux'], { stdio: 'ignore' });
+      return !!process.env.TMUX;
+    } catch {
+      return false;
+    }
+  }
+
+  createPane(options) {
+    try {
+      const output = execFileSync('tmux', [
+        'split-window', '-h', '-d', '-P', '-F', '#{pane_id}',
+        options.command || 'bash',
+      ], { encoding: 'utf8' }).trim();
+
+      return { type: 'tmux', paneId: output };
+    } catch (err) {
+      console.error('  tmux: Failed to create pane:', err.message);
+      return { type: 'background', id: options.agentId };
+    }
+  }
+
+  closePane(paneId) {
+    if (!this.isValidPaneId(paneId)) return;
+    try {
+      execFileSync('tmux', ['kill-pane', '-t', paneId], { stdio: 'ignore' });
+    } catch {
+      // Pane may already be closed
+    }
+  }
+
+  sendKeys(paneId, keys) {
+    if (!this.isValidPaneId(paneId)) return;
+    try {
+      execFileSync('tmux', ['send-keys', '-t', paneId, keys, 'Enter'], { stdio: 'ignore' });
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  notify(message) {
+    try {
+      execFileSync('tmux', ['display-message', String(message).slice(0, 200)], { stdio: 'ignore' });
+    } catch {
+      // tmux not available or not in session
+    }
+  }
+
+  isValidPaneId(paneId) {
+    // tmux pane IDs are like %0, %1, %12
+    return typeof paneId === 'string' && /^%\d+$/.test(paneId);
+  }
+}