groove-dev 0.10.9 → 0.11.0

package/README.md

@@ -45,6 +45,15 @@ Agents in Auto mode knock on the PM before risky operations (creating files, del
 
 Spawn a planner, describe your project. The planner writes a detailed plan and recommends a team. Click **Launch Team** — all agents spawn with proper roles, scopes, and prompts. One click from idea to a full team building your app.
 
+### Workspaces (Large Codebase Support)
+
+GROOVE auto-detects monorepo workspaces (npm, pnpm, lerna) and lets you spawn each agent in its own subdirectory. A frontend agent only sees `packages/frontend/`. A backend agent only sees `packages/backend/`. No wasted context on irrelevant code.
+
+- **Codebase indexer** — scans project structure on start, gives every agent instant orientation
+- **Architecture injection** — auto-detects `ARCHITECTURE.md` and injects it into every agent's context
+- **Per-workspace journalist** — synthesis and handoff briefs scoped to each agent's directory
+- **Quick-pick** — detected workspaces appear as buttons in the spawn panel
+
 ### Multi-Agent Coordination
 
 - **Introduction protocol** — every agent knows its teammates, their files, and their work
@@ -56,10 +65,9 @@ Spawn a planner, describe your project. The planner writes a detailed plan and r
 
 | Provider | Auth | Models |
 |----------|------|--------|
-| **Claude Code** | Subscription | Opus, Sonnet, Haiku |
-| **Codex** | API Key | o3, o4-mini |
-| **Gemini CLI** | API Key | 2.5 Pro, 2.5 Flash |
-
+| **Claude Code** | Subscription | Opus 4.6, Sonnet 4.6, Haiku 4.5 |
+| **Codex** | API Key | o3, o4-mini, GPT-4.1, GPT-4.1 Mini, GPT-4.1 Nano |
+| **Gemini CLI** | API Key | 3.1 Pro, 3 Flash, 3.1 Flash Lite, 2.5 Pro, 2.5 Flash |
 | **Ollama** | Local | Any |
 
 GROOVE is a process manager — it spawns actual AI tool binaries. It never proxies API calls, never touches OAuth tokens, never impersonates any client. Your AI tools talk directly to their servers.
@@ -90,19 +98,19 @@ GROOVE routes tasks to the cheapest model that can handle them. Planners get Opu
 ## Architecture
 
 ```
-         ┌─────────────────────────────────────────┐
-         │            GROOVE DAEMON (:31415)        │
-         │                                         │
-         │  Registry · Introducer · Lock Manager   │
-         │  Journalist · Rotator · Adaptive        │
-         │  Classifier · Router · PM · Teams       │
-         │                                         │
-         │  REST API · WebSocket · GUI Server       │
-         └─────────────────┬───────────────────────┘
+    ┌──────────────────────────────────────────────┐
+    │             GROOVE DAEMON (:31415)            │
+    │                                              │
+    │  Registry · Introducer · Lock Manager        │
+    │  Journalist · Rotator · Adaptive · Indexer   │
+    │  Classifier · Router · PM · Teams            │
+    │                                              │
+    │  REST API · WebSocket · GUI Server           │
+    └──────────────────────┬───────────────────────┘
                            │
-    ┌──────────────────────▼──────────────────────┐
-    │  Claude Code · Codex · Gemini · Ollama           │
-    └─────────────────────────────────────────────┘
+    ┌──────────────────────▼───────────────────────┐
+    │   Claude Code · Codex · Gemini CLI · Ollama  │
+    └──────────────────────────────────────────────┘
 ```
 
 ## Links

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.10.9",
+  "version": "0.11.0",
   "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.10.9",
+  "version": "0.11.0",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -341,6 +341,27 @@ export function createApi(app, daemon) {
     res.json(daemon.adaptive.getAllProfiles());
   });
 
+  // --- Codebase Indexer ---
+
+  app.get('/api/indexer', (req, res) => {
+    res.json(daemon.indexer.getStatus());
+  });
+
+  app.get('/api/indexer/workspaces', (req, res) => {
+    res.json({
+      workspaces: daemon.indexer.getWorkspaces(),
+    });
+  });
+
+  app.post('/api/indexer/rescan', (req, res) => {
+    try {
+      daemon.indexer.scan();
+      res.json({ ok: true, ...daemon.indexer.getStatus() });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // --- Project Manager (AI Review Gate) ---
 
   // Agent knocks on PM before risky operations (Auto permission mode)
@@ -401,6 +422,7 @@ export function createApi(app, daemon) {
           provider: config.provider || 'claude-code',
           model: config.model || 'auto',
           permission: config.permission || 'auto',
+          workingDir: config.workingDir || undefined,
         });
         const agent = await daemon.processes.spawn(validated);
         spawned.push({ id: agent.id, name: agent.name, role: agent.role });

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

@@ -23,6 +23,7 @@ import { CredentialStore } from './credentials.js';
 import { TaskClassifier } from './classifier.js';
 import { ModelRouter } from './router.js';
 import { ProjectManager } from './pm.js';
+import { CodebaseIndexer } from './indexer.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -69,6 +70,7 @@ export class Daemon {
     this.classifier = new TaskClassifier();
     this.router = new ModelRouter(this);
     this.pm = new ProjectManager(this);
+    this.indexer = new CodebaseIndexer(this);
 
     // HTTP + WebSocket server
     this.app = express();
@@ -181,6 +183,9 @@ export class Daemon {
         this.journalist.start();
         this.rotator.start();
 
+        // Scan codebase for workspace/structure awareness
+        this.indexer.scan();
+
         resolvePromise(this);
       });
     });

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

