@grantx/fleet-core 0.1.0

package/src/platform.js

@@ -0,0 +1,102 @@
+// platform.js — Cross-platform abstractions for fleet plugin.
+// Replaces all hardcoded /tmp, /opt/homebrew, /Users/clawcob paths.
+
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export const isWindows = process.platform === 'win32';
+export const isMac = process.platform === 'darwin';
+export const isLinux = process.platform === 'linux';
+
+// Lockfile directory: os.tmpdir()/fleet on Windows, /tmp on Unix
+export const lockDir = isWindows
+  ? path.join(os.tmpdir(), 'fleet')
+  : '/tmp';
+
+/**
+ * Ensure the lockfile directory exists.
+ */
+export function ensureLockDir() {
+  fs.mkdirSync(lockDir, { recursive: true });
+}
+
+/**
+ * Build environment variables for a spawned agent process.
+ * Inherits the user's PATH (no hardcoded /opt/homebrew).
+ */
+export function buildAgentEnv(agentName, agentHome, teamId, extra = {}) {
+  const env = {
+    HOME: agentHome,
+    FLEET_AGENT_ID: agentName,
+    FLEET_TEAM_ID: teamId,
+    PATH: process.env.PATH,
+    CLOUDSDK_CONFIG: process.env.CLOUDSDK_CONFIG || path.join(os.homedir(), '.config', 'gcloud'),
+    ...extra,
+  };
+
+  // Windows uses USERPROFILE as HOME equivalent
+  if (isWindows) {
+    env.USERPROFILE = agentHome;
+  }
+
+  return env;
+}
+
+/**
+ * Set up Claude credentials for an agent.
+ * Unix: symlink to user's credentials (auto-refreshes).
+ * Windows: copy (symlinks require admin privileges).
+ */
+export function setupCredentials(agentHome) {
+  const userCreds = path.join(os.homedir(), '.claude', '.credentials.json');
+  const agentClaudeDir = path.join(agentHome, '.claude');
+  const agentCreds = path.join(agentClaudeDir, '.credentials.json');
+
+  if (!fs.existsSync(userCreds)) {
+    throw new Error(`Claude credentials not found at ${userCreds}. Run 'claude' first to authenticate.`);
+  }
+
+  fs.mkdirSync(agentClaudeDir, { recursive: true });
+
+  // Remove existing (stale copy or broken symlink)
+  try { fs.unlinkSync(agentCreds); } catch { /* doesn't exist */ }
+
+  if (isWindows) {
+    fs.copyFileSync(userCreds, agentCreds);
+  } else {
+    fs.symlinkSync(userCreds, agentCreds);
+  }
+}
+
+/**
+ * Refresh credentials for all agents (Windows only — copies are stale).
+ * No-op on Unix (symlinks auto-refresh).
+ */
+export function refreshCredentials(fleetDir, agentNames) {
+  if (!isWindows) return;
+
+  const userCreds = path.join(os.homedir(), '.claude', '.credentials.json');
+  if (!fs.existsSync(userCreds)) return;
+
+  for (const name of agentNames) {
+    const agentCreds = path.join(fleetDir, 'agents', name, '.claude', '.credentials.json');
+    try {
+      fs.copyFileSync(userCreds, agentCreds);
+    } catch { /* agent dir may not exist yet */ }
+  }
+}
+
+/**
+ * Resolve the fleet working directory (.fleet/) from a project root.
+ */
+export function fleetDir(projectRoot) {
+  return path.join(projectRoot, '.fleet');
+}
+
+/**
+ * Resolve an agent's HOME directory.
+ */
+export function agentHome(projectRoot, agentName) {
+  return path.join(projectRoot, '.fleet', 'agents', agentName);
+}

package/src/smart-dispatcher.js

