groove-dev 0.15.0 → 0.16.0

package/node_modules/@codemirror/view/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@codemirror/view",
+  "version": "6.41.0",
+  "description": "DOM view component for the CodeMirror code editor",
+  "scripts": {
+    "test": "cm-runtests",
+    "prepare": "cm-buildhelper src/index.ts"
+  },
+  "keywords": [
+    "editor",
+    "code"
+  ],
+  "author": {
+    "name": "Marijn Haverbeke",
+    "email": "marijn@haverbeke.berlin",
+    "url": "http://marijnhaverbeke.nl"
+  },
+  "type": "module",
+  "main": "dist/index.cjs",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "sideEffects": false,
+  "license": "MIT",
+  "dependencies": {
+    "@codemirror/state": "^6.6.0",
+    "crelt": "^1.0.6",
+    "style-mod": "^4.1.0",
+    "w3c-keyname": "^2.2.4"
+  },
+  "devDependencies": {
+    "@codemirror/buildhelper": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codemirror/view.git"
+  }
+}

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

@@ -4,7 +4,7 @@
 import express from 'express';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { listProviders } from './providers/index.js';
 import { validateAgentConfig } from './validate.js';
 
@@ -35,7 +35,7 @@ export function createApi(app, daemon) {
     next();
   });
 
-  app.use(express.json({ limit: '1mb' }));
+  app.use(express.json({ limit: '6mb' }));
 
   // Health check
   app.get('/api/health', (req, res) => {
@@ -400,6 +400,16 @@ export function createApi(app, daemon) {
     }
   });
 
