maestro-agent 0.0.1 → 0.0.2

package/src/ops/autopilot.ts

@@ -0,0 +1,338 @@
+import { claimTaskForAgent } from "../api/tasks";
+import { now } from "../core/db";
+import type { HubContext } from "../core/server";
+import { executeHooksForEvent, runDueCrons, runDueScheduledTasks } from "../scheduler";
+import { extractSkillFromTranscript } from "../skills/skill-extractor";
+import { findRoleAndAgentForTask, resolveAgentForRole } from "./role-dispatch";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface AutopilotConfig {
+  enabled: boolean;
+  tick_interval_ms: number;     // Main loop interval (default: 30s)
+  auto_dispatch: boolean;       // Auto-assign open tasks to idle agents
+  auto_crons: boolean;          // Auto-run due crons
+  auto_scheduled_tasks: boolean; // Auto-run due scheduled tasks
+  webhook_bridge: boolean;      // Bridge webhook events to hook_bindings
+  skill_extraction: boolean;    // Auto-extract skills from completed sessions
+  max_concurrent_dispatches: number; // Max tasks to dispatch per tick
+}
+
+export interface AutopilotStatus {
+  running: boolean;
+  config: AutopilotConfig;
+  stats: AutopilotStats;
+  last_tick_at: number | null;
+}
+
+export interface AutopilotStats {
+  ticks: number;
+  crons_executed: number;
+  scheduled_tasks_fired: number;
+  tasks_dispatched: number;
+  webhooks_bridged: number;
+  skills_extracted: number;
+  errors: number;
+  started_at: number;
+}
+
+export interface AutopilotTickResult {
+  crons: { executed: number; blocked: number } | null;
+  scheduled_tasks: { fired: number; created: number; assigned: number; blocked: number } | null;
+  dispatched: { matched: number; claimed: number; failed: number } | null;
+  timestamp: number;
+}
+
+const DEFAULT_CONFIG: AutopilotConfig = {
+  enabled: true,
+  tick_interval_ms: 30_000,
+  auto_dispatch: true,
+  auto_crons: true,
+  auto_scheduled_tasks: true,
+  webhook_bridge: true,
+  skill_extraction: true,
+  max_concurrent_dispatches: 5,
+};
+
+// ─── Autopilot Engine ────────────────────────────────────────────────────────
+
+export class Autopilot {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private config: AutopilotConfig;
+  private stats: AutopilotStats;
+  private lastTickAt: number | null = null;
+  private busListeners: Array<{ event: string; handler: (...args: any[]) => void }> = [];
+
+  constructor(private ctx: HubContext, config?: Partial<AutopilotConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.stats = {
+      ticks: 0,
+      crons_executed: 0,
+      scheduled_tasks_fired: 0,
+      tasks_dispatched: 0,
+      webhooks_bridged: 0,
+      skills_extracted: 0,
+      errors: 0,
+      started_at: now(),
+    };
+  }
+
+  start(): void {
+    if (this.timer) return;
+    if (!this.config.enabled) return;
+
+    // Start tick loop
+    this.timer = setInterval(() => this.tick().catch((err) => {
+      console.error("[autopilot] tick error:", err);
+      this.stats.errors++;
+    }), this.config.tick_interval_ms);
+    (this.timer as any).unref?.();
+
+    // Bridge webhook events to hook system
+    if (this.config.webhook_bridge) {
+      this.setupWebhookBridge();
+    }
+
+    // Bridge task.created to auto-dispatch
+    if (this.config.auto_dispatch) {
+      this.setupAutoDispatchListener();
+    }
+
+    // Extract skills from completed sessions
+    if (this.config.skill_extraction) {
+      this.setupSkillExtractionListener();
+    }
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    // Remove bus listeners
+    for (const { event, handler } of this.busListeners) {
+      this.ctx.bus.removeListener(event, handler);
+    }
+    this.busListeners = [];
+  }
+
+  isRunning(): boolean {
+    return this.timer !== null;
+  }
+
+  getStatus(): AutopilotStatus {
+    return {
+      running: this.isRunning(),
+      config: { ...this.config },
+      stats: { ...this.stats },
+      last_tick_at: this.lastTickAt,
+    };
+  }
+
+  updateConfig(updates: Partial<AutopilotConfig>): void {
+    const wasRunning = this.isRunning();
+    const oldTickInterval = this.config.tick_interval_ms;
+
+    this.config = { ...this.config, ...updates };
+
+    if (wasRunning && !this.config.enabled) {
+      this.stop();
+    } else if (!wasRunning && this.config.enabled) {
+      this.start();
+    } else if (wasRunning && this.config.tick_interval_ms !== oldTickInterval) {
+      // Restart with new interval
+      this.stop();
+      this.start();
+    }
+  }
+
+  /**
+   * Execute a single tick manually (useful for testing / manual trigger).
+   */
+  async tick(): Promise<AutopilotTickResult> {
+    const timestamp = now();
+    this.lastTickAt = timestamp;
+    this.stats.ticks++;
+
+    const result: AutopilotTickResult = {
+      crons: null,
+      scheduled_tasks: null,
+      dispatched: null,
+      timestamp,
+    };
+
+    // 1. Run due crons
+    if (this.config.auto_crons) {
+      try {
+        const cronsResult = runDueCrons(this.ctx.db, timestamp);
+        result.crons = cronsResult;
+        this.stats.crons_executed += cronsResult.executed;
+      } catch (err) {
+        console.error("[autopilot] crons error:", err);
+        this.stats.errors++;
+      }
+    }
+
+    // 2. Run due scheduled tasks
+    if (this.config.auto_scheduled_tasks) {
+      try {
+        const stResult = await runDueScheduledTasks(this.ctx, timestamp);
+        result.scheduled_tasks = stResult;
+        this.stats.scheduled_tasks_fired += stResult.fired;
+      } catch (err) {
+        console.error("[autopilot] scheduled tasks error:", err);
+        this.stats.errors++;
+      }
+    }
+
+    // 3. Auto-dispatch unassigned tasks
+    if (this.config.auto_dispatch) {
+      try {
+        const dispatched = await this.dispatchOpenTasks();
+        result.dispatched = dispatched;
+        this.stats.tasks_dispatched += dispatched.claimed;
+      } catch (err) {
+        console.error("[autopilot] dispatch error:", err);
+        this.stats.errors++;
+      }
+    }
+
+    return result;
+  }
+
+  // ─── Auto-Dispatch Logic ─────────────────────────────────────────────────
+
+  private async dispatchOpenTasks(): Promise<{ matched: number; claimed: number; failed: number }> {
+    const result = { matched: 0, claimed: 0, failed: 0 };
+
+    // Find open tasks without assignee, ordered by priority
+    // Tasks with assignee_role_id get priority — the Role is already determined
+    const openTasks = this.ctx.db.query(
+      `SELECT t.id, t.project_id, t.assignee_role_id, t.required_capabilities_json
+       FROM task t
+       WHERE t.status = 'open'
+         AND t.assignee_agent_id IS NULL
+       ORDER BY t.priority DESC, t.created_at ASC
+       LIMIT ?`
+    ).all(this.config.max_concurrent_dispatches) as any[];
+
+    for (const task of openTasks) {
+      const resolved = this.resolveForTask(task);
+      if (!resolved) continue;
+
+      result.matched++;
+      try {
+        // Record the role assignment if not already set
+        if (resolved.role_id && !task.assignee_role_id) {
+          this.ctx.db.run("UPDATE task SET assignee_role_id = ? WHERE id = ?", [resolved.role_id, task.id]);
+        }
+        const claimResult = await claimTaskForAgent(this.ctx, task.id, resolved.agent_id, { deferIfProjectBusy: true, skipSession: true });
+        if ("error" in claimResult) {
+          result.failed++;
+        } else {
+          result.claimed++;
+        }
+      } catch {
+        result.failed++;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Role-centric resolution: task → Role → Agent (wake if needed).
+   * If task already has assignee_role_id, use that role directly.
+   * Otherwise, find the best matching Role in the workspace.
+   */
+  private resolveForTask(task: any): { role_id: string; agent_id: string } | null {
+    // If task already has a designated role, resolve agent under that role
+    if (task.assignee_role_id) {
+      const agent = resolveAgentForRole(this.ctx.db, task.assignee_role_id);
+      if (agent) return { role_id: task.assignee_role_id, agent_id: agent.id };
+      return null;
+    }
+
+    // Otherwise find best Role + Agent via capabilities matching
+    const match = findRoleAndAgentForTask(this.ctx, task);
+    if (match) return { role_id: match.role_id, agent_id: match.agent.id };
+    return null;
+  }
+
+  // ─── Event Bridge ────────────────────────────────────────────────────────
+
+  private setupWebhookBridge(): void {
+    const bridgeHandler = (event: string) => {
+      const listener = (payload: any) => {
+        try {
+          executeHooksForEvent(this.ctx.db, event, payload || {});
+          this.stats.webhooks_bridged++;
+        } catch (err) {
+          console.error(`[autopilot] webhook bridge error for ${event}:`, err);
+          this.stats.errors++;
+        }
+      };
+      this.ctx.bus.on(event, listener);
+      this.busListeners.push({ event, handler: listener });
+    };
+
+    // Bridge common webhook events
+    for (const source of ["webhook.github", "webhook.lark", "webhook.custom", "webhook.linear"]) {
+      bridgeHandler(source);
+    }
+  }
+
+  private setupAutoDispatchListener(): void {
+    const handler = async (payload: any) => {
+      // When a new task is created, attempt to dispatch it via Role
+      // Skip if task was already assigned by the creator
+      if (!payload?.id || payload.assignee_agent_id) return;
+      try {
+        const task = this.ctx.db.query(
+          "SELECT id, project_id, assignee_role_id, required_capabilities_json FROM task WHERE id = ? AND status = 'open' AND assignee_agent_id IS NULL"
+        ).get(payload.id) as any;
+        if (!task) return;
+
+        const resolved = this.resolveForTask(task);
+        if (!resolved) return;
+
+        // Record role assignment
+        if (!task.assignee_role_id) {
+          this.ctx.db.run("UPDATE task SET assignee_role_id = ? WHERE id = ?", [resolved.role_id, task.id]);
+        }
+
+        const result = await claimTaskForAgent(this.ctx, task.id, resolved.agent_id, { deferIfProjectBusy: true, skipSession: true });
+        if (!("error" in result)) {
+          this.stats.tasks_dispatched++;
+        }
+      } catch (err) {
+        console.error("[autopilot] auto-dispatch on task.created error:", err);
+      }
+    };
+
+    this.ctx.bus.on("task.created", handler);
+    this.busListeners.push({ event: "task.created", handler });
+  }
+
+  private setupSkillExtractionListener(): void {
+    const handler = (payload: any) => {
+      if (!payload?.id) return;
+      // Async extraction — don't block event loop
+      setTimeout(() => {
+        try {
+          const result = extractSkillFromTranscript(this.ctx, payload.id);
+          if (result.extracted) {
+            this.stats.skills_extracted++;
+            console.log(`[autopilot] skill extracted: ${result.skill_name} from session ${payload.id}`);
+          }
+        } catch (err) {
+          console.error("[autopilot] skill extraction error:", err);
+          this.stats.errors++;
+        }
+      }, 1000); // Delay to ensure transcript is fully flushed
+    };
+
+    this.ctx.bus.on("session.ended", handler);
+    this.busListeners.push({ event: "session.ended", handler });
+  }
+}

package/src/ops/gc.ts

@@ -0,0 +1,252 @@
+import { Database } from "bun:sqlite";
+import { existsSync, readdirSync, rmSync, statSync } from "fs";
+import { join } from "path";
+import { now } from "../core/db";
+
+export interface GcConfig {
+  retentionDays: number;
+  maxDiskMb: number;
+  protectedPatterns: string[];
+}
+
+const DEFAULT_CONFIG: GcConfig = {
+  retentionDays: 7,
+  maxDiskMb: 1024,
+  protectedPatterns: ["*.log", "report.*"],
+};
+
+export interface GcResult {
+  level: "artifact" | "full" | "orphan";
+  removed: string[];
+  skipped: string[];
+  freedBytes: number;
+}
+
+// Patterns for build artifacts that can be safely removed
+const ARTIFACT_PATTERNS = [
+  "node_modules",
+  "dist",
+  ".build",
+  "__pycache__",
+  ".next",
+  ".turbo",
+  "target",       // Rust/Java
+  "build",
+  ".cache",
+];
+
+/**
+ * Level 1: Artifact-only GC
+ * Removes build artifacts (node_modules, dist, .build etc.) from completed task dirs.
+ * Preserves logs and user-marked artifacts.
+ */
+export function gcArtifacts(db: Database, hubDir: string, config?: Partial<GcConfig>): GcResult {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const workspacesDir = join(hubDir, "workspaces");
+  if (!existsSync(workspacesDir)) return { level: "artifact", removed: [], skipped: [], freedBytes: 0 };
+
+  const completedTaskIds = getCompletedTaskIds(db);
+  const removed: string[] = [];
+  const skipped: string[] = [];
+  let freedBytes = 0;
+
+  for (const taskId of listTaskDirs(workspacesDir)) {
+    if (!completedTaskIds.has(taskId)) {
+      skipped.push(taskId);
+      continue;
+    }
+
+    const taskWorkspace = join(workspacesDir, taskId, "workspace");
+    if (!existsSync(taskWorkspace)) continue;
+
+    for (const pattern of ARTIFACT_PATTERNS) {
+      const target = join(taskWorkspace, pattern);
+      if (existsSync(target)) {
+        const size = getDirSize(target);
+        rmSync(target, { recursive: true, force: true });
+        freedBytes += size;
+        removed.push(`${taskId}/${pattern}`);
+      }
+    }
+  }
+
+  return { level: "artifact", removed, skipped, freedBytes };
+}
+
+/**
+ * Level 2: Full GC
+ * Removes entire task directories for completed tasks beyond retention period.
+ */
+export function gcFull(db: Database, hubDir: string, config?: Partial<GcConfig>): GcResult {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const workspacesDir = join(hubDir, "workspaces");
+  if (!existsSync(workspacesDir)) return { level: "full", removed: [], skipped: [], freedBytes: 0 };
+
+  const retentionMs = cfg.retentionDays * 24 * 60 * 60 * 1000;
+  const cutoff = now() - retentionMs;
+  const expiredTaskIds = getExpiredTaskIds(db, cutoff);
+  const removed: string[] = [];
+  const skipped: string[] = [];
+  let freedBytes = 0;
+
+  for (const taskId of listTaskDirs(workspacesDir)) {
+    if (!expiredTaskIds.has(taskId)) {
+      skipped.push(taskId);
+      continue;
+    }
+
+    const taskDir = join(workspacesDir, taskId);
+    const size = getDirSize(taskDir);
+    rmSync(taskDir, { recursive: true, force: true });
+    db.run("UPDATE task SET work_dir = NULL, updated_at = ? WHERE id = ?", [now(), taskId]);
+    freedBytes += size;
+    removed.push(taskId);
+  }
+
+  return { level: "full", removed, skipped, freedBytes };
+}
+
+/**
+ * Level 3: Orphan GC
+ * Removes directories that have no corresponding task in the DB.
+ * Typically run on server startup.
+ */
+export function gcOrphans(db: Database, hubDir: string): GcResult {
+  const workspacesDir = join(hubDir, "workspaces");
+  if (!existsSync(workspacesDir)) return { level: "orphan", removed: [], skipped: [], freedBytes: 0 };
+
+  const allTaskIds = new Set(
+    (db.query("SELECT id FROM task").all() as any[]).map((r) => r.id)
+  );
+
+  const removed: string[] = [];
+  const skipped: string[] = [];
+  let freedBytes = 0;
+
+  for (const dirName of listTaskDirs(workspacesDir)) {
+    if (allTaskIds.has(dirName)) {
+      skipped.push(dirName);
+      continue;
+    }
+
+    const orphanDir = join(workspacesDir, dirName);
+    const size = getDirSize(orphanDir);
+    rmSync(orphanDir, { recursive: true, force: true });
+    freedBytes += size;
+    removed.push(dirName);
+  }
+
+  return { level: "orphan", removed, skipped, freedBytes };
+}
+
+/**
+ * Run all GC levels in order: orphan -> artifact -> full.
+ */
+export function gcAll(db: Database, hubDir: string, config?: Partial<GcConfig>): GcResult[] {
+  return [
+    gcOrphans(db, hubDir),
+    gcArtifacts(db, hubDir, config),
+    gcFull(db, hubDir, config),
+  ];
+}
+
+/**
+ * Dry-run: report what would be cleaned without removing anything.
+ */
+export function gcDryRun(db: Database, hubDir: string, config?: Partial<GcConfig>) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const workspacesDir = join(hubDir, "workspaces");
+  if (!existsSync(workspacesDir)) return { orphans: [], artifacts: [], expired: [], totalBytes: 0 };
+
+  const allTaskIds = new Set((db.query("SELECT id FROM task").all() as any[]).map((r) => r.id));
+  const completedTaskIds = getCompletedTaskIds(db);
+  const retentionMs = cfg.retentionDays * 24 * 60 * 60 * 1000;
+  const cutoff = now() - retentionMs;
+  const expiredTaskIds = getExpiredTaskIds(db, cutoff);
+
+  const orphans: string[] = [];
+  const artifacts: { taskId: string; pattern: string; bytes: number }[] = [];
+  const expired: string[] = [];
+  let totalBytes = 0;
+
+  for (const dirName of listTaskDirs(workspacesDir)) {
+    const taskDir = join(workspacesDir, dirName);
+
+    if (!allTaskIds.has(dirName)) {
+      const size = getDirSize(taskDir);
+      orphans.push(dirName);
+      totalBytes += size;
+      continue;
+    }
+
+    if (expiredTaskIds.has(dirName)) {
+      const size = getDirSize(taskDir);
+      expired.push(dirName);
+      totalBytes += size;
+      continue;
+    }
+
+    if (completedTaskIds.has(dirName)) {
+      const taskWorkspace = join(taskDir, "workspace");
+      if (existsSync(taskWorkspace)) {
+        for (const pattern of ARTIFACT_PATTERNS) {
+          const target = join(taskWorkspace, pattern);
+          if (existsSync(target)) {
+            const size = getDirSize(target);
+            artifacts.push({ taskId: dirName, pattern, bytes: size });
+            totalBytes += size;
+          }
+        }
+      }
+    }
+  }
+
+  return { orphans, artifacts, expired, totalBytes };
+}
+
+// --- Helpers ---
+
+function getCompletedTaskIds(db: Database): Set<string> {
+  return new Set(
+    (db.query("SELECT id FROM task WHERE status IN ('done', 'cancelled')").all() as any[]).map((r) => r.id)
+  );
+}
+
+function getExpiredTaskIds(db: Database, cutoff: number): Set<string> {
+  return new Set(
+    (db.query(
+      "SELECT id FROM task WHERE status IN ('done', 'cancelled') AND updated_at <= ?"
+    ).all(cutoff) as any[]).map((r) => r.id)
+  );
+}
+
+function listTaskDirs(workspacesDir: string): string[] {
+  try {
+    return readdirSync(workspacesDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+function getDirSize(dirPath: string): number {
+  try {
+    const stat = statSync(dirPath);
+    if (!stat.isDirectory()) return stat.size;
+
+    let total = 0;
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        total += getDirSize(fullPath);
+      } else {
+        try { total += statSync(fullPath).size; } catch {}
+      }
+    }
+    return total;
+  } catch {
+    return 0;
+  }
+}