@@ -0,0 +1,324 @@
+// GROOVE — Codebase Indexer
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Scans the project structure on daemon start to detect monorepo workspaces,
+// key files, and directory layout. Agents read this instead of spending
+// thousands of tokens exploring the file tree.
+
+import { readdirSync, statSync, readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, relative, basename, join } from 'path';
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.groove', 'dist', 'build', '.next', '.nuxt',
+  '.output', '.cache', '.turbo', '.vercel', '.svelte-kit', 'coverage',
+  '__pycache__', '.venv', 'venv', 'vendor', 'target', '.gradle',
+]);
+
+const KEY_FILES = [
+  'package.json', 'tsconfig.json', 'README.md', 'CLAUDE.md',
+  'ARCHITECTURE.md', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+  'Makefile', 'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
+];
+
+const MAX_DEPTH = 4;
+
+export class CodebaseIndexer {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.index = null;       // { tree, workspaces, keyFiles, stats }
+    this.lastIndexTime = null;
+    this.indexPath = resolve(daemon.grooveDir, 'codebase-index.json');
+  }
+
+  /**
+   * Scan the project directory and build the codebase index.
+   * Called on daemon start. Fast — only reads directory entries, not file contents.
+   */
+  scan() {
+    const rootDir = this.daemon.projectDir;
+    const tree = [];
+    const workspaces = [];
+    const keyFiles = [];
+    let totalFiles = 0;
+    let totalDirs = 0;
+
+    // Recursive directory walker (depth-limited)
+    const walk = (dir, depth, relPath) => {
+      if (depth > MAX_DEPTH) return;
+
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      const dirs = [];
+      const files = [];
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+
+        if (entry.isDirectory()) {
+          if (IGNORE_DIRS.has(entry.name)) continue;
+          dirs.push(entry.name);
+          totalDirs++;
+        } else if (entry.isFile()) {
+          files.push(entry.name);
+          totalFiles++;
+
+          // Track key files
+          if (KEY_FILES.includes(entry.name)) {
+            const filePath = relPath ? `${relPath}/${entry.name}` : entry.name;
+            keyFiles.push(filePath);
+          }
+        }
+      }
+
+      // Add to tree
+      const nodePath = relPath || '.';
+      tree.push({
+        path: nodePath,
+        depth,
+        dirs: dirs.length,
+        files: files.length,
+        children: dirs,
+      });
+
+      // Recurse into subdirectories
+      for (const d of dirs) {
+        walk(resolve(dir, d), depth + 1, relPath ? `${relPath}/${d}` : d);
+      }
+    };
+
+    walk(rootDir, 0, '');
+
+    // Detect workspaces
+    this.detectWorkspaces(rootDir, workspaces, tree);
+
+    this.index = {
+      projectName: basename(rootDir),
+      scannedAt: new Date().toISOString(),
+      stats: { totalFiles, totalDirs, treeDepth: MAX_DEPTH },
+      workspaces,
+      keyFiles,
+      tree,
+    };
+    this.lastIndexTime = Date.now();
+
+    // Persist to .groove/codebase-index.json
+    try {
+      writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+    } catch {
+      // Non-fatal — index is in memory either way
+    }
+
+    // Broadcast to GUI
+    this.daemon.broadcast({
+      type: 'indexer:complete',
+      data: {
+        workspaceCount: workspaces.length,
+        workspaces,
+        stats: this.index.stats,
+      },
+    });
+
+    return this.index;
+  }
+
+  /**
+   * Detect monorepo workspaces from common patterns.
+   */
+  detectWorkspaces(rootDir, workspaces, tree) {
+    // 1. npm/yarn workspaces (package.json → workspaces field)
+    const rootPkg = this.readJson(resolve(rootDir, 'package.json'));
+    if (rootPkg?.workspaces) {
+      const patterns = Array.isArray(rootPkg.workspaces)
+        ? rootPkg.workspaces
+        : rootPkg.workspaces.packages || [];
+      this.resolveWorkspacePatterns(rootDir, patterns, workspaces, 'npm-workspaces');
+    }
+
+    // 2. pnpm workspaces
+    const pnpmPath = resolve(rootDir, 'pnpm-workspace.yaml');
+    if (existsSync(pnpmPath)) {
+      try {
+        const content = readFileSync(pnpmPath, 'utf8');
+        // Simple YAML parse — extract lines like "  - packages/*"
+        const patterns = [];
+        for (const line of content.split('\n')) {
+          const match = line.match(/^\s*-\s+['"]?([^'"]+)['"]?\s*$/);
+          if (match) patterns.push(match[1]);
+        }
+        if (patterns.length > 0) {
+          this.resolveWorkspacePatterns(rootDir, patterns, workspaces, 'pnpm-workspaces');
+        }
+      } catch { /* ignore */ }
+    }
+
+    // 3. lerna.json
+    const lernaPath = resolve(rootDir, 'lerna.json');
+    if (existsSync(lernaPath)) {
+      const lerna = this.readJson(lernaPath);
+      if (lerna?.packages) {
+        this.resolveWorkspacePatterns(rootDir, lerna.packages, workspaces, 'lerna');
+      }
+    }
+
+    // 4. Fallback: multiple package.json at depth 1-2 (non-declared monorepo)
+    if (workspaces.length === 0) {
+      const subPkgs = tree.filter((node) =>
+        node.depth >= 1 && node.depth <= 2 &&
+        this.hasKeyFile(rootDir, node.path, 'package.json')
+      );
+      if (subPkgs.length >= 2) {
+        for (const node of subPkgs) {
+          const pkgJson = this.readJson(resolve(rootDir, node.path, 'package.json'));
+          workspaces.push({
+            path: node.path,
+            name: pkgJson?.name || basename(node.path),
+            type: 'detected',
+            files: node.files,
+            dirs: node.dirs,
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolve workspace glob patterns (e.g. "packages/*") into actual directories.
+   */
+  resolveWorkspacePatterns(rootDir, patterns, workspaces, type) {
+    const seen = new Set(workspaces.map((w) => w.path));
+
+    for (const pattern of patterns) {
+      // Handle simple glob: "packages/*", "apps/*"
+      const clean = pattern.replace(/\/?\*+$/, '');
+      const parentDir = resolve(rootDir, clean);
+
+      if (!existsSync(parentDir)) continue;
+
+      try {
+        const stat = statSync(parentDir);
+
+        if (pattern.includes('*')) {
+          // It's a glob — list children of the parent directory
+          const entries = readdirSync(parentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory() || IGNORE_DIRS.has(entry.name)) continue;
+            const wsPath = clean ? `${clean}/${entry.name}` : entry.name;
+            if (seen.has(wsPath)) continue;
+            seen.add(wsPath);
+
+            const fullPath = resolve(rootDir, wsPath);
+            const pkgJson = this.readJson(resolve(fullPath, 'package.json'));
+            const info = this.dirInfo(fullPath);
+            workspaces.push({
+              path: wsPath,
+              name: pkgJson?.name || entry.name,
+              type,
+              files: info.files,
+              dirs: info.dirs,
+            });
+          }
+        } else if (stat.isDirectory()) {
+          // Direct path (e.g. "shared")
+          if (seen.has(clean)) continue;
+          seen.add(clean);
+
+          const pkgJson = this.readJson(resolve(parentDir, 'package.json'));
+          const info = this.dirInfo(parentDir);
+          workspaces.push({
+            path: clean,
+            name: pkgJson?.name || basename(clean),
+            type,
+            files: info.files,
+            dirs: info.dirs,
+          });
+        }
+      } catch { /* skip inaccessible dirs */ }
+    }
+  }
+
+  // ── Helpers ──
+
+  readJson(filePath) {
+    try {
+      return JSON.parse(readFileSync(filePath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  hasKeyFile(rootDir, relPath, filename) {
+    return existsSync(resolve(rootDir, relPath, filename));
+  }
+
+  dirInfo(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      let files = 0, dirs = 0;
+      for (const e of entries) {
+        if (e.name.startsWith('.')) continue;
+        if (e.isFile()) files++;
+        else if (e.isDirectory() && !IGNORE_DIRS.has(e.name)) dirs++;
+      }
+      return { files, dirs };
+    } catch {
+      return { files: 0, dirs: 0 };
+    }
+  }
+
+  // ── Public API ──
+
+  getWorkspaces() {
+    return this.index?.workspaces || [];
+  }
+
+  getIndex() {
+    return this.index;
+  }
+
+  /**
+   * Get a compact structural summary for agent context injection.
+   * Returns a markdown string with workspace layout and key files.
+   */
+  getStructureSummary() {
+    if (!this.index) return null;
+    const { workspaces, keyFiles, stats, projectName } = this.index;
+
+    const lines = [];
+    lines.push(`Project: **${projectName}** (${stats.totalFiles} files, ${stats.totalDirs} directories)`);
+
+    if (workspaces.length > 0) {
+      lines.push('');
+      lines.push(`Workspaces (${workspaces.length}):`);
+      for (const ws of workspaces) {
+        lines.push(`- \`${ws.path}/\` — ${ws.name} (${ws.files} files, ${ws.dirs} subdirs)`);
+      }
+    }
+
+    if (keyFiles.length > 0) {
+      lines.push('');
+      lines.push('Key files:');
+      for (const f of keyFiles.slice(0, 30)) {
+        lines.push(`- ${f}`);
+      }
+      if (keyFiles.length > 30) {
+        lines.push(`- *(+${keyFiles.length - 30} more)*`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  getStatus() {
+    return {
+      indexed: !!this.index,
+      lastIndexTime: this.lastIndexTime,
+      workspaceCount: this.index?.workspaces?.length || 0,
+      stats: this.index?.stats || null,
+    };
+  }
+}

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

@@ -26,6 +26,10 @@ export class Introducer {
       `You are **${newAgent.name}** (role: ${newAgent.role}), managed by GROOVE.`,
     ];
 
+    if (newAgent.workingDir) {
+      lines.push(`Your working directory: \`${newAgent.workingDir}\` — you are spawned inside this subdirectory. Stay within it unless coordination requires otherwise.`);
+    }
+
     if (newAgent.scope && newAgent.scope.length > 0) {
       lines.push(`Your file scope: \`${newAgent.scope.join('`, `')}\``);
     } else {
@@ -45,7 +49,8 @@ export class Introducer {
 
       for (const other of others) {
         const scope = other.scope?.length > 0 ? other.scope.join(', ') : 'unrestricted';
-        lines.push(`- **${other.name}** (${other.role}) — scope: ${scope} — ${other.status}`);
+        const dir = other.workingDir ? ` — dir: ${other.workingDir}` : '';
+        lines.push(`- **${other.name}** (${other.role}) — scope: ${scope}${dir} — ${other.status}`);
 
         // Get files this agent created/modified
         const files = this.daemon.journalist?.getAgentFiles(other) || [];
@@ -138,9 +143,54 @@ export class Introducer {
       lines.push(`Read GROOVE_PROJECT_MAP.md for current project context from The Journalist.`);
     }
 
+    // Codebase structure injection — give agents instant orientation
+    const structureSummary = this.daemon.indexer?.getStructureSummary();
+    if (structureSummary) {
+      lines.push('');
+      lines.push(`## Codebase Structure (auto-indexed)`);
+      lines.push('');
+      lines.push(structureSummary);
+    }
+
+    // Architecture injection — auto-detect architecture docs and inject
+    // so every agent understands the big picture without spending tokens exploring
+    const archContent = this.loadArchitectureDoc();
+    if (archContent) {
+      lines.push('');
+      lines.push(`## Architecture (auto-injected)`);
+      lines.push('');
+      lines.push(archContent);
+    }
+
     return lines.join('\n');
   }
 
+  loadArchitectureDoc() {
+    const projectDir = this.daemon.projectDir;
+    const candidates = [
+      'ARCHITECTURE.md',
+      'docs/architecture.md',
+      '.github/ARCHITECTURE.md',
+    ];
+
+    for (const candidate of candidates) {
+      const fullPath = resolve(projectDir, candidate);
+      if (existsSync(fullPath)) {
+        try {
+          let content = readFileSync(fullPath, 'utf8').trim();
+          // Truncate to ~5K chars to keep context budget reasonable
+          if (content.length > 5000) {
+            content = content.slice(0, 5000) + '\n\n*(truncated — read full file for details)*';
+          }
+          return content;
+        } catch {
+          // ignore read errors
+        }
+      }
+    }
+    return null;
+  }
+
   writeRegistryFile(projectDir) {
     const agents = this.daemon.registry.getAll();
 
@@ -158,13 +208,14 @@ export class Introducer {
       ``,
       `*Auto-generated by GROOVE. Do not edit manually.*`,
       ``,
-      `| ID | Name | Role | Provider | Scope | Status |`,
-      `|----|------|------|----------|-------|--------|`,
+      `| ID | Name | Role | Provider | Directory | Scope | Status |`,
+      `|----|------|------|----------|-----------|-------|--------|`,
     ];
 
     for (const a of agents) {
       const scope = a.scope?.length > 0 ? `\`${a.scope.join('`, `')}\`` : '-';
-      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${scope} | ${escapeMd(a.status)} |`);
+      const dir = a.workingDir ? escapeMd(a.workingDir) : '-';
+      lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${dir} | ${scope} | ${escapeMd(a.status)} |`);
     }
 
     lines.push('');