groove-dev 0.27.152 → 0.27.154

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.152",
+  "version": "0.27.154",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.152",
+  "version": "0.27.154",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -644,20 +644,14 @@ export class Journalist {
         proc.stdin.write(stdinData);
         proc.stdin.end();
         proc.stdout.on('data', (d) => { stdout += d.toString(); });
-        const timer = setTimeout(() => { proc.kill(); reject(new Error('Headless timeout')); }, 60_000);
+        const timer = setTimeout(() => { proc.kill(); reject(new Error('Headless timeout')); }, 120_000);
         proc.on('exit', (code) => {
           clearTimeout(timer);
           if (code !== 0) return reject(new Error(`Headless exited with code ${code}`));
           this._recordHeadlessUsage(stdout, trackAs, modelId);
-          const lines = stdout.split('\n');
-          for (const line of lines) {
-            try {
-              const json = JSON.parse(line);
-              if (json.result) return resolve(json.result);
-              if (json.content?.[0]?.text) return resolve(json.content[0].text);
-            } catch { /* not json */ }
-          }
-          resolve(stdout.trim());
+          const extracted = this._parseHeadlessOutput(stdout);
+          if (extracted) return resolve(extracted);
+          reject(new Error('Headless produced no usable output'));
         });
         return;
       }
@@ -666,24 +660,61 @@ export class Journalist {
         env: { ...process.env, ...env },
         cwd: this.daemon.projectDir,
         maxBuffer: 1024 * 1024 * 5,
-        timeout: 60_000,
+        timeout: 120_000,
       }, (err, stdout, stderr) => {
         if (err) return reject(err);
         this._recordHeadlessUsage(stdout, trackAs, modelId);
-        const lines = stdout.split('\n');
-        for (const line of lines) {
-          try {
-            const data = JSON.parse(line);
-            if (data.type === 'result' && data.result) {
-              return resolve(data.result);
-            }
-          } catch { /* skip */ }
-        }
-        resolve(stdout);
+        const extracted = this._parseHeadlessOutput(stdout);
+        if (extracted) return resolve(extracted);
+        reject(new Error('Headless produced no usable output'));
       });
     });
   }
 