@@ -0,0 +1,153 @@
+// smart-dispatcher.js — Heuristic fast-path dispatch.
+// Handles the common case (1 pending task + idle worker) in <100ms
+// without invoking conductor AI. Falls through for complex decisions.
+// Keywords loaded from fleet.config.json, not hardcoded.
+
+import { log } from './logger.js';
+import { dispatchAgent } from './fleet-utils.js';
+import { getWorkerAgents } from './config.js';
+
+export class SmartDispatcher {
+  constructor(agentPool, supabase, config) {
+    this.agentPool = agentPool;
+    this.supabase = supabase;
+    this.config = config;
+    this.stats = { fastPath: 0, fallthrough: 0 };
+
+    // Build keyword map from config
+    this.workerAgents = getWorkerAgents(config).map(a => a.name);
+    this.specialtyKeywords = {};
+    for (const agent of getWorkerAgents(config)) {
+      if (agent.keywords?.length > 0) {
+        this.specialtyKeywords[agent.name] = agent.keywords;
+      }
+    }
+  }
+
+  /**
+   * Try to handle events via fast-path. Returns true if handled, false if conductor AI needed.
+   */
+  async tryFastPath(events, state) {
+    if (!this._isSimpleScenario(events, state)) {
+      this.stats.fallthrough++;
+      return false;
+    }
+
+    const pendingTasks = state.pendingTasks || [];
+    if (pendingTasks.length === 0) {
+      log.info('smart-dispatch', 'Fast-path: no pending tasks, skipping cycle');
+      this.stats.fastPath++;
+      return true;
+    }
+
+    const dispatchable = await this._filterByDeps(pendingTasks);
+    if (dispatchable.length === 0 && pendingTasks.length > 0) {
+      log.info('smart-dispatch', `Fast-path: ${pendingTasks.length} pending but all blocked by deps`);
+      this.stats.fastPath++;
+      return true;
+    }
+
+    let dispatched = 0;
+    for (const task of dispatchable) {
+      const agent = this._pickAgent(task);
+      if (!agent) continue;
+
+      log.info('smart-dispatch', `Fast-path: dispatching ${agent} -> "${task.title}" (${task.id.slice(0, 8)})`);
+      await dispatchAgent(
+        { agent, task_id: task.id, reason: 'smart-dispatch: fast-path' },
+        this.agentPool, this.supabase, this.config
+      );
+      dispatched++;
+      break; // One per cycle
+    }
+
+    if (dispatched === 0 && pendingTasks.length > 0) {
+      log.info('smart-dispatch', `Fast-path: ${pendingTasks.length} pending but no idle workers`);
+      this.stats.fallthrough++;
+      return false;
+    }
+
+    this.stats.fastPath++;
+    return true;
+  }
+
+  /**
+   * Chain-dispatch: after a task completion, immediately dispatch next pending for same agent.
+   */
+  async tryChainDispatch(completedAgent, state) {
+    if (this.agentPool.running.has(completedAgent)) return false;
+
+    const pendingForAgent = (state.pendingTasks || []).filter(t => t.to_agent === completedAgent);
+    if (pendingForAgent.length === 0) return false;
+
+    const dispatchable = await this._filterByDeps(pendingForAgent);
+    if (dispatchable.length === 0) return false;
+
+    const next = dispatchable[0];
+    log.info('smart-dispatch', `Chain-dispatch: ${completedAgent} -> "${next.title}"`);
+    await dispatchAgent(
+      { agent: completedAgent, task_id: next.id, reason: 'smart-dispatch: chain after completion' },
+      this.agentPool, this.supabase, this.config
+    );
+
+    this.stats.fastPath++;
+    return true;
+  }
+
+  _isSimpleScenario(events, state) {
+    const complexTypes = ['task_flagged', 'task_failed', 'agent_health', 'sprint_gate'];
+    if (events.some(e => complexTypes.includes(e.type))) return false;
+    if (state.blockedTasks?.length > 0) return false;
+    if ((state.pendingTasks?.length || 0) > 5) return false;
+    if (!events.every(e => e.type === 'dispatch_tick' || e.type === 'task_completed')) return false;
+    return true;
+  }
+
+  async _filterByDeps(tasks) {
+    const tasksWithDeps = tasks.filter(t => t.depends_on?.length > 0);
+    if (tasksWithDeps.length === 0) return tasks;
+
+    const allDepIds = [...new Set(tasksWithDeps.flatMap(t => t.depends_on))];
+    try {
+      const depTasks = await this.supabase.getUnscoped(
+        `task_queue?id=in.(${allDepIds.join(',')})&select=id,status`
+      );
+      const depStatus = new Map(depTasks.map(t => [t.id, t.status]));
+
+      return tasks.filter(task => {
+        if (!task.depends_on?.length) return true;
+        return task.depends_on.every(depId => depStatus.get(depId) === 'completed');
+      });
+    } catch (err) {
+      log.warn('smart-dispatch', `Dep check failed, allowing all: ${err.message}`);
+      return tasks;
+    }
+  }
+
+  _pickAgent(task) {
+    // Explicit assignment
+    if (task.to_agent && this.workerAgents.includes(task.to_agent)) {
+      if (!this.agentPool.running.has(task.to_agent)) return task.to_agent;
+      return null;
+    }
+
+    // Keyword match from config
+    const taskText = `${task.title} ${task.description || ''}`.toLowerCase();
+    for (const [agent, keywords] of Object.entries(this.specialtyKeywords)) {
+      if (keywords.some(kw => taskText.includes(kw)) && !this.agentPool.running.has(agent)) {
+        return agent;
+      }
+    }
+
+    // First idle worker
+    for (const agent of this.workerAgents) {
+      if (!this.agentPool.running.has(agent)) return agent;
+    }
+
+    return null;
+  }
+
+  getStats() {
+    return { ...this.stats };
+  }
+}