+  app.post('/api/skills/:id/rate', async (req, res) => {
+    try {
+      const rating = parseInt(req.body?.rating, 10);
+      const result = await daemon.skills.rate(req.params.id, rating);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   app.get('/api/skills/:id/content', (req, res) => {
     const content = daemon.skills.getContent(req.params.id);
     if (!content) return res.status(404).json({ error: 'Skill not installed' });
@@ -493,6 +503,151 @@ export function createApi(app, daemon) {
     }
   });
 
+  // --- File Editor API ---
+
+  const LANG_MAP = {
+    js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
+    ts: 'typescript', tsx: 'typescript',
+    css: 'css', scss: 'css', html: 'html', json: 'json',
+    md: 'markdown', py: 'python', rs: 'rust', go: 'go',
+    sh: 'shell', bash: 'shell', zsh: 'shell',
+    yaml: 'yaml', yml: 'yaml', toml: 'toml',
+    sql: 'sql', xml: 'xml', java: 'java', c: 'cpp', cpp: 'cpp', h: 'cpp',
+    rb: 'ruby', php: 'php', swift: 'swift', kt: 'kotlin',
+    dockerfile: 'dockerfile', makefile: 'makefile',
+  };
+  function detectLanguage(filename) {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    return LANG_MAP[ext] || 'text';
+  }
+
+  const IGNORED_NAMES = new Set(['.git', 'node_modules', '.DS_Store', '.groove', '__pycache__', '.next', '.cache', 'dist', 'coverage']);
+
+  function validateFilePath(relPath, projectDir) {
+    if (!relPath || typeof relPath !== 'string') return { error: 'path is required' };
+    if (relPath.startsWith('/') || relPath.includes('..') || relPath.includes('\0')) {
+      return { error: 'Invalid path' };
+    }
+    const fullPath = resolve(projectDir, relPath);
+    if (!fullPath.startsWith(projectDir)) return { error: 'Path outside project' };
+    return { fullPath };
+  }
+
+  // File tree — returns dirs + files for a given path
+  app.get('/api/files/tree', (req, res) => {
+    const relPath = req.query.path || '';
+
+    // Security: reuse browse validation
+    if (relPath && (relPath.startsWith('/') || relPath.includes('..') || relPath.includes('\0'))) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+
+    const fullPath = relPath ? resolve(daemon.projectDir, relPath) : daemon.projectDir;
+    if (!fullPath.startsWith(daemon.projectDir)) {
+      return res.status(400).json({ error: 'Path outside project' });
+    }
+    if (!existsSync(fullPath)) {
+      return res.status(404).json({ error: 'Directory not found' });
+    }
+
+    try {
+      const raw = readdirSync(fullPath, { withFileTypes: true });
+      const entries = [];
+
+      // Dirs first (sorted), then files (sorted)
+      const dirs = raw.filter((e) => e.isDirectory() && !IGNORED_NAMES.has(e.name) && !e.name.startsWith('.'))
+        .sort((a, b) => a.name.localeCompare(b.name));
+      const files = raw.filter((e) => e.isFile() && !e.name.startsWith('.'))
+        .sort((a, b) => a.name.localeCompare(b.name));
+
+      for (const d of dirs) {
+        const childPath = relPath ? `${relPath}/${d.name}` : d.name;
+        const childFull = resolve(fullPath, d.name);
+        let hasChildren = false;
+        try {
+          const children = readdirSync(childFull, { withFileTypes: true });
+          hasChildren = children.some((c) => !c.name.startsWith('.') && !IGNORED_NAMES.has(c.name));
+        } catch { /* unreadable */ }
+        entries.push({ name: d.name, type: 'dir', path: childPath, hasChildren });
+      }
+
+      for (const f of files) {
+        const childPath = relPath ? `${relPath}/${f.name}` : f.name;
+        let size = 0;
+        try { size = statSync(resolve(fullPath, f.name)).size; } catch { /* ignore */ }
+        entries.push({
+          name: f.name, type: 'file', path: childPath, size,
+          language: detectLanguage(f.name),
+        });
+      }
+
+      res.json({
+        current: relPath || '.',
+        parent: relPath ? relPath.split('/').slice(0, -1).join('/') : null,
+        entries,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Read file contents
+  app.get('/api/files/read', (req, res) => {
+    const result = validateFilePath(req.query.path, daemon.projectDir);
+    if (result.error) return res.status(400).json({ error: result.error });
+
+    if (!existsSync(result.fullPath)) {
+      return res.status(404).json({ error: 'File not found' });
+    }
+
+    try {
+      const stat = statSync(result.fullPath);
+      if (stat.size > 5 * 1024 * 1024) {
+        return res.status(400).json({ error: 'File too large (>5MB)' });
+      }
+
+      // Binary detection: check first 8KB for null bytes
+      const buf = readFileSync(result.fullPath);
+      const sample = buf.subarray(0, 8192);
+      if (sample.includes(0)) {
+        return res.json({ path: req.query.path, binary: true, size: stat.size });
+      }
+
+      const content = buf.toString('utf8');
+      const filename = req.query.path.split('/').pop();
+      res.json({
+        path: req.query.path,
+        content,
+        size: stat.size,
+        language: detectLanguage(filename),
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Write file contents
+  app.post('/api/files/write', (req, res) => {
+    const { path: relPath, content } = req.body;
+    const result = validateFilePath(relPath, daemon.projectDir);
+    if (result.error) return res.status(400).json({ error: result.error });
+
+    if (typeof content !== 'string') {
+      return res.status(400).json({ error: 'content must be a string' });
+    }
+    if (content.length > 5 * 1024 * 1024) {
+      return res.status(400).json({ error: 'Content too large (>5MB)' });
+    }
+
+    try {
+      writeFileSync(result.fullPath, content, 'utf8');
+      daemon.audit.log('file.write', { path: relPath });
+      res.json({ ok: true, size: Buffer.byteLength(content, 'utf8') });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // --- Codebase Indexer ---
 
   app.get('/api/indexer', (req, res) => {

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

@@ -0,0 +1,59 @@
+// GROOVE — File Watcher (per-file fs.watch + debounced WS broadcast)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { watch } from 'fs';
+import { resolve } from 'path';
+
+export class FileWatcher {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.watchers = new Map(); // relPath → { watcher, timer }
+  }
+
+  watch(relPath) {
+    if (!relPath || typeof relPath !== 'string') return;
+    if (this.watchers.has(relPath)) return; // already watching
+
+    const fullPath = resolve(this.daemon.projectDir, relPath);
+
+    try {
+      const watcher = watch(fullPath, () => {
+        const entry = this.watchers.get(relPath);
+        if (!entry) return;
+
+        // Debounce 300ms — agents write in bursts
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.timer = setTimeout(() => {
+          this.daemon.broadcast({
+            type: 'file:changed',
+            path: relPath,
+            timestamp: Date.now(),
+          });
+        }, 300);
+      });
+
+      watcher.on('error', () => {
+        this.unwatch(relPath);
+      });
+
+      this.watchers.set(relPath, { watcher, timer: null });
+    } catch {
+      // File doesn't exist or not watchable — ignore
+    }
+  }
+
+  unwatch(relPath) {
+    const entry = this.watchers.get(relPath);
+    if (!entry) return;
+
+    if (entry.timer) clearTimeout(entry.timer);
+    try { entry.watcher.close(); } catch { /* already closed */ }
+    this.watchers.delete(relPath);
+  }
+
+  unwatchAll() {
+    for (const [relPath] of this.watchers) {
+      this.unwatch(relPath);
+    }
+  }
+}

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

@@ -28,6 +28,7 @@ import { CodebaseIndexer } from './indexer.js';
 import { AuditLogger } from './audit.js';
 import { Federation } from './federation.js';
 import { SkillStore } from './skills.js';
+import { FileWatcher } from './filewatcher.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -117,6 +118,7 @@ export class Daemon {
     this.audit = new AuditLogger(this.grooveDir);
     this.federation = new Federation(this);
     this.skills = new SkillStore(this);
+    this.fileWatcher = new FileWatcher(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -147,12 +149,34 @@ export class Daemon {
       this.broadcast({ type: 'state', data: this.registry.getAll() });
     });
 
-    // Send full state to new WebSocket clients
+    // Send full state to new WebSocket clients + handle editor messages
     this.wss.on('connection', (ws) => {
       ws.send(JSON.stringify({
         type: 'state',
         data: this.registry.getAll(),
       }));
+
+      // Track which files this client is watching (for cleanup on disconnect)
+      const watchedFiles = new Set();
+
+      ws.on('message', (raw) => {
+        try {
+          const msg = JSON.parse(raw);
+          if (msg.type === 'editor:watch' && msg.path) {
+            this.fileWatcher.watch(msg.path);
+            watchedFiles.add(msg.path);
+          } else if (msg.type === 'editor:unwatch' && msg.path) {
+            this.fileWatcher.unwatch(msg.path);
+            watchedFiles.delete(msg.path);
+          }
+        } catch { /* ignore malformed messages */ }
+      });
+
+      ws.on('close', () => {
+        for (const path of watchedFiles) {
+          this.fileWatcher.unwatch(path);
+        }
+      });
     });
 
     // Auto-update AGENTS_REGISTRY.md and CLAUDE.md GROOVE section on changes
@@ -250,6 +274,9 @@ export class Daemon {
     this.journalist.stop();
     this.rotator.stop();
 
+    // Clean up file watchers
+    this.fileWatcher.unwatchAll();
+
     // Kill all agent processes
     await this.processes.killAll();
 

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

@@ -193,6 +193,26 @@ export class SkillStore {
     return { id: skillId, installed: false };
   }
 
+  /**
+   * Rate a skill. Proxies to the skills server.
+   */
+  async rate(skillId, rating) {
+    if (!Number.isInteger(rating) || rating < 1 || rating > 5) {
+      throw new Error('Rating must be an integer from 1 to 5');
+    }
+    const res = await fetch(`${SKILLS_API}/skills/${skillId}/rate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ rating }),
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      throw new Error(data.error || 'Rating failed');
+    }
+    return res.json();
+  }
+
   /**
    * Get the full content of an installed skill.
    */