groove-dev 0.27.143 → 0.27.145

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

@@ -89,27 +89,10 @@ export class ConversationManager {
     const id = randomUUID().slice(0, 12);
     const now = new Date().toISOString();
 
-    let agentId = null;
-
-    if (mode === 'agent') {
-      const defaultTeam = this.daemon.teams.getDefault();
-      const workingDir = defaultTeam?.workingDir || this.daemon.projectDir;
-
-      const agent = await this.daemon.processes.spawn({
-        role: 'chat',
-        provider,
-        model: model || null,
-        workingDir,
-        teamId: defaultTeam?.id || null,
-        permission: 'full',
-      });
-      agentId = agent.id;
-    }
-
     const conversation = {
       id,
       title: title || 'New Chat',
-      agentId,
+      agentId: null,
       provider,
       model: model || null,
       mode: mode === 'agent' ? 'agent' : 'api',
@@ -265,35 +248,7 @@ export class ConversationManager {
     this._modeChanging.add(id);
 
     try {
-      if (mode === 'agent') {
-        const existingAgent = conv.agentId ? this.daemon.registry.get(conv.agentId) : null;
-        const alive = existingAgent && (existingAgent.status === 'running' || existingAgent.status === 'starting');
-
-        if (!alive) {
-          const defaultTeam = this.daemon.teams.getDefault();
-          const workingDir = defaultTeam?.workingDir || this.daemon.projectDir;
-          const agent = await this.daemon.processes.spawn({
-            role: 'chat',
-            provider: conv.provider,
-            model: conv.model || null,
-            workingDir,
-            teamId: defaultTeam?.id || null,
-            permission: 'full',
-          });
-          conv.agentId = agent.id;
-        }
-      } else {
-        // Switching to API mode — kill the agent if running
-        this._killStreamingProcess(id);
-        if (conv.agentId) {
-          const agent = this.daemon.registry.get(conv.agentId);
-          if (agent && (agent.status === 'running' || agent.status === 'starting')) {
-            try { await this.daemon.processes.kill(conv.agentId); } catch { /* ignore */ }
-          }
-          if (agent) this.daemon.registry.remove(conv.agentId);
-          conv.agentId = null;
-        }
-      }
+      this._killStreamingProcess(id);
 
       conv.mode = mode;
       conv.updatedAt = new Date().toISOString();
@@ -354,7 +309,6 @@ export class ConversationManager {
   async sendMessage(id, message, history, { reasoningEffort, verbosity } = {}) {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
-    if (conv.mode !== 'api') throw new Error('sendMessage only works in API mode');
 
     this._killStreamingProcess(id);
 
@@ -395,6 +349,17 @@ export class ConversationManager {
       try { tcAgentId = tc.onChatTurnStart(id, providerName, modelId, message); } catch { /* never block chat */ }
     }
 
+    // Agent mode prefers headless CLI (has tools + web search), falls back to API
+    if (conv.mode === 'agent') {
+      const headlessCmd = provider.buildHeadlessCommand(
+        this._buildHistoryPrompt(history, message), modelId,
+      );
+      if (headlessCmd) {
+        return this._sendViaHeadlessCLI(id, conv, provider, providerName, modelId, message, history, tcAgentId, tc);
+      }
+      // Provider has no CLI — fall through to API streaming
+    }
+
     // Try direct API streaming first (sub-second latency)
     const controller = provider.streamChat(
       messages, modelId, apiKey,
@@ -448,6 +413,11 @@ export class ConversationManager {
     }
 
     // Fallback: headless CLI spawn (for providers without streamChat or missing API key)
+    return this._sendViaHeadlessCLI(id, conv, provider, providerName, modelId, message, history, tcAgentId, tc);
+  }
+
+  _sendViaHeadlessCLI(id, conv, provider, providerName, modelId, message, history, tcAgentId, tc) {
+    let tcResponseText = '';
     const prompt = this._buildHistoryPrompt(history, message);
     const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
     if (!headlessCmd) {

package/node_modules/@groove-dev/daemon/src/gateways/manager.js

@@ -5,7 +5,7 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlink
 import { resolve } from 'path';
 import { randomUUID } from 'crypto';
 import { validateAgentConfig } from '../validate.js';
-import { eventToSummary, agentListText, statusText, approvalsText, teamsText, schedulesText, briefText, tokensText, logText, planText, truncate, formatTokens } from './formatter.js';
+import { eventToSummary, agentListText, statusText, approvalsText, teamsText, schedulesText, briefText, tokensText, logText, planText, truncate, formatTokens, formatDuration, formatCost } from './formatter.js';
 
 const GATEWAY_TYPES = ['telegram', 'discord', 'slack'];
 
@@ -304,6 +304,40 @@ export class GatewayManager {
     this.daemon.credentials.deleteKey(`gateway:${id}:${key}`);
   }
 
+  // -------------------------------------------------------------------
+  // Schedule Notifications — direct, targeted notification for automations
+  // -------------------------------------------------------------------
+
+  /**
+   * Send a completion notification for a scheduled automation run.
+   * Called directly by the scheduler — bypasses global event routing.
+   */
+  sendScheduleNotification(gatewayIds, summary) {
+    if (!gatewayIds || gatewayIds.length === 0) return;
+
+    const statusIcon = summary.status === 'success' ? '✅' : '❌';
+    const lines = [
+      `${statusIcon} Automation: ${summary.name} — ${summary.status}`,
+    ];
+    if (summary.description) {
+      lines.push(summary.description);
+    }
+    lines.push(`Duration: ${formatDuration(summary.duration)} | Cost: ${formatCost(summary.cost)} | Agents: ${summary.agentCount}`);
+    if (summary.errors) {
+      lines.push(`Error: ${truncate(summary.errors, 500)}`);
+    }
+
+    const message = lines.join('\n');
+
+    for (const gid of gatewayIds) {
+      const gw = this.gateways.get(gid);
+      if (!gw || !gw.connected) continue;
+      gw.send(message).catch((err) => {
+        console.log(`[Groove:Gateway] Schedule notification failed (${gid}): ${err.message}`);
+      });
+    }
+  }
+
   // -------------------------------------------------------------------
   // Command Routing — chat command → daemon internals
   // -------------------------------------------------------------------

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

@@ -42,6 +42,7 @@ import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
 import { ModelLab } from './model-lab.js';
 import { LlamaServerManager } from './llama-server.js';
+import { MLXServerManager } from './mlx-server.js';
 import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
@@ -151,6 +152,7 @@ export class Daemon {
     this.preview = new PreviewService(this);
     this.modelManager = new ModelManager(this);
     this.llamaServer = new LlamaServerManager(this);
+    this.mlxServer = new MLXServerManager(this);
     this.mcpManager = new McpManager(this);
     this.tunnelManager = new TunnelManager(this);
     this.repoImporter = new RepoImporter(this);
@@ -848,6 +850,7 @@ export class Daemon {
     if (this.preview) await this.preview.killAll();
     this.mcpManager.stopAll();
     await this.llamaServer.stopAll();
+    await this.mlxServer.stopAll();
 
     // Clean up PID and host files
     if (existsSync(this.pidFile)) {

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

@@ -168,7 +168,7 @@ export class Journalist {
 
   hasNewActivity(agents) {
     for (const agent of agents) {
-      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
       if (!existsSync(logPath)) continue;
       try {
         const size = statSync(logPath).size;
@@ -182,7 +182,7 @@ export class Journalist {
     const result = {};
 
     for (const agent of agents) {
-      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+      const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
       if (!existsSync(logPath)) {
         result[agent.id] = { agent, entries: [], explorationEntries: [] };
         continue;
@@ -846,7 +846,7 @@ export class Journalist {
     for (const [agentId, { agent, entries }] of Object.entries(filteredLogs)) {
       if (entries.length === 0) continue;
 
-      const agentDir = resolve(logsDir, agent.name);
+      const agentDir = resolve(logsDir, agent.id);
       mkdirSync(agentDir, { recursive: true });
 
       const logPath = resolve(agentDir, `${dateStr}-session.md`);
@@ -904,13 +904,24 @@ export class Journalist {
       .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || e.text || '').slice(0, 200)}`)
       .join('\n');
 
-    // Try AI-synthesized session summary
+    // Try AI-synthesized session summary — but only if the session log has
+    // meaningful entries. With an empty/minimal log the headless Claude sees
+    // repo-wide git status (from its own project context) and fills the brief
+    // with unrelated changes from other teams, leaking cross-team state.
+    const meaningfulEntries = entries.filter((e) => e.type === 'tool' || e.type === 'error' || e.type === 'user' || e.type === 'result');
     let sessionSummary = '';
-    try {
-      const prompt = this.buildRotationSynthesisPrompt(agent, entries, options);
-      sessionSummary = await this.callHeadless(prompt, { trackAs: '__rotation__' });
-    } catch {
-      // Fallback: structural summary from raw logs
+    let needsFallback = meaningfulEntries.length < 3;
+
+    if (!needsFallback) {
+      try {
+        const prompt = this.buildRotationSynthesisPrompt(agent, entries, options);
+        sessionSummary = await this.callHeadless(prompt, { trackAs: '__rotation__' });
+      } catch {
+        needsFallback = true;
+      }
+    }
+
+    if (needsFallback) {
       const errorSummary = entries
         .filter((e) => e.type === 'error')
         .map((e) => `- ${e.text}`)
@@ -941,7 +952,6 @@ export class Journalist {
         .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || '').slice(0, 200)}`)
         .join('\n');
 
-      // Build investigation timeline from thinking entries — these capture reasoning and decisions
       const thinkingEntries = entries
         .filter((e) => e.type === 'thinking' && e.text && e.text.length > 80)
         .slice(-10)
@@ -1005,7 +1015,7 @@ export class Journalist {
    * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
    */
   extractConversationThread(agent, { maxChars = 60000 } = {}) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
     if (!existsSync(logPath)) return null;
 
     let content;
@@ -1211,7 +1221,7 @@ export class Journalist {
    * Used by the Introducer to tell new agents what their teammates built.
    */
   getAgentFiles(agent) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
     if (!existsSync(logPath)) return [];
 
     try {
@@ -1249,7 +1259,7 @@ export class Journalist {
    * Used to capture planner conclusions, build summaries, etc.
    */
   getAgentResult(agent) {
-    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.id}.log`);
     if (!existsSync(logPath)) return '';
 
     try {

package/node_modules/@groove-dev/daemon/src/mlx-server.js

@@ -0,0 +1,365 @@
+// GROOVE — MLX Server Manager
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Manages mlx_lm.server inference server instances on Apple Silicon.
+// Scans ~/.cache/huggingface/hub/ for cached MLX models.
+// Mirrors LlamaServerManager API: ensureServer, stopServer, getStatus.
+
+import { spawn, execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+const BASE_PORT = 8080;
+const MAX_SERVERS = 3;
+const HEALTH_TIMEOUT = 60000; // 60s — MLX may need to load model into memory
+const HEALTH_POLL_INTERVAL = 1000;
+const IDLE_TIMEOUT = 300000; // 5 minutes
+
+const HF_CACHE_DIR = resolve(homedir(), '.cache', 'huggingface', 'hub');
+const HF_MODEL_DIR_PREFIX = 'models--';
+
+export class MLXServerManager {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.servers = new Map(); // modelId -> { proc, port, users, startedAt, lastUsed, ready }
+  }
+
+  static isInstalled() {
+    try {
+      execSync('python3 -c "import mlx_lm; print(mlx_lm.__version__)"', {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 10000,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static getVersion() {
+    try {
+      const out = execSync('python3 -c "import mlx_lm; print(mlx_lm.__version__)"', {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 10000,
+      });
+      return out.toString().trim();
+    } catch {
+      return null;
+    }
+  }
+
+  static getPythonPath() {
+    // Check venv first, then system python
+    const venvPython = resolve(homedir(), '.mlx-env', 'bin', 'python3');
+    if (existsSync(venvPython)) {
+      try {
+        execSync(`${venvPython} -c "import mlx_lm"`, { stdio: 'ignore', timeout: 10000 });
+        return venvPython;
+      } catch { /* fall through */ }
+    }
+    try {
+      execSync('python3 -c "import mlx_lm"', { stdio: 'ignore', timeout: 10000 });
+      return 'python3';
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Model Scanning ---
+
+  static scanModels() {
+    const models = [];
+    if (!existsSync(HF_CACHE_DIR)) return models;
+
+    try {
+      const entries = readdirSync(HF_CACHE_DIR);
+      for (const entry of entries) {
+        if (!entry.startsWith(HF_MODEL_DIR_PREFIX)) continue;
+
+        const modelName = entry.slice(HF_MODEL_DIR_PREFIX.length).replace(/--/g, '/');
+        const snapshotsDir = resolve(HF_CACHE_DIR, entry, 'snapshots');
+        if (!existsSync(snapshotsDir)) continue;
+
+        let snapshotDir = null;
+        try {
+          const snapshots = readdirSync(snapshotsDir);
+          if (snapshots.length === 0) continue;
+          snapshotDir = resolve(snapshotsDir, snapshots[snapshots.length - 1]);
+        } catch { continue; }
+
+        let hasWeights = false;
+        let hasNpz = false;
+        let configData = null;
+        try {
+          const files = readdirSync(snapshotDir);
+          hasWeights = files.some((f) =>
+            f.endsWith('.safetensors') || f.endsWith('.npz') || f === 'weights.npz'
+          );
+          if (!hasWeights) continue;
+          hasNpz = files.some((f) => f.endsWith('.npz'));
+
+          const configPath = resolve(snapshotDir, 'config.json');
+          if (existsSync(configPath)) {
+            configData = JSON.parse(readFileSync(configPath, 'utf8'));
+          }
+        } catch { continue; }
+
+        const isMLX = isMLXModel(modelName, hasNpz, configData);
+        const type = isMLX ? 'mlx' : 'hf';
+        const prefix = isMLX ? 'mlx:' : 'hf:';
+        const shortName = modelName.split('/').pop() || modelName;
+        const params = parseMLXParams(shortName, configData);
+        const quant = parseMLXQuantization(shortName);
+
+        models.push({
+          id: `${prefix}${modelName}`,
+          modelId: modelName,
+          filename: shortName,
+          type,
+          compatibleBackends: isMLX ? ['mlx'] : ['vllm', 'tgi'],
+          parameters: params,
+          quantization: quant,
+          snapshotPath: snapshotDir,
+          cachedAt: entry,
+        });
+      }
+    } catch { /* best effort */ }
+
+    return models;
+  }
+
+  // --- Server Lifecycle ---
+
+  async ensureServer(modelId, options = {}) {
+    if (this.servers.has(modelId)) {
+      const server = this.servers.get(modelId);
+      server.users++;
+      server.lastUsed = Date.now();
+      return `http://127.0.0.1:${server.port}`;
+    }
+
+    if (this.servers.size >= MAX_SERVERS) {
+      await this._evictLRU();
+    }
+
+    const pythonPath = MLXServerManager.getPythonPath();
+    if (!pythonPath) {
+      throw new Error('mlx_lm not installed — run: pip3 install "mlx-lm[server]"');
+    }
+
+    const port = this._allocatePort();
+
+    const args = [
+      '-m', 'mlx_lm.server',
+      '--model', modelId,
+      '--port', String(port),
+    ];
+
+    const proc = spawn(pythonPath, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false,
+    });
+
+    if (!proc.pid) {
+      throw new Error('Failed to start mlx_lm.server — check installation');
+    }
+
+    const server = {
+      proc,
+      port,
+      modelId,
+      users: 1,
+      startedAt: Date.now(),
+      lastUsed: Date.now(),
+      ready: false,
+    };
+
+    this.servers.set(modelId, server);
+
+    const stderrBuf = [];
+    proc.stderr.on('data', (chunk) => {
+      stderrBuf.push(chunk.toString());
+      if (stderrBuf.join('').length > 4096) stderrBuf.shift();
+    });
+
+    proc.on('exit', (code, signal) => {
+      this.servers.delete(modelId);
+      this.daemon?.broadcast({
+        type: 'mlx:server:stopped',
+        data: { modelId, port, code, signal },
+      });
+    });
+
+    try {
+      await this._waitForHealth(port);
+      server.ready = true;
+
+      this.daemon?.broadcast({
+        type: 'mlx:server:ready',
+        data: { modelId, port },
+      });
+
+      return `http://127.0.0.1:${port}`;
+    } catch (err) {
+      await this.stopServer(modelId);
+      const stderr = stderrBuf.join('').slice(-500);
+      throw new Error(`mlx_lm.server failed to start: ${stderr || err.message}`);
+    }
+  }
+
+  releaseServer(modelId) {
+    const server = this.servers.get(modelId);
+    if (!server) return;
+
+    server.users = Math.max(0, server.users - 1);
+    server.lastUsed = Date.now();
+
+    if (server.users === 0) {
+      setTimeout(() => {
+        const s = this.servers.get(modelId);
+        if (s && s.users === 0 && Date.now() - s.lastUsed >= IDLE_TIMEOUT) {
+          this.stopServer(modelId);
+        }
+      }, IDLE_TIMEOUT + 1000);
+    }
+  }
+
+  async stopServer(modelId) {
+    const server = this.servers.get(modelId);
+    if (!server) return false;
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        try { server.proc.kill('SIGKILL'); } catch {}
+      }, 5000);
+
+      server.proc.on('exit', () => {
+        clearTimeout(timeout);
+        this.servers.delete(modelId);
+        resolve(true);
+      });
+
+      try {
+        server.proc.kill('SIGTERM');
+      } catch {
+        clearTimeout(timeout);
+        this.servers.delete(modelId);
+        resolve(true);
+      }
+    });
+  }
+
+  async stopAll() {
+    const ids = Array.from(this.servers.keys());
+    await Promise.all(ids.map((id) => this.stopServer(id)));
+  }
+
+  // --- Health Check ---
+
+  async _waitForHealth(port) {
+    const start = Date.now();
+    while (Date.now() - start < HEALTH_TIMEOUT) {
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/v1/models`, {
+          signal: AbortSignal.timeout(2000),
+        });
+        if (res.ok) return true;
+      } catch { /* server still loading */ }
+      await new Promise((r) => setTimeout(r, HEALTH_POLL_INTERVAL));
+    }
+    throw new Error(`mlx_lm.server health check timed out after ${HEALTH_TIMEOUT / 1000}s`);
+  }
+
+  // --- Port Management ---
+
+  _allocatePort() {
+    const usedPorts = new Set(Array.from(this.servers.values()).map((s) => s.port));
+    let port = BASE_PORT;
+    while (usedPorts.has(port) && port < BASE_PORT + 100) {
+      port++;
+    }
+    return port;
+  }
+
+  async _evictLRU() {
+    let lru = null;
+    for (const [id, server] of this.servers) {
+      if (!lru || server.users < lru.users ||
+          (server.users === lru.users && server.lastUsed < lru.lastUsed)) {
+        lru = { id, ...server };
+      }
+    }
+    if (lru) {
+      await this.stopServer(lru.id);
+    }
+  }
+
+  // --- Status ---
+
+  getRunningServers() {
+    return Array.from(this.servers.entries()).map(([modelId, s]) => ({
+      modelId,
+      port: s.port,
+      users: s.users,
+      ready: s.ready,
+      uptime: Date.now() - s.startedAt,
+      lastUsed: s.lastUsed,
+    }));
+  }
+
+  getStatus() {
+    return {
+      installed: MLXServerManager.isInstalled(),
+      version: MLXServerManager.getVersion(),
+      running: this.servers.size,
+      maxServers: MAX_SERVERS,
+      servers: this.getRunningServers(),
+      cachedModels: MLXServerManager.scanModels().length,
+    };
+  }
+}
+
+// --- Format Detection ---
+
+function isMLXModel(modelName, hasNpz, configData) {
+  if (modelName.startsWith('mlx-community/')) return true;
+  if (hasNpz) return true;
+  if (/[-_]mlx[-_]/i.test(modelName) || modelName.toLowerCase().endsWith('-mlx')) return true;
+  if (configData?.quantization_config?.quant_method === 'mlx') return true;
+  return false;
+}
+
+// --- Parsing Utilities ---
+
+function parseMLXParams(name, config) {
+  // Try config.json first
+  if (config) {
+    const hidden = config.hidden_size;
+    const layers = config.num_hidden_layers;
+    const vocab = config.vocab_size;
+    if (hidden && layers) {
+      const approx = (hidden * layers * vocab * 4) / 1e9;
+      if (approx > 0.1) {
+        if (approx < 1.5) return '0.5-1B';
+        if (approx < 5) return `${Math.round(approx)}B`;
+        if (approx < 10) return `${Math.round(approx)}B`;
+        return `${Math.round(approx)}B`;
+      }
+    }
+  }
+
+  // Fallback: parse from name
+  const match = name.match(/(\d+\.?\d*)[bB]/);
+  if (match) return `${match[1]}B`;
+  return null;
+}
+
+function parseMLXQuantization(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes('8bit') || lower.includes('8-bit')) return 'W8';
+  if (lower.includes('4bit') || lower.includes('4-bit')) return 'W4';
+  if (lower.includes('3bit') || lower.includes('3-bit')) return 'W3';
+  if (lower.includes('bf16') || lower.includes('fp16')) return 'FP16';
+  return null;
+}