+  _parseHeadlessOutput(stdout) {
+    const lines = stdout.split('\n');
+    let resultText = '';
+    let assistantText = '';
+    let codexText = '';
+    let networkText = '';
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+
+        // Claude/Gemini stream-json: {"type":"result","result":"..."}
+        if (typeof json.result === 'string' && json.result.trim()) {
+          resultText = json.result;
+        }
+
+        // Claude/Gemini assistant message: {"type":"assistant","message":{"content":[{"type":"text","text":"..."}]}}
+        const msgContent = json.message?.content?.[0]?.text || json.content?.[0]?.text;
+        if (msgContent && msgContent.trim()) {
+          assistantText = msgContent;
+        }
+
+        // Codex --json: {"type":"item.completed","item":{"type":"agent_message","text":"..."}}
+        if (json.type === 'item.completed' && json.item?.type === 'agent_message' && json.item.text?.trim()) {
+          codexText = json.item.text;
+        }
+
+        // Groove Network: {"type":"done|complete|result","text":"..."}
+        if ((json.type === 'done' || json.type === 'complete') && typeof json.text === 'string' && json.text.trim()) {
+          networkText = json.text;
+        }
+      } catch { /* not json */ }
+    }
+
+    if (resultText) return resultText;
+    if (codexText) return codexText;
+    if (networkText) return networkText;
+    if (assistantText) return assistantText;
+    // Ollama / plain-text providers: raw text output (no JSON)
+    const plain = stdout.trim();
+    if (plain && !plain.startsWith('{') && plain.length > 20) return plain;
+    return null;
+  }
+
   parseSynthesisResult(text, agents) {
     // Parse the structured output from AI
     const sections = {

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

@@ -58,7 +58,7 @@ export class Keeper {
 
   save(tag, content) {
     if (!tag || typeof tag !== 'string') throw new Error('Tag is required');
-    if (content === undefined || content === null) throw new Error('Content is required');
+    if (content === undefined || content === null || !String(content).trim()) throw new Error('Content is required');
     const normalized = this._normalize(tag);
     if (!normalized) throw new Error('Tag is required');
     const filePath = this._tagToPath(normalized);
@@ -129,7 +129,7 @@ export class Keeper {
   update(tag, content) {
     const normalized = this._normalize(tag);
     if (!normalized) throw new Error('Tag is required');
-    if (content === undefined || content === null) throw new Error('Content is required');
+    if (content === undefined || content === null || !String(content).trim()) throw new Error('Content is required');
     const filePath = this._tagToPath(normalized);
     if (!existsSync(filePath)) throw new Error(`Memory #${normalized} does not exist`);
     writeFileSync(filePath, String(content));
@@ -153,6 +153,41 @@ export class Keeper {
     return true;
   }
 
+  move(oldTag, newTag) {
+    const oldNorm = this._normalize(oldTag);
+    const newNorm = this._normalize(newTag);
+    if (!oldNorm || !newNorm) throw new Error('Both old and new tags are required');
+    if (oldNorm === newNorm) return this._index[oldNorm];
+    const oldPath = this._tagToPath(oldNorm);
+    if (!existsSync(oldPath)) throw new Error(`Memory #${oldNorm} does not exist`);
+    if (this._index[newNorm]) throw new Error(`Memory #${newNorm} already exists`);
+    const content = readFileSync(oldPath, 'utf8');
+    const newPath = this._tagToPath(newNorm);
+    this._ensureParentDir(newPath);
+    writeFileSync(newPath, content);
+    unlinkSync(oldPath);
+    this._index[newNorm] = { ...this._index[oldNorm], tag: newNorm, updatedAt: new Date().toISOString() };
+    delete this._index[oldNorm];
+    // Move children too (e.g. moving "a" to "b/a" also moves "a/child" to "b/a/child")
+    const prefix = oldNorm + '/';
+    for (const tag of Object.keys(this._index)) {
+      if (tag.startsWith(prefix)) {
+        const childSuffix = tag.slice(prefix.length);
+        const childNewTag = newNorm + '/' + childSuffix;
+        const childOldPath = this._tagToPath(tag);
+        const childNewPath = this._tagToPath(childNewTag);
+        const childContent = readFileSync(childOldPath, 'utf8');
+        this._ensureParentDir(childNewPath);
+        writeFileSync(childNewPath, childContent);
+        unlinkSync(childOldPath);
+        this._index[childNewTag] = { ...this._index[tag], tag: childNewTag, updatedAt: new Date().toISOString() };
+        delete this._index[tag];
+      }
+    }
+    this._saveIndex();
+    return { tag: newNorm, ...this._index[newNorm] };
+  }
+
   // ── Doc (AI-generated) ───────────────────────────────────
 
   saveDoc(tag, content) {

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

@@ -5,7 +5,10 @@
 // Each model gets its own server on a unique port.
 // Auto-starts when an agent needs a GGUF model, auto-stops when idle.
 
-import { spawn, execSync } from 'child_process';
+import { spawn, execSync, execFileSync } from 'child_process';
+import { existsSync, mkdirSync, chmodSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
 
 const BASE_PORT = 8081;
 const MAX_SERVERS = 5;
@@ -25,10 +28,98 @@ export class LlamaServerManager {
       execSync('which llama-server', { stdio: 'ignore' });
       return true;
     } catch {
-      return false;
+      // Check common manual install locations
+      const paths = [
+        resolve(homedir(), '.local', 'bin', 'llama-server'),
+        resolve(homedir(), '.groove', 'bin', 'llama-server'),
+        '/usr/local/bin/llama-server',
+      ];
+      return paths.some(p => existsSync(p));
     }
   }
 
+  static getLlamaServerPath() {
+    try {
+      return execSync('which llama-server', { stdio: 'pipe', encoding: 'utf8' }).trim();
+    } catch {
+      const paths = [
+        resolve(homedir(), '.local', 'bin', 'llama-server'),
+        resolve(homedir(), '.groove', 'bin', 'llama-server'),
+        '/usr/local/bin/llama-server',
+      ];
+      return paths.find(p => existsSync(p)) || 'llama-server';
+    }
+  }
+
+  static async install() {
+    const platform = process.platform;
+
+    if (platform === 'darwin') {
+      try {
+        execSync('which brew', { stdio: 'ignore' });
+      } catch {
+        throw new Error('Homebrew not found. Install it from https://brew.sh then retry.');
+      }
+      execSync('brew install llama.cpp', { stdio: 'pipe', timeout: 600000 });
+      return { method: 'brew', path: execSync('which llama-server', { encoding: 'utf8', stdio: 'pipe' }).trim() };
+    }
+
+    if (platform === 'linux') {
+      const installDir = resolve(homedir(), '.local', 'bin');
+      mkdirSync(installDir, { recursive: true });
+
+      const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+      const hasCuda = (() => { try { execSync('which nvidia-smi', { stdio: 'ignore' }); return true; } catch { return false; } })();
+
+      const resp = await fetch('https://api.github.com/repos/ggml-org/llama.cpp/releases/latest', {
+        headers: { 'User-Agent': 'groove-dev' },
+      });
+      if (!resp.ok) throw new Error(`GitHub API error: ${resp.status}`);
+      const release = await resp.json();
+
+      const suffix = hasCuda ? `ubuntu-${arch}-cuda` : `ubuntu-${arch}`;
+      let asset = release.assets.find(a => a.name.includes(suffix) && a.name.endsWith('.zip'));
+      if (!asset && hasCuda) {
+        asset = release.assets.find(a => a.name.includes(`ubuntu-${arch}`) && a.name.endsWith('.zip'));
+      }
+      if (!asset) {
+        asset = release.assets.find(a => a.name.includes('ubuntu') && a.name.includes(arch) && a.name.endsWith('.zip'));
+      }
+      if (!asset) throw new Error(`No pre-built binary found for linux-${arch}. Build from source: https://github.com/ggml-org/llama.cpp#build`);
+
+      const tmpZip = `/tmp/groove-llama-${Date.now()}.zip`;
+      const tmpDir = `/tmp/groove-llama-extract-${Date.now()}`;
+
+      execSync(`curl -fSL "${asset.browser_download_url}" -o "${tmpZip}"`, { stdio: 'pipe', timeout: 600000 });
+      execSync(`unzip -o "${tmpZip}" -d "${tmpDir}"`, { stdio: 'pipe', timeout: 60000 });
+
+      const findResult = execSync(`find "${tmpDir}" -name llama-server -type f`, { encoding: 'utf8', stdio: 'pipe' }).trim();
+      const binPath = findResult.split('\n')[0];
+      if (!binPath) throw new Error('llama-server binary not found in release archive');
+
+      const destPath = resolve(installDir, 'llama-server');
+      execSync(`cp "${binPath}" "${destPath}"`, { stdio: 'pipe' });
+      chmodSync(destPath, 0o755);
+
+      // Copy shared libraries if present
+      try {
+        const libDir = resolve(binPath, '..', '..', 'lib');
+        if (existsSync(libDir)) {
+          const userLibDir = resolve(homedir(), '.local', 'lib');
+          mkdirSync(userLibDir, { recursive: true });
+          execSync(`cp -r "${libDir}/"* "${userLibDir}/"`, { stdio: 'pipe' });
+        }
+      } catch { /* libs are optional */ }
+
+      // Cleanup
+      try { execSync(`rm -rf "${tmpZip}" "${tmpDir}"`, { stdio: 'ignore' }); } catch { /* best-effort */ }
+
+      return { method: 'github-release', path: destPath, cuda: hasCuda, release: release.tag_name };
+    }
+
+    throw new Error(`Automatic install not supported on ${platform}. Install llama-server manually: https://github.com/ggml-org/llama.cpp#build`);
+  }
+
   // --- Server Lifecycle ---
 
   /**
@@ -74,9 +165,11 @@ export class LlamaServerManager {
       args.push('--flash-attn', 'auto');
     }
 
-    const proc = spawn('llama-server', args, {
+    const serverBin = LlamaServerManager.getLlamaServerPath();
+    const proc = spawn(serverBin, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: false,
+      env: { ...process.env, LD_LIBRARY_PATH: [resolve(homedir(), '.local', 'lib'), process.env.LD_LIBRARY_PATH].filter(Boolean).join(':') },
     });
 
     if (!proc.pid) {

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

@@ -69,7 +69,6 @@ export class ModelManager {
   async search(query, { limit = 20, sort = 'downloads' } = {}) {
     const params = new URLSearchParams({
       search: query,
-      filter: 'gguf',
       sort,
       direction: '-1',
       limit: String(limit),
@@ -83,15 +82,20 @@ export class ModelManager {
     if (!res.ok) throw new Error(`HuggingFace API error: ${res.status}`);
     const models = await res.json();
 
-    return models.map((m) => ({
-      id: m.modelId || m.id,
-      name: m.modelId?.split('/').pop() || m.id,
-      author: m.modelId?.split('/')[0] || '',
-      downloads: m.downloads || 0,
-      likes: m.likes || 0,
-      tags: m.tags || [],
-      lastModified: m.lastModified,
-    }));
+    return models.map((m) => {
+      const id = m.modelId || m.id;
+      const tags = m.tags || [];
+      return {
+        id,
+        name: id.split('/').pop() || id,
+        author: id.split('/')[0] || '',
+        downloads: m.downloads || 0,
+        likes: m.likes || 0,
+        tags,
+        lastModified: m.lastModified,
+        recommendedRuntimes: inferRuntimes(id, tags),
+      };
+    });
   }
 
   async getModelFiles(repoId) {
@@ -409,3 +413,41 @@ function classifyTier(params, quant) {
   if (billions >= 10) return 'medium';
   return 'light';
 }
+
+function inferRuntimes(repoId, tags) {
+  const lower = repoId.toLowerCase();
+  const tagSet = new Set(tags.map((t) => t.toLowerCase()));
+  const runtimes = new Set();
+
+  // GGUF → llama.cpp and (implicitly) Ollama
+  if (tagSet.has('gguf') || lower.includes('-gguf') || lower.includes('_gguf')) {
+    runtimes.add('llama.cpp');
+  }
+
+  // MLX-optimized models
+  if (tagSet.has('mlx') || lower.includes('-mlx') || lower.includes('_mlx')) {
+    runtimes.add('MLX');
+  }
+
+  // GPTQ / AWQ quantized → vLLM handles these well
+  if (tagSet.has('gptq') || tagSet.has('awq') || lower.includes('-gptq') || lower.includes('-awq')) {
+    runtimes.add('vLLM');
+  }
+
+  // SafeTensors / standard transformer weights → vLLM, TGI, MLX
+  if (tagSet.has('safetensors') || tagSet.has('transformers')) {
+    runtimes.add('vLLM');
+    runtimes.add('TGI');
+    if (!runtimes.has('MLX')) runtimes.add('MLX');
+  }
+
+  // If nothing matched, infer from general model traits
+  if (runtimes.size === 0) {
+    if (tagSet.has('pytorch') || tagSet.has('tf') || tagSet.has('jax')) {
+      runtimes.add('vLLM');
+      runtimes.add('TGI');
+    }
+  }
+
+  return [...runtimes];
+}

package/node_modules/@groove-dev/daemon/src/routes/coordination.js

@@ -249,6 +249,19 @@ export function registerCoordinationRoutes(app, daemon) {
     }
   });
 
+  app.post('/api/keeper/move', (req, res) => {
+    try {
+      const { oldTag, newTag } = req.body || {};
+      if (!oldTag || !newTag) return res.status(400).json({ error: 'oldTag and newTag are required' });
+      const item = daemon.keeper.move(oldTag, newTag);
+      daemon.audit.log('keeper.move', { oldTag, newTag: item.tag });
+      daemon.broadcast({ type: 'keeper:moved', oldTag, item });
+      res.json(item);
+    } catch (err) {
+      res.status(err.message.includes('does not exist') ? 404 : 400).json({ error: err.message });
+    }
+  });
+
   app.delete('/api/keeper/link/:tag(*)', (req, res) => {
     try {
       const { docPath } = req.body || {};
@@ -289,6 +302,9 @@ export function registerCoordinationRoutes(app, daemon) {
       } else {
         doc = `# ${tag}\n\n*Auto-generated document from conversation*\n\n${transcript.slice(0, 5000)}`;
       }
+      if (!doc || !doc.trim()) {
+        return res.status(502).json({ error: 'AI synthesis returned empty content — try again' });
+      }
       const item = daemon.keeper.saveDoc(tag, doc);
       daemon.audit.log('keeper.doc', { tag: item.tag, agentId });
       daemon.broadcast({ type: 'keeper:saved', item });

package/node_modules/@groove-dev/daemon/src/routes/files.js

@@ -1,5 +1,5 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
-import { resolve, sep, isAbsolute } from 'path';
+import { resolve, sep, isAbsolute, basename } from 'path';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, unlinkSync, renameSync, rmSync, createReadStream, realpathSync } from 'fs';
 import { execFile, execFileSync } from 'child_process';
 import { homedir } from 'os';
@@ -331,6 +331,53 @@ export function registerFileRoutes(app, daemon) {
     }
   });
 
+  // Download a file (serves raw with Content-Disposition)
+  app.get('/api/files/download', (req, res) => {
+    const relPath = req.query.path;
+    const result = validateFilePath(relPath, getEditorRoot(daemon));
+    if (result.error) return res.status(400).json({ error: result.error });
+    if (!existsSync(result.fullPath)) return res.status(404).json({ error: 'File not found' });
+
+    const stat = statSync(result.fullPath);
+    if (stat.isDirectory()) return res.status(400).json({ error: 'Cannot download a directory' });
+
+    const name = basename(result.fullPath);
+    const mime = mimeLookup(name) || 'application/octet-stream';
+    res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(name)}"`);
+    res.setHeader('Content-Type', mime);
+    res.setHeader('Content-Length', stat.size);
+    createReadStream(result.fullPath).pipe(res);
+  });
+
+  // Upload files (base64-encoded) to a target directory
+  app.post('/api/files/upload', (req, res) => {
+    const { dir = '', files } = req.body;
+    const rootDir = getEditorRoot(daemon);
+    if (!rootDir) return res.status(400).json({ error: 'Editor root not set' });
+    if (!Array.isArray(files) || files.length === 0) return res.status(400).json({ error: 'files[] required' });
+    if (files.length > 50) return res.status(400).json({ error: 'Max 50 files per upload' });
+
+    const uploaded = [];
+    for (const file of files) {
+      if (!file.name || !file.content) continue;
+      const safeName = String(file.name).replace(/\.\./g, '').replace(/\//g, '_');
+      if (!safeName) continue;
+      const relPath = dir ? `${dir}/${safeName}` : safeName;
+      const result = validateFilePath(relPath, rootDir);
+      if (result.error) continue;
+
+      try {
+        const parentDir = resolve(result.fullPath, '..');
+        mkdirSync(parentDir, { recursive: true });
+        const buf = Buffer.from(file.content, 'base64');
+        writeFileSync(result.fullPath, buf);
+        daemon.audit.log('file.upload', { path: relPath, size: buf.length });
+        uploaded.push({ path: relPath, size: buf.length });
+      } catch { /* skip failed files */ }
+    }
+    res.json({ uploaded, total: uploaded.length });
+  });
+
   // Create a new file
   app.post('/api/files/create', (req, res) => {
     const { path: relPath, content = '' } = req.body;
@@ -595,9 +642,31 @@ export function registerFileRoutes(app, daemon) {
     if (!agent) return res.status(404).json({ error: 'Agent not found' });
     const rawFiles = daemon.registry.getFilesTouched(req.params.id);
     const rootDir = agent.workingDir || daemon.projectDir;
+
+    // Build git diff numstat for line-level +/- counts
+    let numstatMap = {};
+    const writtenPaths = rawFiles.filter(f => f.writes > 0).map(f => f.path);
+    if (writtenPaths.length > 0) {
+      try {
+        const out = execFileSync('git', ['diff', '--numstat', '--', ...writtenPaths], {
+          cwd: rootDir, timeout: 10000, maxBuffer: 2 * 1024 * 1024,
+        }).toString();
+        for (const line of out.split('\n')) {
+          const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+          if (m) {
+            numstatMap[m[3]] = {
+              additions: m[1] === '-' ? 0 : Number(m[1]),
+              deletions: m[2] === '-' ? 0 : Number(m[2]),
+            };
+          }
+        }
+      } catch { /* git not available or not a repo */ }
+    }
+
     const files = rawFiles.map(f => {
       const fullPath = isAbsolute(f.path) ? f.path : resolve(rootDir, f.path);
-      return { ...f, exists: existsSync(fullPath) };
+      const stats = numstatMap[f.path] || null;
+      return { ...f, exists: existsSync(fullPath), additions: stats?.additions ?? null, deletions: stats?.deletions ?? null };
     });
     res.json({ files, total: files.length });
   });

package/node_modules/@groove-dev/daemon/src/routes/providers.js

@@ -713,6 +713,17 @@ export function registerProviderRoutes(app, daemon) {
     res.json(daemon.llamaServer.getStatus());
   });
 
+  app.post('/api/llama/install', async (req, res) => {
+    try {
+      const { LlamaServerManager } = await import('../llama-server.js');
+      const result = await LlamaServerManager.install();
+      daemon.modelLab.refreshInstalledTools();
+      res.json({ success: true, ...result });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   app.get('/api/mlx/status', (req, res) => {
     res.json(daemon.mlxServer.getStatus());
   });