package/src/supabase-client.js

@@ -0,0 +1,87 @@
+// supabase-client.js — Team-scoped Supabase REST wrapper.
+// All queries automatically filtered by team_id.
+
+import { log } from './logger.js';
+
+export class SupabaseClient {
+  /**
+   * @param {string} url - Supabase project URL
+   * @param {string} key - Supabase API key (anon or service_role)
+   * @param {string} teamId - Team ID for scoping queries
+   */
+  constructor(url, key, teamId) {
+    this.url = url.replace(/\/$/, '');
+    this.key = key;
+    this.teamId = teamId;
+  }
+
+  /**
+   * GET with team_id filter auto-appended.
+   */
+  async get(path) {
+    const sep = path.includes('?') ? '&' : '?';
+    const scopedPath = `${path}${sep}team_id=eq.${this.teamId}`;
+    return this._request('GET', scopedPath);
+  }
+
+  /**
+   * GET without team_id filter (for cross-team queries like dep checking).
+   */
+  async getUnscoped(path) {
+    return this._request('GET', path);
+  }
+
+  /**
+   * POST with team_id auto-injected into body.
+   */
+  async post(path, body) {
+    const scopedBody = { ...body, team_id: this.teamId };
+    return this._request('POST', path, scopedBody);
+  }
+
+  /**
+   * PATCH with team_id filter on path and in body.
+   */
+  async patch(path, body) {
+    const sep = path.includes('?') ? '&' : '?';
+    const scopedPath = `${path}${sep}team_id=eq.${this.teamId}`;
+    const scopedBody = { ...body, team_id: this.teamId };
+    return this._request('PATCH', scopedPath, scopedBody);
+  }
+
+  async _request(method, path, body) {
+    const opts = {
+      method,
+      headers: {
+        'apikey': this.key,
+        'Authorization': `Bearer ${this.key}`,
+        'Content-Type': 'application/json',
+        'Prefer': 'return=representation',
+        'x-team-id': this.teamId,
+      },
+    };
+
+    if (body && (method === 'POST' || method === 'PATCH')) {
+      opts.body = JSON.stringify(body);
+    }
+
+    const url = `${this.url}/rest/v1/${path}`;
+    const res = await fetch(url, opts);
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      const msg = `Supabase ${method} ${path}: ${res.status} ${text.slice(0, 200)}`;
+      log.error('supabase', msg);
+      throw new Error(msg);
+    }
+
+    const text = await res.text();
+    if (!text) return method === 'GET' ? [] : {};
+
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+}